Recent changes to BaseMicroServicesVerticle

BaseMicroServicesVerticle modified by Gary Cheng

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

--- v4
+++ v5
@@ -2,93 +2,244 @@
 package com.ezshop.common;

 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;
+
+import static com.ezshop.common.ConfigKeys.*;

 /**
- * 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_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);
-    }
-
-    /**
-     * 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, uri, future))
-                .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
-    }
-
-    protected 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"));
-    }
-
-    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());
-        }
+    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 serviceName the name of service to be published
+     * @param config      the configure of HttpEndPoint
+     * @return
+     */
+    protected final Single<Record> publishHttpEndPoint(String serviceName, JsonObject config) {
+        String host = config.getString(KEY_HOST, "localhost");
+        Integer port = config.getInteger(KEY_PORT, 8080);
+        String root = config.getString(KEY_ROOT, "/");
+        logger.debug("publishHttpEndPoint service:{}, host:{}, port:{}, root:{}", serviceName, host, port, 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);
+        }
     }
 }
 ~~~

BaseMicroServicesVerticle modified by Gary Cheng

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

--- v3
+++ v4
@@ -1,246 +1,94 @@
 ~~~
-package com.example.microservices.com;
+package com.ezshop.common;

 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()));
-    }
-
-    @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());
+        CorsHandler corsHandler = CorsHandler.create("*").allowedHeaders(allowedHeaders);
+        Arrays.asList(HttpMethod.values()).stream().forEach(method -> corsHandler.allowedMethod(method));
+        router.route().handler(corsHandler);
     }

     /**
-     * Return Service discovery configure, the default implementation store them in verticle's config()
+     * Dispatch a HTTP request to a HttpEndPoint service
      *
-     * @return Service discovery configure
+     * @param context Routing context
+     * @param serviceName the name of service
+     * @param uri the uri at HttpEndPoint service
+     * @param errorHandler the async error handler
      */
-    protected JsonObject getServiceDiscoveryConfig() {
-        return this.config();
+    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, uri, future))
+                .subscribe(v -> logger.debug("dispatch request completed"), errorHandler::handle);
     }

-    /**
-     * 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;
+    protected 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"));
     }

-    /**
-     * 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);
+    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());
+        }
+        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);
     }
 }
 ~~~

BaseMicroServicesVerticle modified by Gary Cheng

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

--- v2
+++ v3
@@ -1,12 +1,16 @@
 ~~~
-package com.example.common;
+package com.example.microservices.com;

 import io.reactivex.Single;
 import io.vertx.circuitbreaker.CircuitBreakerOptions;
+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.buffer.Buffer;
 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.servicediscovery.ServiceDiscovery;
 import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
@@ -163,6 +167,54 @@
                 .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) {
@@ -191,5 +243,4 @@
         }
     }
 }
-
 ~~~

BaseMicroServicesVerticle modified by Gary Cheng

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

--- v1
+++ v2
@@ -1,14 +1,13 @@
 ~~~
-package com.example.microservices.com;
+package com.example.common;

-import io.reactivex.Completable;
 import io.reactivex.Single;
 import io.vertx.circuitbreaker.CircuitBreakerOptions;
-import io.vertx.core.impl.ConcurrentHashSet;
 import io.vertx.core.json.JsonObject;
 import io.vertx.reactivex.circuitbreaker.CircuitBreaker;
 import io.vertx.reactivex.core.AbstractVerticle;
 import io.vertx.reactivex.core.http.HttpClient;
+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;
@@ -16,9 +15,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;

@@ -28,18 +24,18 @@
  * @author Gary Cheng
  */
 public abstract class BaseMicroServicesVerticle extends AbstractVerticle {
-    public static final String KEY_SERVICE_NAME = "service.name";
-    public static final String KEY_HOST = "host";
-    public static final String KEY_PORT = "port";
-    public static final String KEY_ROOT = "root";
-    private static final String KEY_NAME = "name";
+    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);

     protected ServiceDiscovery discovery;
-    private Collection<Record> publishedRecords = new ConcurrentHashSet<>();
+    private Record publishedRecord;
     private Map<String, CircuitBreaker=""> circuitBreakerMap = new ConcurrentHashMap<>();
