org.eclipse.microprofile.context.spi.ThreadContextSnapshot Java Examples

@Override
public ThreadContextSnapshot currentContext(Map<String, String> map) {
    ArcContainer arc = Arc.container();
    if (arc == null || !arc.isRunning()) {
        //return null as per docs to state that propagation of this context is not supported
        return null;
    }

    // capture the state, null indicates no active context while capturing snapshot
    InjectableContext.ContextState state = null;
    ManagedContext requestContext = arc.requestContext();
    if (requestContext.isActive()) {
        state = requestContext.getState();
    }
    if (state == null) {
        return NULL_CONTEXT_SNAPSHOT;
    } else {
        return new ContextSnapshot(state);
    }
}
 

/**
 * Construct a snapshot of context for the specified 'label'
 */
private ThreadContextSnapshot snapshot(String label) {
    return () -> {
        String labelToRestore = Label.get();
        AtomicBoolean restored = new AtomicBoolean();

        // Construct an instance that restores the previous context that was on the thread
        // prior to applying the specified 'label' as the new context.
        ThreadContextController contextRestorer = () -> {
            if (restored.compareAndSet(false, true)) {
                Label.set(labelToRestore);
            }
            else {
                throw new IllegalStateException();
            }
        };

        Label.set(label);
        return contextRestorer;
    };
}
 

private ThreadContextSnapshot snapshot(String label) {
    return () -> {
        String labelToRestore = CustomContext.get();
        AtomicBoolean restored = new AtomicBoolean();

        // Construct an instance that restores the previous context that was on the thread
        // prior to applying the specified 'label' as the new context.
        ThreadContextController contextRestorer = () -> {
            if (restored.compareAndSet(false, true)) {
                CustomContext.set(labelToRestore);
            } else {
                throw new IllegalStateException();
            }
        };

        CustomContext.set(label);
        return contextRestorer;
    };
}
 

@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return () -> {
        MyContext movedContext = MyContext.get();
        MyContext.clear();
        return () -> {
            if (movedContext == null)
                MyContext.clear();
            else
                MyContext.set(movedContext);
        };
    };
}
 

@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    Map<Class<?>, Object> context = Collections.emptyMap();
    return () -> {
        ResteasyContext.pushContextDataMap(context);
        return () -> {
            ResteasyContext.removeContextDataLevel();
        };
    };
}
 

@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    Map<Class<?>, Object> context = ResteasyContext.getContextDataMap(false);
    if (context == null) {
        return null;
    }
    return () -> {
        ResteasyContext.pushContextDataMap(context);
        return () -> {
            ResteasyContext.removeContextDataLevel();
        };
    };
}
 

@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return () -> {
        ServletRequestContext current = restore(null);
        return () -> restore(current);
    };
}
 

@Override
public ThreadContextSnapshot clearedContext(Map<String, String> map) {
    // note that by cleared we mean that we still activate context if need be, just leave the contents blank
    ArcContainer arc = Arc.container();
    if (arc == null || !arc.isRunning()) {
        //return null as per docs to state that propagation of this context is not supported
        return null;
    }
    return CLEAR_CONTEXT_SNAPSHOT;
}
 

@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return () -> {
        Tracer tracer = GlobalTracer.get();
        ScopeManager scopeManager = tracer.scopeManager();
        Scope activeScope = scopeManager.active();
        if (activeScope != null) {
            activeScope.close();
        }
        return () -> {
            // TODO: we should bring back the span here
        };
    };
}
 

@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    Tracer tracer = GlobalTracer.get();
    ScopeManager scopeManager = tracer.scopeManager();
    Scope activeScope = scopeManager.active();

    if (activeScope != null) {
        Span span = activeScope.span();
        return () -> {
            Scope propagated = scopeManager.activate(span, false);
            return propagated::close;
        };
    }
    return () -> DO_NOTHING;
}
 

@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    MyContext capturedContext = MyContext.get();
    return () -> {
        MyContext movedContext = MyContext.get();
        MyContext.set(capturedContext);
        return () -> {
            MyContext.set(movedContext);
        };
    };
}
 

/**
 * Save the buffer instance that is associated with the current thread.
 */
@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    return new BufferContextSnapshot(Buffer.get());
}
 

/**
 * Thread priority context is considered cleared by resetting to normal priority (Thread.NORM_PRIORITY).
 */
@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return new ThreadPrioritySnapshot(Thread.NORM_PRIORITY);
}
 

/**
 * Save the current thread priority.
 */
@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    return new ThreadPrioritySnapshot(Thread.currentThread().getPriority());
}
 

public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return snapshot("");
}
 

public ThreadContextSnapshot currentContext(Map<String, String> props) {
    return snapshot(CustomContext.get());
}
 

/**
 * Buffer context is considered cleared by associating a new empty StringBuffer with the thread.
 */
@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return new BufferContextSnapshot(null);
}
 

/**
 * Save the current context.
 */
@Override
public ThreadContextSnapshot currentContext(Map<String, String> props) {
    return snapshot(Label.get());
}
 

/**
 * Cleared context is the empty string.
 */
@Override
public ThreadContextSnapshot clearedContext(Map<String, String> props) {
    return snapshot("");
}