@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();
}
