org.swisspush.gateleen.queue.queuing.circuitbreaker.impl

Class QueueCircuitBreakerImpl

java.lang.Object

org.swisspush.gateleen.queue.queuing.circuitbreaker.impl.QueueCircuitBreakerImpl

All Implemented Interfaces:

Refreshable, QueueCircuitBreaker, RuleProvider.RuleChangesObserver

public class QueueCircuitBreakerImpl
extends Object
implements QueueCircuitBreaker, RuleProvider.RuleChangesObserver, Refreshable

Author:

https://github.com/mcweba [Marc-Andre Weber]

Field Summary

Fields

Modifier and Type	Field and Description
static String	OPEN_TO_HALF_OPEN_TASK_LOCK
static String	UNLOCK_QUEUES_TASK_LOCK
static String	UNLOCK_SAMPLE_QUEUES_TASK_LOCK

Constructor Summary

Constructors

Constructor and Description

QueueCircuitBreakerImpl(io.vertx.core.Vertx vertx, Lock lock, String redisquesAddress, QueueCircuitBreakerStorage queueCircuitBreakerStorage, RuleProvider ruleProvider, QueueCircuitBreakerRulePatternToCircuitMapping ruleToCircuitMapping, QueueCircuitBreakerConfigurationResourceManager configResourceManager, io.vertx.core.Handler<io.vertx.core.http.HttpServerRequest> queueCircuitBreakerHttpRequestHandler, int requestHandlerPort) Constructor for the QueueCircuitBreakerImpl.

Method Summary

Modifier and Type	Method and Description
io.vertx.core.Future<Void>	closeAllCircuits() Closes all non-closed circuits.
io.vertx.core.Future<Void>	closeCircuit(HttpRequest queuedRequest) Closes the circuit representing the queued request.
io.vertx.core.Future<QueueCircuitState>	handleQueuedRequest(String queueName, HttpRequest queuedRequest) Handles a queued request by checking the current QueueCircuitState of the corresponding circuit.
boolean	isCircuitCheckEnabled() Check whether the circuit check is enabled.
boolean	isStatisticsUpdateEnabled() Check whether the statistics update is enabled.
io.vertx.core.Future<Void>	lockQueue(String queueName, HttpRequest queuedRequest) Locks the queue having the provided queueName by calling the vertx-redisques API.
void	refresh()
io.vertx.core.Future<Void>	reOpenCircuit(HttpRequest queuedRequest) Re-Opens the (half-open) circuit representing the provided queued request again.
void	rulesChanged(List<Rule> rules)
io.vertx.core.Future<Long>	setOpenCircuitsToHalfOpen() Changes the status of all circuits having a status equals QueueCircuitState.OPEN to QueueCircuitState.HALF_OPEN.
io.vertx.core.Future<String>	unlockNextQueue() Unlocks the next queue in-line.
io.vertx.core.Future<String>	unlockQueue(String queueName) Unlocks the queue having the provided queueName by calling the vertx-redisques API.
io.vertx.core.Future<Long>	unlockSampleQueues() Unlocks a sample queue of all circuits having a status equals QueueCircuitState.HALF_OPEN.
io.vertx.core.Future<Void>	updateStatistics(String queueName, HttpRequest queuedRequest, QueueResponseType queueResponseType) Updates the statistics of the corresponding circuit based on the provided request to execute.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

OPEN_TO_HALF_OPEN_TASK_LOCK

public static final String OPEN_TO_HALF_OPEN_TASK_LOCK

See Also:

Constant Field Values

UNLOCK_QUEUES_TASK_LOCK

public static final String UNLOCK_QUEUES_TASK_LOCK

See Also:

Constant Field Values

UNLOCK_SAMPLE_QUEUES_TASK_LOCK

public static final String UNLOCK_SAMPLE_QUEUES_TASK_LOCK

See Also:

Constant Field Values

Constructor Detail

QueueCircuitBreakerImpl

public QueueCircuitBreakerImpl(io.vertx.core.Vertx vertx,
                               Lock lock,
                               String redisquesAddress,
                               QueueCircuitBreakerStorage queueCircuitBreakerStorage,
                               RuleProvider ruleProvider,
                               QueueCircuitBreakerRulePatternToCircuitMapping ruleToCircuitMapping,
                               QueueCircuitBreakerConfigurationResourceManager configResourceManager,
                               io.vertx.core.Handler<io.vertx.core.http.HttpServerRequest> queueCircuitBreakerHttpRequestHandler,
                               int requestHandlerPort)

Constructor for the QueueCircuitBreakerImpl.

Parameters:

vertx - vertx

lock - the lock implementation

redisquesAddress - the event bus address of redisques

queueCircuitBreakerStorage - the storage

ruleProvider - the provider for the rule objects

ruleToCircuitMapping - ruleToCircuitMapping helper class

configResourceManager - the manager for the configuration resource

queueCircuitBreakerHttpRequestHandler - request handler

requestHandlerPort - the port to listen to

Method Detail

rulesChanged

public void rulesChanged(List<Rule> rules)

Specified by:

rulesChanged in interface RuleProvider.RuleChangesObserver

refresh

public void refresh()

Specified by:

refresh in interface Refreshable

isCircuitCheckEnabled

public boolean isCircuitCheckEnabled()

Description copied from interface: QueueCircuitBreaker

Check whether the circuit check is enabled. The circuit check can be enabled/disabled with the 'circuitCheckEnabled' configuration property.

Specified by:

isCircuitCheckEnabled in interface QueueCircuitBreaker

Returns:

returns true when circuit check is enabled, false otherwise

isStatisticsUpdateEnabled

public boolean isStatisticsUpdateEnabled()

Description copied from interface: QueueCircuitBreaker

