/** * Used to create a proxy that only sends and has no returns * * @param serviceInterface serviceInterface * @param myService myService * @param <T> T * @return new local proxy that is one way (no async returns) */ default <T> T createOneWayLocalProxy(Class<T> serviceInterface, String myService) { return createLocalProxy(serviceInterface, myService); }
/** * Add a method call consumer directly to the bundle. * * @param address address of method call consumer * @param service method call consumer acting as a service. * @return this, fluent */ default ServiceBundle addServiceConsumer(String address, Consumer<MethodCall<Object>> service) { this.addServiceObject(address, service); return this; }
@Before public void setup() { systemManager = new QBitSystemManager(); myServiceList = new ArrayList<>(numServices); for (int index = 0; index < numServices; index++) { myServiceList.add(new MyService()); } final AtomicInteger serviceCount = new AtomicInteger(); serviceBundleBuilder = ServiceBundleBuilder.serviceBundleBuilder().setSystemManager(systemManager); serviceBundle = serviceBundleBuilder.build(); serviceBundle.addRoundRobinService("/myService", numServices, () -> myServiceList.get(serviceCount.getAndIncrement())); serviceBundle.start(); myService = serviceBundle.createLocalProxy(IMyService.class, "/myService"); }
@Override public ServiceEndpointServer addService(final Object serviceObject) { serviceBundle.addService(serviceObject); httpRequestServerHandler.addRestSupportFor(serviceObject.getClass(), serviceBundle.address()); return this; }
@Override public ServiceEndpointServer addServiceWithQueueCallBackHandlers(final Object serviceObject, final QueueCallBackHandler... queueCallBackHandlers) { serviceBundle.addServiceWithQueueCallBackHandlers(serviceObject, queueCallBackHandlers); httpRequestServerHandler.addRestSupportFor(serviceObject.getClass(), serviceBundle.address()); return this; }
@Override public ServiceEndpointServer addServiceObjectWithQueueCallBackHandlers(final String address, final Object serviceObject, final QueueCallBackHandler... queueCallBackHandlers) { if (debug) logger.debug("registering service: " + serviceObject.getClass().getName()); serviceBundle.addServiceObjectWithQueueCallBackHandlers(address, serviceObject, queueCallBackHandlers); httpRequestServerHandler.addRestSupportFor(address, serviceObject.getClass(), serviceBundle.address()); return this; }
@Test public void testWithServiceBundle() throws Exception { final ServiceBundleBuilder serviceBundleBuilder = ServiceBundleBuilder.serviceBundleBuilder(); serviceBundleBuilder.setCallbackManager(callbackManager); final ServiceBundle serviceBundle = serviceBundleBuilder.build(); serviceBundle.addServiceObject("abc", new MyService()); final IMyService myService = serviceBundle.createLocalProxy(IMyService.class, "abc"); serviceBundle.start(); final CountDownLatch countDownLatch = new CountDownLatch(1); callbackBuilder.setCallback(Object.class, o -> { result.set(o); countDownLatch.countDown(); }); myService.method1(callbackBuilder.build()); ServiceProxyUtils.flushServiceProxy(myService); Sys.sleep(500); assertEquals(1, callbackManagerWithTimeout.outstandingCallbacksCount()); continueMethod.countDown(); countDownLatch.await(20, TimeUnit.SECONDS); assertEquals(0, callbackManagerWithTimeout.outstandingCallbacksCount()); assertEquals("METHOD 1 RETURN", result.get()); }
@Test //Works public void testWithServiceBundle() { final ServiceBundleBuilder serviceBundleBuilder = ServiceBundleBuilder.serviceBundleBuilder(); final ServiceBundle serviceBundle = serviceBundleBuilder.build().startServiceBundle(); serviceBundle.addServiceObject("foo", new FeedServiceImpl()); final FeedService feedService = serviceBundle.createLocalProxy(FeedService.class, "foo"); final Promise<List<FeedMeta>> listPromise = feedService.listFeeds().asHandler() .invokeAsBlockingPromise(Duration.ofSeconds(30)); ServiceProxyUtils.flushServiceProxy(feedService); final List<FeedMeta> feedMetas = listPromise.asHandler().get(); assertNotNull(feedMetas); assertEquals(1, feedMetas.size()); assertEquals("Hello", feedMetas.get(0).name); serviceBundle.stop(); }
@Test public void test() { serviceBundle.addService(new MockService()); proxy = serviceBundle.createLocalProxy(MockServiceInterface.class, "mockService"); serviceBundle.startReturnHandlerProcessor(); proxy.method1(); proxy.clientProxyFlush(); Sys.sleep(1000); ok = callCount == 1 || die(); }
@Test public void testResponses() throws Exception { call = MethodCallBuilder.methodCallBuilder().setAddress("/foo/adder").setName("add").setBody(Lists.list(1, 2)).build(); serviceBundle.addServiceObject("/adder", adderService); serviceBundle.call(call); serviceBundle.flushSends(); Sys.sleep(1000); responseReceiveQueue = serviceBundle.responses().receiveQueue(); serviceBundle.flush(); Sys.sleep(200); response = responseReceiveQueue.pollWait(); responseBody = response.body(); int sum = Conversions.toInt(responseBody); Assert.assertEquals("Sum should be 3", 3, sum); serviceBundle.stop(); }
@Before public void setup() { systemManager = new QBitSystemManager(); eventManager = EventManagerBuilder .eventManagerBuilder().setName("Event Bus") .build(); serviceBundleBuilder = ServiceBundleBuilder.serviceBundleBuilder() .setEventManager(eventManager) .setSystemManager(systemManager); final ServiceBundle serviceBundle = serviceBundleBuilder.buildAndStart(); serviceBundle.addServiceObject("eventManager", eventManager); serviceB = new ServiceB(); serviceBundle.addServiceObject("serviceB", serviceB); ServiceA serviceA = new ServiceA(serviceBundle.createLocalProxy(EventManager.class, "eventManager")); serviceBundle.addServiceObject("serviceA", serviceA); serviceAQueueProxy = serviceBundle.createLocalProxy(ServiceAInterface.class, "serviceA"); serviceBundle.startReturnHandlerProcessor(); }
serviceBundle.addService(myService); serviceBundle.startReturnHandlerProcessor(); final ClientInterfaceThrowsException myServiceProxy = serviceBundle.createLocalProxy( ClientInterfaceThrowsException.class, "myService"); serviceBundle.flush(); Sys.sleep(5000); serviceBundle.flush(); Sys.sleep(2000);
@Test public void callingActualService() { SomeInterface myService = new SomeInterface() { @Override public void method1() { } @Override public void method2(String hi, int amount) { } @Override public String method3(String hi, int amount) { return null; } }; final ServiceBundle bundle = new ServiceBundleBuilder().setAddress("/root").buildAndStart(); bundle.addServiceObject("myService", myService); final SomeInterface myServiceProxy = bundle.createLocalProxy(SomeInterface.class, "myService"); myServiceProxy.method2("hi", 5); Sys.sleep(1000); }
@Test //TODO fails sometimes during build but not always public void callingActualServiceWithReturn() { @RequestMapping("myService") class MyServiceClass implements SomeInterface { @Override public void method1() { } @Override public void method2(String hi, int amount) { } @Override public String method3(String hi, int amount) { return "Hi" + hi + " " + amount; } } SomeInterface myService = new MyServiceClass(); final ServiceBundle bundle = new ServiceBundleBuilder().setAddress("/root").buildAndStart(); bundle.addService(myService); final ReceiveQueue<Response<Object>> responseReceiveQueue = bundle.responses().receiveQueue(); final SomeInterface myServiceProxy = bundle.createLocalProxy( SomeInterface.class, "myService"); myServiceProxy.method3("hi", 5); bundle.flush(); Sys.sleep(1000); final Response<Object> objectResponse = responseReceiveQueue.pollWait(); objectResponse.address(); puts(objectResponse.body()); ok = "Hihi 5".equals(objectResponse.body()) || die(); }
public void stop() { try { serviceBundle.stop(); } catch (Exception ex) { if (debug) logger.debug("Unable to cleanly shutdown bundle", ex); } try { if (httpServer instanceof Stoppable) { ((Stoppable) httpServer) .stop(); } } catch (Exception ex) { if (debug) logger.debug("Unable to cleanly shutdown httpServer", ex); } if (systemManager != null) systemManager.serviceShutDown(); }
public static void main(final String... args) throws Exception { //To test locally use https://hub.docker.com/r/samuelebistoletti/docker-statsd-influxdb-grafana/ final URI statsdURI = URI.create("udp://192.168.99.100:8125"); //For timer final Reactor reactor = Reactor.reactor(); /* Create the ManagedServiceBuilder which manages a clean shutdown, health, stats, etc. */ final ManagedServiceBuilder managedServiceBuilder = ManagedServiceBuilder.managedServiceBuilder() .setRootURI("/v1") //Defaults to services .setPort(8888); //Defaults to 8080 or environment variable PORT /** Enable statsD */ enableStatsD(managedServiceBuilder, statsdURI); final StatsCollector statsCollector = managedServiceBuilder.createStatsCollector(); /** Create todo impl. */ final TodoManagerImpl impl = new TodoManagerImpl(reactor, statsCollector); /** Create service bundle for internal todo manager. */ final ServiceBundle serviceBundle = managedServiceBuilder.createServiceBundleBuilder().build(); serviceBundle.addServiceObject("todoManager", impl).startServiceBundle(); /** Create TodoManager. */ final TodoManager todoManager = serviceBundle.createLocalProxy(TodoManager.class, "todoManager"); /** Start the REST/Websocket service. */ managedServiceBuilder.addEndpointService(new TodoService(todoManager)).getEndpointServerBuilder() .build().startServer(); /* Start the admin builder which exposes health end-points and swagger meta data. */ managedServiceBuilder.getAdminBuilder().build().startServer(); System.out.println("Todo Server and Admin Server started"); }
@Test public void testWithService() { final ServiceQueue serviceQueue = serviceBuilder().setServiceObject(new MockService()).buildAndStart(); serviceBundle.addServiceQueue("mockService", serviceQueue); proxy = serviceBundle.createLocalProxy(MockServiceInterface.class, "mockService"); serviceBundle.startReturnHandlerProcessor(); proxy.method1(); proxy.clientProxyFlush(); Sys.sleep(1000); ok = callCount == 1 || die(); }
@Before public void setup() { /* test service */ testService = new TestService(); /* service bundle builder */ serviceBundleBuilder = serviceBundleBuilder(); /* service bundle */ serviceBundle = serviceBundleBuilder.build(); serviceBundle.addServiceObject("service", testService); /* vertx event bus bridge to qbit. */ vertxEventBusBridgeBuilder = VertxEventBusBridgeBuilder.vertxEventBusBridgeBuilder(); vertxEventBusBridgeBuilder.addBridgeAddress(address, TestService.class); vertxEventBusBridgeBuilder.setServiceBundle(serviceBundle); serviceBundle.start(); //startall not supported yet for bridge. vertxEventBusBridgeBuilder.build(); /* latch so we can test results coming back from bridge. */ countDownLatch = new CountDownLatch(1); /* grab vertx from the bridge. */ vertx = vertxEventBusBridgeBuilder.getVertx(); ref = new AtomicReference<>(); }
@Test public void testAllowCall() { final ServiceBundle serviceBundle = new ServiceBundleBuilder().setBeforeMethodCall(new BeforeMethodCall() { @Override public boolean before(MethodCall call) { beforeHandlerCalled = true; return true; } }).buildAndStart(); serviceBundle.addService(new MockServer()); serviceBundle.startReturnHandlerProcessor(); final MethodCall<Object> method = QBit.factory().createMethodCallByNames("callme", "mockserver", "", Collections.emptyList(), params); serviceBundle.call(method); serviceBundle.flush(); Sys.sleep(200); ok = called || die(); ok = beforeHandlerCalled || die(); }
@Before public void setup() { method = new AtomicReference<>(); event = new AtomicReference<>(); eventManager = EventManagerBuilder.eventManagerBuilder().build("localtest"); eventServiceQueue = ServiceBuilder.serviceBuilder().setServiceObject(eventManager).buildAndStartAll(); eventManager = eventServiceQueue.createProxy(EventManager.class); testServiceImpl = new TestServiceImpl(); ServiceBuilder serviceBuilder = ServiceBuilder.serviceBuilder().setEventManager(eventManager); serviceBuilder.getRequestQueueBuilder().setBatchSize(100); this.serviceQueue = serviceBuilder .setServiceObject(testServiceImpl).buildAndStart(); serviceBundle = serviceBundleBuilder().buildAndStart(); eventBusProxyCreator = QBit.factory().eventBusProxyCreator(); sender = eventBusProxyCreator.createProxy(eventManager, EventChannel1.class); serviceBundle.addServiceQueue(serviceName, this.serviceQueue); testService = serviceBundle.createLocalProxy(TestService.class, serviceName); }