Recent changes to ServiceDiscovery

ServiceDiscovery modified by Gary Cheng

Gary Cheng — Fri, 13 Apr 2018 19:53:56 -0000

--- v3
+++ v4
@@ -1,41 +1,275 @@
-GatewayVerticle
-
-~~~
-package com.example.discovery;
-
-import io.vertx.core.Future;
-import io.vertx.core.VertxOptions;
+~~~
+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.Vertx;
+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
+     */
+    protected JsonObject getServiceDiscoveryConfig() {
+        return this.config();
+    }
+
+    /**
+     * Return circuit breaker of service by service name
+     *
+     * @param serviceName the name of service
+     * @return
+     */
+    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
+     */
+    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
+     * @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);
+                });
+    }
+}
+
+~~~
+~~~
+package com.example.common;
+
+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;
+
+/**
+ * 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);
+
+    /**
+     * 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 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.executeDispatchHttpRequest(context, httpClient, future),
+                                throwable -> future.fail("Service [" + serviceName + "] not published")),
+                throwable -> this.circuitFallback(errorHandler, throwable))
+                .subscribe(v -> logger.debug("dispatch request completed"));
+    }
+
+    private Void circuitFallback(Handler errorHandler, Throwable throwable) {
+        errorHandler.handle(throwable);
+        return null;
+    }
+
+    private void executeDispatchHttpRequest(RoutingContext context, HttpClient httpClient, io.vertx.reactivex.core.Future<Void> future) {
+        logger.debug("executeDispatchHttpRequest, uri:{}", context.request().uri());
+        HttpClientRequest clientRequest = httpClient.request(context.request().method(), context.request().uri());
+        clientRequest.toFlowable()
+                .flatMap(response -> {
+                    context.response().setStatusCode(response.statusCode());
+                    response.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
+                    return response.toFlowable();
+                })
+                .subscribe(buffer -> {
+                    context.response().end(buffer);
+                    future.complete();
+                }, future::fail);
+        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();
+        }
+    }
+}
+
+~~~
+
+~~~
+package com.example.discovery;
+
+import com.example.common.BaseHttpMicroServicesVerticle;
+import io.vertx.core.Future;
+import io.vertx.core.VertxOptions;
+import io.vertx.core.json.JsonObject;
+import io.vertx.reactivex.core.Vertx;
+import io.vertx.reactivex.ext.web.Router;
+import io.vertx.reactivex.ext.web.RoutingContext;
 import io.vertx.reactivex.ext.web.handler.BodyHandler;
-import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
-import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
 import io.vertx.servicediscovery.rest.ServiceDiscoveryRestEndpoint;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-public class GatewayVerticle extends AbstractVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(GatewayVerticle.class);
+public class ApiGatewayVerticle extends BaseHttpMicroServicesVerticle {
+    private static final Logger logger = LoggerFactory.getLogger(ApiGatewayVerticle.class);
     private static final int PORT = 8080;
     private static final String PREFIX_SERVICE = "/service/";
-    private ServiceDiscovery discovery;

     public static void main(String[] args) throws InterruptedException {
         Vertx.rxClusteredVertx(new VertxOptions().setClustered(true))
-                .flatMap(vertx -> vertx.rxDeployVerticle(GatewayVerticle.class.getName()))
+                .flatMap(vertx -> vertx.rxDeployVerticle(ApiGatewayVerticle.class.getName()))
                 .subscribe(id -> logger.debug("GatewayVerticle deployed successfully"));
     }

     @Override
     public void start(Future<Void> startFuture) throws Exception {
-        logger.debug("Starting GatewayVerticle");
-        this.discovery = ServiceDiscovery.create(vertx);
+        super.start();
         Router router = Router.router(vertx);
+        this.enableCorsSupport(router);
         ServiceDiscoveryRestEndpoint.create(router.getDelegate(), discovery.getDelegate());
         this.configureRouter(router);
         vertx.createHttpServer()
@@ -52,6 +286,7 @@
         router.route(PREFIX_SERVICE + "*").handler(this::serviceHandler);
         String regexMatcher = "^(?!" + PREFIX_SERVICE + ").*";
         router.routeWithRegex(regexMatcher).handler(this::indexHandler);
+        //router.route("/").handler(this::indexHandler);
     }

     private void indexHandler(RoutingContext context) {
@@ -69,32 +304,8 @@
         if (null == serviceName || serviceName.trim().equalsIgnoreCase("")) {
             this.error(context, 500, "Empty service name");
         } else {
-            HttpEndpoint.rxGetClient(discovery, new JsonObject().put("name", serviceName))
-                    .subscribe(httpClient -> this.dispatchRequest(context, httpClient), error -> this.serviceNotFound(context, serviceName));
-        }
-    }
-
-    private void dispatchRequest(RoutingContext context, HttpClient client) {
-        logger.debug("Dispatch Request, uri:{}", context.request().uri());
-        HttpClientRequest clientRequest = client.request(context.request().method(), context.request().uri());
-        clientRequest.toFlowable()
-                .flatMap(res -> {
-                    context.response().setStatusCode(res.statusCode());
-                    res.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
-                    return res.toFlowable();
-                })
-                .doAfterTerminate(() -> ServiceDiscovery.releaseServiceObject(discovery, client))
-                .subscribe(context.response()::end, error -> this.error(context, error));
-        context.request().headers().getDelegate().forEach(header -> clientRequest.putHeader(header.getKey(), header.getValue()));
-        if (null != context.getBody()) {
-            clientRequest.end(context.getBody());
-        } else {
-            clientRequest.end();
-        }
-    }
-
-    private void serviceNotFound(RoutingContext context, String serviceName) {
-        this.error(context, 404, "Service [" + serviceName + "] not found");
+            this.dispatchHttpRequest(context, serviceName, error -> this.error(context, error));
+        }
     }

     private void error(RoutingContext context, Throwable throwable) {
@@ -102,135 +313,11 @@
     }

     private void error(RoutingContext context, int statusCode, String errorMessage) {
-        context.response().setStatusCode(statusCode).putHeader("content-type", "application/json")
-                .end(new JsonObject().put("statusCode", statusCode).put("error", errorMessage).encodePrettily());
+        if (!context.response().ended()) {
+            context.response().setStatusCode(statusCode).putHeader("content-type", "application/json")
+                    .end(new JsonObject().put("statusCode", statusCode).put("error", errorMessage).encodePrettily());
+        }
     }
 }

 ~~~
-
-BaseServiceVerticle
-~~~
-package com.example.discovery;
-
-import io.reactivex.Completable;
-import io.reactivex.Single;
-import io.vertx.core.Handler;
-import io.vertx.core.impl.ConcurrentHashSet;
-import io.vertx.core.json.JsonObject;
-import io.vertx.reactivex.core.AbstractVerticle;
-import io.vertx.reactivex.core.http.HttpServerRequest;
-import io.vertx.reactivex.ext.web.Router;
-import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
-import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
-import io.vertx.servicediscovery.Record;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-public abstract class BaseServiceVerticle extends AbstractVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(BaseServiceVerticle.class);
-
-    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 ServiceDiscovery discovery;
-    private Set<Record> publishedRecords = new ConcurrentHashSet<>();
-
-    @Override
-    public void start() throws Exception {
-        logger.debug("Starting {} verticle", this.config().getString(KEY_SERVICE_NAME));
-        logger.debug("Config:{}", this.config().encodePrettily());
-        this.discovery = ServiceDiscovery.create(vertx);
-    }
-
-    @Override
-    public void stop() throws Exception {
-        logger.debug("Stopping {} verticle", this.config().getString(KEY_SERVICE_NAME));
-        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();
-                    });
-        }
-    }
-
-    protected Handler<HttpServerRequest> getHttpRequestHandler() {
-        Router router = Router.router(vertx);
-        router.route().handler(routingContext -> {
-            logger.debug("Received a http request");
-            routingContext.response()
-                    .putHeader("content-type", "text/json")
-                    .end(new JsonObject().put("message", "Welcome to " + this.config().getString(KEY_SERVICE_NAME) + " service").encodePrettily());
-        });
-        return router::accept;
-    }
-
-    protected final Single<Record> publishHttpServer() {
-        String serviceName = this.config().getString(KEY_SERVICE_NAME);
-        String host = this.config().getString(KEY_HOST, "localhost");
-        Integer port = this.config().getInteger(KEY_PORT, 8080);
-        String root = this.config().getString(KEY_ROOT, "/");
-        return vertx.createHttpServer()
-                .requestHandler(this.getHttpRequestHandler())
-                .rxListen(port)
-                .flatMap(httpServer -> {
-                    logger.debug("{} http server started on port {}", serviceName, port);
-                    return this.publishRecord(HttpEndpoint.createRecord(serviceName, host, port, root));
-                });
-    }
-
-    protected final 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);
-                });
-    }
-}
-
-~~~
-
-ProductVerticle
-~~~
-package com.example.discovery;
-
-import io.vertx.core.DeploymentOptions;
-import io.vertx.core.Future;
-import io.vertx.core.VertxOptions;
-import io.vertx.core.json.JsonObject;
-import io.vertx.reactivex.core.Vertx;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class ProductVerticle extends BaseServiceVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(ProductVerticle.class);
-
-    public static void main(String[] args) throws InterruptedException {
-        JsonObject config = new JsonObject()
-                .put(KEY_SERVICE_NAME, "product")
-                .put(KEY_PORT, 8081)
-                .put(KEY_ROOT, "/service/product");
-        Vertx.rxClusteredVertx(new VertxOptions().setClustered(true))
-                .flatMap(vertx -> vertx.rxDeployVerticle(ProductVerticle.class.getName(), new DeploymentOptions().setConfig(config)))
-                .subscribe(id -> logger.debug("ProductVerticle deployed successfully"));
-    }
-
-    @Override
-    public void start(Future<Void> startFuture) throws Exception {
-        super.start();
-        this.publishHttpServer()
-                .subscribe(record -> startFuture.complete(), startFuture::fail);
-    }
-}
-
-~~~

ServiceDiscovery modified by Gary Cheng

Gary Cheng — Thu, 05 Apr 2018 18:56:10 -0000

--- v2
+++ v3
@@ -1,4 +1,5 @@
 GatewayVerticle
+
 ~~~
 package com.example.discovery;

@@ -43,13 +44,14 @@
                 .subscribe(s -> {
                     logger.debug("Gateway HTTP server started on port 8080");
                     startFuture.complete();
-                }, error -> startFuture.fail(error));
+                }, startFuture::fail);
     }

     private void configureRouter(Router router) {
         router.route().handler(BodyHandler.create());
         router.route(PREFIX_SERVICE + "*").handler(this::serviceHandler);
-        router.route("/").handler(this::indexHandler);
+        String regexMatcher = "^(?!" + PREFIX_SERVICE + ").*";
+        router.routeWithRegex(regexMatcher).handler(this::indexHandler);
     }

     private void indexHandler(RoutingContext context) {
@@ -104,104 +106,131 @@
                 .end(new JsonObject().put("statusCode", statusCode).put("error", errorMessage).encodePrettily());
     }
 }
-~~~
-ProductVerticle
-~~~
-package com.example.discovery.product;
-
-import io.vertx.core.DeploymentOptions;
-import io.vertx.core.Future;
-import io.vertx.core.VertxOptions;
+
+~~~
+
+BaseServiceVerticle
+~~~
+package com.example.discovery;
+
+import io.reactivex.Completable;
+import io.reactivex.Single;
+import io.vertx.core.Handler;
+import io.vertx.core.impl.ConcurrentHashSet;
+import io.vertx.core.json.JsonObject;
 import io.vertx.reactivex.core.AbstractVerticle;
-import io.vertx.reactivex.core.Vertx;
+import io.vertx.reactivex.core.http.HttpServerRequest;
+import io.vertx.reactivex.ext.web.Router;
 import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
 import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
 import io.vertx.servicediscovery.Record;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-import static com.example.discovery.product.ProductHttpVerticle.PORT;
-
-public class ProductVerticle extends AbstractVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(ProductVerticle.class);
-
-    private static final String SERVICE_NAME = "product";
-
-    private ServiceDiscovery discovery;
-    private Record record;
-
-    public static void main(String[] args) throws InterruptedException {
-        Vertx.rxClusteredVertx(new VertxOptions().setClustered(true))
-                .flatMap(vertx -> vertx.rxDeployVerticle(ProductVerticle.class.getName()))
-                .subscribe(id -> logger.debug("ProductVerticle deployed successfully"));
-    }
-
-    @Override
-    public void start(Future<Void> startFuture) throws Exception {
-        logger.debug("Starting ProductVerticle");
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+public abstract class BaseServiceVerticle extends AbstractVerticle {
+    private static final Logger logger = LoggerFactory.getLogger(BaseServiceVerticle.class);
+
+    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 ServiceDiscovery discovery;
+    private Set<Record> publishedRecords = new ConcurrentHashSet<>();
+
+    @Override
+    public void start() throws Exception {
+        logger.debug("Starting {} verticle", this.config().getString(KEY_SERVICE_NAME));
+        logger.debug("Config:{}", this.config().encodePrettily());
         this.discovery = ServiceDiscovery.create(vertx);
-        DeploymentOptions options = new DeploymentOptions().setConfig(config());
-        vertx.rxDeployVerticle(ProductHttpVerticle.class.getName(), options)
-                .flatMap(id -> discovery.rxPublish(HttpEndpoint.createRecord(SERVICE_NAME, "localhost", PORT, "/service/product")))
-                .subscribe(record -> {
-                    this.record = record;
-                    logger.debug("{} service has been published", SERVICE_NAME);
-                    startFuture.complete();
-                }, startFuture::fail);
-    }
-
-    @Override
-    public void stop(Future<Void> stopFuture) throws Exception {
-        if (null != discovery && null != record) {
-            discovery.rxUnpublish(this.record.getRegistration())
+    }
+
+    @Override
+    public void stop() throws Exception {
+        logger.debug("Stopping {} verticle", this.config().getString(KEY_SERVICE_NAME));
+        if (null != discovery) {
+            List<Completable> completables = new ArrayList<>();
+            publishedRecords.forEach(record -> completables.add(discovery.rxUnpublish(record.getRegistration())));
+            Completable.merge(completables)
                     .subscribe(() -> {
-                        logger.debug("Service {} has been un-published", SERVICE_NAME);
-                        stopFuture.complete();
+                        logger.debug("All services have been un-published");
+                        discovery.close();
                     });
-        } else {
-            stopFuture.complete();
         }
     }
+
+    protected Handler<HttpServerRequest> getHttpRequestHandler() {
+        Router router = Router.router(vertx);
+        router.route().handler(routingContext -> {
+            logger.debug("Received a http request");
+            routingContext.response()
+                    .putHeader("content-type", "text/json")
+                    .end(new JsonObject().put("message", "Welcome to " + this.config().getString(KEY_SERVICE_NAME) + " service").encodePrettily());
+        });
+        return router::accept;
+    }
+
+    protected final Single<Record> publishHttpServer() {
+        String serviceName = this.config().getString(KEY_SERVICE_NAME);
+        String host = this.config().getString(KEY_HOST, "localhost");
+        Integer port = this.config().getInteger(KEY_PORT, 8080);
+        String root = this.config().getString(KEY_ROOT, "/");
+        return vertx.createHttpServer()
+                .requestHandler(this.getHttpRequestHandler())
+                .rxListen(port)
+                .flatMap(httpServer -> {
+                    logger.debug("{} http server started on port {}", serviceName, port);
+                    return this.publishRecord(HttpEndpoint.createRecord(serviceName, host, port, root));
+                });
+    }
+
+    protected final 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);
+                });
+    }
 }

 ~~~

-ProductHttpVerticle
-~~~
-package com.example.discovery.product;
-
+ProductVerticle
+~~~
+package com.example.discovery;
+
+import io.vertx.core.DeploymentOptions;
 import io.vertx.core.Future;
+import io.vertx.core.VertxOptions;
 import io.vertx.core.json.JsonObject;
-import io.vertx.reactivex.core.AbstractVerticle;
-import io.vertx.reactivex.ext.web.Router;
-import io.vertx.reactivex.ext.web.RoutingContext;
+import io.vertx.reactivex.core.Vertx;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

-public class ProductHttpVerticle extends AbstractVerticle {
-
-    public static final int PORT = 8081;
-    private static final Logger logger = LoggerFactory.getLogger(ProductHttpVerticle.class);
+public class ProductVerticle extends BaseServiceVerticle {
+    private static final Logger logger = LoggerFactory.getLogger(ProductVerticle.class);
+
+    public static void main(String[] args) throws InterruptedException {
+        JsonObject config = new JsonObject()
+                .put(KEY_SERVICE_NAME, "product")
+                .put(KEY_PORT, 8081)
+                .put(KEY_ROOT, "/service/product");
+        Vertx.rxClusteredVertx(new VertxOptions().setClustered(true))
+                .flatMap(vertx -> vertx.rxDeployVerticle(ProductVerticle.class.getName(), new DeploymentOptions().setConfig(config)))
+                .subscribe(id -> logger.debug("ProductVerticle deployed successfully"));
+    }

     @Override
     public void start(Future<Void> startFuture) throws Exception {
-        logger.debug("Starting ProductHttpVerticle");
-        Router router = Router.router(vertx);
-        router.get("/*").handler(this::productServiceHandler);
-        vertx.createHttpServer()
-                .requestHandler(router::accept)
-                .rxListen(PORT)
-                .subscribe(s -> {
-                    logger.debug("Product HTTP server started on port {}", PORT);
-                    startFuture.complete();
-                }, error -> startFuture.fail(error));
-    }
-
-    private void productServiceHandler(RoutingContext context) {
-        logger.debug("Received a product service request");
-        context.response()
-                .putHeader("content-type", "application/json")
-                .end(new JsonObject().put("message", "Welcome to product service").encodePrettily());
+        super.start();
+        this.publishHttpServer()
+                .subscribe(record -> startFuture.complete(), startFuture::fail);
     }
 }
-~~~
+
+~~~

ServiceDiscovery modified by Gary Cheng

Gary Cheng — Wed, 04 Apr 2018 19:58:03 -0000

--- v1
+++ v2
@@ -1,3 +1,4 @@
+GatewayVerticle
 ~~~
 package com.example.discovery;

@@ -6,18 +7,21 @@
 import io.vertx.core.json.JsonObject;
 import io.vertx.reactivex.core.AbstractVerticle;
 import io.vertx.reactivex.core.Vertx;
+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.BodyHandler;
 import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
-
+import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
 import io.vertx.servicediscovery.rest.ServiceDiscoveryRestEndpoint;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class GatewayVerticle extends AbstractVerticle {
     private static final Logger logger = LoggerFactory.getLogger(GatewayVerticle.class);
-
+    private static final int PORT = 8080;
+    private static final String PREFIX_SERVICE = "/service/";
     private ServiceDiscovery discovery;

     public static void main(String[] args) throws InterruptedException {
@@ -29,29 +33,175 @@
     @Override
     public void start(Future<Void> startFuture) throws Exception {
         logger.debug("Starting GatewayVerticle");
-        discovery = ServiceDiscovery.create(vertx);
+        this.discovery = ServiceDiscovery.create(vertx);
         Router router = Router.router(vertx);
         ServiceDiscoveryRestEndpoint.create(router.getDelegate(), discovery.getDelegate());
-        this.configRouter(router);
-        router.get("/").handler(this::indexHandler);
-
-        vertx.createHttpServer().requestHandler(router::accept).rxListen(8080)
+        this.configureRouter(router);
+        vertx.createHttpServer()
+                .requestHandler(router::accept)
+                .rxListen(PORT)
                 .subscribe(s -> {
                     logger.debug("Gateway HTTP server started on port 8080");
                     startFuture.complete();
                 }, error -> startFuture.fail(error));
     }

-    private void configRouter(Router router) {
+    private void configureRouter(Router router) {
         router.route().handler(BodyHandler.create());
-        router.get("/*").handler(this::indexHandler);
+        router.route(PREFIX_SERVICE + "*").handler(this::serviceHandler);
+        router.route("/").handler(this::indexHandler);
     }

     private void indexHandler(RoutingContext context) {
+        logger.debug("Received http request");
         context.response()
                 .putHeader("content-type", "application/json")
-                .end(new JsonObject().put("message", "Hello from gateway").encodePrettily());
+                .end(new JsonObject().put("message", "Welcome to gateway").encodePrettily());
+    }
+
+    private void serviceHandler(RoutingContext context) {
+        String path = context.request().uri();
+        logger.debug("path:{}", path);
+        String serviceName = path.substring(PREFIX_SERVICE.length()).split("/")[0];
+        logger.debug("Service Name:{}", serviceName);
+        if (null == serviceName || serviceName.trim().equalsIgnoreCase("")) {
+            this.error(context, 500, "Empty service name");
+        } else {
+            HttpEndpoint.rxGetClient(discovery, new JsonObject().put("name", serviceName))
+                    .subscribe(httpClient -> this.dispatchRequest(context, httpClient), error -> this.serviceNotFound(context, serviceName));
+        }
+    }
+
+    private void dispatchRequest(RoutingContext context, HttpClient client) {
+        logger.debug("Dispatch Request, uri:{}", context.request().uri());
+        HttpClientRequest clientRequest = client.request(context.request().method(), context.request().uri());
+        clientRequest.toFlowable()
+                .flatMap(res -> {
+                    context.response().setStatusCode(res.statusCode());
+                    res.headers().getDelegate().forEach(header -> context.response().putHeader(header.getKey(), header.getValue()));
+                    return res.toFlowable();
+                })
+                .doAfterTerminate(() -> ServiceDiscovery.releaseServiceObject(discovery, client))
+                .subscribe(context.response()::end, error -> this.error(context, error));
+        context.request().headers().getDelegate().forEach(header -> clientRequest.putHeader(header.getKey(), header.getValue()));
+        if (null != context.getBody()) {
+            clientRequest.end(context.getBody());
+        } else {
+            clientRequest.end();
+        }
+    }
+
+    private void serviceNotFound(RoutingContext context, String serviceName) {
+        this.error(context, 404, "Service [" + serviceName + "] not found");
+    }
+
+    private void error(RoutingContext context, Throwable throwable) {
+        this.error(context, 500, throwable.getMessage());
+    }
+
+    private void error(RoutingContext context, int statusCode, String errorMessage) {
+        context.response().setStatusCode(statusCode).putHeader("content-type", "application/json")
+                .end(new JsonObject().put("statusCode", statusCode).put("error", errorMessage).encodePrettily());
     }
 }
-
-~~~
+~~~
+ProductVerticle
+~~~
+package com.example.discovery.product;
+
+import io.vertx.core.DeploymentOptions;
+import io.vertx.core.Future;
+import io.vertx.core.VertxOptions;
+import io.vertx.reactivex.core.AbstractVerticle;
+import io.vertx.reactivex.core.Vertx;
+import io.vertx.reactivex.servicediscovery.ServiceDiscovery;
+import io.vertx.reactivex.servicediscovery.types.HttpEndpoint;
+import io.vertx.servicediscovery.Record;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static com.example.discovery.product.ProductHttpVerticle.PORT;
+
+public class ProductVerticle extends AbstractVerticle {
+    private static final Logger logger = LoggerFactory.getLogger(ProductVerticle.class);
+
+    private static final String SERVICE_NAME = "product";
+
+    private ServiceDiscovery discovery;
+    private Record record;
+
+    public static void main(String[] args) throws InterruptedException {
+        Vertx.rxClusteredVertx(new VertxOptions().setClustered(true))
+                .flatMap(vertx -> vertx.rxDeployVerticle(ProductVerticle.class.getName()))
+                .subscribe(id -> logger.debug("ProductVerticle deployed successfully"));
+    }
+
+    @Override
+    public void start(Future<Void> startFuture) throws Exception {
+        logger.debug("Starting ProductVerticle");
+        this.discovery = ServiceDiscovery.create(vertx);
+        DeploymentOptions options = new DeploymentOptions().setConfig(config());
+        vertx.rxDeployVerticle(ProductHttpVerticle.class.getName(), options)
+                .flatMap(id -> discovery.rxPublish(HttpEndpoint.createRecord(SERVICE_NAME, "localhost", PORT, "/service/product")))
+                .subscribe(record -> {
+                    this.record = record;
+                    logger.debug("{} service has been published", SERVICE_NAME);
+                    startFuture.complete();
+                }, startFuture::fail);
+    }
+
+    @Override
+    public void stop(Future<Void> stopFuture) throws Exception {
+        if (null != discovery && null != record) {
+            discovery.rxUnpublish(this.record.getRegistration())
+                    .subscribe(() -> {
+                        logger.debug("Service {} has been un-published", SERVICE_NAME);
+                        stopFuture.complete();
+                    });
+        } else {
+            stopFuture.complete();
+        }
+    }
+}
+
+~~~
+
+ProductHttpVerticle
+~~~
+package com.example.discovery.product;
+
+import io.vertx.core.Future;
+import io.vertx.core.json.JsonObject;
+import io.vertx.reactivex.core.AbstractVerticle;
+import io.vertx.reactivex.ext.web.Router;
+import io.vertx.reactivex.ext.web.RoutingContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ProductHttpVerticle extends AbstractVerticle {
+
+    public static final int PORT = 8081;
+    private static final Logger logger = LoggerFactory.getLogger(ProductHttpVerticle.class);
+
+    @Override
+    public void start(Future<Void> startFuture) throws Exception {
+        logger.debug("Starting ProductHttpVerticle");
+        Router router = Router.router(vertx);
+        router.get("/*").handler(this::productServiceHandler);
+        vertx.createHttpServer()
+                .requestHandler(router::accept)
+                .rxListen(PORT)
+                .subscribe(s -> {
+                    logger.debug("Product HTTP server started on port {}", PORT);
+                    startFuture.complete();
+                }, error -> startFuture.fail(error));
+    }
+
+    private void productServiceHandler(RoutingContext context) {
+        logger.debug("Received a product service request");
+        context.response()
+                .putHeader("content-type", "application/json")
+                .end(new JsonObject().put("message", "Welcome to product service").encodePrettily());
+    }
+}
+~~~

ServiceDiscovery modified by Gary Cheng

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

package com.example.discovery;

import io.vertx.core.Future;
import io.vertx.core.VertxOptions;
import io.vertx.core.json.JsonObject;
import io.vertx.reactivex.core.AbstractVerticle;
import io.vertx.reactivex.core.Vertx;
import io.vertx.reactivex.ext.web.Router;
import io.vertx.reactivex.ext.web.RoutingContext;
import io.vertx.reactivex.ext.web.handler.BodyHandler;
import io.vertx.reactivex.servicediscovery.ServiceDiscovery;

import io.vertx.servicediscovery.rest.ServiceDiscoveryRestEndpoint;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class GatewayVerticle extends AbstractVerticle {
    private static final Logger logger = LoggerFactory.getLogger(GatewayVerticle.class);

    private ServiceDiscovery discovery;

    public static void main(String[] args) throws InterruptedException {
        Vertx.rxClusteredVertx(new VertxOptions().setClustered(true))
                .flatMap(vertx -> vertx.rxDeployVerticle(GatewayVerticle.class.getName()))
                .subscribe(id -> logger.debug("GatewayVerticle deployed successfully"));
    }

    @Override
    public void start(Future<Void> startFuture) throws Exception {
        logger.debug("Starting GatewayVerticle");
        discovery = ServiceDiscovery.create(vertx);
        Router router = Router.router(vertx);
        ServiceDiscoveryRestEndpoint.create(router.getDelegate(), discovery.getDelegate());
        this.configRouter(router);
        router.get("/").handler(this::indexHandler);

        vertx.createHttpServer().requestHandler(router::accept).rxListen(8080)
                .subscribe(s -> {
                    logger.debug("Gateway HTTP server started on port 8080");
                    startFuture.complete();
                }, error -> startFuture.fail(error));
    }

    private void configRouter(Router router) {
        router.route().handler(BodyHandler.create());
        router.get("/*").handler(this::indexHandler);
    }

    private void indexHandler(RoutingContext context) {
        context.response()
                .putHeader("content-type", "application/json")
                .end(new JsonObject().put("message", "Hello from gateway").encodePrettily());
    }
}