HystrixCommand (Hystrix Javadoc 1.5.3)

java.lang.Object
- com.netflix.hystrix.HystrixCommand<R>

Type Parameters:

R - the return type

All Implemented Interfaces:

HystrixExecutable<R>, HystrixInvokable<R>, HystrixInvokableInfo<R>, HystrixObservable<R>
```
public abstract class HystrixCommand<R>
extends java.lang.Object
implements HystrixExecutable<R>, HystrixInvokableInfo<R>, HystrixObservable<R>
```
Used to wrap code that will execute potentially risky functionality (typically meaning a service call over the network) with fault and latency tolerance, statistics and performance metrics capture, circuit breaker and bulkhead functionality. This command is essentially a blocking command but provides an Observable facade if used with observe()

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AbstractCommand.CommandState`
`protected static class`	`AbstractCommand.ThreadState`
`protected static class`	`AbstractCommand.TimedOutStatus`
`static class`	`HystrixCommand.Setter` Fluent interface for arguments to the `HystrixCommand` constructor.

Field Summary

Fields
Modifier and Type	Field and Description
`protected HystrixCircuitBreaker`	`circuitBreaker`
`protected HystrixCommandGroupKey`	`commandGroup`
`protected HystrixCommandKey`	`commandKey`
`protected long`	`commandStartTimestamp`
`protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.CommandState>`	`commandState`
`protected HystrixConcurrencyStrategy`	`concurrencyStrategy`
`protected HystrixRequestLog`	`currentRequestLog`
`protected rx.functions.Action0`	`endCurrentThreadExecutingCommand`
`protected HystrixEventNotifier`	`eventNotifier` Plugin implementations
`protected HystrixCommandExecutionHook`	`executionHook`
`protected ExecutionResult`	`executionResult`
`protected ExecutionResult`	`executionResultAtTimeOfCancellation`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`executionSemaphoreOverride`
`protected static java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore>`	`executionSemaphorePerCircuit`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`fallbackSemaphoreOverride`
`protected static java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore>`	`fallbackSemaphorePerCircuit`
`protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.TimedOutStatus>`	`isCommandTimedOut`
`protected boolean`	`isResponseFromCache`
`protected HystrixCommandMetrics`	`metrics`
`protected HystrixCommandProperties`	`properties`
`protected HystrixRequestCache`	`requestCache` Instance of RequestCache logic
`protected HystrixThreadPool`	`threadPool`
`protected HystrixThreadPoolKey`	`threadPoolKey`
`protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.ThreadState>`	`threadState`
`protected java.util.concurrent.atomic.AtomicReference<java.lang.ref.Reference<com.netflix.hystrix.util.HystrixTimer.TimerListener>>`	`timeoutTimer`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`HystrixCommand(HystrixCommand.Setter setter)` Construct a `HystrixCommand` with defined `HystrixCommand.Setter` that allows injecting property and strategy overrides and other optional arguments.
`protected`	`HystrixCommand(HystrixCommandGroupKey group)` Construct a `HystrixCommand` with defined `HystrixCommandGroupKey`.
`protected`	`HystrixCommand(HystrixCommandGroupKey group, int executionIsolationThreadTimeoutInMilliseconds)` Construct a `HystrixCommand` with defined `HystrixCommandGroupKey` and thread timeout
`protected`	`HystrixCommand(HystrixCommandGroupKey group, HystrixThreadPoolKey threadPool)` Construct a `HystrixCommand` with defined `HystrixCommandGroupKey` and `HystrixThreadPoolKey`.
`protected`	`HystrixCommand(HystrixCommandGroupKey group, HystrixThreadPoolKey threadPool, int executionIsolationThreadTimeoutInMilliseconds)` Construct a `HystrixCommand` with defined `HystrixCommandGroupKey`, `HystrixThreadPoolKey`, and thread timeout.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected java.lang.RuntimeException`	`decomposeException(java.lang.Exception e)` Take an Exception and determine whether to throw it, its cause or a new HystrixRuntimeException.
`R`	`execute()` Used for synchronous execution of command.
`protected java.lang.String`	`getCacheKey()` Key to be used for request caching.
`HystrixCommandGroupKey`	`getCommandGroup()`
`HystrixCommandKey`	`getCommandKey()`
`long`	`getCommandRunStartTimeInNanos()` Time in Nanos when this command instance's run method was called, or -1 if not executed for e.g., command threw an exception
`ExecutionResult.EventCounts`	`getEventCounts()`
`protected java.lang.Exception`	`getExceptionFromThrowable(java.lang.Throwable t)`
`java.util.List<HystrixEventType>`	`getExecutionEvents()` List of HystrixCommandEventType enums representing events that occurred during execution.
`java.lang.Throwable`	`getExecutionException()` Get the Throwable/Exception emitted by this command instance prior to checking the fallback.
`protected rx.Observable<R>`	`getExecutionObservable()`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`getExecutionSemaphore()` Get the TryableSemaphore this HystrixCommand should use for execution if not running in a separate thread.
`int`	`getExecutionTimeInMilliseconds()` The execution time of this command instance in milliseconds, or -1 if not executed.
`java.lang.Throwable`	`getFailedExecutionException()` Get the Throwable/Exception thrown that caused the failure.
`protected R`	`getFallback()` If `execute()` or `queue()` fails in any way then this method will be invoked to provide an opportunity to return a fallback response.
`protected java.lang.String`	`getFallbackMethodName()` Each concrete implementation of AbstractCommand should return the name of the fallback method as a String This will be used to determine if the fallback "exists" for firing the onFallbackStart/onFallbackError hooks
`protected rx.Observable<R>`	`getFallbackObservable()`
`protected com.netflix.hystrix.AbstractCommand.TryableSemaphore`	`getFallbackSemaphore()` Get the TryableSemaphore this HystrixCommand should use if a fallback occurs.
`protected java.lang.String`	`getLogMessagePrefix()`
`HystrixCommandMetrics`	`getMetrics()` The `HystrixCommandMetrics` associated with this `AbstractCommand` instance.
`int`	`getNumberCollapsed()`
`int`	`getNumberEmissions()` Number of emissions of the execution of a command.
`int`	`getNumberFallbackEmissions()` Number of emissions of the execution of a fallback.
`HystrixCollapserKey`	`getOriginatingCollapserKey()`
`HystrixCommandProperties`	`getProperties()` The `HystrixCommandProperties` associated with this `AbstractCommand` instance.
`java.lang.String`	`getPublicCacheKey()`
`HystrixThreadPoolKey`	`getThreadPoolKey()`
`protected void`	`handleThreadEnd(com.netflix.hystrix.AbstractCommand<R> _cmd)`
`boolean`	`isCircuitBreakerOpen()` Whether the 'circuit-breaker' is open meaning that `execute()` will immediately return the `getFallback()` response and not attempt a HystrixCommand execution.
`boolean`	`isExecutedInThread()` Whether the execution occurred in a separate thread.
`boolean`	`isExecutionComplete()` If this command has completed execution either successfully, via fallback or failure.
`boolean`	`isFailedExecution()` Whether the `run()` resulted in a failure (exception).
`protected boolean`	`isRequestCachingEnabled()`
`boolean`	`isResponseFromCache()` Whether the response is from cache and `run()` was not invoked.
`boolean`	`isResponseFromFallback()` Whether the response received from was the result of some type of failure and `getFallback()` being called.
`boolean`	`isResponseRejected()` Whether the response received was a fallback as result of being rejected (either via threadpool or semaphore)
`boolean`	`isResponseSemaphoreRejected()` Whether the response received was a fallback as result of being rejected via sempahore
`boolean`	`isResponseShortCircuited()` Whether the response received was a fallback as result of being short-circuited (meaning `isCircuitBreakerOpen() == true`) and `getFallback()` being called.
`boolean`	`isResponseThreadPoolRejected()` Whether the response received was a fallback as result of being rejected via threadpool
`boolean`	`isResponseTimedOut()` Whether the response received was the result of a timeout and `getFallback()` being called.
`boolean`	`isSuccessfulExecution()` Whether the response was returned successfully either by executing `run()` or from cache.
`rx.Observable<R>`	`observe()` Used for asynchronous execution of command with a callback by subscribing to the `Observable`.
`java.util.concurrent.Future<R>`	`queue()` Used for asynchronous execution of command.
`protected abstract R`	`run()` Implement this method with code to be executed when `execute()` or `queue()` are invoked.
`protected boolean`	`shouldOutputOnNextEvents()`
`rx.Observable<R>`	`toObservable()` Used for asynchronous execution of command with a callback by subscribing to the `Observable`.

