Recent changes to BaseHttpMicroServicesVerticle

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Wed, 25 Apr 2018 02:03:43 -0000

--- v10
+++ v11
@@ -5,8 +5,11 @@
 import io.vertx.core.Handler;
 import io.vertx.core.http.HttpMethod;
 import io.vertx.core.json.JsonObject;
+import io.vertx.reactivex.RxHelper;
 import io.vertx.reactivex.core.Future;
 import io.vertx.reactivex.core.buffer.Buffer;
+import io.vertx.reactivex.core.http.HttpServer;
+import io.vertx.reactivex.core.http.HttpServerRequest;
 import io.vertx.reactivex.ext.web.Router;
 import io.vertx.reactivex.ext.web.RoutingContext;
 import io.vertx.reactivex.ext.web.client.HttpRequest;
@@ -20,6 +23,7 @@
 import java.util.HashSet;
 import java.util.Set;

+import static com.ezshop.common.ConfigKeys.KEY_PORT;
 import static com.ezshop.common.ErrorCodes.SYSTEM_ERROR_CODE;
 import static com.ezshop.common.HttpResponseCodes.SC_INTERNAL_SERVER_ERROR;
 import static com.ezshop.common.HttpResponseCodes.SC_OK;
@@ -34,6 +38,28 @@
     private static final String KEY_ERROR = "error";
     private static final String KEY_ERROR_CODE = "errorCode";
     private static final String KEY_ERROR_MESSAGE = "errorMessage";
