@Test public void test() { String serviceName = "FOO-BAR-"; final String id1 = discovery1.registerWithTTL(serviceName, 7000, 30).getId(); final String id2 = discovery2.registerWithTTL(serviceName, 8000, 30).getId(); final String id3 = discovery3.registerWithTTL(serviceName, 9000, 30).getId(); for (int index = 0; index < 10; index++) { Sys.sleep(100); discovery1.checkIn(id1, HealthStatus.PASS); discovery2.checkIn(id2, HealthStatus.PASS); discovery3.checkIn(id3, HealthStatus.PASS); } Sys.sleep(100); List<EndpointDefinition> endpointDefinitions = discovery1.loadServices(serviceName); assertEquals(3, endpointDefinitions.size()); for (int index = 0; index < 10; index++) { Sys.sleep(100); discovery1.checkIn(id1, HealthStatus.PASS); discovery2.checkIn(id2, HealthStatus.FAIL); discovery3.checkIn(id3, HealthStatus.PASS); } Sys.sleep(1000); endpointDefinitions = discovery1.loadServices(serviceName); assertEquals(2, endpointDefinitions.size()); }
public static void main(String... args) { QBit.factory().systemEventManager(); final ServiceBundle serviceBundle = serviceBundleBuilder().setAddress("/root").build(); serviceBundle.start(); final UserDataServiceClient userDataServiceClient = createUserDataServiceClientProxy(serviceBundle, 8); final RecommendationServiceClient recommendationServiceClient = createRecommendationServiceClientProxy(serviceBundle, userDataServiceClient, 4); List<String> userNames = list("Bob", "Joe", "Scott", "William"); userNames.forEach( userName -> recommendationServiceClient.recommend( recommendations -> { System.out.println("Recommendations for: " + userName); recommendations.forEach( recommendation -> System.out.println("\t" + recommendation)); }, userName)); flushServiceProxy(recommendationServiceClient); Sys.sleep(1000); }
public static void main(String... args) throws Exception { final AdminBuilder adminBuilder = AdminBuilder.adminBuilder(); final ServiceEndpointServer adminServer = adminBuilder.build(); adminServer.startServer(); final HealthServiceAsync healthService = adminBuilder.getHealthService(); healthService.register("foo", 1, TimeUnit.DAYS); healthService.checkInOk("foo"); healthService.register("bar", 1, TimeUnit.DAYS); healthService.checkInOk("bar"); healthService.clientProxyFlush(); Sys.sleep(100); final HttpClient client = HttpClientBuilder.httpClientBuilder().setPort(adminBuilder.getPort()).buildAndStart(); final HttpResponse httpResponse = client.get("/services/qbit-admin/ok"); puts(httpResponse.body()); final HttpResponse httpResponsePage = client.get("/qbit/admin.html"); puts(httpResponsePage.body()); }
@Test public void test() throws Exception { final int openPortStartAt = PortUtils.findOpenPortStartAt(7777); HttpServer server = HttpServerBuilder.httpServerBuilder().setPort(openPortStartAt).build(); server.setHttpRequestConsumer( serverRequest -> { final MultiMap<String, String> headers = MultiMap.multiMap(); headers.add("foo", "bar").add("foo", "baz"); serverRequest.getReceiver().response(200, "application/json", "true", headers); }); server.startServer(); HttpClient client = HttpClientBuilder.httpClientBuilder().setPort(openPortStartAt).setHost("localhost").build(); client.start(); final HttpTextResponse httpResponse = client.get("/hi"); Sys.sleep(1000); puts(httpResponse.headers()); boolean foundFoo = httpResponse.headers().keySet().contains("foo"); assertTrue(foundFoo); }
@Test public void test() { HTTP.Response response = HTTP.jsonRestCallViaPOST( buildURL("addall"), "[{\"i\": 1, \"s\": \"string\"}, " + "{\"i\": 2, \"s\": \"string2\"}]"); assertEquals(202, response.status()); while (ref.get() == null) { Sys.sleep(10); } assertNotNull(ref.get()); }
@Test public void test() throws Exception { // docker run -d --name graphite -p 80:80 -p 2003:2003 -p 8125:8125/udp // hopsoft/graphite-statsd // https://github.com/advantageous/qbit/wiki/%5BZ-Blog%5D-StatsD-and-QBit // .setHost("192.168.59.103") System.setProperty("qbit.statsd.replicator.host", "192.168.59.103"); final StatReplicator statReplicator = StatsDReplicatorBuilder.statsDReplicatorBuilder().buildAndStart(); final Random random = new Random(); // for (int index = 0; index < 200_000; index++) { for (int index = 0; index < 10; index++) { statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountB", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountC", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountD", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountE", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountF", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountH", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountI", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountJ", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountK", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountL", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountM", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountN", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountO", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountP", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountQ", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountR", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountS", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountT", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCountU", index + 1, -1); statReplicator.replicateCount("StatsDReplicatorBuilderTest.replicateCount", index + 1, -1); statReplicator.replicateLevel( "StatsDReplicatorBuilderTest.replicateLevel", index + 1 * 100, -1); int duration = (int) (400 * random.nextFloat()) + 200; statReplicator.replicateTiming("StatsDReplicatorBuilderTest.replicateTiming", duration, -1); statReplicator.flush(); Sys.sleep(1000); } Sys.sleep(1000); }
public static void main(String... args) { String host = args.length > 0 ? args[0] : "localhost"; int port = args.length > 1 ? Integer.parseInt(args[1]) : 6060; List<Thread> threads = new ArrayList<>(); final long start = System.currentTimeMillis(); for (int numThreads = 0; numThreads < 20; numThreads++) { Sys.sleep((33 * numThreads) + 1); final Client client = new ClientBuilder().setPort(port).setHost(host).setProtocolBatchSize(1_000).build(); client.start(); Thread thread = new Thread( new Runnable() { final SimpleServiceProxy myService = client.createProxy(SimpleServiceProxy.class, "myServiceQBit"); @Override public void run() { for (int index = 0; index < 10_000_000; index++) { if (index % 1000 == 0) { sentCount += 1000; } final int findex = index; myService.ping( new Callback<List<String>>() { @Override public void accept(List<String> strings) { if (findex % 1000 == 0) { count += 1000; } } }); if (index % 333_000 == 0) { Sys.sleep(333); } if (index % 100_000 == 0) { for (int i = 0; i < 100; i++) { if (count < (sentCount - 99_000)) { Sys.sleep(111 * (index % 9)); } } } } } }); threads.add(thread); thread.start(); } loop: for (int x = 0; x < 10000; x++) { Sys.sleep(1000); if (count > 100_000_000) { break loop; } long now = System.currentTimeMillis(); long c = count; long rate = (c / (now - start)) * 1000; System.out.println(rate + " " + c + " " + rate * 2); } System.out.println("Done"); }
public static void main(String... args) throws Exception { final BrokerService broker; // JMS Broker to make this a self contained example. final int port; // port to bind to JMS Broker to /* ******************************************************************************/ /* START JMS BROKER. ************************************************************/ /* Start up JMS Broker. */ port = PortUtils.findOpenPortStartAt(4000); broker = new BrokerService(); broker.addConnector("tcp://localhost:" + port); broker.start(); Sys.sleep(5_000); /* ******************************************************************************/ /* START JMS CLIENTS FOR SERVER A AND B *******************************************/ /* Create a JMS Builder to create JMS Queues. */ final JmsServiceBuilder jmsBuilder = JmsServiceBuilder.newJmsServiceBuilder() .setPort(port) .setDefaultDestination(NEW_HIRE_CHANNEL) .setAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE); /* JMS client for server A. */ final JsonQueue<Employee> employeeJsonQueueServerA = new JsonQueue<>(Employee.class, new JmsTextQueue(jmsBuilder)); /* JMS client for server B. */ final JsonQueue<Employee> employeeJsonQueueServerB = new JsonQueue<>(Employee.class, new JmsTextQueue(jmsBuilder)); /* Send Queue to send messages to JMS broker. */ final SendQueue<Employee> sendQueueA = employeeJsonQueueServerA.sendQueue(); Sys.sleep(1_000); /* ReceiveQueueB Queue B to receive messages from JMS broker. */ final ReceiveQueue<Employee> receiveQueueB = employeeJsonQueueServerB.receiveQueue(); Sys.sleep(1_000); /* ******************************************************************************/ /* START EVENT BUS A ************************************************************/ /* Create you own private event bus for Server A. */ final EventManager privateEventBusServerAInternal = EventManagerBuilder.eventManagerBuilder() .setEventConnector( new EventConnector() { @Override public void forwardEvent(EventTransferObject<Object> event) { if (event.channel().equals(NEW_HIRE_CHANNEL)) { System.out.println(event); final Object body = event.body(); final Object[] bodyArray = ((Object[]) body); final Employee employee = (Employee) bodyArray[0]; System.out.println(employee); sendQueueA.sendAndFlush(employee); } } }) .setName("serverAEventBus") .build(); /* Create a service queue for this event bus. */ final ServiceQueue privateEventBusServiceQueueA = serviceBuilder() .setServiceObject(privateEventBusServerAInternal) .setInvokeDynamic(false) .build(); final EventManager privateEventBusServerA = privateEventBusServiceQueueA.createProxyWithAutoFlush( EventManager.class, 50, TimeUnit.MILLISECONDS); /* Create you own private event bus for Server B. */ final EventManager privateEventBusServerBInternal = EventManagerBuilder.eventManagerBuilder() .setEventConnector( new EventConnector() { @Override public void forwardEvent(EventTransferObject<Object> event) { System.out.println(event); final Object body = event.body(); final Object[] bodyArray = ((Object[]) body); final Employee employee = (Employee) bodyArray[0]; System.out.println(employee); sendQueueA.sendAndFlush(employee); } }) .setName("serverBEventBus") .build(); /* Create a service queue for this event bus. */ final ServiceQueue privateEventBusServiceQueueB = serviceBuilder() .setServiceObject(privateEventBusServerBInternal) .setInvokeDynamic(false) .build(); final EventManager privateEventBusServerB = privateEventBusServiceQueueB.createProxyWithAutoFlush( EventManager.class, 50, TimeUnit.MILLISECONDS); final EventBusProxyCreator eventBusProxyCreator = QBit.factory().eventBusProxyCreator(); final EmployeeEventManager employeeEventManagerA = eventBusProxyCreator.createProxy(privateEventBusServerA, EmployeeEventManager.class); final EmployeeEventManager employeeEventManagerB = eventBusProxyCreator.createProxy(privateEventBusServerB, EmployeeEventManager.class); // This did not work. Not sure why? // /* ******************************************************************************/ // /* LISTEN TO JMS CLIENT B and FORWARD to Event bus. **********************/ // /* Listen to JMS client and push to B event bus ****************************/ // employeeJsonQueueServerB.startListener(new ReceiveQueueListener<Employee>(){ // @Override // public void receive(final Employee employee) { // System.out.println("HERE " + employee); // employeeEventManagerB.sendNewEmployee(employee); // System.out.println("LEFT " + employee); // // } // }); final PeriodicScheduler periodicScheduler = QBit.factory().createPeriodicScheduler(1); periodicScheduler.repeat( new Runnable() { @Override public void run() { final Employee employee = receiveQueueB.pollWait(); if (employee != null) { employeeEventManagerB.sendNewEmployee(employee); } } }, 50, TimeUnit.MILLISECONDS); final SalaryChangedChannel salaryChangedChannel = eventBusProxyCreator.createProxy(privateEventBusServerA, SalaryChangedChannel.class); /* Create your EmployeeHiringService but this time pass the private event bus. Note you could easily use Spring or Guice for this wiring. */ final EmployeeHiringService employeeHiring = new EmployeeHiringService(employeeEventManagerA, salaryChangedChannel); // Runs on Server A /* Now create your other service POJOs which have no compile time dependencies on QBit. */ final PayrollService payroll = new PayrollService(); // Runs on Server A final BenefitsService benefits = new BenefitsService(); // Runs on Server A final VolunteerService volunteering = new VolunteerService(); // Runs on Server B /** Employee hiring service. A. */ ServiceQueue employeeHiringServiceQueue = serviceBuilder().setServiceObject(employeeHiring).setInvokeDynamic(false).build(); /** Payroll service A. */ ServiceQueue payrollServiceQueue = serviceBuilder().setServiceObject(payroll).setInvokeDynamic(false).build(); /** Employee Benefits service. A. */ ServiceQueue employeeBenefitsServiceQueue = serviceBuilder().setServiceObject(benefits).setInvokeDynamic(false).build(); /** Community outreach program. B. */ ServiceQueue volunteeringServiceQueue = serviceBuilder().setServiceObject(volunteering).setInvokeDynamic(false).build(); /* Now wire in the event bus so it can fire events into the service queues. * For ServerA. */ privateEventBusServerA.joinService(payrollServiceQueue); privateEventBusServerA.joinService(employeeBenefitsServiceQueue); /* Now wire in event B bus. */ privateEventBusServerB.joinService(volunteeringServiceQueue); /* Start Server A bus. */ privateEventBusServiceQueueA.start(); /* Start Server B bus. */ privateEventBusServiceQueueB.start(); employeeHiringServiceQueue.start(); volunteeringServiceQueue.start(); payrollServiceQueue.start(); employeeBenefitsServiceQueue.start(); /** Now create the service proxy like before. */ EmployeeHiringServiceClient employeeHiringServiceClientProxy = employeeHiringServiceQueue.createProxy(EmployeeHiringServiceClient.class); /** Call the hireEmployee method which triggers the other events. */ employeeHiringServiceClientProxy.hireEmployee(new Employee("Lucas", 1)); flushServiceProxy(employeeHiringServiceClientProxy); Sys.sleep(5_000); }
private static void run( int runs, int tradeCount, final int batchSize, int checkEvery, int numThreads, boolean forceLinkTransferQueue, int subscriberCount) throws InterruptedException { final QueueBuilder queueBuilder = QueueBuilder.queueBuilder().setName("trades").setBatchSize(batchSize).setSize(1_000_000); if (checkEvery > 0 || forceLinkTransferQueue) { queueBuilder.setLinkTransferQueue(); queueBuilder.setCheckEvery(checkEvery); } final Queue<Trade> queue = queueBuilder.build(); final AtomicLong tradeCounterReceived = new AtomicLong(); final AtomicLong tradeCounterSent = new AtomicLong(); final int totalTradeCount = tradeCount * numThreads; final QueueToStreamRoundRobin<Trade> stream = new QueueToStreamRoundRobin<>(queue); for (int s = 0; s < subscriberCount; s++) { stream.subscribe( new Subscriber<Trade>() { int count = batchSize / subscriberCount; Subscription subscription; @Override public void onSubscribe(Subscription s) { subscription = s; s.request(count); } @Override public void onNext(Trade trade) { tradeCounterReceived.incrementAndGet(); trade.getName(); trade.getAmount(); count--; if (count == 0) { count = batchSize / subscriberCount; subscription.request(count); } } @Override public void onError(Throwable t) {} @Override public void onComplete() {} }); } final long startRun = System.currentTimeMillis(); for (int r = 0; r < runs; r++) { List<Thread> threads = new ArrayList<>(numThreads); tradeCounterReceived.set(0L); tradeCounterSent.set(0L); for (int t = 0; t < numThreads; t++) { Thread thread = new Thread( () -> { sendMessages(tradeCount, queue); }); thread.start(); threads.add(thread); } for (int index = 0; index < 100000; index++) { Sys.sleep(10); if (tradeCounterReceived.get() >= totalTradeCount) { break; } } } System.out.printf( "DONE PUB traded %,d in %d batchSize = %,d, checkEvery = %,d, threads=%d\n", tradeCount * runs * numThreads, System.currentTimeMillis() - startRun, batchSize, checkEvery, numThreads); queue.stop(); }