Methods inherited from interface com.netflix.hystrix.HystrixExecutable
observe

Methods inherited from interface com.netflix.hystrix.HystrixObservable
observe, toObservable

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - circuitBreaker
```
protected final HystrixCircuitBreaker circuitBreaker
```
  - commandGroup
```
protected final HystrixCommandGroupKey commandGroup
```
  - commandKey
```
protected final HystrixCommandKey commandKey
```
  - commandStartTimestamp
```
protected volatile long commandStartTimestamp
```
  - commandState
```
protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.CommandState> commandState
```
  - concurrencyStrategy
```
protected final HystrixConcurrencyStrategy concurrencyStrategy
```
  - currentRequestLog
```
protected final HystrixRequestLog currentRequestLog
```
  - endCurrentThreadExecutingCommand
```
protected volatile rx.functions.Action0 endCurrentThreadExecutingCommand
```
  - eventNotifier
```
protected final HystrixEventNotifier eventNotifier
```
    Plugin implementations
  - executionHook
```
protected final HystrixCommandExecutionHook executionHook
```
  - executionResult
```
protected volatile ExecutionResult executionResult
```
  - executionResultAtTimeOfCancellation
```
protected volatile ExecutionResult executionResultAtTimeOfCancellation
```
  - executionSemaphoreOverride