Check whether the statistics update is enabled. The statistics update can be enabled/disabled with the 'statisticsUpdateEnabled' configuration property.

Specified by:

isStatisticsUpdateEnabled in interface QueueCircuitBreaker

Returns:

returns true when statistics update is enabled, false otherwise

handleQueuedRequest

public io.vertx.core.Future<QueueCircuitState> handleQueuedRequest(String queueName,
                                                                   HttpRequest queuedRequest)

Description copied from interface: QueueCircuitBreaker

Handles a queued request by checking the current QueueCircuitState of the corresponding circuit. When the QueueCircuitState of the corresponding circuit equals QueueCircuitState.OPEN, the provided queueName will be locked.

Specified by:

handleQueuedRequest in interface QueueCircuitBreaker

Parameters:

queueName - the name of the queue

queuedRequest - the queued request

Returns:

returns a QueueCircuitState representing the current status of the circuit

updateStatistics

public io.vertx.core.Future<Void> updateStatistics(String queueName,
                                                   HttpRequest queuedRequest,
                                                   QueueResponseType queueResponseType)

Description copied from interface: QueueCircuitBreaker

Updates the statistics of the corresponding circuit based on the provided request to execute.

Updating the statistics includes the following steps:

• Record queuedRequest as failed when queueResponseType equals QueueResponseType.FAILURE
• Record queuedRequest as success when queueResponseType equals QueueResponseType.SUCCESS
• Calculate failRatio based on fail/success records
• Change status of corresponding circuit to 'OPEN' when failRatio threshold is reached

Specified by:

updateStatistics in interface QueueCircuitBreaker

Parameters:

queueName - the name of the queue

queuedRequest - the queued request

queueResponseType - the QueueResponseType representing the execution result of the queuedRequest

Returns:

returns a void future when statistics could be updated successfully.

closeCircuit

public io.vertx.core.Future<Void> closeCircuit(HttpRequest queuedRequest)

Description copied from interface: QueueCircuitBreaker

Closes the circuit representing the queued request.

Closing the circuit includes the following steps:

• Clear statistics of this circuit
• Reset failRatio of this circuit to zero
• Set status of this circuit to 'CLOSED'
• Unlock all queues related to this circuit

Specified by:

closeCircuit in interface QueueCircuitBreaker

Parameters:

queuedRequest - the queued request

Returns:

returns a void future when circuit could be closed successfully.

closeAllCircuits

public io.vertx.core.Future<Void> closeAllCircuits()

Description copied from interface: QueueCircuitBreaker

Closes all non-closed circuits.

Closing all non-closed circuits includes the following steps:

• Clear statistics of all non-closed circuits
• Reset failRatio of all non-closed circuits to zero
• Set status of all non-closed circuits to 'CLOSED'
• Unlock all queues related to all non-closed circuits

Specified by:

closeAllCircuits in interface QueueCircuitBreaker

Returns:

returns a void future when all non-closed circuits could be closed successfully.

reOpenCircuit

public io.vertx.core.Future<Void> reOpenCircuit(HttpRequest queuedRequest)

Description copied from interface: QueueCircuitBreaker

Re-Opens the (half-open) circuit representing the provided queued request again. Circuits should be re-opened after a sample queue request was not successful.

Specified by:

reOpenCircuit in interface QueueCircuitBreaker

Parameters:

queuedRequest - the queued request

Returns:

returns a void future when the circuit representing the provided queued request could be re-opened successfully

lockQueue

public io.vertx.core.Future<Void> lockQueue(String queueName,
                                            HttpRequest queuedRequest)

Description copied from interface: QueueCircuitBreaker

Locks the queue having the provided queueName by calling the vertx-redisques API. Additionally, marks the queueName as a locked queue of the circuit representing the provided queuedRequest.

Specified by:

lockQueue in interface QueueCircuitBreaker

Parameters:

queueName - the name of the queue

queuedRequest - the queued request

Returns:

returns a void future when the queue could be locked successfully through vertx-redisques and also successfully marked as a locked queue of the circuit.

unlockNextQueue

public io.vertx.core.Future<String> unlockNextQueue()

Description copied from interface: QueueCircuitBreaker

Unlocks the next queue in-line. Does nothing when there's no next queue to unlock. Returns a null string in this case.

Specified by:

unlockNextQueue in interface QueueCircuitBreaker

Returns:

returns a string future holding the name of the queue which was successfully unlocked. Also returns the name of the queue (as failureMessage) when the next queue could not be unlocked. Returns a null string when no queue was available to unlock.

setOpenCircuitsToHalfOpen

public io.vertx.core.Future<Long> setOpenCircuitsToHalfOpen()

Description copied from interface: QueueCircuitBreaker

Changes the status of all circuits having a status equals QueueCircuitState.OPEN to QueueCircuitState.HALF_OPEN.

Specified by:

setOpenCircuitsToHalfOpen in interface QueueCircuitBreaker

Returns:

returns a future holding the amount of circuits updated

unlockSampleQueues

public io.vertx.core.Future<Long> unlockSampleQueues()

Description copied from interface: QueueCircuitBreaker

Unlocks a sample queue of all circuits having a status equals QueueCircuitState.HALF_OPEN. The sample queues are always the queues which have not been unlocked the longest.

Specified by:

unlockSampleQueues in interface QueueCircuitBreaker

Returns:

returns a future holding the amount of unlocked sample queues

unlockQueue

public io.vertx.core.Future<String> unlockQueue(String queueName)

Description copied from interface: QueueCircuitBreaker

Unlocks the queue having the provided queueName by calling the vertx-redisques API.

Specified by:

unlockQueue in interface QueueCircuitBreaker

Parameters:

queueName - the name of the queue

Returns:

returns a string future holding the name of the queue when successfully unlocked. Also returns the name of the queue (as failureMessage) when the unlocking failed.