public CompletableFuture<ClientSecureChannel> getChannel() {
State currentState = state.get();
logger.trace("getChannel(), currentState={}", currentState.getClass().getSimpleName());
if (currentState instanceof Idle) {
Connecting nextState = new Connecting();
if (state.compareAndSet(currentState, nextState)) {
CompletableFuture<ClientSecureChannel> connected = nextState.connected;
connect(true, connected);
return connected.whenCompleteAsync(
(sc, ex) -> {
if (sc != null) {
if (state.compareAndSet(nextState, new Connected(connected))) {
sc.getChannel().pipeline().addLast(new InactivityHandler());
}
} else {
state.compareAndSet(nextState, new Idle());
}
});
} else {
return getChannel();
}
} else if (currentState instanceof Connecting) {
return ((Connecting) currentState).connected;
} else if (currentState instanceof Connected) {
return ((Connected) currentState).connected;
} else if (currentState instanceof Reconnecting) {
return ((Reconnecting) currentState).reconnected;
} else if (currentState instanceof Disconnecting) {
CompletableFuture<ClientSecureChannel> future = new CompletableFuture<>();
CompletableFuture<Unit> disconnectFuture = ((Disconnecting) currentState).disconnectFuture;
disconnectFuture.whenCompleteAsync(
(u, ex) ->
getChannel()
.whenCompleteAsync(
(sc, ex2) -> {
if (sc != null) future.complete(sc);
else future.completeExceptionally(ex2);
}),
client.getExecutorService());
return future;
} else {
throw new IllegalStateException(currentState.getClass().getSimpleName());
}
}
@Override
public void run() {
while (running.get()) {
switch (random.nextInt() % 2) {
case 0: // start a server
try {
cluster.startServer();
} catch (Exception e) {
LOG.warn(e);
exception.compareAndSet(null, e);
}
break;
case 1: // stop a server
try {
cluster.stopRandomServer();
} catch (Exception e) {
LOG.warn(e);
exception.compareAndSet(null, e);
}
default:
}
Threads.sleep(100);
}
}
/**
* Called to indicate that the last write has been performed. It updates the state and performs
* cleanup operations.
*/
void closed() {
while (true) {
OutputState state = _state.get();
switch (state) {
case CLOSED:
{
return;
}
case UNREADY:
{
if (_state.compareAndSet(state, OutputState.ERROR))
_writeListener.onError(
_onError == null ? new EofException("Async closed") : _onError);
break;
}
default:
{
if (!_state.compareAndSet(state, OutputState.CLOSED)) break;
try {
_channel.getResponse().closeOutput();
} catch (Throwable x) {
if (LOG.isDebugEnabled()) LOG.debug(x);
abort(x);
} finally {
releaseBuffer();
}
// Return even if an exception is thrown by closeOutput().
return;
}
}
}
}
/** @see javax.servlet.ServletOutputStream#isReady() */
@Override
public boolean isReady() {
while (true) {
switch (_state.get()) {
case OPEN:
return true;
case ASYNC:
if (!_state.compareAndSet(OutputState.ASYNC, OutputState.READY)) continue;
return true;
case READY:
return true;
case PENDING:
if (!_state.compareAndSet(OutputState.PENDING, OutputState.UNREADY)) continue;
return false;
case UNREADY:
return false;
case ERROR:
return true;
case CLOSED:
return true;
default:
throw new IllegalStateException();
}
}
}
public boolean analyze(
@NotNull PsiFile file,
TextRange dirtyScope,
@NotNull Runnable analyze,
@NotNull ProgressIndicator indicator) {
ProgressIndicator old = myState.get();
if (old != VIRGIN && old != READY) return false;
if (!myState.compareAndSet(old, indicator)) {
log("a: failed to change ", old, "->", indicator);
return false;
}
log("a: changed ", old, "->", indicator);
analyzedUnder = null;
boolean completed = false;
try {
if (dirtyScope != null) {
if (dirtyScope.equals(file.getTextRange())) {
clear();
} else {
removeInvalidRefs();
}
}
analyze.run();
analyzedUnder = indicator;
completed = true;
} finally {
ProgressIndicator resultState = completed ? READY : VIRGIN;
boolean set = myState.compareAndSet(indicator, resultState);
assert set : myState.get();
log("a: changed after analyze", indicator, "->", resultState);
}
return true;
}
private void reconnect(Reconnecting reconnectState, long delaySeconds) {
logger.debug("Scheduling reconnect for +{} seconds...", delaySeconds);
Stack.sharedScheduledExecutor()
.schedule(
() -> {
logger.debug("{} seconds elapsed; reconnecting...", delaySeconds);
CompletableFuture<ClientSecureChannel> reconnected = reconnectState.reconnected;
connect(true, reconnected);
reconnected.whenCompleteAsync(
(sc, ex) -> {
if (sc != null) {
logger.debug("Reconnect succeeded, channelId={}", sc.getChannelId());
if (state.compareAndSet(reconnectState, new Connected(reconnected))) {
sc.getChannel().pipeline().addLast(new InactivityHandler());
}
} else {
logger.debug("Reconnect failed: {}", ex.getMessage(), ex);
Reconnecting nextState = new Reconnecting();
if (state.compareAndSet(reconnectState, nextState)) {
reconnect(nextState, nextDelay(delaySeconds));
}
}
});
},
delaySeconds,
TimeUnit.SECONDS);
}
@Override
public CloseFuture close(boolean immediately) {
if (immediately) {
if (state.compareAndSet(State.Opened, State.Immediate)
|| state.compareAndSet(State.Graceful, State.Immediate)) {
if (log.isDebugEnabled()) {
log.debug("close({}) Closing immediately", this);
}
preClose();
doCloseImmediately();
if (log.isDebugEnabled()) {
log.debug("close({})[Immediately] closed", this);
}
} else {
if (log.isDebugEnabled()) {
log.debug("close({})[Immediately] state already {}", this, state.get());
}
}
} else {
if (state.compareAndSet(State.Opened, State.Graceful)) {
if (log.isDebugEnabled()) {
log.debug("close({}) Closing gracefully", this);
}
preClose();
SshFuture<CloseFuture> grace = doCloseGracefully();
if (grace != null) {
grace.addListener(
new SshFutureListener<CloseFuture>() {
@Override
@SuppressWarnings("synthetic-access")
public void operationComplete(CloseFuture future) {
if (state.compareAndSet(State.Graceful, State.Immediate)) {
doCloseImmediately();
if (log.isDebugEnabled()) {
log.debug(
"close({}][Graceful] - operationComplete() closed",
AbstractCloseable.this);
}
}
}
});
} else {
if (state.compareAndSet(State.Graceful, State.Immediate)) {
doCloseImmediately();
if (log.isDebugEnabled()) {
log.debug("close({})[Graceful] closed", this);
}
}
}
} else {
if (log.isDebugEnabled()) {
log.debug("close({})[Graceful] state already {}", this, state.get());
}
}
}
return closeFuture;
}
/**
* Ensures that |sDefaultTrustManager| and |sCertificateFactory| are initialized.
*
* @throws CertificateException,KeyStoreException,NoSuchAlgorithmException on error initializing
* the TrustManager.
*/
private static void ensureInitialized()
throws CertificateException, KeyStoreException, NoSuchAlgorithmException {
// There could be a begin race creating two instances of these objects, which
// is harmless save for a bit of wasted effort.
if (sDefaultTrustManager.get() == null) {
sDefaultTrustManager.compareAndSet(null, createDefaultTrustManager());
}
if (sCertificateFactory.get() == null) {
sCertificateFactory.compareAndSet(null, CertificateFactory.getInstance("X.509"));
}
}
public void process(Runnable aTask) {
Scripts.LocalContext context = Scripts.getContext();
Runnable taskWrapper =
() -> {
Scripts.setContext(context);
try {
aTask.run();
} finally {
Scripts.setContext(null);
}
};
queue.offer(taskWrapper);
offerTask(
() -> {
// Runnable processedTask = taskWrapper;
int version;
int newVersion;
Thread thisThread = Thread.currentThread();
do {
version = queueVersion.get();
// Zombie counter ...
newVersion = version + 1;
if (newVersion == Integer.MAX_VALUE) {
newVersion = 0;
}
/* moved to top of body
if (processedTask != null) {//Single attempt to offer aTask.
queue.offer(processedTask);
processedTask = null;
}
*/
if (worker.compareAndSet(null, thisThread)) { // Worker electing.
try {
// already single threaded environment
if (global == null) {
Scripts.Space.this.initSpaceGlobal();
}
// Zombie processing ...
Runnable task = queue.poll();
while (task != null) {
task.run();
task = queue.poll();
}
} catch (Throwable t) {
Logger.getLogger(Scripts.class.getName()).log(Level.SEVERE, null, t);
} finally {
boolean setted = worker.compareAndSet(thisThread, null);
assert setted : "Worker electing assumption failed"; // Always successfull CAS.
}
}
} while (!queueVersion.compareAndSet(version, newVersion));
});
}
@Override
public void write(int b) throws IOException {
_written += 1;
boolean complete = _channel.getResponse().isAllContentWritten(_written);
// Async or Blocking ?
while (true) {
switch (_state.get()) {
case OPEN:
if (_aggregate == null)
_aggregate = _channel.getByteBufferPool().acquire(getBufferSize(), false);
BufferUtil.append(_aggregate, (byte) b);
// Check if all written or full
if (complete || BufferUtil.isFull(_aggregate)) {
BlockingCallback callback = _channel.getWriteBlockingCallback();
_channel.write(_aggregate, complete, callback);
callback.block();
if (complete) closed();
}
break;
case ASYNC:
throw new IllegalStateException("isReady() not called");
case READY:
if (!_state.compareAndSet(State.READY, State.PENDING)) continue;
if (_aggregate == null)
_aggregate = _channel.getByteBufferPool().acquire(getBufferSize(), false);
BufferUtil.append(_aggregate, (byte) b);
// Check if all written or full
if (!complete && !BufferUtil.isFull(_aggregate)) {
if (!_state.compareAndSet(State.PENDING, State.ASYNC))
throw new IllegalStateException();
return;
}
// Do the asynchronous writing from the callback
new AsyncFlush().process();
return;
case PENDING:
case UNREADY:
throw new WritePendingException();
case CLOSED:
throw new EofException("Closed");
}
break;
}
}
private static void doClear(
ThrowableRunnable<StorageException> clearAction, AtomicReference<RebuildStatus> status)
throws StorageException {
try {
clearAction.run();
} catch (StorageException e) {
status.compareAndSet(DOING_REBUILD, REQUIRES_REBUILD);
throw e;
}
if (!status.compareAndSet(DOING_REBUILD, OK)) {
FileBasedIndexImpl.LOG.error("Unexpected status " + status.get());
}
}
/* ------------------------------------------------------------ */
protected void invalidate() {
ByteBuffer indirect = _indirectBuffer.get();
if (indirect != null && _indirectBuffer.compareAndSet(indirect, null))
_cachedSize.addAndGet(-BufferUtil.length(indirect));
ByteBuffer direct = _directBuffer.get();
if (direct != null
&& !BufferUtil.isMappedBuffer(direct)
&& _directBuffer.compareAndSet(direct, null))
_cachedSize.addAndGet(-BufferUtil.length(direct));
_cachedFiles.decrementAndGet();
_resource.close();
}
public void registerGlobal(final Serializer serializer) {
SerializerAdapter adapter = createSerializerAdapter(serializer);
if (!global.compareAndSet(null, adapter)) {
throw new IllegalStateException("Global serializer is already registered!");
}
SerializerAdapter current = idMap.putIfAbsent(serializer.getTypeId(), adapter);
if (current != null && current.getImpl().getClass() != adapter.getImpl().getClass()) {
global.compareAndSet(adapter, null);
throw new IllegalStateException(
"Serializer ["
+ current.getImpl()
+ "] has been already registered for type-id: "
+ serializer.getTypeId());
}
}
@Override
public void flush() throws IOException {
while (true) {
switch (_state.get()) {
case OPEN:
write(BufferUtil.hasContent(_aggregate) ? _aggregate : BufferUtil.EMPTY_BUFFER, false);
return;
case ASYNC:
throw new IllegalStateException("isReady() not called");
case READY:
if (!_state.compareAndSet(OutputState.READY, OutputState.PENDING)) continue;
new AsyncFlush().iterate();
return;
case PENDING:
return;
case UNREADY:
throw new WritePendingException();
case ERROR:
throw new EofException(_onError);
case CLOSED:
return;
default:
throw new IllegalStateException();
}
}
}
/**
* Asynchronous send of HTTP content.
*
* @param httpContent The HTTP content to send
* @param callback The callback to use to notify success or failure
*/
public void sendContent(HttpContent httpContent, Callback callback) {
if (LOG.isDebugEnabled()) LOG.debug("sendContent(http={},{})", httpContent, callback);
if (BufferUtil.hasContent(_aggregate)) {
callback.failed(new IOException("cannot sendContent() after write()"));
return;
}
if (_channel.isCommitted()) {
callback.failed(new IOException("committed"));
return;
}
while (true) {
switch (_state.get()) {
case OPEN:
if (!_state.compareAndSet(OutputState.OPEN, OutputState.PENDING)) continue;
break;
case ERROR:
callback.failed(new EofException(_onError));
return;
case CLOSED:
callback.failed(new EofException("Closed"));
return;
default:
throw new IllegalStateException();
}
break;
}
ByteBuffer buffer = _channel.useDirectBuffers() ? httpContent.getDirectBuffer() : null;
if (buffer == null) buffer = httpContent.getIndirectBuffer();
if (buffer != null) {
sendContent(buffer, callback);
return;
}
try {
ReadableByteChannel rbc = httpContent.getReadableByteChannel();
if (rbc != null) {
// Close of the rbc is done by the async sendContent
sendContent(rbc, callback);
return;
}
InputStream in = httpContent.getInputStream();
if (in != null) {
sendContent(in, callback);
return;
}
throw new IllegalArgumentException("unknown content for " + httpContent);
} catch (Throwable th) {
abort(th);
callback.failed(th);
}
}
/**
* Start the server running - accepting connections, receiving messages. If the server is already
* running, it will not be started again. This method is designed to be called in its own thread
* and will not return until the server is stopped.
*
* @throws RuntimeException if the server fails
*/
public void run() {
// ensure that the server is not started twice
if (!state.compareAndSet(State.STOPPED, State.RUNNING)) {
started(true);
return;
}
Selector selector = null;
ServerSocketChannel server = null;
try {
selector = Selector.open();
server = ServerSocketChannel.open();
server.socket().bind(new InetSocketAddress(port));
server.configureBlocking(false);
server.register(selector, SelectionKey.OP_ACCEPT);
started(false);
while (state.get() == State.RUNNING) {
selector.select(100); // check every 100ms whether the server has been requested to stop
for (Iterator<SelectionKey> it = selector.selectedKeys().iterator(); it.hasNext(); ) {
SelectionKey key = it.next();
try {
// remove key from the ready list
it.remove();
if (key.isConnectable()) {
((SocketChannel) key.channel()).finishConnect();
}
if (key.isAcceptable()) {
// accept connection
SocketChannel client = server.accept();
client.configureBlocking(false);
client.socket().setTcpNoDelay(true);
// channel is registered for further events such as read or write
SelectionKey acceptKey = client.register(selector, SelectionKey.OP_READ);
connection(acceptKey);
}
if (key.isReadable()) {
for (ByteBuffer message : readIncomingMessage(key)) {
messageReceived(message, key);
}
}
} catch (IOException ioe) {
resetKey(key);
disconnected(key);
}
}
}
} catch (Throwable e) {
throw new RuntimeException("Server failure: " + e.getMessage());
} finally {
try {
selector.close();
server.socket().close();
server.close();
state.set(State.STOPPED);
stopped();
} catch (Exception e) {
// do nothing - server failed
}
}
}
/**
* Add this instance to the leadership election and attempt to acquire leadership.
*
* @throws Exception errors
*/
public void start() throws Exception {
Preconditions.checkState(
state.compareAndSet(State.LATENT, State.STARTED), "Cannot be started more than once");
client.getConnectionStateListenable().addListener(listener);
reset();
}
public void unsubscribe() {
Subscription s = rollingDistributionSubscription.get();
if (s != null) {
s.unsubscribe();
rollingDistributionSubscription.compareAndSet(s, null);
}
}
/**
* Remove all configuration values under a single section.
*
* @param section section name, e.g "branch"
* @param subsection optional subsection value, e.g. a branch name
*/
public void unsetSection(String section, String subsection) {
State src, res;
do {
src = state.get();
res = unsetSection(src, section, subsection);
} while (!state.compareAndSet(src, res));
}
@Override
public void run() {
while (running.get()) {
boolean isBigPayload = random.nextBoolean();
String message = isBigPayload ? BIG_PAYLOAD : id + numCalls;
EchoRequestProto param = EchoRequestProto.newBuilder().setMessage(message).build();
EchoResponseProto ret;
TestRpcServer server = cluster.getRandomServer();
try {
sending.set(true);
BlockingInterface stub = newBlockingStub(rpcClient, server.getListenerAddress());
ret = stub.echo(null, param);
} catch (Exception e) {
LOG.warn(e);
continue; // expected in case connection is closing or closed
}
try {
assertNotNull(ret);
assertEquals(message, ret.getMessage());
} catch (Throwable t) {
exception.compareAndSet(null, t);
}
numCalls++;
}
}
@Nullable
public static StubIndexImpl getInstanceOrInvalidate() {
if (ourForcedClean.compareAndSet(null, Boolean.TRUE)) {
return null;
}
return (StubIndexImpl) getInstance();
}
private void dispatchTasks(CancellationToken cancelToken) {
if (isCurrentThreadDispatching()) {
// Tasks will be dispatched there.
return;
}
Thread currentThread = Thread.currentThread();
Throwable toThrow = null;
while (!isQueueEmpty()) {
if (dispatcherThread.compareAndSet(null, currentThread)) {
try {
TaskDef taskDef = pollFromQueue();
if (taskDef != null) {
taskDef.doTask(cancelToken);
}
} catch (Throwable ex) {
// Only in a case of a very serious error (like OutOfMemory)
// will this block be executed because exceptions thrown
// by the task (and the cleanup task) is caught and logged.
if (toThrow == null) toThrow = ex;
else toThrow.addSuppressed(ex);
} finally {
dispatcherThread.set(null);
}
} else {
return;
}
}
ExceptionHelper.rethrowIfNotNull(toThrow);
}
/**
* If no thread has been spawned so far, spawns a new one that will perform the cache init.
* Optionally waits for the cache initialization to be performed in a another thread.
*/
private void useNewThreadToInitialize(boolean wait) {
if (wait && isWorkspaceLockedByCurrentThread()) {
// may not wait if we currently hold a conflicting rule
throw new IllegalStateException(
"Cannot wait for the thread to finish if we currently hold the WS lock");
}
CountDownLatch myGuard = initializerGuard.get();
// check if there was already a thread scheduled
if (myGuard == null) {
// no guard found so far
final CountDownLatch newGuard = new CountDownLatch(1);
if (initializerGuard.compareAndSet(null, newGuard)) {
// still no other thread created a guard in the (short) meantime
myGuard = newGuard;
// aquire the WS rule in an own thread and perform the initialization from there
startInitializerThread(newGuard);
} else {
// use the guard that was created by another thread
myGuard = initializerGuard.get();
}
}
if (myGuard == null) {
throw new IllegalStateException();
}
if (wait) {
try {
// optionally wait for the initialization to finish
myGuard.await();
} catch (InterruptedException e) {
// ignore
}
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
exception.compareAndSet(null, cause);
// System.err.print("[" + Thread.currentThread().getName() + "] ");
// cause.printStackTrace();
super.exceptionCaught(ctx, cause);
}
/**
* Retrieve instance of {@link HystrixEventNotifier} to use based on order of precedence as
* defined in {@link HystrixPlugins} class header.
*
* <p>Override default by using {@link #registerEventNotifier(HystrixEventNotifier)} or setting
* property: <code>hystrix.plugin.HystrixEventNotifier.implementation</code> with the full
* classname to load.
*
* @return {@link HystrixEventNotifier} implementation to use
*/
public HystrixEventNotifier getEventNotifier() {
if (notifier.get() == null) {
// check for an implementation from System.getProperty first
Object impl = getPluginImplementationViaProperty(HystrixEventNotifier.class);
if (impl == null) {
// nothing set via properties so initialize with default
notifier.compareAndSet(null, HystrixEventNotifierDefault.getInstance());
// we don't return from here but call get() again in case of thread-race so the winner will
// always get returned
} else {
// we received an implementation from the system property so use it
notifier.compareAndSet(null, (HystrixEventNotifier) impl);
}
}
return notifier.get();
}
/**
* Retrieve instance of {@link HystrixPropertiesStrategy} to use based on order of precedence as
* defined in {@link HystrixPlugins} class header.
*
* <p>Override default by using {@link #registerPropertiesStrategy(HystrixPropertiesStrategy)} or
* setting property (via Archaius): <code>hystrix.plugin.HystrixPropertiesStrategy.implementation
* </code> with the full classname to load.
*
* @return {@link HystrixPropertiesStrategy} implementation to use
*/
public HystrixPropertiesStrategy getPropertiesStrategy() {
if (propertiesFactory.get() == null) {
// check for an implementation from Archaius first
Object impl = getPluginImplementationViaArchaius(HystrixPropertiesStrategy.class);
if (impl == null) {
// nothing set via Archaius so initialize with default
propertiesFactory.compareAndSet(null, HystrixPropertiesStrategyDefault.getInstance());
// we don't return from here but call get() again in case of thread-race so the winner will
// always get returned
} else {
// we received an implementation from Archaius so use it
propertiesFactory.compareAndSet(null, (HystrixPropertiesStrategy) impl);
}
}
return propertiesFactory.get();
}
public void update(EncodingStats newStats) {
while (true) {
EncodingStats current = stats.get();
EncodingStats updated = current.mergeWith(newStats);
if (stats.compareAndSet(current, updated)) return;
}
}
/**
* The local endpoint has reached a write failure.
*
* <p>A low level I/O failure, or even a jetty side EndPoint close (from idle timeout) are a few
* scenarios
*
* @param t the throwable that caused the write failure
*/
public void onWriteFailure(Throwable t) {
ConnectionState event = null;
synchronized (this) {
if (this.state == ConnectionState.CLOSED) {
// already closed
return;
}
// Build out Close Reason
String reason = "WebSocket Write Failure";
if (t instanceof EOFException) {
reason = "WebSocket Write EOF";
Throwable cause = t.getCause();
if ((cause != null) && (StringUtil.isNotBlank(cause.getMessage()))) {
reason = "EOF: " + cause.getMessage();
}
} else {
if (StringUtil.isNotBlank(t.getMessage())) {
reason = t.getMessage();
}
}
CloseInfo close = new CloseInfo(StatusCode.ABNORMAL, reason);
finalClose.compareAndSet(null, close);
this.cleanClose = false;
this.state = ConnectionState.CLOSED;
this.inputAvailable = false;
this.outputAvailable = false;
this.closeHandshakeSource = CloseHandshakeSource.ABNORMAL;
event = this.state;
}
notifyStateListeners(event);
}
@Override
public void start() {
log.info("Starting");
if (!state.compareAndSet(CuratorFrameworkState.LATENT, CuratorFrameworkState.STARTED)) {
IllegalStateException error = new IllegalStateException();
log.error("Cannot be started more than once", error);
throw error;
}
try {
connectionStateManager.start(); // ordering dependency - must be called before client.start()
client.start();
executorService =
Executors.newFixedThreadPool(2, threadFactory); // 1 for listeners, 1 for background ops
executorService.submit(
new Callable<Object>() {
@Override
public Object call() throws Exception {
backgroundOperationsLoop();
return null;
}
});
} catch (Exception e) {
handleBackgroundOperationException(null, e);
}
}
/**
* Retrieve instance of {@link HystrixCommandExecutionHook} to use based on order of precedence as
* defined in {@link HystrixPlugins} class header.
*
* <p>Override default by using {@link #registerCommandExecutionHook(HystrixCommandExecutionHook)}
* or setting property (via Archaius): <code>
* hystrix.plugin.HystrixCommandExecutionHook.implementation</code> with the full classname to
* load.
*
* @return {@link HystrixCommandExecutionHook} implementation to use
* @since 1.2
*/
public HystrixCommandExecutionHook getCommandExecutionHook() {
if (commandExecutionHook.get() == null) {
// check for an implementation from Archaius first
Object impl = getPluginImplementationViaArchaius(HystrixCommandExecutionHook.class);
if (impl == null) {
// nothing set via Archaius so initialize with default
commandExecutionHook.compareAndSet(null, HystrixCommandExecutionHookDefault.getInstance());
// we don't return from here but call get() again in case of thread-race so the winner will
// always get returned
} else {
// we received an implementation from Archaius so use it
commandExecutionHook.compareAndSet(null, (HystrixCommandExecutionHook) impl);
}
}
return commandExecutionHook.get();
}