```
protected final com.netflix.hystrix.AbstractCommand.TryableSemaphore executionSemaphoreOverride
```
  - executionSemaphorePerCircuit
```
protected static final java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore> executionSemaphorePerCircuit
```
  - fallbackSemaphoreOverride
```
protected final com.netflix.hystrix.AbstractCommand.TryableSemaphore fallbackSemaphoreOverride
```
  - fallbackSemaphorePerCircuit
```
protected static final java.util.concurrent.ConcurrentHashMap<java.lang.String,com.netflix.hystrix.AbstractCommand.TryableSemaphore> fallbackSemaphorePerCircuit
```
  - isCommandTimedOut
```
protected final java.util.concurrent.atomic.AtomicReference<AbstractCommand.TimedOutStatus> isCommandTimedOut
```
  - isResponseFromCache
```
protected volatile boolean isResponseFromCache
```
  - metrics
```
protected final HystrixCommandMetrics metrics
```
  - properties
```
protected final HystrixCommandProperties properties
```
  - requestCache
```
protected final HystrixRequestCache requestCache
```
    Instance of RequestCache logic
  - threadPool
```
protected final HystrixThreadPool threadPool
```
  - threadPoolKey
```
protected final HystrixThreadPoolKey threadPoolKey
```
  - threadState
```
protected java.util.concurrent.atomic.AtomicReference<AbstractCommand.ThreadState> threadState
```
  - timeoutTimer
```
protected final java.util.concurrent.atomic.AtomicReference<java.lang.ref.Reference<com.netflix.hystrix.util.HystrixTimer.TimerListener>> timeoutTimer
```
- Constructor Detail
  - HystrixCommand
