WorkerContext (Vertx Javadocs 4.0.3.GA API)

java.lang.Object
- io.vertx.core.impl.WorkerContext

All Implemented Interfaces:

Context, ContextInternal
```
public class WorkerContext
extends Object
```
Author:

Tim Fox

Field Summary

Fields
Modifier and Type Field and Description

protected JsonObject config

protected VertxInternal owner

protected VertxTracer<?,?> tracer

Fields
Modifier and Type	Field and Description
`protected JsonObject`	`config`
`protected VertxInternal`	`owner`
`protected VertxTracer<?,?>`	`tracer`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addCloseHook(Closeable hook)` Add a close hook.
`ContextInternal`	`beginDispatch()` Begin the execution of a task on this context.
`ClassLoader`	`classLoader()`
`CloseHooks`	`closeHooks()`
`JsonObject`	`config()` If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
`ConcurrentMap<Object,Object>`	`contextData()`
`String`	`deploymentID()` If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
`void`	`dispatch(Handler<Void> handler)`
`void`	`dispatch(Runnable handler)`
`<T> void`	`dispatch(T event, Handler<T> handler)` Dispatch an `event` to the `handler` on this context.
`ContextInternal`	`duplicate()` Returns a context sharing with this context the same concurrency the same exception handler the same context data the same deployment the same config the same classloader
`void`	`emit(Handler<Void> task)`
`<T> void`	`emit(T argument, Handler<T> task)` Emit the given `argument` event to the `task` and switch on this context if necessary, this also associates the current thread with the current context so `Vertx.currentContext()` returns this context.
`void`	`endDispatch(ContextInternal previous)` End the execution of a task on this context, see `ContextInternal.beginDispatch()`
`Handler<Throwable>`	`exceptionHandler()`
`Context`	`exceptionHandler(Handler<Throwable> handler)` Set an exception handler called when the context runs an action throwing an uncaught throwable. When this handler is called, `Vertx.currentContext()` will return this context.
`void`	`execute(Handler<Void> task)`
`void`	`execute(Runnable task)` Execute the `task` on this context, it will be executed according to the context concurrency model.
`<T> void`	`execute(T argument, Handler<T> task)` Execute a `task` on this context, the task will be executed according to the context concurrency model.
`<T> Future<T>`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler)` Same as `Context.executeBlocking(Handler, Handler)` but with an `handler` called when the operation completes
`<T> Future<T>`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered)` Same as `Context.executeBlocking(Handler, boolean, Handler)` but with an `handler` called when the operation completes
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler)` Safely execute some blocking code.
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler)` Invoke `Context.executeBlocking(Handler, boolean, Handler)` with order = true.
`<T> Future<T>`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue)` Like `Context.executeBlocking(Handler, boolean)` but uses the `queue` to order the tasks instead of the internal queue of this context.
`<T> void`	`executeBlocking(Handler<Promise<T>> blockingCodeHandler, TaskQueue queue, Handler<AsyncResult<T>> resultHandler)` Like `Context.executeBlocking(Handler, boolean, Handler)` but uses the `queue` to order the tasks instead of the internal queue of this context.
`<T> Future<T>`	`executeBlockingInternal(Handler<Promise<T>> action)` Like `ContextInternal.executeBlockingInternal(Handler, Handler)` but returns a `Future` of the asynchronous result
`<T> Future<T>`	`executeBlockingInternal(Handler<Promise<T>> action, boolean ordered)` Like `ContextInternal.executeBlockingInternal(Handler, boolean, Handler)` but returns a `Future` of the asynchronous result
`<T> void`	`executeBlockingInternal(Handler<Promise<T>> action, boolean ordered, Handler<AsyncResult<T>> resultHandler)`
`<T> void`	`executeBlockingInternal(Handler<Promise<T>> action, Handler<AsyncResult<T>> resultHandler)` Execute an internal task on the internal blocking ordered executor.
`<T> Future<T>`	`failedFuture(String message)`
`<T> Future<T>`	`failedFuture(Throwable failure)`
`<T> T`	`get(String key)` Get some data from the context.
`Deployment`	`getDeployment()`
`int`	`getInstanceCount()`
`<T> T`	`getLocal(String key)` Get some local data from the context.
`boolean`	`isDeployment()`
`boolean`	`isEventLoopContext()` Is the current context an event loop context?
`boolean`	`isRunningOnContext()`
`boolean`	`isWorkerContext()` Is the current context a worker context?
`ConcurrentMap<Object,Object>`	`localContextData()`
`io.netty.channel.EventLoop`	`nettyEventLoop()` Return the Netty EventLoop used by this Context.
`VertxInternal`	`owner()`
`List<String>`	`processArgs()` The process args
`<T> PromiseInternal<T>`	`promise()`
`<T> PromiseInternal<T>`	`promise(Handler<AsyncResult<T>> handler)`
`void`	`put(String key, Object value)` Put some data in the context.
`void`	`putLocal(String key, Object value)` Put some local data in the context.
`boolean`	`remove(String key)` Remove some data from the context.
`void`	`removeCloseHook(Closeable hook)` Remove a close hook.
`boolean`	`removeLocal(String key)` Remove some local data from the context.
`void`	`reportException(Throwable t)` Report an exception to this context synchronously.
`void`	`runOnContext(Handler<Void> action)` Run the specified action asynchronously on the same context, some time after the current execution has completed.
`long`	`setPeriodic(long delay, Handler<Long> handler)` Like `Vertx.setPeriodic(long, Handler)` except the periodic timer will fire on this context.
`long`	`setTimer(long delay, Handler<Long> handler)` Like `Vertx.setTimer(long, Handler)` except the timer will fire on this context.
`<T> Future<T>`	`succeededFuture()`
`<T> Future<T>`	`succeededFuture(T result)`
`VertxTracer`	`tracer()`
`WorkerPool`	`workerPool()`

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

