/** * 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); }
@Test public void testProxySimpleTwoArg() { final SomeInterface myService = serviceBundle.createLocalProxy(SomeInterface.class, "myService"); calls.clear(); myService.method2("Hello", 5); }
@Test public void testProxySimpleNoArg() { final SomeInterface myService = serviceBundle.createLocalProxy(SomeInterface.class, "myService"); myService.method1(); }
@Test public void testWithReturn() { final MultiWorkerClient worker = bundle.createLocalProxy(MultiWorkerClient.class, "/workers"); final AtomicInteger callbackCounter = new AtomicInteger(); for (int index = 0; index < 200; index++) { worker.doSomeWork2(integer -> callbackCounter.incrementAndGet()); } ServiceProxyUtils.flushServiceProxy(worker); super.waitForTrigger(30, o -> callbackCounter.get() >= 200); assertEquals(200, callbackCounter.get()); }
@Test public void testWithReturns() { final MultiWorkerClient worker = bundle.createLocalProxy(MultiWorkerClient.class, "/workers"); final AtomicReference<String> value = new AtomicReference<>(); final AtomicLong callbackCount = new AtomicLong(); for (int index = 0; index < 200; index++) { worker.pickSuggestions2(new Callback<String>() { @Override public void accept(String s) { callbackCount.incrementAndGet(); value.set(s); } }, "rickhigh" + index); } worker.clientProxyFlush(); Sys.sleep(1000); super.waitForTrigger(10, o -> callbackCount.get() >= 200); assertEquals(200, callbackCount.get()); }
@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"); }
@Test public void testProxySimpleServiceBundle() { final SomeInterface myService = serviceBundle.createLocalProxy(SomeInterface.class, "myService"); calls.clear(); myService.method2("Hello", 5); boolean found = false; for (MethodCall<Object> call : calls) { if (call.name().equals("method2")) { final Object body = call.body(); puts(body); ok = body != null || die(); ok = body.getClass().isArray() || die(); ok = body.getClass().equals(Object[].class); Object[] args = (Object[]) body; String arg1 = (String) args[0]; ok = arg1.equals("Hello") || die(); int i = (int) args[1]; ok = i == 5 || die(); found = true; } } ok = found || die(); }
@Test public void testCallback() throws Exception { serviceBundle.addService(new MockService()); proxy = serviceBundle.createLocalProxy(MockServiceInterface.class, "mockService"); serviceBundle.startReturnHandlerProcessor(); AtomicInteger returnValue = new AtomicInteger(); proxy.method2(integer -> { returnValue.set(integer); }); proxy.clientProxyFlush(); Sys.sleep(1000); ok = callCount == 1 || die(); ok = returnValue.get() == 1 || die(returnValue.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 testCallbackWithCallBackInService() throws Exception { serviceBundle.addService(new MockService()); proxy = serviceBundle.createLocalProxy(MockServiceInterface.class, "mockService"); serviceBundle.startReturnHandlerProcessor(); AtomicReference<String> str = new AtomicReference<>(); AtomicInteger returnValue = new AtomicInteger(); proxy.methodWithCallBack(new Callback<String>() { @Override public void accept(String s) { str.set(s); } }); proxy.clientProxyFlush(); Sys.sleep(1000); ok = callCount == 1 || die(); ok = str.get().equals("hello") || die(); }
@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 public void test() { final MultiWorkerClient worker = bundle.createLocalProxy(MultiWorkerClient.class, "/workers"); for (int index = 0; index < 200; index++) { worker.doSomeWork(); } Sys.sleep(100); ServiceProxyUtils.flushServiceProxy(worker); Sys.sleep(100); ServiceProxyUtils.flushServiceProxy(worker); super.waitForTrigger(30, o -> MultiWorker.totalCount >= 90); ok = MultiWorker.totalCount >= 90 || die(MultiWorker.totalCount); }
@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(); }
@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(); }
@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); }
@Before public void before() { latch = new CountDownLatch(1); returnValue = new AtomicReference<>(); errorRef = new AtomicReference<>(); impl = new ServiceDiscoveryImpl(); empURI = URI.create("marathon://default/employeeService?env=staging"); ServiceBuilder serviceBuilder = ServiceBuilder.serviceBuilder(); serviceBuilder.getRequestQueueBuilder().setArrayBlockingQueue().setBatchSize(10); serviceQueue = serviceBuilder.setServiceObject(impl).buildAndStartAll(); ServiceBundleBuilder serviceBundleBuilder = ServiceBundleBuilder.serviceBundleBuilder(); serviceBundleBuilder.getRequestQueueBuilder().setArrayBlockingQueue().setBatchSize(10); serviceBundle = serviceBundleBuilder.build(); serviceBundle.addServiceObject("myservice", impl); serviceQueue2 = ServiceBuilder.serviceBuilder().setInvokeDynamic(false).setServiceObject(impl) .buildAndStartAll(); serviceDiscoveryServiceBundle = serviceBundle.createLocalProxy(ServiceDiscovery.class, "myservice"); serviceBundle.start(); serviceDiscovery = serviceQueue.createProxyWithAutoFlush(ServiceDiscovery.class, Duration.TEN_MILLIS); serviceDiscoveryStrongTyped = serviceQueue2.createProxyWithAutoFlush(ServiceDiscovery.class, Duration.TEN_MILLIS); }
@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(); }
public static void main(String... args) { ServiceEndpointServer server = startStatService(11500); final ServiceBundle serviceBundle = server.serviceBundle(); final StatService statService = serviceBundle.createLocalProxy(StatService.class, "stat-service"); for (int index = 0; index < 100; index++) { statService.recordCount("abc.count", index); statService.recordLevel("abc.level", index); Sys.sleep(1000); serviceBundle.flushSends(); statService.lastTenSecondCount(new Callback<Long>() { @Override public void accept(Long integer) { puts("Last ten second count for abc.count", integer); } }, "abc.count"); statService.averageLastLevel(new Callback<Long>() { @Override public void accept(Long integer) { puts("Average level second count for abc.level", integer); } }, "abc.level", 10); } }
@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); }
@Test public void testIntegrationWithServiceBundle() throws Exception { mdcForHttpRequestInterceptor = new SetupMdcForHttpRequestInterceptor(Sets.set("foo")); final CaptureRequestInterceptor captureRequestInterceptor = new CaptureRequestInterceptor(); captureRequestInterceptor.before(methodCallBuilder.setName("restMethod").setOriginatingRequest(httpRequest).build()); final ServiceBundle serviceBundle = ServiceBundleBuilder.serviceBundleBuilder() .setBeforeMethodCallOnServiceQueue(BeforeMethodCallChain.beforeMethodCallChain(captureRequestInterceptor, mdcForHttpRequestInterceptor)) .setAfterMethodCallOnServiceQueue(AfterMethodCallChain.afterMethodCallChain(captureRequestInterceptor, mdcForHttpRequestInterceptor)) .setBeforeMethodSent(new ForwardCallMethodInterceptor(new RequestContext())).build().startServiceBundle(); serviceBundle.addServiceObject("my", new MyServiceImpl()); final MyService localProxy = serviceBundle.createLocalProxy(MyService.class, "my"); final AsyncFutureCallback<String> callback = AsyncFutureBuilder.asyncFutureBuilder().build(String.class); localProxy.getRequestURI(callback); localProxy.clientProxyFlush(); assertEquals("/foo", callback.get()); final AsyncFutureCallback<Map<String, String>> callbackMap = AsyncFutureBuilder.asyncFutureBuilder() .buildMap(String.class, String.class); localProxy.getMDC(callbackMap); localProxy.clientProxyFlush(); validate(callbackMap.get()); captureRequestInterceptor.after(null, null); serviceBundle.stop(); }