```
protected HystrixCommand(HystrixCommand.Setter setter)
```
    Construct a HystrixCommand with defined HystrixCommand.Setter that allows injecting property and strategy overrides and other optional arguments.
    NOTE: The HystrixCommandKey is used to associate a HystrixCommand with HystrixCircuitBreaker, HystrixCommandMetrics and other objects.
    Do not create multiple HystrixCommand implementations with the same HystrixCommandKey but different injected default properties as the first instantiated will win.
    Properties passed in via HystrixCommand.Setter.andCommandPropertiesDefaults(com.netflix.hystrix.HystrixCommandProperties.Setter) or HystrixCommand.Setter.andThreadPoolPropertiesDefaults(com.netflix.hystrix.HystrixThreadPoolProperties.Setter) are cached for the given HystrixCommandKey for the life of the JVM or until Hystrix.reset() is called. Dynamic properties allow runtime changes. Read more on the Hystrix Wiki.
    
    Parameters:
    
    setter - Fluent interface for constructor arguments
  - HystrixCommand
```
protected HystrixCommand(HystrixCommandGroupKey group)
```
    Construct a HystrixCommand with defined HystrixCommandGroupKey.
    The HystrixCommandKey will be derived from the implementing class name.
    
    Parameters:
    
    group - HystrixCommandGroupKey used to group together multiple HystrixCommand objects.
    The HystrixCommandGroupKey is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interact with, common business purpose etc.
  - HystrixCommand
```
protected HystrixCommand(HystrixCommandGroupKey group,
                         int executionIsolationThreadTimeoutInMilliseconds)
```
    Construct a HystrixCommand with defined HystrixCommandGroupKey and thread timeout
    The HystrixCommandKey will be derived from the implementing class name.
    
    Parameters:
    
    group - HystrixCommandGroupKey used to group together multiple HystrixCommand objects.
    The HystrixCommandGroupKey is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interact with, common business purpose etc.
    
    executionIsolationThreadTimeoutInMilliseconds - Time in milliseconds at which point the calling thread will timeout (using Future.get()) and walk away from the executing thread.
  - HystrixCommand
```
protected HystrixCommand(HystrixCommandGroupKey group,
                         HystrixThreadPoolKey threadPool)
```
    Construct a HystrixCommand with defined HystrixCommandGroupKey and HystrixThreadPoolKey.
    The HystrixCommandKey will be derived from the implementing class name.
    
    Parameters:
    
    group - HystrixCommandGroupKey used to group together multiple HystrixCommand objects.
    The HystrixCommandGroupKey is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interact with, common business purpose etc.
    
    threadPool - HystrixThreadPoolKey used to identify the thread pool in which a HystrixCommand executes.
  - HystrixCommand
```
protected HystrixCommand(HystrixCommandGroupKey group,
                         HystrixThreadPoolKey threadPool,
                         int executionIsolationThreadTimeoutInMilliseconds)
```
    Construct a HystrixCommand with defined HystrixCommandGroupKey, HystrixThreadPoolKey, and thread timeout.
    The HystrixCommandKey will be derived from the implementing class name.
    
    Parameters:
    
    group - HystrixCommandGroupKey used to group together multiple HystrixCommand objects.
    The HystrixCommandGroupKey is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interact with, common business purpose etc.
    
    threadPool - HystrixThreadPool used to identify the thread pool in which a HystrixCommand executes.
    
    executionIsolationThreadTimeoutInMilliseconds - Time in milliseconds at which point the calling thread will timeout (using Future.get()) and walk away from the executing thread.
- Method Detail
  - run
```
protected abstract R run()
                  throws java.lang.Exception
```
    Implement this method with code to be executed when execute() or queue() are invoked.
    
    Returns:
    
    R response type
    
    Throws:
    
    java.lang.Exception - if command execution fails
  - getFallback
```
protected R getFallback()
```
    If execute() or queue() fails in any way then this method will be invoked to provide an opportunity to return a fallback response.
    This should do work that does not require network transport to produce.
    In other words, this should be a static or cached result that can immediately be returned upon failure.
    If network traffic is wanted for fallback (such as going to MemCache) then the fallback implementation should invoke another HystrixCommand instance that protects against that network access and possibly has another level of fallback that does not involve network access.
    DEFAULT BEHAVIOR: It throws UnsupportedOperationException.
    
    Returns:
    
    R or throw UnsupportedOperationException if not implemented
  - getExecutionObservable
