Package io.vertx.rxjava3.circuitbreaker

## Class CircuitBreaker

- java.lang.Object
- - io.vertx.rxjava3.circuitbreaker.CircuitBreaker

- All Implemented Interfaces:
    `io.vertx.lang.rx.RxDelegate`

      public class CircuitBreaker
      extends Object
      implements io.vertx.lang.rx.RxDelegate

  An implementation of the circuit breaker pattern for Vert.x

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static io.vertx.lang.rx.TypeArg<CircuitBreaker>` | `__TYPE_ARG` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `CircuitBreaker​(CircuitBreaker delegate)` |
    `CircuitBreaker​(Object delegate)` |

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `CircuitBreaker` | `close()` | Closes the circuit breaker.
    `CircuitBreaker` | `closeHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to closed.
    `static CircuitBreaker` | `create​(String name, Vertx vertx)` | Creates a new instance of `CircuitBreaker`, with default options.
    `static CircuitBreaker` | `create​(String name, Vertx vertx, CircuitBreakerOptions options)` | Creates a new instance of `CircuitBreaker`.
    `boolean` | `equals​(Object o)` |
    `<T> Single<T>` | `execute​(Handler<Promise<T>> command)` | Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Single<T>` | `execute​(Supplier<Single<T>> command)` | Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> CircuitBreaker` | `executeAndReport​(Promise<T> resultPromise, Handler<Promise<T>> command)` | Same as `executeAndReportWithFallback(io.vertx.rxjava3.core.Promise<T>, io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> CircuitBreaker` | `executeAndReportWithFallback​(Promise<T> resultPromise, Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | `executeWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | `executeWithFallback​(Supplier<Single<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `long` | `failureCount()` |
    `<T> CircuitBreaker` | `failurePolicy​(FailurePolicy<T> failurePolicy)` | Configures the failure policy for this circuit-breaker.
    `<T> CircuitBreaker` | `fallback​(Function<Throwable,​T> handler)` | Sets a default fallback to be invoked when the circuit breaker is open or when failure occurs and `CircuitBreakerOptions` is enabled.
    `CircuitBreaker` | `getDelegate()` |
    `CircuitBreaker` | `halfOpenHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to half-open.
    `int` | `hashCode()` |
    `String` | `name()` |
    `static CircuitBreaker` | `newInstance​(CircuitBreaker arg)` |
    `CircuitBreaker` | `open()` | Explicitly opens the circuit breaker.
    `CircuitBreaker` | `openHandler​(Handler<Void> handler)` | Sets a to be invoked when the circuit breaker state switches to open.
    `CircuitBreaker` | `reset()` | Resets the circuit breaker state.
    `CircuitBreaker` | `retryPolicy​(RetryPolicy retryPolicy)` | Set a `RetryPolicy` which computes a delay before a retry attempt.
    `<T> Single<T>` | `rxExecute​(Handler<Promise<T>> command)` | Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Single<T>` | `rxExecute​(Supplier<Single<T>> command)` | Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
    `<T> Single<T>` | `rxExecuteWithFallback​(Handler<Promise<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `<T> Single<T>` | `rxExecuteWithFallback​(Supplier<Single<T>> command, Function<Throwable,​T> fallback)` | Executes the given operation with the circuit breaker control.
    `CircuitBreakerState` | `state()` |
    `String` | `toString()` |

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<CircuitBreaker> __TYPE_ARG

  - ### Constructor Detail

    - #### CircuitBreaker

          public CircuitBreaker​(CircuitBreaker delegate)

    - #### CircuitBreaker

          public CircuitBreaker​(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals​(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public CircuitBreaker getDelegate()

      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`

    - #### create

          public static CircuitBreaker create​(String name,
                                              Vertx vertx,
                                              CircuitBreakerOptions options)

      Creates a new instance of `CircuitBreaker`.
      Parameters:
        `name` - the name
        `vertx` - the Vert.x instance
        `options` - the configuration options
      Returns:
        the created instance

    - #### create

          public static CircuitBreaker create​(String name,
                                              Vertx vertx)

      Creates a new instance of `CircuitBreaker`, with default options.
      Parameters:
        `name` - the name
        `vertx` - the Vert.x instance
      Returns:
        the created instance

    - #### close

          public CircuitBreaker close()

      Closes the circuit breaker. It stops sending events on its state on the event bus.

      This method is not related to the `closed` state of the circuit breaker. To move the circuit breaker to the `closed` state, use `reset()`.

      Returns:

    - #### openHandler

          public CircuitBreaker openHandler​(Handler<Void> handler)

      Sets a to be invoked when the circuit breaker state switches to open.
      Parameters:
        `handler` - the handler, must not be `null`
      Returns:
        this `CircuitBreaker`

    - #### halfOpenHandler

          public CircuitBreaker halfOpenHandler​(Handler<Void> handler)

      Sets a to be invoked when the circuit breaker state switches to half-open.
      Parameters:
        `handler` - the handler, must not be `null`
      Returns:
        this `CircuitBreaker`

    - #### closeHandler

          public CircuitBreaker closeHandler​(Handler<Void> handler)

      Sets a to be invoked when the circuit breaker state switches to closed.
      Parameters:
        `handler` - the handler, must not be `null`
      Returns:
        this `CircuitBreaker`

    - #### executeWithFallback

          public <T> Single<T> executeWithFallback​(Handler<Promise<T>> command,
                                                   Function<Throwable,​T> fallback)

      Executes the given operation with the circuit breaker control. The operation is generally calling an external system. The operation receives a object as parameter and must call when the operation has terminated successfully. The operation must also call in case of a failure.

      The operation is not invoked if the circuit breaker is open, and the given fallback is called instead. The circuit breaker also monitors whether the operation completes in time. The operation is considered failed if it does not terminate before the configured timeout.

      This method returns a object to retrieve the status and result of the operation, with the status being a success or a failure. If the fallback is called, the returned future is successfully completed with the value returned from the fallback. If the fallback throws an exception, the returned future is marked as failed.

      Parameters:
        `command` - the operation
        `fallback` - the fallback function; gets an exception as parameter and returns the fallback result
      Returns:
        a future object completed when the operation or the fallback completes

    - #### rxExecuteWithFallback

          public <T> Single<T> rxExecuteWithFallback​(Handler<Promise<T>> command,
                                                     Function<Throwable,​T> fallback)

      Executes the given operation with the circuit breaker control. The operation is generally calling an external system. The operation receives a object as parameter and must call when the operation has terminated successfully. The operation must also call in case of a failure.

      The operation is not invoked if the circuit breaker is open, and the given fallback is called instead. The circuit breaker also monitors whether the operation completes in time. The operation is considered failed if it does not terminate before the configured timeout.

      This method returns a object to retrieve the status and result of the operation, with the status being a success or a failure. If the fallback is called, the returned future is successfully completed with the value returned from the fallback. If the fallback throws an exception, the returned future is marked as failed.

      Parameters:
        `command` - the operation
        `fallback` - the fallback function; gets an exception as parameter and returns the fallback result
      Returns:
        a future object completed when the operation or the fallback completes

    - #### executeWithFallback

          public <T> Single<T> executeWithFallback​(Supplier<Single<T>> command,
                                                   Function<Throwable,​T> fallback)

      Executes the given operation with the circuit breaker control. The operation is generally calling an external system. The operation receives a object as parameter and must call when the operation has terminated successfully. The operation must also call in case of a failure.

      The operation is not invoked if the circuit breaker is open, and the given fallback is called instead. The circuit breaker also monitors whether the operation completes in time. The operation is considered failed if it does not terminate before the configured timeout.

      This method returns a object to retrieve the status and result of the operation, with the status being a success or a failure. If the fallback is called, the returned future is successfully completed with the value returned from the fallback. If the fallback throws an exception, the returned future is marked as failed.

      Parameters:
        `command` - the operation
        `fallback` - the fallback function; gets an exception as parameter and returns the fallback result
      Returns:
        a future object completed when the operation or the fallback completes

    - #### rxExecuteWithFallback

          public <T> Single<T> rxExecuteWithFallback​(Supplier<Single<T>> command,
                                                     Function<Throwable,​T> fallback)

      Executes the given operation with the circuit breaker control. The operation is generally calling an external system. The operation receives a object as parameter and must call when the operation has terminated successfully. The operation must also call in case of a failure.

      The operation is not invoked if the circuit breaker is open, and the given fallback is called instead. The circuit breaker also monitors whether the operation completes in time. The operation is considered failed if it does not terminate before the configured timeout.

      This method returns a object to retrieve the status and result of the operation, with the status being a success or a failure. If the fallback is called, the returned future is successfully completed with the value returned from the fallback. If the fallback throws an exception, the returned future is marked as failed.

      Parameters:
        `command` - the operation
        `fallback` - the fallback function; gets an exception as parameter and returns the fallback result
      Returns:
        a future object completed when the operation or the fallback completes

    - #### execute

          public <T> Single<T> execute​(Handler<Promise<T>> command)

      Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
      Parameters:
        `command` - the operation
      Returns:
        a future object completed when the operation or its fallback completes

    - #### rxExecute

          public <T> Single<T> rxExecute​(Handler<Promise<T>> command)

      Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
      Parameters:
        `command` - the operation
      Returns:
        a future object completed when the operation or its fallback completes

    - #### execute

          public <T> Single<T> execute​(Supplier<Single<T>> command)

      Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
      Parameters:
        `command` - the operation
      Returns:
        a future object completed when the operation or its fallback completes

    - #### rxExecute

          public <T> Single<T> rxExecute​(Supplier<Single<T>> command)

      Same as `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
      Parameters:
        `command` - the operation
      Returns:
        a future object completed when the operation or its fallback completes

    - #### executeAndReport

          public <T> CircuitBreaker executeAndReport​(Promise<T> resultPromise,
                                                     Handler<Promise<T>> command)

      Same as `executeAndReportWithFallback(io.vertx.rxjava3.core.Promise<T>, io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)` but using the circuit breaker .
      Parameters:
        `resultPromise` - the promise on which the operation result is reported
        `command` - the operation
      Returns:
        this `CircuitBreaker`

    - #### executeAndReportWithFallback

          public <T> CircuitBreaker executeAndReportWithFallback​(Promise<T> resultPromise,
                                                                 Handler<Promise<T>> command,
                                                                 Function<Throwable,​T> fallback)

      Executes the given operation with the circuit breaker control. The operation is generally calling an external system. The operation receives a object as parameter and must call when the operation has terminated successfully. The operation must also call in case of a failure.

      The operation is not invoked if the circuit breaker is open, and the given fallback is called instead. The circuit breaker also monitors whether the operation completes in time. The operation is considered failed if it does not terminate before the configured timeout.

      Unlike `executeWithFallback(io.vertx.core.Handler<io.vertx.rxjava3.core.Promise<T>>, java.util.function.Function<java.lang.Throwable, T>)`, this method does not return a object, but lets the caller pass a object on which the result is reported. If the fallback is called, the promise is successfully completed with the value returned by the fallback function. If the fallback throws an exception, the promise is marked as failed.

      Parameters:
        `resultPromise` - the promise on which the operation result is reported
        `command` - the operation
        `fallback` - the fallback function; gets an exception as parameter and returns the fallback result
      Returns:
        this `CircuitBreaker`

    - #### fallback

          public <T> CircuitBreaker fallback​(Function<Throwable,​T> handler)

      Sets a default fallback to be invoked when the circuit breaker is open or when failure occurs and `CircuitBreakerOptions` is enabled.

      The function gets the exception as parameter and returns the fallback result.

      Parameters:
        `handler` - the fallback handler
      Returns:
        this `CircuitBreaker`

    - #### failurePolicy

          public <T> CircuitBreaker failurePolicy​(FailurePolicy<T> failurePolicy)

      Configures the failure policy for this circuit-breaker.
      Parameters:
        `failurePolicy` -
      Returns:
        the current `CircuitBreaker`

    - #### reset

          public CircuitBreaker reset()

      Resets the circuit breaker state. The number of recent failures is set to 0 and if the state is half-open, it is set to closed.
      Returns:
        this `CircuitBreaker`

    - #### open

          public CircuitBreaker open()

      Explicitly opens the circuit breaker.
      Returns:
        this `CircuitBreaker`

    - #### state

          public CircuitBreakerState state()

      Returns:
        the current state of this circuit breaker

    - #### failureCount

          public long failureCount()

      Returns:
        the current number of recorded failures

    - #### name

          public String name()

      Returns:
        the name of this circuit breaker

    - #### retryPolicy

          public CircuitBreaker retryPolicy​(RetryPolicy retryPolicy)

      Set a `RetryPolicy` which computes a delay before a retry attempt.
      Parameters:
        `retryPolicy` -
      Returns:

    - #### newInstance

          public static CircuitBreaker newInstance​(CircuitBreaker arg)