+
+    /**
+     * Create a HTTP server by given config and router
+     *
+     * @param config HTTP config
+     * @param router the router receives HTTP request
+     * @return
+     */
+    protected Single<HttpServer> createHttpServer(JsonObject config, Router router) {
+        int port = config.getInteger(KEY_PORT);
+        HttpServer server = vertx.createHttpServer();
+        server.requestStream()
+                .toFlowable()
+                .map(HttpServerRequest::pause)
+                .onBackpressureDrop(req -> req.response().setStatusCode(503).end())
+                .observeOn(RxHelper.scheduler(vertx.getDelegate()))
+                .subscribe(req -> {
+                    req.resume();
+                    router.accept(req);
+                });
+        return server.rxListen(port).doAfterSuccess(s -> logger.debug("http server started on port {}", port));
+    }

     /**
      * Enable CORS

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Tue, 24 Apr 2018 20:15:40 -0000

--- v9
+++ v10
@@ -4,6 +4,7 @@
 import io.reactivex.Single;
 import io.vertx.core.Handler;
 import io.vertx.core.http.HttpMethod;
+import io.vertx.core.json.JsonObject;
 import io.vertx.reactivex.core.Future;
 import io.vertx.reactivex.core.buffer.Buffer;
 import io.vertx.reactivex.ext.web.Router;
@@ -19,6 +20,10 @@
 import java.util.HashSet;
 import java.util.Set;

+import static com.ezshop.common.ErrorCodes.SYSTEM_ERROR_CODE;
+import static com.ezshop.common.HttpResponseCodes.SC_INTERNAL_SERVER_ERROR;
+import static com.ezshop.common.HttpResponseCodes.SC_OK;
+
 /**
  * The abstract verticle which work as HTTP server
  *
@@ -26,6 +31,9 @@
  */
 public abstract class BaseHttpMicroServicesVerticle extends BaseMicroServicesVerticle {
     private static final Logger logger = LoggerFactory.getLogger(BaseMicroServicesVerticle.class);
+    private static final String KEY_ERROR = "error";
+    private static final String KEY_ERROR_CODE = "errorCode";
+    private static final String KEY_ERROR_MESSAGE = "errorMessage";

     /**
      * Enable CORS
@@ -46,11 +54,50 @@
     }

     /**
+     * Write generic json object to HTTP response
+     *
+     * @param context
+     * @param jsonString the json context to be wrote to HTTP response
+     */
+    protected void restResponseHandler(RoutingContext context, String jsonString) {
+        if (!context.response().ended()) {
+            context.response().setStatusCode(SC_OK).putHeader("content-type", "application/json")
+                    .end(jsonString);
+        }
+    }
+
+    /**
+     * Generate Rest error response by given exception
+     *
+     * @param context
+     * @param throwable
+     */
+    protected void restErrorHandler(RoutingContext context, Throwable throwable) {
+        this.restErrorHandler(context, SC_INTERNAL_SERVER_ERROR, SYSTEM_ERROR_CODE, throwable.getMessage());
+    }
+
+    /**
+     * Generate Rest error response by given statusCode, errorCode and error message
+     *
+     * @param context
+     * @param statusCode   the HTTP response status code
+     * @param errorCode    the error code
+     * @param errorMessage the error message
+     */
+    protected void restErrorHandler(RoutingContext context, int statusCode, String errorCode, String errorMessage) {
+        if (!context.response().ended()) {
+            JsonObject json = new JsonObject().put(KEY_ERROR, new JsonObject().put(KEY_ERROR_CODE, errorCode).put(KEY_ERROR_MESSAGE, errorMessage));
+            context.response().setStatusCode(statusCode).putHeader("content-type", "application/json")
+                    .end(json.encodePrettily());
+        }
+    }
+
+    /**
      * Dispatch a HTTP request to a HttpEndPoint service
      *
-     * @param context Routing context
-     * @param serviceName the name of service
-     * @param uri the uri at HttpEndPoint service
+     * @param context      Routing context
+     * @param serviceName  the name of service
+     * @param uri          the uri at HttpEndPoint service
      * @param errorHandler the async error handler
      */
     protected void dispatchRequest(RoutingContext context, String serviceName, String uri, Handler errorHandler) {
@@ -60,7 +107,7 @@
                 .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
     }

-    protected void dispatchRequestHandler(RoutingContext context, String serviceName, String uri, Future<Void> future) {
+    private void dispatchRequestHandler(RoutingContext context, String serviceName, String uri, Future<Void> future) {
         this.getWebEndPoint(serviceName)
                 .subscribe(webClient -> invokeDispatchHttpRequest(context, webClient, uri, future),
                         throwable -> future.fail("Service [" + serviceName + "] not published"));

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Tue, 24 Apr 2018 01:59:15 -0000

--- v8
+++ v9
@@ -1,5 +1,5 @@
 ~~~
-package com.example.microservices.com;
+package com.ezshop.common;

 import io.reactivex.Single;
 import io.vertx.core.Handler;
@@ -45,22 +45,30 @@
         router.route().handler(corsHandler);
     }

-    protected void dispatchRequest(RoutingContext context, String serviceName, Handler errorHandler) {
-        logger.debug("Dispatch Http Request {} to service {}", context.request().uri(), serviceName);
+    /**
+     * Dispatch a HTTP request to a HttpEndPoint service
+     *
+     * @param context Routing context
+     * @param serviceName the name of service
+     * @param uri the uri at HttpEndPoint service
+     * @param errorHandler the async error handler
+     */
+    protected void dispatchRequest(RoutingContext context, String serviceName, String uri, Handler errorHandler) {
+        logger.debug("Dispatch Http Request {} to {} service", uri, serviceName);
         this.getCircuitBreaker(serviceName).<Void>rxExecuteCommand(
-                future -> this.dispatchRequestHandler(context, serviceName, future))
+                future -> this.dispatchRequestHandler(context, serviceName, uri, future))
                 .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
     }

-    protected void dispatchRequestHandler(RoutingContext context, String serviceName, Future<Void> future) {
+    protected void dispatchRequestHandler(RoutingContext context, String serviceName, String uri, Future<Void> future) {
         this.getWebEndPoint(serviceName)
-                .subscribe(webClient -> invokeDispatchHttpRequest(context, webClient, future),
+                .subscribe(webClient -> invokeDispatchHttpRequest(context, webClient, uri, future),
                         throwable -> future.fail("Service [" + serviceName + "] not published"));
     }

-    private void invokeDispatchHttpRequest(RoutingContext context, WebClient webClient, Future<Void> future) {
-        logger.debug("invokeDispatchHttpRequest, uri:{}", context.request().uri());
-        HttpRequest<Buffer> httpRequest = webClient.request(context.request().method(), context.request().uri());
+    private void invokeDispatchHttpRequest(RoutingContext context, WebClient webClient, String uri, Future<Void> future) {
+        logger.debug("invokeDispatchHttpRequest, uri:{}", uri);
+        HttpRequest<Buffer> httpRequest = webClient.request(context.request().method(), uri);
         context.request().headers().getDelegate().forEach(header -> httpRequest.putHeader(header.getKey(), header.getValue()));
         if (context.user() != null) {
             httpRequest.putHeader("user-principal", context.user().principal().encode());

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Wed, 18 Apr 2018 01:46:57 -0000

--- v7
+++ v8
@@ -2,245 +2,85 @@
 package com.example.microservices.com;

 import io.reactivex.Single;
-import io.vertx.circuitbreaker.CircuitBreakerOptions;
+import io.vertx.core.Handler;
 import io.vertx.core.http.HttpMethod;
-import io.vertx.core.json.JsonObject;
-import io.vertx.reactivex.circuitbreaker.CircuitBreaker;
-import io.vertx.reactivex.core.AbstractVerticle;
+import io.vertx.reactivex.core.Future;
 import io.vertx.reactivex.core.buffer.Buffer;
-import io.vertx.reactivex.core.http.HttpClient;
+import io.vertx.reactivex.ext.web.Router;
+import io.vertx.reactivex.ext.web.RoutingContext;
 import io.vertx.reactivex.ext.web.client.HttpRequest;
 import io.vertx.reactivex.ext.web.client.HttpResponse;
 import io.vertx.reactivex.ext.web.client.WebClient;
-import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
-import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
-import io.vertx.servicediscovery.Record;
-import io.vertx.servicediscovery.ServiceDiscoveryOptions;
+import io.vertx.reactivex.ext.web.handler.CorsHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;

 /**
- * The base verticle class which provided some common functions include service discovery
+ * The abstract verticle which work as HTTP server
  *
  * @author Gary Cheng
  */
-public abstract class BaseMicroServicesVerticle extends AbstractVerticle {
-    protected static final String KEY_SERVICE_NAME = "service.name";
-    protected static final String KEY_HOST = "host";
-    protected static final String KEY_PORT = "port";
-    protected static final String KEY_ROOT = "root";
-    protected static final String KEY_NAME = "name";
-
+public abstract class BaseHttpMicroServicesVerticle extends BaseMicroServicesVerticle {
     private static final Logger logger = LoggerFactory.getLogger(BaseMicroServicesVerticle.class);

-    protected ServiceDiscovery discovery;
-    private Record publishedRecord;
-    private Map<String, CircuitBreaker=""> circuitBreakerMap = new ConcurrentHashMap<>();
-    private Map<String, Object=""> serviceEndPointMap = new ConcurrentHashMap<>();
+    /**
+     * Enable CORS
+     *
+     * @param router
+     */
+    protected void enableCorsSupport(Router router) {
+        Set<String> allowedHeaders = new HashSet<>();
+        allowedHeaders.add("x-requested-with");
+        allowedHeaders.add("Access-Control-Allow-Origin");
+        allowedHeaders.add("origin");
+        allowedHeaders.add("Content-Type");
+        allowedHeaders.add("accept");

-    @Override
-    public void start() {
-        logger.debug("Starting verticle - {}", this.getClass().getName());
-        logger.debug("Config:{}", this.config().encodePrettily());
-        this.discovery = ServiceDiscovery.create(vertx, new ServiceDiscoveryOptions().setBackendConfiguration(this.getServiceDiscoveryConfig()));
+        CorsHandler corsHandler = CorsHandler.create("*").allowedHeaders(allowedHeaders);
+        Arrays.asList(HttpMethod.values()).stream().forEach(method -> corsHandler.allowedMethod(method));
+        router.route().handler(corsHandler);
     }

-    @Override
-    public void stop() {
-        logger.debug("Stopping verticle - {}", this.getClass().getName());
-        this.serviceEndPointMap.keySet().stream().forEach(serviceName -> this.closeCachedEndPoint(serviceName));
-        this.serviceEndPointMap.clear();
-        this.circuitBreakerMap.values().stream().forEach(circuitBreaker -> circuitBreaker.close());
-        this.circuitBreakerMap.clear();
-        this.unpublishRecord().subscribe(b -> discovery.close());
+    protected void dispatchRequest(RoutingContext context, String serviceName, Handler errorHandler) {
+        logger.debug("Dispatch Http Request {} to service {}", context.request().uri(), serviceName);
+        this.getCircuitBreaker(serviceName).<Void>rxExecuteCommand(
+                future -> this.dispatchRequestHandler(context, serviceName, future))
+                .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
     }

-    /**
-     * Return Service discovery configure, the default implementation store them in verticle's config()
-     *
-     * @return Service discovery configure
-     */
-    protected JsonObject getServiceDiscoveryConfig() {
-        return this.config();
+    protected void dispatchRequestHandler(RoutingContext context, String serviceName, Future<Void> future) {
+        this.getWebEndPoint(serviceName)
+                .subscribe(webClient -> invokeDispatchHttpRequest(context, webClient, future),
+                        throwable -> future.fail("Service [" + serviceName + "] not published"));
     }

-    /**
-     * Return circuit breaker of service by service name
-     *
-     * @param serviceName the name of service
-     * @return circuit breaker of service
-     */
-    protected final CircuitBreaker getCircuitBreaker(String serviceName) {
-        logger.debug("Get CircuitBreaker of service {}", serviceName);
-        CircuitBreaker circuitBreaker = circuitBreakerMap.get(serviceName);
-        if (null == circuitBreaker) {
-            circuitBreaker = this.createCircuitBreaker(serviceName);
-            this.circuitBreakerMap.put(serviceName, circuitBreaker);
+    private void invokeDispatchHttpRequest(RoutingContext context, WebClient webClient, Future<Void> future) {
+        logger.debug("invokeDispatchHttpRequest, uri:{}", context.request().uri());
+        HttpRequest<Buffer> httpRequest = webClient.request(context.request().method(), context.request().uri());
+        context.request().headers().getDelegate().forEach(header -> httpRequest.putHeader(header.getKey(), header.getValue()));
+        if (context.user() != null) {
+            httpRequest.putHeader("user-principal", context.user().principal().encode());
         }
-        return circuitBreaker;
-    }
-
-    /**
-     * Create circuit breaker for service
-     *
-     * @param serviceName the name of service
-     * @return circuit breaker of service
-     */
-    protected CircuitBreaker createCircuitBreaker(String serviceName) {
-        logger.debug("Create CircuitBreaker for service {}", serviceName);
-        String circuitBreakerName = serviceName + "-" + "circuit-breaker";
-        CircuitBreakerOptions options = new CircuitBreakerOptions()
-                .setMaxFailures(5)
-                .setTimeout(5000)
-                .setResetTimeout(10000)
-                .setFallbackOnFailure(true);
-        return CircuitBreaker.create(circuitBreakerName, vertx, options)
-                .openHandler(v -> {
-                    logger.debug("{} opened", circuitBreakerName);
-                    this.closeCachedEndPoint(serviceName);
-                })
-                .halfOpenHandler(v -> logger.debug("{} half opened", circuitBreakerName))
-                .closeHandler(v -> logger.debug("{} closed", circuitBreakerName));
-    }
-
-    /**
-     * Return an async HttpClient by service name
-     *
-     * @param serviceName the name of service
-     * @return
-     */
-    protected final Single<HttpClient> getHttpEndPoint(String serviceName) {
-        logger.debug("Get HTTP client by service name[{}]", serviceName);
-        Object endPoint = this.serviceEndPointMap.get(serviceName);
-        if (null != endPoint && endPoint instanceof HttpClient) {
-            return Single.just((HttpClient) endPoint);
+        Single<HttpResponse<Buffer>> result;
+        if (null != context.request().formAttributes() && !context.request().formAttributes().isEmpty()) {
+            result = httpRequest.rxSendForm(context.request().formAttributes());
+        } else if (null != context.getBody()) {
+            result = httpRequest.rxSendBuffer(context.getBody());
         } else {
-            return HttpEndpoint.rxGetClient(discovery, new JsonObject().put(KEY_NAME, serviceName))
-                    .doOnSuccess(httpClient -> this.serviceEndPointMap.put(serviceName, httpClient));
+            result = httpRequest.rxSend();
         }
-    }
-
-    /**
-     * Return an async HttpClient by service name
-     *
-     * @param serviceName the name of service
-     * @return
-     */
-    protected final Single<WebClient> getWebEndPoint(String serviceName) {
-        logger.debug("Get Web client by service name[{}]", serviceName);
-        Object endPoint = this.serviceEndPointMap.get(serviceName);
-        if (null != endPoint && endPoint instanceof WebClient) {
-            return Single.just((WebClient) endPoint);
-        } else {
-            logger.debug("Getting Web client from ServiceDiscovery...");
-            return HttpEndpoint.rxGetWebClient(discovery, new JsonObject().put(KEY_NAME, serviceName))
-                    .doOnSuccess(webClient -> this.serviceEndPointMap.put(serviceName, webClient));
-        }
-    }
-
-    /**
-     * Publish a HttpEndPoint service to ServiceDiscovery
-     *
-     * @param config the configure of HttpEndPoint
-     * @return
-     */
-    protected final Single<Record> publishHttpEndPoint(JsonObject config) {
-        String serviceName = config.getString(KEY_SERVICE_NAME);
-        String host = config.getString(KEY_HOST, "localhost");
-        Integer port = config.getInteger(KEY_PORT, 8080);
-        String root = config.getString(KEY_ROOT, "/");
-        return this.publishRecord(HttpEndpoint.createRecord(serviceName, host, port, root));
-    }
-
-    /**
-     * Publish a service record to ServiceDiscovery
-     *
-     * @param record record to publish
-     * @return
-     */
-    protected Single<Record> publishRecord(Record record) {
-        return this.unpublishRecord()
-                .flatMap(b -> discovery.rxPublish(record))
-                .doOnSuccess(r -> this.publishedRecord = r);
-    }
-
-    /**
-     * Invoke a restful service by service name
-     *
-     * @param serviceName the name of service
-     * @param method      HTTP method
-     * @param uri         uri of request
-     * @param body        body of request
-     * @return result as JsonObject
-     */
-    protected Single<JsonObject> invokeRestfulService(String serviceName, HttpMethod method, String uri, JsonObject body) {
-        logger.debug("invokeRestfulService, service name:{}, uri:{}", serviceName, uri);
-        return this.getCircuitBreaker(serviceName).rxExecuteCommand(future -> this.getWebEndPoint(serviceName).subscribe(
-                webClient -> {
-                    HttpRequest request = webClient.request(method, uri);
-                    Single<HttpResponse<Buffer>> result;
-                    if (null == body) {
-                        result = request.rxSend();
-                    } else {
-                        result = request.rxSendJsonObject(body);
-                    }
-                    result.map(HttpResponse::bodyAsJsonObject).subscribe(future::complete, future::fail);
-                },
-                throwable -> future.fail("Service [" + serviceName + "] not found"))
-        );
-    }
-
-    /**
-     * Invoke a restful service by given host and port
-     *
-     * @param method HTTP method
-     * @param port   port of EndPoint
-     * @param host   host of EndPoint
-     * @param uri    uri of request
-     * @param body   body of request
-     * @return
-     */
-    protected Single<JsonObject> invokeRestful(HttpMethod method, int port, String host, String uri, JsonObject body) {
-        logger.debug("invokeRestfulService, host:{}, port:{}, uri:{}", host, port, uri);
-        HttpRequest<Buffer> request = WebClient.create(vertx).request(method, port, host, uri);
-        Single<HttpResponse<Buffer>> result;
-        if (null == body) {
-            result = request.rxSend();
-        } else {
-            result = request.rxSendJsonObject(body);
-        }
-        return result.map(HttpResponse::bodyAsJsonObject);
-    }
-
-    private Single<Boolean> unpublishRecord() {
-        return Single.create(emitter -> {
-            if (null != this.publishedRecord) {
-                discovery.rxUnpublish(this.publishedRecord.getRegistration())
-                        .subscribe(() -> {
-                            logger.debug("Service {} unpublished", this.publishedRecord.getName());
-                            this.publishedRecord = null;
-                            emitter.onSuccess(true);
-                        }, emitter::onError);
-            } else {
-                emitter.onSuccess(true);
+        result.subscribe(response -> {
+            if (!context.response().ended()) {
+                context.response().setStatusCode(response.statusCode());
+                response.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
+                context.response().end(response.body());
             }
-        });
-    }
-
-    private void closeCachedEndPoint(String serviceName) {
-        Object endPoint = this.serviceEndPointMap.get(serviceName);
-        if (null != endPoint) {
-            logger.debug("Close cached EndPoint for service {}", serviceName);
-            if (endPoint instanceof WebClient) {
-                ((WebClient) endPoint).close();
-            } else if (endPoint instanceof HttpClient) {
-                ((HttpClient) endPoint).close();
-            }
-            this.serviceEndPointMap.remove(serviceName);
-        }
+            future.complete();
+        }, future::fail);
     }
 }
 ~~~

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Wed, 18 Apr 2018 01:44:50 -0000

--- v6
+++ v7
@@ -1,87 +1,246 @@
 ~~~
-package com.example.common;
+package com.example.microservices.com;

 import io.reactivex.Single;
-import io.vertx.core.Handler;
+import io.vertx.circuitbreaker.CircuitBreakerOptions;
 import io.vertx.core.http.HttpMethod;
-import io.vertx.reactivex.core.Future;
+import io.vertx.core.json.JsonObject;
+import io.vertx.reactivex.circuitbreaker.CircuitBreaker;
+import io.vertx.reactivex.core.AbstractVerticle;
 import io.vertx.reactivex.core.buffer.Buffer;
-import io.vertx.reactivex.ext.web.Router;
-import io.vertx.reactivex.ext.web.RoutingContext;
+import io.vertx.reactivex.core.http.HttpClient;
 import io.vertx.reactivex.ext.web.client.HttpRequest;
 import io.vertx.reactivex.ext.web.client.HttpResponse;
 import io.vertx.reactivex.ext.web.client.WebClient;
-import io.vertx.reactivex.ext.web.handler.CorsHandler;
+import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
+import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
+import io.vertx.servicediscovery.Record;
+import io.vertx.servicediscovery.ServiceDiscoveryOptions;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;

 /**
- * The abstract verticle which work as HTTP server
+ * The base verticle class which provided some common functions include service discovery
  *
  * @author Gary Cheng
  */
-public abstract class BaseHttpMicroServicesVerticle extends BaseMicroServicesVerticle {
+public abstract class BaseMicroServicesVerticle extends AbstractVerticle {
+    protected static final String KEY_SERVICE_NAME = "service.name";
+    protected static final String KEY_HOST = "host";
+    protected static final String KEY_PORT = "port";
+    protected static final String KEY_ROOT = "root";
+    protected static final String KEY_NAME = "name";
+
     private static final Logger logger = LoggerFactory.getLogger(BaseMicroServicesVerticle.class);

-    /**
-     * Enable CORS
-     *
-     * @param router
-     */
-    protected void enableCorsSupport(Router router) {
-        Set<String> allowedHeaders = new HashSet<>();
-        allowedHeaders.add("x-requested-with");
-        allowedHeaders.add("Access-Control-Allow-Origin");
-        allowedHeaders.add("origin");
-        allowedHeaders.add("Content-Type");
-        allowedHeaders.add("accept");
-
-        CorsHandler corsHandler = CorsHandler.create("*").allowedHeaders(allowedHeaders);
-        Arrays.asList(HttpMethod.values()).stream().forEach(method -> corsHandler.allowedMethod(method));
-        router.route().handler(corsHandler);
-    }
-
-    protected void dispatchRequest(RoutingContext context, String serviceName, Handler errorHandler) {
-        logger.debug("Dispatch Http Request {} to service {}", context.request().uri(), serviceName);
-        this.getCircuitBreaker(serviceName).<Void>rxExecuteCommand(
-                future -> this.dispatchRequestHandler(context, serviceName, future))
-                .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
-    }
-
-    protected void dispatchRequestHandler(RoutingContext context, String serviceName, Future<Void> future) {
-        this.getWebEndPoint(serviceName)
-                .subscribe(webClient -> invokeDispatchHttpRequest(context, webClient, future),
-                        throwable -> future.fail("Service [" + serviceName + "] not published"));
-    }
-
-    private void invokeDispatchHttpRequest(RoutingContext context, WebClient webClient, Future<Void> future) {
-        logger.debug("invokeDispatchHttpRequest, uri:{}", context.request().uri());
-        HttpRequest<Buffer> httpRequest = webClient.request(context.request().method(), context.request().uri());
-        context.request().headers().getDelegate().forEach(header -> httpRequest.putHeader(header.getKey(), header.getValue()));
-        if (context.user() != null) {
-            httpRequest.putHeader("user-principal", context.user().principal().encode());
-        }
+    protected ServiceDiscovery discovery;
+    private Record publishedRecord;
+    private Map<String, CircuitBreaker=""> circuitBreakerMap = new ConcurrentHashMap<>();
+    private Map<String, Object=""> serviceEndPointMap = new ConcurrentHashMap<>();
+
+    @Override
+    public void start() {
+        logger.debug("Starting verticle - {}", this.getClass().getName());
+        logger.debug("Config:{}", this.config().encodePrettily());
+        this.discovery = ServiceDiscovery.create(vertx, new ServiceDiscoveryOptions().setBackendConfiguration(this.getServiceDiscoveryConfig()));
+    }
+
+    @Override
+    public void stop() {
+        logger.debug("Stopping verticle - {}", this.getClass().getName());
+        this.serviceEndPointMap.keySet().stream().forEach(serviceName -> this.closeCachedEndPoint(serviceName));
+        this.serviceEndPointMap.clear();
+        this.circuitBreakerMap.values().stream().forEach(circuitBreaker -> circuitBreaker.close());
+        this.circuitBreakerMap.clear();
+        this.unpublishRecord().subscribe(b -> discovery.close());
+    }
+
+    /**
+     * Return Service discovery configure, the default implementation store them in verticle's config()
+     *
+     * @return Service discovery configure
+     */
+    protected JsonObject getServiceDiscoveryConfig() {
+        return this.config();
+    }
+
+    /**
+     * Return circuit breaker of service by service name
+     *
+     * @param serviceName the name of service
+     * @return circuit breaker of service
+     */
+    protected final CircuitBreaker getCircuitBreaker(String serviceName) {
+        logger.debug("Get CircuitBreaker of service {}", serviceName);
+        CircuitBreaker circuitBreaker = circuitBreakerMap.get(serviceName);
+        if (null == circuitBreaker) {
+            circuitBreaker = this.createCircuitBreaker(serviceName);
+            this.circuitBreakerMap.put(serviceName, circuitBreaker);
+        }
+        return circuitBreaker;
+    }
+
+    /**
+     * Create circuit breaker for service
+     *
+     * @param serviceName the name of service
+     * @return circuit breaker of service
+     */
+    protected CircuitBreaker createCircuitBreaker(String serviceName) {
+        logger.debug("Create CircuitBreaker for service {}", serviceName);
+        String circuitBreakerName = serviceName + "-" + "circuit-breaker";
+        CircuitBreakerOptions options = new CircuitBreakerOptions()
+                .setMaxFailures(5)
+                .setTimeout(5000)
+                .setResetTimeout(10000)
+                .setFallbackOnFailure(true);
+        return CircuitBreaker.create(circuitBreakerName, vertx, options)
+                .openHandler(v -> {
+                    logger.debug("{} opened", circuitBreakerName);
+                    this.closeCachedEndPoint(serviceName);
+                })
+                .halfOpenHandler(v -> logger.debug("{} half opened", circuitBreakerName))
+                .closeHandler(v -> logger.debug("{} closed", circuitBreakerName));
+    }
+
+    /**
+     * Return an async HttpClient by service name
+     *
+     * @param serviceName the name of service
+     * @return
+     */
+    protected final Single<HttpClient> getHttpEndPoint(String serviceName) {
+        logger.debug("Get HTTP client by service name[{}]", serviceName);
+        Object endPoint = this.serviceEndPointMap.get(serviceName);
+        if (null != endPoint && endPoint instanceof HttpClient) {
+            return Single.just((HttpClient) endPoint);
+        } else {
+            return HttpEndpoint.rxGetClient(discovery, new JsonObject().put(KEY_NAME, serviceName))
+                    .doOnSuccess(httpClient -> this.serviceEndPointMap.put(serviceName, httpClient));
+        }
+    }
+
+    /**
+     * Return an async HttpClient by service name
+     *
+     * @param serviceName the name of service
+     * @return
+     */
+    protected final Single<WebClient> getWebEndPoint(String serviceName) {
+        logger.debug("Get Web client by service name[{}]", serviceName);
+        Object endPoint = this.serviceEndPointMap.get(serviceName);
+        if (null != endPoint && endPoint instanceof WebClient) {
+            return Single.just((WebClient) endPoint);
+        } else {
+            logger.debug("Getting Web client from ServiceDiscovery...");
+            return HttpEndpoint.rxGetWebClient(discovery, new JsonObject().put(KEY_NAME, serviceName))
+                    .doOnSuccess(webClient -> this.serviceEndPointMap.put(serviceName, webClient));
+        }
+    }
+
+    /**
+     * Publish a HttpEndPoint service to ServiceDiscovery
+     *
+     * @param config the configure of HttpEndPoint
+     * @return
+     */
+    protected final Single<Record> publishHttpEndPoint(JsonObject config) {
+        String serviceName = config.getString(KEY_SERVICE_NAME);
+        String host = config.getString(KEY_HOST, "localhost");
+        Integer port = config.getInteger(KEY_PORT, 8080);
+        String root = config.getString(KEY_ROOT, "/");
+        return this.publishRecord(HttpEndpoint.createRecord(serviceName, host, port, root));
+    }
+
+    /**
+     * Publish a service record to ServiceDiscovery
+     *
+     * @param record record to publish
+     * @return
+     */
+    protected Single<Record> publishRecord(Record record) {
+        return this.unpublishRecord()
+                .flatMap(b -> discovery.rxPublish(record))
+                .doOnSuccess(r -> this.publishedRecord = r);
+    }
+
+    /**
+     * Invoke a restful service by service name
+     *
+     * @param serviceName the name of service
+     * @param method      HTTP method
+     * @param uri         uri of request
+     * @param body        body of request
+     * @return result as JsonObject
+     */
+    protected Single<JsonObject> invokeRestfulService(String serviceName, HttpMethod method, String uri, JsonObject body) {
+        logger.debug("invokeRestfulService, service name:{}, uri:{}", serviceName, uri);
+        return this.getCircuitBreaker(serviceName).rxExecuteCommand(future -> this.getWebEndPoint(serviceName).subscribe(
+                webClient -> {
+                    HttpRequest request = webClient.request(method, uri);
+                    Single<HttpResponse<Buffer>> result;
+                    if (null == body) {
+                        result = request.rxSend();
+                    } else {
+                        result = request.rxSendJsonObject(body);
+                    }
+                    result.map(HttpResponse::bodyAsJsonObject).subscribe(future::complete, future::fail);
+                },
+                throwable -> future.fail("Service [" + serviceName + "] not found"))
+        );
+    }
+
+    /**
+     * Invoke a restful service by given host and port
+     *
+     * @param method HTTP method
+     * @param port   port of EndPoint
+     * @param host   host of EndPoint
+     * @param uri    uri of request
+     * @param body   body of request
+     * @return
+     */
+    protected Single<JsonObject> invokeRestful(HttpMethod method, int port, String host, String uri, JsonObject body) {
+        logger.debug("invokeRestfulService, host:{}, port:{}, uri:{}", host, port, uri);
+        HttpRequest<Buffer> request = WebClient.create(vertx).request(method, port, host, uri);
         Single<HttpResponse<Buffer>> result;
-        if (null != context.request().formAttributes() && !context.request().formAttributes().isEmpty()) {
-            result = httpRequest.rxSendForm(context.request().formAttributes());
-        } else if (null != context.getBody()) {
-            result = httpRequest.rxSendBuffer(context.getBody());
+        if (null == body) {
+            result = request.rxSend();
         } else {
-            result = httpRequest.rxSend();
-        }
-        result.subscribe(response -> {
-            if (!context.response().ended()) {
-                context.response().setStatusCode(response.statusCode());
-                response.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
-                context.response().end(response.body());
+            result = request.rxSendJsonObject(body);
+        }
+        return result.map(HttpResponse::bodyAsJsonObject);
+    }
+
+    private Single<Boolean> unpublishRecord() {
+        return Single.create(emitter -> {
+            if (null != this.publishedRecord) {
+                discovery.rxUnpublish(this.publishedRecord.getRegistration())
+                        .subscribe(() -> {
+                            logger.debug("Service {} unpublished", this.publishedRecord.getName());
+                            this.publishedRecord = null;
+                            emitter.onSuccess(true);
+                        }, emitter::onError);
+            } else {
+                emitter.onSuccess(true);
             }
-            future.complete();
-        }, future::fail);
+        });
+    }
+
+    private void closeCachedEndPoint(String serviceName) {
+        Object endPoint = this.serviceEndPointMap.get(serviceName);
+        if (null != endPoint) {
+            logger.debug("Close cached EndPoint for service {}", serviceName);
+            if (endPoint instanceof WebClient) {
+                ((WebClient) endPoint).close();
+            } else if (endPoint instanceof HttpClient) {
+                ((HttpClient) endPoint).close();
+            }
+            this.serviceEndPointMap.remove(serviceName);
+        }
     }
 }
-
 ~~~

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Mon, 16 Apr 2018 20:17:40 -0000

--- v5
+++ v6
@@ -1,12 +1,16 @@
 ~~~
-package com.example.microservices.com;
+package com.example.common;

+import io.reactivex.Single;
 import io.vertx.core.Handler;
 import io.vertx.core.http.HttpMethod;
-import io.vertx.reactivex.core.http.HttpClient;
-import io.vertx.reactivex.core.http.HttpClientRequest;
+import io.vertx.reactivex.core.Future;
+import io.vertx.reactivex.core.buffer.Buffer;
 import io.vertx.reactivex.ext.web.Router;
 import io.vertx.reactivex.ext.web.RoutingContext;
+import io.vertx.reactivex.ext.web.client.HttpRequest;
+import io.vertx.reactivex.ext.web.client.HttpResponse;
+import io.vertx.reactivex.ext.web.client.WebClient;
 import io.vertx.reactivex.ext.web.handler.CorsHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -41,58 +45,42 @@
         router.route().handler(corsHandler);
     }

-    /**
-     * Dispatch a http request to MicroServices http end point
-     *
-     * @param context
-     * @param serviceName
-     * @param errorHandler
-     */
-    protected void dispatchHttpRequest(RoutingContext context, String serviceName, Handler errorHandler) {
+    protected void dispatchRequest(RoutingContext context, String serviceName, Handler errorHandler) {
         logger.debug("Dispatch Http Request {} to service {}", context.request().uri(), serviceName);
-        this.getCircuitBreaker(serviceName).rxExecuteCommandWithFallback(
-                future -> this.getServiceHttpClient(serviceName)
-                        .subscribe(httpClient -> this.doDispatchHttpRequest(context, httpClient, future),
-                                throwable -> future.fail("Service [" + serviceName + "] not published")),
-                throwable -> this.circuitFallback(errorHandler, throwable))
-                .subscribe(v -> logger.debug("dispatch request completed"));
+        this.getCircuitBreaker(serviceName).<Void>rxExecuteCommand(
+                future -> this.dispatchRequestHandler(context, serviceName, future))
+                .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
     }

-    private Void circuitFallback(Handler errorHandler, Throwable throwable) {
-        errorHandler.handle(throwable);
-        return null;
+    protected void dispatchRequestHandler(RoutingContext context, String serviceName, Future<Void> future) {
+        this.getWebEndPoint(serviceName)
+                .subscribe(webClient -> invokeDispatchHttpRequest(context, webClient, future),
+                        throwable -> future.fail("Service [" + serviceName + "] not published"));
     }

-    private void doDispatchHttpRequest(RoutingContext context, HttpClient httpClient, io.vertx.reactivex.core.Future<Void> future) {
-        logger.debug("doDispatchHttpRequest, uri:{}", context.request().uri());
-        HttpClientRequest clientRequest = httpClient.request(context.request().method(), context.request().uri());
-        this.addHttpResponseHandler(context, clientRequest, future);
-        context.request().headers().getDelegate().forEach(header -> clientRequest.putHeader(header.getKey(), header.getValue()));
+    private void invokeDispatchHttpRequest(RoutingContext context, WebClient webClient, Future<Void> future) {
+        logger.debug("invokeDispatchHttpRequest, uri:{}", context.request().uri());
+        HttpRequest<Buffer> httpRequest = webClient.request(context.request().method(), context.request().uri());
+        context.request().headers().getDelegate().forEach(header -> httpRequest.putHeader(header.getKey(), header.getValue()));
         if (context.user() != null) {
-            clientRequest.putHeader("user-principal", context.user().principal().encode());
+            httpRequest.putHeader("user-principal", context.user().principal().encode());
         }
-        if (null != context.getBody()) {
-            clientRequest.end(context.getBody());
+        Single<HttpResponse<Buffer>> result;
+        if (null != context.request().formAttributes() && !context.request().formAttributes().isEmpty()) {
+            result = httpRequest.rxSendForm(context.request().formAttributes());
+        } else if (null != context.getBody()) {
+            result = httpRequest.rxSendBuffer(context.getBody());
         } else {
-            clientRequest.end();
+            result = httpRequest.rxSend();
         }
-    }
-
-    private void addHttpResponseHandler(RoutingContext context, HttpClientRequest clientRequest, io.vertx.reactivex.core.Future<Void> future) {
-        clientRequest.toFlowable()
-                .flatMap(response -> {
-                    if (!context.response().ended()) {
-                        context.response().setStatusCode(response.statusCode());
-                        response.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
-                    }
-                    return response.toFlowable();
-                })
-                .subscribe(buffer -> {
-                    if (!context.response().ended()) {
-                        context.response().end(buffer);
-                    }
-                    future.complete();
-                }, future::fail);
+        result.subscribe(response -> {
+            if (!context.response().ended()) {
+                context.response().setStatusCode(response.statusCode());
+                response.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
+                context.response().end(response.body());
+            }
+            future.complete();
+        }, future::fail);
     }
 }

BaseHttpMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Sun, 15 Apr 2018 23:26:44 -0000

--- v4
+++ v5
@@ -1,140 +1,99 @@
-#### RxEventBusApp .java
 ~~~
-package com.example.rx;
+package com.example.microservices.com;

-import io.reactivex.Single;
-import io.vertx.core.DeploymentOptions;
-import io.vertx.core.json.JsonObject;
-import io.vertx.reactivex.core.Vertx;
+import io.vertx.core.Handler;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.reactivex.core.http.HttpClient;
+import io.vertx.reactivex.core.http.HttpClientRequest;
+import io.vertx.reactivex.ext.web.Router;
+import io.vertx.reactivex.ext.web.RoutingContext;
+import io.vertx.reactivex.ext.web.handler.CorsHandler;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;

-public class RxEventBusApp {
-    private static final Logger logger = LoggerFactory.getLogger(RxEventBusApp.class);
+/**
+ * The abstract verticle which work as HTTP server
+ *
+ * @author Gary Cheng
+ */
+public abstract class BaseHttpMicroServicesVerticle extends BaseMicroServicesVerticle {
+    private static final Logger logger = LoggerFactory.getLogger(BaseMicroServicesVerticle.class);

-    public static void main(String[] args) {
-        Vertx vertx = Vertx.vertx();
+    /**
+     * Enable CORS
+     *
+     * @param router
+     */
+    protected void enableCorsSupport(Router router) {
+        Set<String> allowedHeaders = new HashSet<>();
+        allowedHeaders.add("x-requested-with");
+        allowedHeaders.add("Access-Control-Allow-Origin");
+        allowedHeaders.add("origin");
+        allowedHeaders.add("Content-Type");
+        allowedHeaders.add("accept");

-        deployReceiver(vertx, "Receiver 1")
-                .flatMap(deploymentId -> deployReceiver(vertx, "Receiver 2"))
-                .flatMap(deploymentId -> vertx.rxDeployVerticle(RxEventBusSenderVerticle.class.getName()))
-                .subscribe(deploymentId -> logger.debug("Deployment completed"));
+        CorsHandler corsHandler = CorsHandler.create("*").allowedHeaders(allowedHeaders);
+        Arrays.asList(HttpMethod.values()).stream().forEach(method -> corsHandler.allowedMethod(method));
+        router.route().handler(corsHandler);
     }

-    private static Single<String> deployReceiver(Vertx vertx, String name) {
-        JsonObject config = new JsonObject();
-        config.put("name", name);
-        return vertx.rxDeployVerticle(RxEventBusReceiverVerticle.class.getName(), new DeploymentOptions().setConfig(config));
-    }
-}
-~~~
-
-### V2
-~~~
-package com.example.rx;
-
-import io.reactivex.Single;
-import io.vertx.core.DeploymentOptions;
-import io.vertx.core.json.JsonObject;
-import io.vertx.reactivex.core.Vertx;
-import io.vertx.reactivex.core.eventbus.EventBus;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-
-public class RxEventBusApp {
-    private static final Logger logger = LoggerFactory.getLogger(RxEventBusApp.class);
-    private Vertx vertx;
-
-    private RxEventBusApp() throws InterruptedException {
-        logger.debug("RxEventBusApp staring");
-        this.vertx = Vertx.vertx();
-        Single<String> deployment1 = deployReceiver("Receiver 1");
-        Single<String> deployment2 = deployReceiver("Receiver 2");
-        Single.zipArray(ids -> ids, deployment1, deployment2).blockingGet();
-        this.sendMessages();
+    /**
+     * Dispatch a http request to MicroServices http end point
+     *
+     * @param context
+     * @param serviceName
+     * @param errorHandler
+     */
+    protected void dispatchHttpRequest(RoutingContext context, String serviceName, Handler errorHandler) {
+        logger.debug("Dispatch Http Request {} to service {}", context.request().uri(), serviceName);
+        this.getCircuitBreaker(serviceName).rxExecuteCommandWithFallback(
+                future -> this.getServiceHttpClient(serviceName)
+                        .subscribe(httpClient -> this.doDispatchHttpRequest(context, httpClient, future),
+                                throwable -> future.fail("Service [" + serviceName + "] not published")),
+                throwable -> this.circuitFallback(errorHandler, throwable))
+                .subscribe(v -> logger.debug("dispatch request completed"));
     }

-    public static void main(String[] args) throws InterruptedException {
-        new RxEventBusApp();
+    private Void circuitFallback(Handler errorHandler, Throwable throwable) {
+        errorHandler.handle(throwable);
+        return null;
     }

-    private Single<String> deployReceiver(String name) {
-        JsonObject config = new JsonObject();
-        config.put("name", name);
-        return this.vertx.rxDeployVerticle(RxEventBusReceiverVerticle.class.getName(), new DeploymentOptions().setConfig(config));
+    private void doDispatchHttpRequest(RoutingContext context, HttpClient httpClient, io.vertx.reactivex.core.Future<Void> future) {
+        logger.debug("doDispatchHttpRequest, uri:{}", context.request().uri());
+        HttpClientRequest clientRequest = httpClient.request(context.request().method(), context.request().uri());
+        this.addHttpResponseHandler(context, clientRequest, future);
+        context.request().headers().getDelegate().forEach(header -> clientRequest.putHeader(header.getKey(), header.getValue()));
+        if (context.user() != null) {
+            clientRequest.putHeader("user-principal", context.user().principal().encode());
+        }
+        if (null != context.getBody()) {
+            clientRequest.end(context.getBody());
+        } else {
+            clientRequest.end();
+        }
     }

-    private void sendMessages() throws InterruptedException {
-        logger.debug("Start send messages to event bus");
-        EventBus eventBus = vertx.eventBus();
-        eventBus.publish("anAddress", "Published a message");
-        eventBus.rxSend("anAddress", "Sent a message")
-                .subscribe(reply -> {
-                    logger.debug("Received reply:{}", reply.body());
-                    reply.reply("replied to reply");
-                });
-        logger.debug("send message completed");
+    private void addHttpResponseHandler(RoutingContext context, HttpClientRequest clientRequest, io.vertx.reactivex.core.Future<Void> future) {
+        clientRequest.toFlowable()
+                .flatMap(response -> {
+                    if (!context.response().ended()) {
+                        context.response().setStatusCode(response.statusCode());
+                        response.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
+                    }
+                    return response.toFlowable();
+                })
+                .subscribe(buffer -> {
+                    if (!context.response().ended()) {
+                        context.response().end(buffer);
+                    }
+                    future.complete();
+                }, future::fail);
     }
 }

 ~~~
-#### RxEventBusSenderVerticle .java
-~~~
-package com.example.rx;
-
-import io.vertx.reactivex.core.AbstractVerticle;
-import io.vertx.reactivex.core.eventbus.EventBus;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class RxEventBusSenderVerticle extends AbstractVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(RxEventBusSenderVerticle.class);
-
-    @Override
-    public void start() throws Exception {
-        logger.debug("Start Sender verticle");
-        EventBus eventBus = vertx.eventBus();
-        eventBus.publish("anAddress", "Published a message");
-        eventBus.
-                rxSend("anAddress", "Sent a message")
-                .subscribe(reply -> {
-                    logger.debug("Received reply:{}", reply.body());
-                    reply.reply("replied to reply");
-                });
-    }
-}
-~~~
-
-#### RxEventBusReceiverVerticle .java
-~~~
-package com.example.rx;
-
-import io.vertx.reactivex.core.AbstractVerticle;
-import io.vertx.reactivex.core.eventbus.Message;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class RxEventBusReceiverVerticle extends AbstractVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(RxEventBusReceiverVerticle.class);
-    private String name;
-
-    @Override
-    public void start() throws Exception {
-        this.name = config().getString("name");
-        logger.debug("Start Receiver verticle, name:{}", name);
-        vertx.eventBus()
-                .<String>consumer("anAddress")
-                .toFlowable()
-                .subscribe(message -> this.onMessage(message));
-    }
-
-    private void onMessage(Message<String> message) {
-        logger.debug("{} Received message: {}", this.name, message.body());
-        String replyMessage = "Message replied from receiver[" + this.name + "]";
-        message.<String>rxReply(replyMessage).
-                subscribe(result -> logger.debug("Received message after replied:{}", result.body()));
-    }
-}
-~~~

Vertx.EventBus modified by Gary Cheng

Gary Cheng — Mon, 02 Apr 2018 17:00:14 -0000

--- v3
+++ v4
@@ -35,7 +35,6 @@
 package com.example.rx;

 import io.reactivex.Single;
-import io.reactivex.schedulers.Schedulers;
 import io.vertx.core.DeploymentOptions;
 import io.vertx.core.json.JsonObject;
 import io.vertx.reactivex.core.Vertx;
@@ -48,16 +47,16 @@
     private static final Logger logger = LoggerFactory.getLogger(RxEventBusApp.class);
     private Vertx vertx;

-    private RxEventBusApp() {
+    private RxEventBusApp() throws InterruptedException {
         logger.debug("RxEventBusApp staring");
         this.vertx = Vertx.vertx();
-        deployReceiver("Receiver 1")
-                .flatMap(deploymentId -> deployReceiver("Receiver 2"))
-                .subscribe(this::sendMessages);
-        logger.debug("RxEventBusApp started");
+        Single<String> deployment1 = deployReceiver("Receiver 1");
+        Single<String> deployment2 = deployReceiver("Receiver 2");
+        Single.zipArray(ids -> ids, deployment1, deployment2).blockingGet();
+        this.sendMessages();
     }

-    public static void main(String[] args) {
+    public static void main(String[] args) throws InterruptedException {
         new RxEventBusApp();
     }

@@ -67,18 +66,15 @@
         return this.vertx.rxDeployVerticle(RxEventBusReceiverVerticle.class.getName(), new DeploymentOptions().setConfig(config));
     }

-    private void sendMessages(String deploymentId) throws InterruptedException {
-        logger.debug("Receivers deployed successful, deploymentId:{}", deploymentId);
+    private void sendMessages() throws InterruptedException {
         logger.debug("Start send messages to event bus");
         EventBus eventBus = vertx.eventBus();
         eventBus.publish("anAddress", "Published a message");
         eventBus.rxSend("anAddress", "Sent a message")
-                .subscribeOn(Schedulers.io())
                 .subscribe(reply -> {
                     logger.debug("Received reply:{}", reply.body());
                     reply.reply("replied to reply");
                 });
-        Thread.sleep(5000);
         logger.debug("send message completed");
     }
 }

Vertx.EventBus modified by Gary Cheng

Gary Cheng — Mon, 02 Apr 2018 15:58:35 -0000

--- v2
+++ v3
@@ -30,6 +30,60 @@
 }
 ~~~

+### V2
+~~~
+package com.example.rx;
+
+import io.reactivex.Single;
+import io.reactivex.schedulers.Schedulers;
+import io.vertx.core.DeploymentOptions;
+import io.vertx.core.json.JsonObject;
+import io.vertx.reactivex.core.Vertx;
+import io.vertx.reactivex.core.eventbus.EventBus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class RxEventBusApp {
+    private static final Logger logger = LoggerFactory.getLogger(RxEventBusApp.class);
+    private Vertx vertx;
+
+    private RxEventBusApp() {
+        logger.debug("RxEventBusApp staring");
+        this.vertx = Vertx.vertx();
+        deployReceiver("Receiver 1")
+                .flatMap(deploymentId -> deployReceiver("Receiver 2"))
+                .subscribe(this::sendMessages);
+        logger.debug("RxEventBusApp started");
+    }
+
+    public static void main(String[] args) {
+        new RxEventBusApp();
+    }
+
+    private Single<String> deployReceiver(String name) {
+        JsonObject config = new JsonObject();
+        config.put("name", name);
+        return this.vertx.rxDeployVerticle(RxEventBusReceiverVerticle.class.getName(), new DeploymentOptions().setConfig(config));
+    }
+
+    private void sendMessages(String deploymentId) throws InterruptedException {
+        logger.debug("Receivers deployed successful, deploymentId:{}", deploymentId);
+        logger.debug("Start send messages to event bus");
+        EventBus eventBus = vertx.eventBus();
+        eventBus.publish("anAddress", "Published a message");
+        eventBus.rxSend("anAddress", "Sent a message")
+                .subscribeOn(Schedulers.io())
+                .subscribe(reply -> {
+                    logger.debug("Received reply:{}", reply.body());
+                    reply.reply("replied to reply");
+                });
+        Thread.sleep(5000);
+        logger.debug("send message completed");
+    }
+}
+
+~~~
 #### RxEventBusSenderVerticle .java
 ~~~
 package com.example.rx;

Vertx.EventBus modified by Gary Cheng

Gary Cheng — Mon, 02 Apr 2018 12:52:46 -0000

--- v1
+++ v2
@@ -1,3 +1,4 @@
+#### RxEventBusApp .java
 ~~~
 package com.example.rx;

@@ -27,12 +28,11 @@
         return vertx.rxDeployVerticle(RxEventBusReceiverVerticle.class.getName(), new DeploymentOptions().setConfig(config));
     }
 }
-
 ~~~

+#### RxEventBusSenderVerticle .java
 ~~~
 package com.example.rx;
-

 import io.vertx.reactivex.core.AbstractVerticle;
 import io.vertx.reactivex.core.eventbus.EventBus;
@@ -57,9 +57,9 @@
 }
 ~~~

+#### RxEventBusReceiverVerticle .java
 ~~~
 package com.example.rx;
-

 import io.vertx.reactivex.core.AbstractVerticle;
 import io.vertx.reactivex.core.eventbus.Message;