```
protected final rx.Observable<R> getExecutionObservable()
```
  - getFallbackObservable
```
protected final rx.Observable<R> getFallbackObservable()
```
  - execute
```
public R execute()
```
    Used for synchronous execution of command.
    
    Specified by:
    
    execute in interface HystrixExecutable<R>
    
    Returns:
    
    R Result of run() execution or a fallback from getFallback() if the command fails for any reason.
    
    Throws:
    
    HystrixRuntimeException - if a failure occurs and a fallback cannot be retrieved
    
    HystrixBadRequestException - if invalid arguments or state were used representing a user failure, not a system failure
    
    java.lang.IllegalStateException - if invoked more than once
  - queue
```
public java.util.concurrent.Future<R> queue()
```
    Used for asynchronous execution of command.
    This will queue up the command on the thread pool and return an Future to get the result once it completes.
    NOTE: If configured to not run in a separate thread, this will have the same effect as execute() and will block.
    We don't throw an exception but just flip to synchronous execution so code doesn't need to change in order to switch a command from running on a separate thread to the calling thread.
    Specified by:
    
    queue in interface HystrixExecutable<R>
    
    Returns:
    
    Future<R> Result of run() execution or a fallback from getFallback() if the command fails for any reason.
    
    Throws:
    HystrixRuntimeException - if a fallback does not exist
    
    via Future.get() in Throwable.getCause() if a failure occurs
    
    or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)
    HystrixBadRequestException - via Future.get() in Throwable.getCause() if invalid arguments or state were used representing a user failure, not a system failure
    
    java.lang.IllegalStateException - if invoked more than once
  - getFallbackMethodName
```
protected java.lang.String getFallbackMethodName()
```
    Each concrete implementation of AbstractCommand should return the name of the fallback method as a String This will be used to determine if the fallback "exists" for firing the onFallbackStart/onFallbackError hooks
    
    Returns:
    
    method name of fallback
  - observe
```
public rx.Observable<R> observe()
```
    Used for asynchronous execution of command with a callback by subscribing to the Observable.
    This eagerly starts execution of the command the same as queue() and execute().
    A lazy Observable can be obtained from toObservable().
    See https://github.com/Netflix/RxJava/wiki for more information.
    Specified by:
    
    observe in interface HystrixObservable<R>
    
    Returns:
    
    Observable<R> that executes and calls back with the result of command execution or a fallback if the command fails for any reason.
    
    Throws:
    HystrixRuntimeException - if a fallback does not exist
    
    via Observer#onError if a failure occurs
    
    or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)
    HystrixBadRequestException - via Observer#onError if invalid arguments or state were used representing a user failure, not a system failure
    
    java.lang.IllegalStateException - if invoked more than once
  - toObservable
```
public rx.Observable<R> toObservable()
```
    Used for asynchronous execution of command with a callback by subscribing to the Observable.
    This lazily starts execution of the command once the Observable is subscribed to.
    An eager Observable can be obtained from observe().
    See https://github.com/ReactiveX/RxJava/wiki for more information.
    Specified by:
    
    toObservable in interface HystrixObservable<R>
    
    Returns:
    
    Observable<R> that executes and calls back with the result of command execution or a fallback if the command fails for any reason.
    
    Throws:
    HystrixRuntimeException - if a fallback does not exist
    
    via Observer#onError if a failure occurs
    
    or immediately if the command can not be queued (such as short-circuited, thread-pool/semaphore rejected)
    HystrixBadRequestException - via Observer#onError if invalid arguments or state were used representing a user failure, not a system failure
    
    java.lang.IllegalStateException - if invoked more than once
  - handleThreadEnd
```
protected void handleThreadEnd(com.netflix.hystrix.AbstractCommand<R> _cmd)
```
  - shouldOutputOnNextEvents
