public static ServiceQueue regularService(final String name, Object service) { ServiceQueueImpl serviceQueue = (ServiceQueueImpl) ServiceBuilder.serviceBuilder().setServiceAddress(name).setServiceObject(service).build(); serviceQueue.start(); return serviceQueue; } }
public LocalKeyValueStoreServiceBuilder<T> setWriteBehindAndReadFallback( final KeyValueStoreService<T> keyValueStoreServiceInternal) { final KeyValueStoreService<T> keyValueStoreService = keyValueStoreServiceInternal instanceof ClientProxy ? keyValueStoreServiceInternal : getServiceBuilder().setServiceObject(keyValueStoreServiceInternal).buildAndStartAll() .createProxy(KeyValueStoreService.class); setWriteBehind(keyValueStoreService); setReadFallback(keyValueStoreService); return this; }
this.addQueueCallbackHandler(new ServiceStatsListener(statsConfig.serviceName, statsConfig.statsCollector, getTimer(), statsConfig.flushTimeSeconds, TimeUnit.SECONDS, statsConfig.sampleEvery, serviceQueueSizer)); ServiceQueue serviceQueue = new ServiceQueueImpl(this.getRootAddress(), this.getServiceAddress(), this.getServiceObject(), this.getRequestQueueBuilder(), this.getResponseQueueBuilder(), this.getServiceMethodHandler(), this.getResponseQueue(), this.isAsyncResponse(), this.isHandleCallbacks(), this.getSystemManager(), this.getBeforeMethodCall(), this.getBeforeMethodCallAfterTransform(), this.getAfterMethodCall(), this.getAfterMethodCallAfterTransform(), buildQueueCallBackHandler(), getCallbackManager(), getBeforeMethodSent(), getEventManager(), isJoinEventManager() );
public ServiceBuilder getServiceBuilder() { if (serviceBuilder == null) { serviceBuilder = new ServiceBuilder(); return serviceBuilder; } return serviceBuilder.copy(); }
public ServiceBuilder getServiceBuilder() { if (serviceBuilder == null) { serviceBuilder = ServiceBuilder.serviceBuilder(); return serviceBuilder; } return serviceBuilder.copy(); }
public ServiceBuilder copy() { ServiceBuilder serviceBuilder = new ServiceBuilder(); serviceBuilder.setAfterMethodCall(this.getAfterMethodCall()); serviceBuilder.setBeforeMethodCall(this.getBeforeMethodCall()); serviceBuilder.setAsyncResponse(this.isAsyncResponse()); serviceBuilder.setEventManager(this.getEventManager()); serviceBuilder.setHandleCallbacks(this.handleCallbacks); serviceBuilder.setSystemManager(this.getSystemManager()); serviceBuilder.setBeforeMethodCallAfterTransform(this.getBeforeMethodCallAfterTransform()); serviceBuilder.setResponseQueueBuilder(this.getResponseQueueBuilder()); serviceBuilder.setRequestQueueBuilder(this.getRequestQueueBuilder()); return serviceBuilder; }
final ServiceBuilder serviceBuilder = ServiceBuilder.serviceBuilder() .setRootAddress(rootAddress) .setServiceObject(serviceObject) .setServiceAddress(serviceAddress) .setTimer(timer) .setResponseQueue(responseQueue) .setAsyncResponse(asyncCalls) .setInvokeDynamic(invokeDynamic) .setSystemManager(systemManager) .setRequestQueueBuilder(BeanUtils.copy(this.requestQueueBuilder)) .setRequestQueueBuilder(requestQueueBuilder) .setHandleCallbacks(false) .setCreateCallbackHandler(false) .setEventManager(eventManager) .setBeforeMethodCall(this.beforeMethodCallOnServiceQueue) .setAfterMethodCall(this.afterMethodCallOnServiceQueue); serviceBuilder.registerHealthChecks(healthService, bindStatHealthName); serviceBuilder.registerStatsCollections(bindStatHealthName, statsCollector, sampleStatFlushRate, checkTimingEveryXCalls); final ServiceQueue serviceQueue = serviceBuilder.buildAndStart();
public ServiceQueue getServiceQueue() { if (serviceQueue == null) { serviceQueue = getServiceBuilder().setServiceObject(getImplementation()).build(); } return serviceQueue; }
@Test //(expected = IllegalStateException.class) public void noOverloading() { ServiceQueue serviceQueue = ServiceBuilder.serviceBuilder().setServiceObject(new MyService()).build(); }
@Before public void setup() { systemManager = new QBitSystemManager(); eventManager = EventManagerBuilder .eventManagerBuilder().setName("Event Bus") .build(); serviceBuilder = ServiceBuilder.serviceBuilder() .setSystemManager(systemManager); eventServiceQueue = serviceBuilder.setServiceObject(eventManager).build().startServiceQueue(); serviceBuilder = ServiceBuilder.serviceBuilder() .setSystemManager(systemManager).setEventManager(eventManager); serviceB = new ServiceB(); serviceBuilder.setServiceObject(serviceB).buildAndStartAll(); serviceBuilder = ServiceBuilder.serviceBuilder() .setSystemManager(systemManager).setEventManager(eventManager); serviceA = new ServiceA(eventServiceQueue.createProxyWithAutoFlush(EventManager.class, Duration.SECOND), QBit.factory().eventBusProxyCreator()); final ServiceQueue serviceAQueue = serviceBuilder .setServiceObject(serviceA).buildAndStartAll(); serviceAQueueProxy = serviceAQueue.createProxy(ServiceAInterface.class); }
public ServiceBuilder createServiceBuilderForServiceObject(final Object serviceObject) { final ServiceBuilder serviceBuilder = ServiceBuilder.serviceBuilder(); serviceBuilder.setSystemManager(this.getSystemManager()); serviceBuilder.setEventManager(this.getEventManager()); serviceBuilder.setServiceObject(serviceObject); final String bindStatHealthName = AnnotationUtils.readServiceName(serviceObject); if (isEnableLocalHealth()) { serviceBuilder.registerHealthChecks(getHealthService(), bindStatHealthName); } configureServiceBuilderForInterceptors(serviceBuilder); if (isEnableStats()) { serviceBuilder.registerStatsCollections(bindStatHealthName, getStatServiceBuilder().buildStatsCollector(), getSampleStatFlushRate(), getCheckTimingEveryXCalls()); } return serviceBuilder; }
@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); }
@Before public void setup() { systemManager = new QBitSystemManager(); eventManager = EventManagerBuilder .eventManagerBuilder().setName("Event Bus") .build(); eventServiceQueue = ServiceBuilder.serviceBuilder().setServiceObject(eventManager).buildAndStartAll(); serviceB = new ServiceB(); serviceA = new ServiceA(eventServiceQueue.createProxy(EventManager.class)); serviceBuilder = ServiceBuilder.serviceBuilder() .setServiceObject(serviceA) .setJoinEventManager(false) .setEventManager(eventManager).setSystemManager(systemManager); final ServiceQueue serviceAQueue = serviceBuilder.buildAndStartAll(); ServiceBuilder.serviceBuilder() .setServiceObject(serviceB) .setJoinEventManager(false) .setEventManager(eventManager) .setSystemManager(systemManager) .buildAndStartAll(); serviceAQueueProxy = serviceAQueue.createProxy(ServiceAInterface.class); }
@Before public void setUp() throws Exception { serviceQueue = ServiceBuilder.serviceBuilder().setServiceObject(new FooService()).buildAndStartAll(); foo = serviceQueue.createProxy(Foo.class); }
@Override public EventManager systemEventManager() { final EventManager eventManager = eventManagerThreadLocal.get(); if (eventManager != null) { return eventManager; } EventManager proxy; if (systemEventManager.get() == null) { final ServiceQueue serviceQueue = serviceBuilder().setInvokeDynamic(false) .setServiceObject( EventManagerBuilder.eventManagerBuilder().setName("QBIT_SYSTEM").build()).build().startServiceQueue(); systemEventManager.set(serviceQueue); proxy = serviceQueue.createProxyWithAutoFlush(EventManager.class, 100, TimeUnit.MILLISECONDS); } else { proxy = systemEventManager.get().createProxyWithAutoFlush(EventManager.class, 100, TimeUnit.MILLISECONDS); } eventManagerThreadLocal.set(proxy); return proxy; }
@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); }
public ServiceQueue buildServiceQueueWithCallbackHandler() { ServiceBuilder serviceBuilder = getServiceBuilder() .setRequestQueueBuilder(getSendQueueBuilder()) .setServiceObject(getStatServiceImpl()) .setCreateCallbackHandler(true); serviceQueue = serviceBuilder.build(); if (serviceDiscovery != null) { if (eventManager != null && eventManager != QBit.factory().systemEventManager()) { eventManager.joinService(serviceQueue); } } return serviceQueue; }
@Test public void testWithServiceQueue() { final Factory factory = QBit.factory(); final ProtocolParser protocolParser = factory.createProtocolParser(); final ProtocolEncoder encoder = factory.createEncoder(); final Queue<Response<Object>> responseQueue = QueueBuilder.queueBuilder().setName("RESPONSE QUEUE TEST").build(); final ServiceBundle serviceBundle = new ServiceBundleBuilder() .setResponseQueue(responseQueue).setAddress("/services").build(); final JsonMapper mapper = factory.createJsonMapper(); httpServer = new HttpServerMock(); serviceServerImpl = new ServiceEndpointServerImpl(httpServer, encoder, protocolParser, serviceBundle, mapper, 1, 100, 30, 10, null, null, null, null, null, "localhost", 8080, 0, null, null, 50, 2, 2); callMeCounter = 0; responseCounter = 0; ServiceQueue serviceQueue = serviceBuilder() .setResponseQueue(responseQueue) .setServiceObject(new MyOtherService()).buildAndStart(); serviceServerImpl.addServiceQueue("/services/other/serviceCall", serviceQueue); serviceServerImpl.start(); final HttpRequest request = new HttpRequestBuilder().setUri("/services/other/servicecall") .setTextReceiver(new MockReceiver()).setBody("\"call\"").build(); httpServer.sendRequest(request); Sys.sleep(100); waitForTrigger(20, o -> responseCounter == 1 && callMeCounter == 1); ok |= responseCounter == 1 || die(); ok |= callMeCounter == 1 || die(); }
private void buildQueue() { final StatsDReplicator statsDReplicator = createStatsDReplicator(); final ServiceBuilder serviceBuilder = this.getServiceBuilder(); serviceBuilder.getRequestQueueBuilder().setUnableToEnqueueHandler( new UnableToEnqueueHandler() { public boolean unableToEnqueue(BlockingQueue<Object> queue, String queueName, Object item) { final Logger logger = LoggerFactory.getLogger(StatsDReplicator.class); logger.error("Unable to send method call to StatsDReplicator " + queueName); queue.clear(); return false; } } ); serviceBuilder.getResponseQueueBuilder().setUnableToEnqueueHandler(new UnableToEnqueueHandler() { public boolean unableToEnqueue(BlockingQueue<Object> queue, String queueName, Object item) { final Logger logger = LoggerFactory.getLogger(StatsDReplicator.class); logger.error("Unable to send response from method call from StatsDReplicator " + queueName); queue.clear(); return false; } }); serviceBuilder.setServiceObject(statsDReplicator); this.serviceQueue = serviceBuilder.buildAndStartAll(); }
@Before public void setup() { serviceQueue = new ServiceBuilder().setServiceObject( new MockService()).setInvokeDynamic(false).build().startServiceQueue(); proxy = serviceQueue.createProxy(MockServiceInterface.class); ok = true; }