-    private Map<String, Object=""> serviceClientMap = new ConcurrentHashMap<>();
+    private Map<String, Object=""> serviceEndPointMap = new ConcurrentHashMap<>();

     @Override
     public void start() {
@@ -51,15 +47,11 @@
     @Override
     public void stop() {
         logger.debug("Stopping verticle - {}", this.getClass().getName());
-        if (null != discovery) {
-            List<Completable> completables = new ArrayList<>();
-            publishedRecords.forEach(record -> completables.add(discovery.rxUnpublish(record.getRegistration())));
-            Completable.merge(completables)
-                    .subscribe(() -> {
-                        logger.debug("All services have been un-published");
-                        discovery.close();
-                    });
-        }
+        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());
     }

     /**
@@ -78,6 +70,7 @@
      * @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);
@@ -93,7 +86,7 @@
      * @return circuit breaker of service
      */
     protected CircuitBreaker createCircuitBreaker(String serviceName) {
-        logger.debug("create circuit breaker for service {}", serviceName);
+        logger.debug("Create CircuitBreaker for service {}", serviceName);
         String circuitBreakerName = serviceName + "-" + "circuit-breaker";
         CircuitBreakerOptions options = new CircuitBreakerOptions()
                 .setMaxFailures(5)
@@ -101,25 +94,46 @@
                 .setResetTimeout(10000)
                 .setFallbackOnFailure(true);
         return CircuitBreaker.create(circuitBreakerName, vertx, options)
-                .openHandler(v -> logger.debug("{} opened", circuitBreakerName))
+                .openHandler(v -> {
+                    logger.debug("{} opened", circuitBreakerName);
+                    this.closeCachedEndPoint(serviceName);
+                })
                 .halfOpenHandler(v -> logger.debug("{} half opened", circuitBreakerName))
                 .closeHandler(v -> logger.debug("{} closed", circuitBreakerName));
     }

     /**
-     * Lookup ServiceDiscovery by service name and return an async HttpClient
+     * Return an async HttpClient by service name
      *
      * @param serviceName the name of service
      * @return
      */
-    protected final Single<HttpClient> getServiceHttpClient(String serviceName) {
+    protected final Single<HttpClient> getHttpEndPoint(String serviceName) {
         logger.debug("Get HTTP client by service name[{}]", serviceName);
-        Object serviceClient = this.serviceClientMap.get(serviceName);
-        if (null != serviceClient) {
-            return Single.just((HttpClient) serviceClient);
+        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.serviceClientMap.put(serviceName, httpClient));
+                    .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));
         }
     }

@@ -143,13 +157,39 @@
      * @param record record to publish
      * @return
      */
-    private Single<Record> publishRecord(Record record) {
-        return discovery.rxPublish(record)
-                .flatMap(r -> {
-                    logger.debug("Service {} has been published", record.getName());
-                    this.publishedRecords.add(r);
-                    return Single.just(r);
-                });
+    protected Single<Record> publishRecord(Record record) {
+        return this.unpublishRecord()
+                .flatMap(b -> discovery.rxPublish(record))
+                .doOnSuccess(r -> this.publishedRecord = r);
+    }
+
+    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);
+            }
+        });
+    }
+
+    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);
+        }
     }
 }
+
 ~~~

BaseMicroServicesVerticle modified by Gary Cheng

Gary Cheng — Sun, 15 Apr 2018 23:25:21 -0000

package com.example.microservices.com;

import io.reactivex.Completable;
import io.reactivex.Single;
import io.vertx.circuitbreaker.CircuitBreakerOptions;
import io.vertx.core.impl.ConcurrentHashSet;
import io.vertx.core.json.JsonObject;
import io.vertx.reactivex.circuitbreaker.CircuitBreaker;
import io.vertx.reactivex.core.AbstractVerticle;
import io.vertx.reactivex.core.http.HttpClient;
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.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * The base verticle class which provided some common functions include service discovery
 *
 * @author Gary Cheng
 */
public abstract class BaseMicroServicesVerticle extends AbstractVerticle {
    public static final String KEY_SERVICE_NAME = "service.name";
    public static final String KEY_HOST = "host";
    public static final String KEY_PORT = "port";
    public static final String KEY_ROOT = "root";
    private static final String KEY_NAME = "name";

    private static final Logger logger = LoggerFactory.getLogger(BaseMicroServicesVerticle.class);

    protected ServiceDiscovery discovery;
    private Collection<Record> publishedRecords = new ConcurrentHashSet<>();
    private Map<String, CircuitBreaker> circuitBreakerMap = new ConcurrentHashMap<>();
    private Map<String, Object> serviceClientMap = 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());
        if (null != discovery) {
            List<Completable> completables = new ArrayList<>();
            publishedRecords.forEach(record -> completables.add(discovery.rxUnpublish(record.getRegistration())));
            Completable.merge(completables)
                    .subscribe(() -> {
                        logger.debug("All services have been un-published");
                        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) {
        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 circuit breaker 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))
                .halfOpenHandler(v -> logger.debug("{} half opened", circuitBreakerName))
                .closeHandler(v -> logger.debug("{} closed", circuitBreakerName));
    }

    /**
     * Lookup ServiceDiscovery by service name and return an async HttpClient
     *
     * @param serviceName the name of service
     * @return
     */
    protected final Single<HttpClient> getServiceHttpClient(String serviceName) {
        logger.debug("Get HTTP client by service name[{}]", serviceName);
        Object serviceClient = this.serviceClientMap.get(serviceName);
        if (null != serviceClient) {
            return Single.just((HttpClient) serviceClient);
        } else {
            return HttpEndpoint.rxGetClient(discovery, new JsonObject().put(KEY_NAME, serviceName))
                    .doOnSuccess(httpClient -> this.serviceClientMap.put(serviceName, httpClient));
        }
    }

    /**
     * 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
     */
    private Single<Record> publishRecord(Record record) {
        return discovery.rxPublish(record)
                .flatMap(r -> {
                    logger.debug("Service {} has been published", record.getName());
                    this.publishedRecords.add(r);
                    return Single.just(r);
                });
    }
}