```
protected boolean shouldOutputOnNextEvents()
```
    Returns:
    
    if onNext events should be reported on This affects HystrixRequestLog, and HystrixEventNotifier currently.
  - getFallbackSemaphore
```
protected com.netflix.hystrix.AbstractCommand.TryableSemaphore getFallbackSemaphore()
```
    Get the TryableSemaphore this HystrixCommand should use if a fallback occurs.
    
    Returns:
    
    TryableSemaphore
  - getExecutionSemaphore
```
protected com.netflix.hystrix.AbstractCommand.TryableSemaphore getExecutionSemaphore()
```
    Get the TryableSemaphore this HystrixCommand should use for execution if not running in a separate thread.
    
    Returns:
    
    TryableSemaphore
  - getCommandGroup
```
public HystrixCommandGroupKey getCommandGroup()
```
    Specified by:
    
    getCommandGroup in interface HystrixInvokableInfo<R>
    
    Returns:
    
    HystrixCommandGroupKey used to group together multiple AbstractCommand objects.
    The HystrixCommandGroupKey is used to represent a common relationship between commands. For example, a library or team name, the system all related commands interace with, common business purpose etc.
  - getCommandKey
```
public HystrixCommandKey getCommandKey()
```
    Specified by:
    
    getCommandKey in interface HystrixInvokableInfo<R>
    
    Returns:
    
    HystrixCommandKey identifying this command instance for statistics, circuit-breaker, properties, etc.
  - getThreadPoolKey
```
public HystrixThreadPoolKey getThreadPoolKey()
```
    Specified by:
    
    getThreadPoolKey in interface HystrixInvokableInfo<R>
    
    Returns:
    
    HystrixThreadPoolKey identifying which thread-pool this command uses (when configured to run on separate threads via HystrixCommandProperties.executionIsolationStrategy()).
  - getMetrics
```
public HystrixCommandMetrics getMetrics()
```
    The HystrixCommandMetrics associated with this AbstractCommand instance.
    
    Specified by:
    
    getMetrics in interface HystrixInvokableInfo<R>
    
    Returns:
    
    HystrixCommandMetrics
  - getProperties
```
public HystrixCommandProperties getProperties()
```
    The HystrixCommandProperties associated with this AbstractCommand instance.
    
    Specified by:
    
    getProperties in interface HystrixInvokableInfo<R>
    
    Returns:
    
    HystrixCommandProperties
  - decomposeException
```
protected java.lang.RuntimeException decomposeException(java.lang.Exception e)
```
    Take an Exception and determine whether to throw it, its cause or a new HystrixRuntimeException.
    This will only throw an HystrixRuntimeException, HystrixBadRequestException or IllegalStateException
    
    Parameters:
    
    e - initial exception
    
    Returns:
    
    HystrixRuntimeException, HystrixBadRequestException or IllegalStateException
  - getCacheKey
```
protected java.lang.String getCacheKey()
```
    Key to be used for request caching.
    By default this returns null which means "do not cache".
    To enable caching override this method and return a string key uniquely representing the state of a command instance.
    If multiple command instances in the same request scope match keys then only the first will be executed and all others returned from cache.
    
    Returns:
    
    cacheKey
  - getPublicCacheKey
```
public java.lang.String getPublicCacheKey()
```
    Specified by:
    
    getPublicCacheKey in interface HystrixInvokableInfo<R>
  - isRequestCachingEnabled
```
protected boolean isRequestCachingEnabled()
```
  - getLogMessagePrefix
```
protected java.lang.String getLogMessagePrefix()
```
  - isCircuitBreakerOpen