Methods inherited from interface io.vertx.core.impl.ContextInternal
current

Methods inherited from interface io.vertx.core.Context
isOnEventLoopThread, isOnVertxThread, isOnWorkerThread

- Field Detail
  - owner
```
protected final VertxInternal owner
```
  - tracer
```
protected final VertxTracer<?,?> tracer
```
  - config
```
protected final JsonObject config
```
- Method Detail
  - isEventLoopContext
```
public boolean isEventLoopContext()
```
    Description copied from interface: Context
    
    Is the current context an event loop context?
    NOTE! when running blocking code using Vertx.executeBlocking(Handler, Handler) from a standard (not worker) verticle, the context will still an event loop context and this this#isEventLoopContext() will return true.
    
    Specified by:
    
    isEventLoopContext in interface Context
    
    Returns:
    
    true if false otherwise
  - getDeployment
```
public Deployment getDeployment()
```
    Returns:
    
    the deployment associated with this context or null
  - closeHooks
```
public CloseHooks closeHooks()
```
  - addCloseHook
```
public void addCloseHook(Closeable hook)
```
    Description copied from interface: ContextInternal
    
    Add a close hook.
    The hook will be called when the associated resource needs to be released. Hooks are useful for automatically cleanup resources when a Verticle is undeployed.
    
    Parameters:
    
    hook - the close hook
  - isDeployment
```
public boolean isDeployment()
```
    Returns:
    
    true when the context is associated with a deployment
  - removeCloseHook
```
public void removeCloseHook(Closeable hook)
```
    Description copied from interface: ContextInternal
    
    Remove a close hook.
    This is called when the resource is released explicitly and does not need anymore a managed close.
    
    Parameters:
    
    hook - the close hook
  - deploymentID
```
public String deploymentID()
```
    Description copied from interface: Context
    
    If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
    
    Returns:
    
    the deployment ID of the deployment or null if not a Verticle deployment
  - config
```
public JsonObject config()
```
    Description copied from interface: Context
    
    If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
    
    Returns:
    
    the configuration of the deployment or null if not a Verticle deployment
  - nettyEventLoop
```
public io.netty.channel.EventLoop nettyEventLoop()
```
    Description copied from interface: ContextInternal
    
    Return the Netty EventLoop used by this Context. This can be used to integrate a Netty Server with a Vert.x runtime, specially the Context part.
    
    Returns:
    
    the EventLoop
  - owner
```
public VertxInternal owner()
```
    Returns:
    
    The Vertx instance that created the context
  - executeBlockingInternal
```
public <T> Future<T> executeBlockingInternal(Handler<Promise<T>> action)
```
    Description copied from interface: ContextInternal
    
    Like ContextInternal.executeBlockingInternal(Handler, Handler) but returns a Future of the asynchronous result
  - executeBlockingInternal
```
public <T> Future<T> executeBlockingInternal(Handler<Promise<T>> action,
                                             boolean ordered)
```
    Description copied from interface: ContextInternal
    
    Like ContextInternal.executeBlockingInternal(Handler, boolean, Handler) but returns a Future of the asynchronous result
  - executeBlocking
```
public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                     boolean ordered)
```
    Description copied from interface: Context
    
    Same as Context.executeBlocking(Handler, boolean, Handler) but with an handler called when the operation completes
  - executeBlocking
