CircuitBreaker modified by Gary Cheng

Gary Cheng — Sun, 08 Apr 2018 20:51:24 -0000

--- v1
+++ v2
@@ -1,12 +1,11 @@
 ~~~
 package com.example.circuitbreaker;

-import io.reactivex.Flowable;
 import io.vertx.circuitbreaker.CircuitBreakerOptions;
-import io.vertx.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.Future;
 import io.vertx.reactivex.core.Vertx;
 import io.vertx.reactivex.core.http.HttpClientRequest;
 import io.vertx.reactivex.ext.web.Router;
@@ -20,13 +19,13 @@
     private static final int PORT = 8080;
     private CircuitBreaker circuitBreaker;

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

     @Override
-    public void start(Future<Void> startFuture) throws Exception {
+    public void start(io.vertx.core.Future<Void> startFuture) {
         logger.debug("Starting GatewayVerticle");
         Router router = Router.router(vertx);
         router.route().handler(BodyHandler.create());
@@ -34,9 +33,11 @@
         CircuitBreakerOptions options = new CircuitBreakerOptions()
                 .setMaxFailures(5)
                 .setTimeout(5000)
+                .setResetTimeout(30000)
                 .setFallbackOnFailure(true);
         this.circuitBreaker = CircuitBreaker.create("circuit-breaker", vertx, options)
                 .openHandler(v -> logger.debug("Circuit opened"))
+                .halfOpenHandler(v -> logger.debug("Circuit half opened"))
                 .closeHandler(v -> logger.debug("Circuit closed"));
         vertx.createHttpServer()
                 .requestHandler(router::accept)
@@ -49,75 +50,25 @@

     private void requestHandler(RoutingContext context) {
         logger.debug("Received http request");
-        circuitBreaker.rxExecuteCommandWithFallback(future -> this.dispachRequest(context), error -> this.fallbackHandler(context, error))
-                .<JsonObject>subscribe(json ->
-                        context.response()
-                                .putHeader("content-type", "application/json")
-                                .end(json.)
-
-                );
+        circuitBreaker.rxExecuteCommandWithFallback(this::invokeService, this::fallbackHandler)
+                .subscribe(json -> context.response()
+                        .putHeader("content-type", "application/json")
+                        .end(json.encodePrettily()));
     }

-    private Flowable<JsonObject> dispachRequest(RoutingContext context) {
+    private void invokeService(Future<JsonObject> future) {
         logger.debug("Sending request to service server");
         HttpClientRequest clientRequest = vertx.createHttpClient().get(8081, "localhost", "/");
-        Flowable<JsonObject> json = clientRequest.toFlowable()
-                .flatMap(res -> res.toFlowable()).flatMap(buffer -> Flowable.just(buffer.toJsonObject()));
+        clientRequest.toFlowable()
+                .flatMap(res -> res.toFlowable()).subscribe(buffer -> future.complete(buffer.toJsonObject()), error -> future.fail(error.getMessage()));
         clientRequest.end();
-        return json;
     }

-    private Flowable<JsonObject> fallbackHandler(RoutingContext context, Throwable error) {
+    private JsonObject fallbackHandler(Throwable error) {
         logger.debug("Handle fallback");
-        return Flowable.just(new JsonObject().put("message", "Service is not available, error message:" + error.getMessage()));
+        logger.debug(error.getClass().getName());
+        return new JsonObject().put("error", "Service is not available, reason:" + error.getMessage());
     }

 }
-
-
-package com.example.circuitbreaker;
-
-import io.vertx.core.Future;
-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 org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class ServiceVerticle extends AbstractVerticle {
-    private static final Logger logger = LoggerFactory.getLogger(ServiceVerticle.class);
-    private static final int PORT = 8081;
-
-    public static void main(String[] args) throws InterruptedException {
-        Vertx.vertx().rxDeployVerticle(ServiceVerticle.class.getName())
-                .subscribe(id -> logger.debug("ServiceVerticle deployed successfully"));
-    }
-
-    @Override
-    public void start(Future<Void> startFuture) throws Exception {
-        logger.debug("Starting ServiceVerticle");
-        Router router = Router.router(vertx);
-        router.route().handler(BodyHandler.create());
-        router.route("/*").handler(this::requestHandler);
-        vertx.createHttpServer()
-                .requestHandler(router::accept)
-                .rxListen(PORT)
-                .subscribe(s -> {
-                    logger.debug("Service HTTP server started on port 8081");
-                    startFuture.complete();
-                }, startFuture::fail);
-    }
-
-    private void requestHandler(RoutingContext context) {
-        logger.debug("Received http request");
-        context.response()
-                .putHeader("content-type", "application/json")
-                .end(new JsonObject().put("message", "Invoked service successful").encodePrettily());
-    }
-}
-
 ~~~
-

CircuitBreaker modified by Gary Cheng

Gary Cheng — Sat, 07 Apr 2018 00:27:11 -0000

package com.example.circuitbreaker;

import io.reactivex.Flowable;
import io.vertx.circuitbreaker.CircuitBreakerOptions;
import io.vertx.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.Vertx;
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 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 CircuitBreaker circuitBreaker;

    public static void main(String[] args) throws InterruptedException {
        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");
        Router router = Router.router(vertx);
        router.route().handler(BodyHandler.create());
        router.route("/*").handler(this::requestHandler);
        CircuitBreakerOptions options = new CircuitBreakerOptions()
                .setMaxFailures(5)
                .setTimeout(5000)
                .setFallbackOnFailure(true);
        this.circuitBreaker = CircuitBreaker.create("circuit-breaker", vertx, options)
                .openHandler(v -> logger.debug("Circuit opened"))
                .closeHandler(v -> logger.debug("Circuit closed"));
        vertx.createHttpServer()
                .requestHandler(router::accept)
                .rxListen(PORT)
                .subscribe(s -> {
                    logger.debug("Gateway HTTP server started on port 8080");
                    startFuture.complete();
                }, startFuture::fail);
    }

    private void requestHandler(RoutingContext context) {
        logger.debug("Received http request");
        circuitBreaker.rxExecuteCommandWithFallback(future -> this.dispachRequest(context), error -> this.fallbackHandler(context, error))
                .<JsonObject>subscribe(json ->
                        context.response()
                                .putHeader("content-type", "application/json")
                                .end(json.)

                );
    }

    private Flowable<JsonObject> dispachRequest(RoutingContext context) {
        logger.debug("Sending request to service server");
        HttpClientRequest clientRequest = vertx.createHttpClient().get(8081, "localhost", "/");
        Flowable<JsonObject> json = clientRequest.toFlowable()
                .flatMap(res -> res.toFlowable()).flatMap(buffer -> Flowable.just(buffer.toJsonObject()));
        clientRequest.end();
        return json;
    }

    private Flowable<JsonObject> fallbackHandler(RoutingContext context, Throwable error) {
        logger.debug("Handle fallback");
        return Flowable.just(new JsonObject().put("message", "Service is not available, error message:" + error.getMessage()));
    }

}

package com.example.circuitbreaker;

import io.vertx.core.Future;
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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ServiceVerticle extends AbstractVerticle {
    private static final Logger logger = LoggerFactory.getLogger(ServiceVerticle.class);
    private static final int PORT = 8081;

    public static void main(String[] args) throws InterruptedException {
        Vertx.vertx().rxDeployVerticle(ServiceVerticle.class.getName())
                .subscribe(id -> logger.debug("ServiceVerticle deployed successfully"));
    }

    @Override
    public void start(Future<Void> startFuture) throws Exception {
        logger.debug("Starting ServiceVerticle");
        Router router = Router.router(vertx);
        router.route().handler(BodyHandler.create());
        router.route("/*").handler(this::requestHandler);
        vertx.createHttpServer()
                .requestHandler(router::accept)
                .rxListen(PORT)
                .subscribe(s -> {
                    logger.debug("Service HTTP server started on port 8081");
                    startFuture.complete();
                }, startFuture::fail);
    }

    private void requestHandler(RoutingContext context) {
        logger.debug("Received http request");
        context.response()
                .putHeader("content-type", "application/json")
                .end(new JsonObject().put("message", "Invoked service successful").encodePrettily());
    }
}

Recent changes to CircuitBreaker

CircuitBreaker modified by Gary Cheng

CircuitBreaker modified by Gary Cheng