```
public boolean isCircuitBreakerOpen()
```
    Whether the 'circuit-breaker' is open meaning that execute() will immediately return the getFallback() response and not attempt a HystrixCommand execution. 4 columns are ForcedOpen | ForcedClosed | CircuitBreaker open due to health ||| Expected Result T | T | T ||| OPEN (true) T | T | F ||| OPEN (true) T | F | T ||| OPEN (true) T | F | F ||| OPEN (true) F | T | T ||| CLOSED (false) F | T | F ||| CLOSED (false) F | F | T ||| OPEN (true) F | F | F ||| CLOSED (false)
    
    Specified by:
    
    isCircuitBreakerOpen in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isExecutionComplete
```
public boolean isExecutionComplete()
```
    If this command has completed execution either successfully, via fallback or failure.
    
    Specified by:
    
    isExecutionComplete in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isExecutedInThread
```
public boolean isExecutedInThread()
```
    Whether the execution occurred in a separate thread.
    This should be called only once execute()/queue()/fireOrForget() are called otherwise it will always return false.
    This specifies if a thread execution actually occurred, not just if it is configured to be executed in a thread.
    
    Specified by:
    
    isExecutedInThread in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isSuccessfulExecution
```
public boolean isSuccessfulExecution()
```
    Whether the response was returned successfully either by executing run() or from cache.
    
    Specified by:
    
    isSuccessfulExecution in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isFailedExecution
```
public boolean isFailedExecution()
```
    Whether the run() resulted in a failure (exception).
    
    Specified by:
    
    isFailedExecution in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - getFailedExecutionException
```
public java.lang.Throwable getFailedExecutionException()
```
    Get the Throwable/Exception thrown that caused the failure.
    If isFailedExecution() == true then this would represent the Exception thrown by the run() method.
    If isFailedExecution() == false then this would return null.
    
    Specified by:
    
    getFailedExecutionException in interface HystrixInvokableInfo<R>
    
    Returns:
    
    Throwable or null
  - getExecutionException
```
public java.lang.Throwable getExecutionException()
```
    Get the Throwable/Exception emitted by this command instance prior to checking the fallback. This exception instance may have been generated via a number of mechanisms: 1) failed execution (in this case, same result as getFailedExecutionException(). 2) timeout 3) short-circuit 4) rejection 5) bad request If the command execution was successful, then this exception instance is null (there was no exception) Note that the caller of the command may not receive this exception, as fallbacks may be served as a response to the exception.
    
    Returns:
    
    Throwable or null
  - isResponseFromFallback
```
public boolean isResponseFromFallback()
```
    Whether the response received from was the result of some type of failure and getFallback() being called.
    
    Specified by:
    
    isResponseFromFallback in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseTimedOut
```
public boolean isResponseTimedOut()
```
    Whether the response received was the result of a timeout and getFallback() being called.
    
    Specified by:
    
    isResponseTimedOut in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseShortCircuited
```
public boolean isResponseShortCircuited()
```
    Whether the response received was a fallback as result of being short-circuited (meaning isCircuitBreakerOpen() == true) and getFallback() being called.
    
    Specified by:
    
    isResponseShortCircuited in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseFromCache
```
public boolean isResponseFromCache()
```
    Whether the response is from cache and run() was not invoked.
    
    Specified by:
    
    isResponseFromCache in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseSemaphoreRejected
```
public boolean isResponseSemaphoreRejected()
```
    Whether the response received was a fallback as result of being rejected via sempahore
    
    Specified by:
    
    isResponseSemaphoreRejected in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseThreadPoolRejected
```
public boolean isResponseThreadPoolRejected()
```
    Whether the response received was a fallback as result of being rejected via threadpool
    
    Specified by:
    
    isResponseThreadPoolRejected in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - isResponseRejected
```
public boolean isResponseRejected()
```
    Whether the response received was a fallback as result of being rejected (either via threadpool or semaphore)
    
    Specified by:
    
    isResponseRejected in interface HystrixInvokableInfo<R>
    
    Returns:
    
    boolean
  - getExecutionEvents
```
public java.util.List<HystrixEventType> getExecutionEvents()
```
    List of HystrixCommandEventType enums representing events that occurred during execution.
    Examples of events are SUCCESS, FAILURE, TIMEOUT, and SHORT_CIRCUITED
    
    Specified by:
    
    getExecutionEvents in interface HystrixInvokableInfo<R>
    
    Returns:
    
    List<HystrixEventType>
  - getNumberEmissions