```
public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                     TaskQueue queue)
```
    Description copied from interface: ContextInternal
    
    Like Context.executeBlocking(Handler, boolean) but uses the queue to order the tasks instead of the internal queue of this context.
  - tracer
```
public VertxTracer tracer()
```
    Returns:
    
    the tracer for this context
  - classLoader
```
public ClassLoader classLoader()
```
    Returns:
    
    the classloader associated with this context
  - workerPool
```
public WorkerPool workerPool()
```
    Returns:
    
    the context worker pool
  - contextData
```
public ConcurrentMap<Object,Object> contextData()
```
    Returns:
    
    the ConcurrentMap used to store context data
    
    See Also:
    
    Context.get(String), Context.put(String, Object)
  - localContextData
```
public ConcurrentMap<Object,Object> localContextData()
```
    Returns:
    
    the ConcurrentMap used to store local context data
  - reportException
```
public void reportException(Throwable t)
```
    Description copied from interface: ContextInternal
    
    Report an exception to this context synchronously.
    The exception handler will be called when there is one, otherwise the exception will be logged.
    
    Parameters:
    
    t - the exception to report
  - exceptionHandler
```
public Context exceptionHandler(Handler<Throwable> handler)
```
    Description copied from interface: Context
    
    Set an exception handler called when the context runs an action throwing an uncaught throwable.
    When this handler is called, Vertx.currentContext() will return this context.
    
    Parameters:
    
    handler - the exception handler
    
    Returns:
    
    a reference to this, so the API can be used fluently
  - exceptionHandler
```
public Handler<Throwable> exceptionHandler()
```
    Returns:
    
    the current exception handler of this context
  - getInstanceCount
```
public int getInstanceCount()
```
    Returns:
    
    the number of instances of the verticle that were deployed in the deployment (if any) related to this context
  - runOnContext
```
public final void runOnContext(Handler<Void> action)
```
    Description copied from interface: Context
    
    Run the specified action asynchronously on the same context, some time after the current execution has completed.
    
    Parameters:
    
    action - the action to run
  - execute
```
public void execute(Runnable task)
```
    Description copied from interface: ContextInternal
    
    Execute the task on this context, it will be executed according to the context concurrency model.
    
    Parameters:
    
    task - the task to execute
  - execute
```
public final <T> void execute(T argument,
                              Handler<T> task)
```
    Description copied from interface: ContextInternal
    
    Execute a task on this context, the task will be executed according to the context concurrency model.
    
    Parameters:
    
    argument - the task argument
    
    task - the task to execute
  - emit
```
public <T> void emit(T argument,
                     Handler<T> task)
```
    Description copied from interface: ContextInternal
    
    Emit the given argument event to the task and switch on this context if necessary, this also associates the current thread with the current context so Vertx.currentContext() returns this context.
    Any exception thrown from the task will be reported on this context.
    Calling this method is equivalent to execute(v -> dispatch(argument, task))
    
    Parameters:
    
    argument - the task argument
    
    task - the handler to execute with the event argument
  - duplicate
```
public final ContextInternal duplicate()
```
    Description copied from interface: ContextInternal
    Returns a context sharing with this context
    - the same concurrency
    - the same exception handler
    - the same context data
    - the same deployment
    - the same config
    - the same classloader
    The duplicate context has its own
    - local context data
    - worker task queue
    Returns:
    
    a duplicate of this context
  - isRunningOnContext
```
public final boolean isRunningOnContext()
```
    Specified by:
    
    isRunningOnContext in interface ContextInternal
    
    Returns:
    
    whether the current thread is running on this context
  - isWorkerContext
```
public boolean isWorkerContext()
```
    Description copied from interface: Context
    
    Is the current context a worker context?
    NOTE! when running blocking code using Vertx.executeBlocking(Handler, Handler) from a standard (not worker) verticle, the context will still an event loop context and this this#isWorkerContext() will return false.
    
    Specified by:
    
    isWorkerContext in interface Context
    
    Returns:
    
    true if the current context is a worker context, false otherwise
  - emit
```
public void emit(Handler<Void> task)
```
    Specified by:
    
    emit in interface ContextInternal
    
    See Also:
    
    ContextInternal.emit(Object, Handler)
  - execute
```
public final void execute(Handler<Void> task)
```
    Specified by:
    
    execute in interface ContextInternal
    
    See Also:
    
    ContextInternal.execute(Object, Handler)
  - dispatch
