static final Logger log = Logger.getLogger(Context.class.getName());

// Long chains of contexts are suspicious and usually indicate a misuse of Context.

// The threshold is arbitrarily chosen.

// VisibleForTesting

static final int CONTEXT_DEPTH_WARN_THRESH = 1000;

/**

public static final Context ROOT = new Context();

// Visible For testing

static Storage storage() {

return LazyStorage.storage;

}

// Lazy-loaded storage. Delaying storage initialization until after class initialization makes it

// much easier to avoid circular loading since there can still be references to Context as long as

// they don't depend on storage, like key() and currentContextExecutor(). It also makes it easier

// to handle exceptions.

private static final class LazyStorage {

static final Storage storage;

static {

AtomicReference<Throwable> deferredStorageFailure = new AtomicReference<>();

storage = createStorage(deferredStorageFailure);

Throwable failure = deferredStorageFailure.get();

// Logging must happen after storage has been set, as loggers may use Context.

if (failure != null) {

log.log(Level.FINE, "Storage override doesn't exist. Using default", failure);

}

}

private static Storage createStorage(

AtomicReference<? super ClassNotFoundException> deferredStorageFailure) {

try {

Class<?> clazz = Class.forName("io.grpc.override.ContextStorageOverride");

// The override's constructor is prohibited from triggering any code that can loop back to

// Context

return clazz.asSubclass(Storage.class).getConstructor().newInstance();

} catch (ClassNotFoundException e) {

deferredStorageFailure.set(e);

return new ThreadLocalContextStorage();

} catch (Exception e) {

throw new RuntimeException("Storage override failed to initialize", e);

}

}

}

/**

public static <T> Key<T> key(String debugString) {

return new Key<>(debugString);

}

/**

public static <T> Key<T> keyWithDefault(String debugString, T defaultValue) {

return new Key<>(debugString, defaultValue);

}

/**

public static Context current() {

Context current = storage().current();

if (current == null) {

return ROOT;

}

return current;

}

final CancellableContext cancellableAncestor;

final Node<Key<?>, Object> keyValueEntries;

// The number parents between this context and the root context.

final int generation;

/**

private Context(Node<Key<?>, Object> keyValueEntries, int generation) {

this.cancellableAncestor = null;

this.keyValueEntries = keyValueEntries;

this.generation = generation;

validateGeneration(generation);

}

/**

private Context(Context parent, Node<Key<?>, Object> keyValueEntries) {

this.cancellableAncestor = cancellableAncestor(parent);

this.keyValueEntries = keyValueEntries;

this.generation = parent.generation + 1;

validateGeneration(generation);

}

/**

private Context() {

this.cancellableAncestor = null;

this.keyValueEntries = null;

this.generation = 0;

validateGeneration(generation);

}

/**

public CancellableContext withCancellation() {

return new CancellableContext(this);

}

/**

public CancellableContext withDeadlineAfter(long duration, TimeUnit unit,

ScheduledExecutorService scheduler) {

return withDeadline(Deadline.after(duration, unit), scheduler);

}

/**

public CancellableContext withDeadline(Deadline newDeadline, ScheduledExecutorService scheduler) {

checkNotNull(newDeadline, "deadline");

checkNotNull(scheduler, "scheduler");

Deadline existingDeadline = getDeadline();

boolean scheduleDeadlineCancellation = true;

if (existingDeadline != null && existingDeadline.compareTo(newDeadline) <= 0) {

// The new deadline won't have an effect, so ignore it

newDeadline = existingDeadline;

scheduleDeadlineCancellation = false;

}

CancellableContext newCtx = new CancellableContext(this, newDeadline);

if (scheduleDeadlineCancellation) {

newCtx.setUpDeadlineCancellation(newDeadline, scheduler);

}

return newCtx;

}

/**

public <V> Context withValue(Key<V> k1, V v1) {

Node<Key<?>, Object> newKeyValueEntries =

PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);

return new Context(this, newKeyValueEntries);

}

/**

public <V1, V2> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2) {

Node<Key<?>, Object> newKeyValueEntries =

PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);

newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k2, v2);

return new Context(this, newKeyValueEntries);

}

/**

public <V1, V2, V3> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2, Key<V3> k3, V3 v3) {

Node<Key<?>, Object> newKeyValueEntries =

PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);

newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k2, v2);

newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k3, v3);

return new Context(this, newKeyValueEntries);

}

/**

public <V1, V2, V3, V4> Context withValues(Key<V1> k1, V1 v1, Key<V2> k2, V2 v2,

Key<V3> k3, V3 v3, Key<V4> k4, V4 v4) {

Node<Key<?>, Object> newKeyValueEntries =

PersistentHashArrayMappedTrie.put(keyValueEntries, k1, v1);

newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k2, v2);

newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k3, v3);

newKeyValueEntries = PersistentHashArrayMappedTrie.put(newKeyValueEntries, k4, v4);

return new Context(this, newKeyValueEntries);

}

/**

public Context fork() {

return new Context(keyValueEntries, generation + 1);

}

/**

public Context attach() {

Context prev = storage().doAttach(this);

if (prev == null) {

return ROOT;

}

return prev;

}

/**

public void detach(Context toAttach) {

checkNotNull(toAttach, "toAttach");

storage().detach(this, toAttach);

}

// Visible for testing

boolean isCurrent() {

return current() == this;

}

/**

public boolean isCancelled() {

if (cancellableAncestor == null) {

return false;

} else {

return cancellableAncestor.isCancelled();

}

}

/**

public Throwable cancellationCause() {

if (cancellableAncestor == null) {

return null;

} else {

return cancellableAncestor.cancellationCause();

}

}

/**

public Deadline getDeadline() {

if (cancellableAncestor == null) {

return null;

}

return cancellableAncestor.getDeadline();

}

/**

public void addListener(final CancellationListener cancellationListener,

final Executor executor) {

checkNotNull(cancellationListener, "cancellationListener");

checkNotNull(executor, "executor");

if (cancellableAncestor == null) {

return;

}

cancellableAncestor.addListenerInternal(

new ExecutableListener(executor, cancellationListener, this));

}

/**

public void removeListener(CancellationListener cancellationListener) {

if (cancellableAncestor == null) {

return;

}

cancellableAncestor.removeListenerInternal(cancellationListener, this);

}

// Used in tests to ensure that listeners are defined and released when cancellation cascades.

// It's very important to ensure that we do not accidentally retain listeners.

int listenerCount() {

if (cancellableAncestor == null) {

return 0;

}

return cancellableAncestor.listenerCount();

}

/**

public void run(Runnable r) {

Context previous = attach();

try {

r.run();

} finally {

detach(previous);

}

}

/**

@CanIgnoreReturnValue

public <V> V call(Callable<V> c) throws Exception {

Context previous = attach();

try {

return c.call();

} finally {

detach(previous);

}

}

/**

public Runnable wrap(final Runnable r) {

return new Runnable() {

@Override

public void run() {

Context previous = attach();

try {

r.run();

} finally {

detach(previous);

}

}

};

}

/**

public <C> Callable<C> wrap(final Callable<C> c) {

return new Callable<C>() {

@Override

public C call() throws Exception {

Context previous = attach();

try {

return c.call();

} finally {

detach(previous);

}

}

};

}

/**

public Executor fixedContextExecutor(final Executor e) {

final class FixedContextExecutor implements Executor {

@Override

public void execute(Runnable r) {

e.execute(wrap(r));

}

}

return new FixedContextExecutor();

}

/**

public static Executor currentContextExecutor(final Executor e) {

final class CurrentContextExecutor implements Executor {

@Override

public void execute(Runnable r) {

e.execute(Context.current().wrap(r));

}

}

return new CurrentContextExecutor();

}

/**

public static final class CancellableContext extends Context implements Closeable {

private final Deadline deadline;

private final Context uncancellableSurrogate;

private ArrayList<ExecutableListener> listeners;

// parentListener is initialized when listeners is initialized (only if there is a

// cancellable ancestor), and uninitialized when listeners is uninitialized.

private CancellationListener parentListener;

private Throwable cancellationCause;

private ScheduledFuture<?> pendingDeadline;

private boolean cancelled;

/**

private CancellableContext(Context parent) {

super(parent, parent.keyValueEntries);

deadline = parent.getDeadline();

// Create a surrogate that inherits from this to attach so that you cannot retrieve a

// cancellable context from Context.current()

uncancellableSurrogate = new Context(this, keyValueEntries);

}

/**

private CancellableContext(Context parent, Deadline deadline) {

super(parent, parent.keyValueEntries);

this.deadline = deadline;

this.uncancellableSurrogate = new Context(this, keyValueEntries);

}

private void setUpDeadlineCancellation(Deadline deadline, ScheduledExecutorService scheduler) {

if (!deadline.isExpired()) {

final class CancelOnExpiration implements Runnable {

@Override

public void run() {

try {

cancel(new TimeoutException("context timed out"));

} catch (Throwable t) {

log.log(Level.SEVERE, "Cancel threw an exception, which should not happen", t);

}

}

}

synchronized (this) {

pendingDeadline = deadline.runOnExpiration(new CancelOnExpiration(), scheduler);

}

} else {

// Cancel immediately if the deadline is already expired.

cancel(new TimeoutException("context timed out"));

}

}

@Override

public Context attach() {

return uncancellableSurrogate.attach();

}

@Override

public void detach(Context toAttach) {

uncancellableSurrogate.detach(toAttach);

}

@Override

public void addListener(

final CancellationListener cancellationListener, final Executor executor) {

checkNotNull(cancellationListener, "cancellationListener");

checkNotNull(executor, "executor");

addListenerInternal(new ExecutableListener(executor, cancellationListener, this));

}

private void addListenerInternal(ExecutableListener executableListener) {

synchronized (this) {

if (isCancelled()) {

executableListener.deliver();

} else {

if (listeners == null) {

// Now that we have a listener we need to listen to our parent so

// we can cascade listener notification.

listeners = new ArrayList<>();

listeners.add(executableListener);

if (cancellableAncestor != null) {

parentListener =

new CancellationListener() {

@Override

public void cancelled(Context context) {

CancellableContext.this.cancel(context.cancellationCause());

}

};

cancellableAncestor.addListenerInternal(

new ExecutableListener(DirectExecutor.INSTANCE, parentListener, this));

}

} else {

listeners.add(executableListener);

}

}

}

}

@Override

public void removeListener(CancellationListener cancellationListener) {

removeListenerInternal(cancellationListener, this);

}

private void removeListenerInternal(CancellationListener cancellationListener,

Context context) {

synchronized (this) {

if (listeners != null) {

for (int i = listeners.size() - 1; i >= 0; i--) {

ExecutableListener executableListener = listeners.get(i);

if (executableListener.listener == cancellationListener

&& executableListener.context == context) {

listeners.remove(i);

// Just remove the first matching listener, given that we allow duplicate

// adds we should allow for duplicates after remove.

break;

}

}

// We have no listeners so no need to listen to our parent

if (listeners.isEmpty()) {

if (cancellableAncestor != null) {

cancellableAncestor.removeListener(parentListener);

}

parentListener = null;

listeners = null;

}

}

}

}

/**

//TODO(spencerfang): The superclass's method is package-private, so this should really match.

@Override

@Deprecated

public boolean isCurrent() {

return uncancellableSurrogate.isCurrent();

}

/**

@CanIgnoreReturnValue

public boolean cancel(Throwable cause) {

boolean triggeredCancel = false;

ScheduledFuture<?> localPendingDeadline = null;

synchronized (this) {

if (!cancelled) {

cancelled = true;

if (pendingDeadline != null) {

// If we have a scheduled cancellation pending attempt to cancel it.

localPendingDeadline = pendingDeadline;

pendingDeadline = null;

}

this.cancellationCause = cause;

triggeredCancel = true;

}

}

if (localPendingDeadline != null) {

localPendingDeadline.cancel(false);

}

if (triggeredCancel) {

notifyAndClearListeners();

}

return triggeredCancel;

}

/**

private void notifyAndClearListeners() {

ArrayList<ExecutableListener> tmpListeners;

CancellationListener tmpParentListener;

synchronized (this) {

if (listeners == null) {

return;

}

tmpParentListener = parentListener;

parentListener = null;

tmpListeners = listeners;

listeners = null;

}

// Deliver events to this context listeners before we notify child contexts. We do this

// to cancel higher level units of work before child units. This allows for a better error

// handling paradigm where the higher level unit of work knows it is cancelled and so can

// ignore errors that bubble up as a result of cancellation of lower level units.

for (ExecutableListener tmpListener : tmpListeners) {

if (tmpListener.context == this) {

tmpListener.deliver();

}

}

for (ExecutableListener tmpListener : tmpListeners) {

if (!(tmpListener.context == this)) {

tmpListener.deliver();

}

}

if (cancellableAncestor != null) {

cancellableAncestor.removeListener(tmpParentListener);

}

}

@Override

int listenerCount() {

synchronized (this) {

return listeners == null ? 0 : listeners.size();

}

}

/**

public void detachAndCancel(Context toAttach, Throwable cause) {

try {

detach(toAttach);

} finally {

cancel(cause);

}

}

@Override

public boolean isCancelled() {

synchronized (this) {

if (cancelled) {

return true;

}

}

// Detect cancellation of parent in the case where we have no listeners and

// record it.

if (super.isCancelled()) {

cancel(super.cancellationCause());

return true;

}

return false;

}

@Override

public Throwable cancellationCause() {

if (isCancelled()) {

return cancellationCause;

}

return null;

}

@Override

public Deadline getDeadline() {

return deadline;

}

/**

@Override

public void close() {

cancel(null);

}

}

/**

public interface CancellationListener {

/**

void cancelled(Context context);

}

/**

public static final class Key<T> {

private final String name;

private final T defaultValue;

Key(String name) {

this(name, null);

}

Key(String name, T defaultValue) {

this.name = checkNotNull(name, "name");

this.defaultValue = defaultValue;

}

/**

public T get() {

return get(Context.current());

}

/**

@SuppressWarnings("unchecked")

public T get(Context context) {

T value = (T) PersistentHashArrayMappedTrie.get(context.keyValueEntries, this);

return value == null ? defaultValue : value;

}

@Override

public String toString() {

return name;

}

}

/**