```
public int getNumberEmissions()
```
    Number of emissions of the execution of a command. Only interesting in the streaming case.
    
    Specified by:
    
    getNumberEmissions in interface HystrixInvokableInfo<R>
    
    Returns:
    
    number of OnNext emissions by a streaming command
  - getNumberFallbackEmissions
```
public int getNumberFallbackEmissions()
```
    Number of emissions of the execution of a fallback. Only interesting in the streaming case.
    
    Specified by:
    
    getNumberFallbackEmissions in interface HystrixInvokableInfo<R>
    
    Returns:
    
    number of OnNext emissions by a streaming fallback
  - getNumberCollapsed
```
public int getNumberCollapsed()
```
    Specified by:
    
    getNumberCollapsed in interface HystrixInvokableInfo<R>
  - getOriginatingCollapserKey
```
public HystrixCollapserKey getOriginatingCollapserKey()
```
    Specified by:
    
    getOriginatingCollapserKey in interface HystrixInvokableInfo<R>
  - getExecutionTimeInMilliseconds
```
public int getExecutionTimeInMilliseconds()
```
    The execution time of this command instance in milliseconds, or -1 if not executed.
    
    Specified by:
    
    getExecutionTimeInMilliseconds in interface HystrixInvokableInfo<R>
    
    Returns:
    
    int
  - getCommandRunStartTimeInNanos
```
public long getCommandRunStartTimeInNanos()
```
    Time in Nanos when this command instance's run method was called, or -1 if not executed for e.g., command threw an exception
    
    Specified by:
    
    getCommandRunStartTimeInNanos in interface HystrixInvokableInfo<R>
    
    Returns:
    
    long
  - getEventCounts
```
public ExecutionResult.EventCounts getEventCounts()
```
    Specified by:
    
    getEventCounts in interface HystrixInvokableInfo<R>
  - getExceptionFromThrowable
```
protected java.lang.Exception getExceptionFromThrowable(java.lang.Throwable t)
```

Hystrix: Latency and Fault Tolerance for Distributed Systems

Class HystrixCommand<R>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from interface com.netflix.hystrix.HystrixExecutable

Methods inherited from interface com.netflix.hystrix.HystrixInvokableInfo

Methods inherited from interface com.netflix.hystrix.HystrixObservable

Methods inherited from class java.lang.Object

Field Detail

circuitBreaker

commandGroup

commandKey

commandStartTimestamp

commandState

concurrencyStrategy

currentRequestLog

endCurrentThreadExecutingCommand

eventNotifier

executionHook

executionResult

executionResultAtTimeOfCancellation

executionSemaphoreOverride

executionSemaphorePerCircuit

fallbackSemaphoreOverride

fallbackSemaphorePerCircuit

isCommandTimedOut

isResponseFromCache

metrics

properties

requestCache

threadPool

threadPoolKey

threadState

timeoutTimer

Constructor Detail

HystrixCommand

HystrixCommand

HystrixCommand

HystrixCommand

HystrixCommand

Method Detail

run

getFallback

getExecutionObservable

getFallbackObservable

execute

queue

getFallbackMethodName

observe

toObservable

handleThreadEnd

shouldOutputOnNextEvents

getFallbackSemaphore

getExecutionSemaphore

getCommandGroup

getCommandKey

getThreadPoolKey

getMetrics

getProperties

decomposeException

getCacheKey

getPublicCacheKey

isRequestCachingEnabled

getLogMessagePrefix

isCircuitBreakerOpen

isExecutionComplete

isExecutedInThread

isSuccessfulExecution

isFailedExecution

getFailedExecutionException

getExecutionException

isResponseFromFallback

isResponseTimedOut

isResponseShortCircuited

isResponseFromCache

isResponseSemaphoreRejected

isResponseThreadPoolRejected

isResponseRejected