```
public final void dispatch(Handler<Void> handler)
```
    Specified by:
    
    dispatch in interface ContextInternal
    
    See Also:
    
    ContextInternal.dispatch(Object, Handler)
  - beginDispatch
```
public final ContextInternal beginDispatch()
```
    Description copied from interface: ContextInternal
    
    Begin the execution of a task on this context.
    The task execution is monitored by the blocked thread checker.
    This context is thread-local associated during the task execution.
    You should not use this API directly, instead you should use ContextInternal.dispatch(Object, Handler)
    
    Specified by:
    
    beginDispatch in interface ContextInternal
    
    Returns:
    
    the previous context that shall be restored after or null if there is none
  - endDispatch
```
public final void endDispatch(ContextInternal previous)
```
    Description copied from interface: ContextInternal
    
    End the execution of a task on this context, see ContextInternal.beginDispatch()
    You should not use this API directly, instead you should use ContextInternal.dispatch(Object, Handler)
    
    Specified by:
    
    endDispatch in interface ContextInternal
    
    Parameters:
    
    previous - the previous context to restore or null if there is none
  - setPeriodic
```
public long setPeriodic(long delay,
                        Handler<Long> handler)
```
    Description copied from interface: ContextInternal
    
    Like Vertx.setPeriodic(long, Handler) except the periodic timer will fire on this context.
    
    Specified by:
    
    setPeriodic in interface ContextInternal
  - setTimer
```
public long setTimer(long delay,
                     Handler<Long> handler)
```
    Description copied from interface: ContextInternal
    
    Like Vertx.setTimer(long, Handler) except the timer will fire on this context.
    
    Specified by:
    
    setTimer in interface ContextInternal
  - dispatch
```
public final <T> void dispatch(T event,
                               Handler<T> handler)
```
    Description copied from interface: ContextInternal
    
    Dispatch an event to the handler on this context.
    The handler is executed directly by the caller thread which must be a VertxThread or a FastThreadLocalThread.
    The handler execution is monitored by the blocked thread checker.
    This context is thread-local associated during the task execution.
    
    Specified by:
    
    dispatch in interface ContextInternal
    
    Parameters:
    
    event - the event for the handler
    
    handler - the handler to execute with the event
  - dispatch
```
public final void dispatch(Runnable handler)
```
    Specified by:
    
    dispatch in interface ContextInternal
    
    See Also:
    
    ContextInternal.dispatch(Handler)
  - processArgs
```
public final List<String> processArgs()
```
    Description copied from interface: Context
    
    The process args
    
    Specified by:
    
    processArgs in interface Context
  - executeBlockingInternal
```
public final <T> void executeBlockingInternal(Handler<Promise<T>> action,
                                              Handler<AsyncResult<T>> resultHandler)
```
    Description copied from interface: ContextInternal
    
    Execute an internal task on the internal blocking ordered executor.
    
    Specified by:
    
    executeBlockingInternal in interface ContextInternal
  - executeBlockingInternal
```
public <T> void executeBlockingInternal(Handler<Promise<T>> action,
                                        boolean ordered,
                                        Handler<AsyncResult<T>> resultHandler)
```
    Specified by:
    
    executeBlockingInternal in interface ContextInternal
  - executeBlocking
```
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                boolean ordered,
                                Handler<AsyncResult<T>> resultHandler)
```
    Description copied from interface: Context
    
    Safely execute some blocking code.
    Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.
    When the code is complete the handler resultHandler will be called with the result on the original context (e.g. on the original event loop of the caller).
    A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(Object) method, or the Promise.fail(java.lang.Throwable) method if it failed.
    The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.
    When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.
    Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context.runOnContext(Handler)
    
    Specified by:
    
    executeBlocking in interface Context
    
    Type Parameters:
    
    T - the type of the result
    
    Parameters:
    
    blockingCodeHandler - handler representing the blocking code to run
    
    ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
    
    resultHandler - handler that will be called when the blocking code is complete
  - executeBlocking
```
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                TaskQueue queue,
                                Handler<AsyncResult<T>> resultHandler)
```
    Description copied from interface: ContextInternal
    
    Like Context.executeBlocking(Handler, boolean, Handler) but uses the queue to order the tasks instead of the internal queue of this context.
    
    Specified by:
    
    executeBlocking in interface ContextInternal
  - executeBlocking
```
public final <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                      Handler<AsyncResult<T>> resultHandler)
```
    Description copied from interface: Context
    
    Invoke Context.executeBlocking(Handler, boolean, Handler) with order = true.
    
    Specified by:
    
    executeBlocking in interface Context
    
    Type Parameters:
    
    T - the type of the result
    
    Parameters:
    
    blockingCodeHandler - handler representing the blocking code to run
    
    resultHandler - handler that will be called when the blocking code is complete
  - executeBlocking
