@Override public Boolean call() throws Exception { return ServletScopes.transferRequest(FALSE_CALLABLE).call(); } };
/** * Wraps the given callable in a contextual callable that "transfers" the request to another * thread. This acts as a way of transporting request context data from the current thread to a * future thread. * * <p>As opposed to {@link #continueRequest}, this method propagates all existing scoped objects. * The primary use case is in server implementations where you can detach the request processing * thread while waiting for data, and reattach to a different thread to finish processing at a * later time. * * <p>Because request-scoped objects are not typically thread-safe, the callable returned by this * method must not be run on a different thread until the current request scope has terminated. * The returned callable will block until the current thread has released the request scope. * * @param callable code to be executed in another thread, which depends on the request scope. * @return a callable that will invoke the given callable, making the request context available to * it. * @throws OutOfScopeException if this method is called from a non-request thread, or if the * request has completed. * @since 4.0 */ public static <T> Callable<T> transferRequest(Callable<T> callable) { return wrap(callable, transferRequest()); }
@Override public Callable<Boolean> call() { final Object original = injector.getInstance(Object.class); return ServletScopes.transferRequest( new Callable<Boolean>() { @Override public Boolean call() { return original == injector.getInstance(Object.class); } }); } };
@Override public Data call() { Data data = new Data(); data.object = injector.getInstance(Object.class); data.scoper = ServletScopes.transferRequest(); return data; } };
@Override public Boolean call() throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); try { Future<Boolean> future = executor.submit(ServletScopes.transferRequest(FALSE_CALLABLE)); try { return future.get(100, TimeUnit.MILLISECONDS); } catch (TimeoutException e) { return true; } } finally { executor.shutdownNow(); } } };
public void testTransferHttp_outOfScope() { try { ServletScopes.transferRequest(FALSE_CALLABLE); fail(); } catch (OutOfScopeException expected) { } }
public void testTransferNonHttp_outOfScope() { try { ServletScopes.transferRequest(FALSE_CALLABLE); fail(); } catch (OutOfScopeException expected) { } }
public void testTransferNonHttp_outOfScope_closeable() { try { ServletScopes.transferRequest(); fail(); } catch (OutOfScopeException expected) { } }
@Override public Boolean call() throws Exception { final RequestScoper scoper = ServletScopes.transferRequest(); ExecutorService executor = Executors.newSingleThreadExecutor(); try { Future<Boolean> future = executor.submit( new Callable<Boolean>() { @Override public Boolean call() { RequestScoper.CloseableScope scope = scoper.open(); try { return false; } finally { scope.close(); } } }); try { return future.get(100, TimeUnit.MILLISECONDS); } catch (TimeoutException e) { return true; } } finally { executor.shutdownNow(); } } };
@Override public Boolean call() throws Exception { RequestScoper.CloseableScope scope = ServletScopes.transferRequest().open(); try { return false; } finally { scope.close(); } } };
/** * Wraps the given callable in a contextual callable that "transfers" the request to another * thread. This acts as a way of transporting request context data from the current thread to a * future thread. * * <p>As opposed to {@link #continueRequest}, this method propagates all existing scoped objects. * The primary use case is in server implementations where you can detach the request processing * thread while waiting for data, and reattach to a different thread to finish processing at a * later time. * * <p>Because request-scoped objects are not typically thread-safe, the callable returned by this * method must not be run on a different thread until the current request scope has terminated. * The returned callable will block until the current thread has released the request scope. * * @param callable code to be executed in another thread, which depends on the request scope. * @return a callable that will invoke the given callable, making the request context available to * it. * @throws OutOfScopeException if this method is called from a non-request thread, or if the * request has completed. * @since 4.0 */ public static <T> Callable<T> transferRequest(Callable<T> callable) { return wrap(callable, transferRequest()); }
/** * Wraps the given callable in a contextual callable that "transfers" the request to another * thread. This acts as a way of transporting request context data from the current thread to a * future thread. * * <p>As opposed to {@link #continueRequest}, this method propagates all existing scoped objects. * The primary use case is in server implementations where you can detach the request processing * thread while waiting for data, and reattach to a different thread to finish processing at a * later time. * * <p>Because request-scoped objects are not typically thread-safe, the callable returned by this * method must not be run on a different thread until the current request scope has terminated. * The returned callable will block until the current thread has released the request scope. * * @param callable code to be executed in another thread, which depends on the request scope. * @return a callable that will invoke the given callable, making the request context available to * it. * @throws OutOfScopeException if this method is called from a non-request thread, or if the * request has completed. * @since 4.0 */ public static <T> Callable<T> transferRequest(Callable<T> callable) { return wrap(callable, transferRequest()); }
public ExtDirectJsonRequestProcessorThread() { Subject subject = SecurityUtils.getSubject(); checkState(subject != null, "Subject is not set"); // create the thread state by this moment as this is created in the master (web container) thread threadState = new SubjectThreadState(subject); final String baseUrl = BaseUrlHolder.get(); processRequest = ServletScopes.transferRequest(new Callable<String>() { @Override public String call() { threadState.bind(); UserIdMdcHelper.set(); try { // apply base-url from the original thread BaseUrlHolder.set(baseUrl); return ExtDirectJsonRequestProcessorThread.super.processRequest(); } finally { UserIdMdcHelper.unset(); threadState.restore(); } } }); }