```
public <T> Future<T> executeBlocking(Handler<Promise<T>> blockingCodeHandler)
```
    Description copied from interface: Context
    
    Same as Context.executeBlocking(Handler, Handler) but with an handler called when the operation completes
    
    Specified by:
    
    executeBlocking in interface Context
  - promise
```
public <T> PromiseInternal<T> promise()
```
    Specified by:
    
    promise in interface ContextInternal
    
    Returns:
    
    a Promise associated with this context
  - promise
```
public <T> PromiseInternal<T> promise(Handler<AsyncResult<T>> handler)
```
    Specified by:
    
    promise in interface ContextInternal
    
    Returns:
    
    a Promise associated with this context or the handler if that handler is already an instance of PromiseInternal
  - succeededFuture
```
public <T> Future<T> succeededFuture()
```
    Specified by:
    
    succeededFuture in interface ContextInternal
    
    Returns:
    
    an empty succeeded Future associated with this context
  - succeededFuture
```
public <T> Future<T> succeededFuture(T result)
```
    Specified by:
    
    succeededFuture in interface ContextInternal
    
    Returns:
    
    a succeeded Future of the result associated with this context
  - failedFuture
```
public <T> Future<T> failedFuture(Throwable failure)
```
    Specified by:
    
    failedFuture in interface ContextInternal
    
    Returns:
    
    a Future failed with the failure associated with this context
  - failedFuture
```
public <T> Future<T> failedFuture(String message)
```
    Specified by:
    
    failedFuture in interface ContextInternal
    
    Returns:
    
    a Future failed with the message associated with this context
  - get
```
public final <T> T get(String key)
```
    Description copied from interface: Context
    
    Get some data from the context.
    
    Specified by:
    
    get in interface Context
    
    Type Parameters:
    
    T - the type of the data
    
    Parameters:
    
    key - the key of the data
    
    Returns:
    
    the data
  - put
```
public final void put(String key,
                      Object value)
```
    Description copied from interface: Context
    
    Put some data in the context.
    This can be used to share data between different handlers that share a context
    
    Specified by:
    
    put in interface Context
    
    Parameters:
    
    key - the key of the data
    
    value - the data
  - remove
```
public final boolean remove(String key)
```
    Description copied from interface: Context
    
    Remove some data from the context.
    
    Specified by:
    
    remove in interface Context
    
    Parameters:
    
    key - the key to remove
    
    Returns:
    
    true if removed successfully, false otherwise
  - getLocal
```
public final <T> T getLocal(String key)
```
    Description copied from interface: Context
    
    Get some local data from the context.
    
    Specified by:
    
    getLocal in interface Context
    
    Type Parameters:
    
    T - the type of the data
    
    Parameters:
    
    key - the key of the data
    
    Returns:
    
    the data
  - putLocal
```
public final void putLocal(String key,
                           Object value)
```
    Description copied from interface: Context
    
    Put some local data in the context.
    This can be used to share data between different handlers that share a context
    
    Specified by:
    
    putLocal in interface Context
    
    Parameters:
    
    key - the key of the data
    
    value - the data
  - removeLocal
```
public final boolean removeLocal(String key)
```
    Description copied from interface: Context
    
    Remove some local data from the context.
    
    Specified by:
    
    removeLocal in interface Context
    
    Parameters:
    
    key - the key to remove
    
    Returns:
    
    true if removed successfully, false otherwise

Class WorkerContext

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.vertx.core.impl.ContextInternal

Methods inherited from interface io.vertx.core.Context

Field Detail

owner

tracer

config

Method Detail

isEventLoopContext

getDeployment

closeHooks

addCloseHook

isDeployment

removeCloseHook

deploymentID

config

nettyEventLoop

owner

executeBlockingInternal

executeBlockingInternal

executeBlocking

executeBlocking

tracer

classLoader

workerPool

contextData

localContextData

reportException

exceptionHandler

exceptionHandler

getInstanceCount

runOnContext

execute

execute

emit

duplicate

isRunningOnContext

isWorkerContext

emit

execute

dispatch

beginDispatch

endDispatch

setPeriodic

setTimer

dispatch

dispatch

processArgs

executeBlockingInternal

executeBlockingInternal

executeBlocking

executeBlocking

executeBlocking

executeBlocking

promise

promise

succeededFuture

succeededFuture

failedFuture

failedFuture

get

put

remove

getLocal

putLocal

removeLocal