io.vertx.reactivex.core

Class Context

java.lang.Object

io.vertx.reactivex.core.Context

public class Context
extends Object

The execution context of a Handler execution.

When Vert.x provides an event to a handler or calls the start or stop methods of a Verticle, the execution is associated with a Context.

Usually a context is an *event-loop context* and is tied to a specific event loop thread. So executions for that context always occur on that exact same event loop thread.

In the case of worker verticles and running inline blocking code a worker context will be associated with the execution which will use a thread from the worker thread pool.

When a handler is set by a thread associated with a specific context, the Vert.x will guarantee that when that handler is executed, that execution will be associated with the same context.

If a handler is set by a thread not associated with a context (i.e. a non Vert.x thread). Then a new context will be created for that handler.

In other words, a context is propagated.

This means that when a verticle is deployed, any handlers it sets will be associated with the same context - the context of the verticle.

This means (in the case of a standard verticle) that the verticle code will always be executed with the exact same thread, so you don't have to worry about multi-threaded acccess to the verticle state and you can code your application as single threaded.

This class also allows arbitrary data to be put(java.lang.String, java.lang.Object) and get(java.lang.String) on the context so it can be shared easily amongst different handlers of, for example, a verticle instance.

This class also provides runOnContext(io.vertx.core.Handler<java.lang.Void>) which allows an action to be executed asynchronously using the same context.

NOTE: This class has been automatically generated from the original non RX-ified interface using Vert.x codegen.

Field Summary

Fields

Modifier and Type	Field and Description
static io.vertx.lang.rx.TypeArg<Context>	__TYPE_ARG

Constructor Summary

Constructors

Constructor and Description
Context(Context delegate)
Context(Object delegate)

Method Summary

Modifier and Type	Method and Description
JsonObject	config() If the context is associated with a Verticle deployment, this returns the configuration that was specified when the verticle was deployed.
String	deploymentID() If the context is associated with a Verticle deployment, this returns the deployment ID of that deployment.
boolean	equals(Object o)
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.
<T> void	executeBlocking(Handler<Promise<T>> blockingCodeHandler) Invoke executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) with order = true.
<T> void	executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered) Safely execute some blocking code.
<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 executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) with order = true.
<T> T	get(String key) Get some data from the context.
Context	getDelegate()
int	getInstanceCount()
<T> T	getLocal(String key) Get some local data from the context.
int	hashCode()
boolean	isEventLoopContext() Is the current context an event loop context?
static boolean	isOnEventLoopThread() Is the current thread an event thread?
static boolean	isOnVertxThread() Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread
static boolean	isOnWorkerThread() Is the current thread a worker thread?
boolean	isWorkerContext() Is the current context a worker context?
static Context	newInstance(Context arg)
Vertx	owner()
List<String>	processArgs() The process args
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.
boolean	removeLocal(String key) Remove some local data from the context.
void	runOnContext(Handler<Void> action) Run the specified action asynchronously on the same context, some time after the current execution has completed.
<T> Maybe<T>	rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler) Invoke executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) with order = true.
<T> Maybe<T>	rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered) Safely execute some blocking code.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final io.vertx.lang.rx.TypeArg<Context> __TYPE_ARG

Constructor Detail

Context

public Context(Context delegate)

Context

public Context(Object delegate)

Method Detail

toString

public String toString()

Overrides:

toString in class Object

equals

public boolean equals(Object o)

Overrides:

equals in class Object

hashCode

public int hashCode()

Overrides:

hashCode in class Object

getDelegate

public Context getDelegate()

isOnWorkerThread

public static boolean isOnWorkerThread()

Is the current thread a worker thread?

NOTE! This is not always the same as calling isWorkerContext(). If you are running blocking code from an event loop context, then this will return true but isWorkerContext() will return false.

Returns:

true if current thread is a worker thread, false otherwise

isOnEventLoopThread

public static boolean isOnEventLoopThread()

Is the current thread an event thread?

NOTE! This is not always the same as calling isEventLoopContext(). If you are running blocking code from an event loop context, then this will return false but isEventLoopContext() will return true.

Returns:

true if current thread is an event thread, false otherwise

isOnVertxThread

public static boolean isOnVertxThread()

Is the current thread a Vert.x thread? That's either a worker thread or an event loop thread

Returns:

true if current thread is a Vert.x thread, false otherwise

runOnContext

public void runOnContext(Handler<Void> action)

Run the specified action asynchronously on the same context, some time after the current execution has completed.

Parameters:

action - the action to run

executeBlocking

public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                boolean ordered,
                                Handler<AsyncResult<T>> resultHandler)

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(T) 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 runOnContext(io.vertx.core.Handler<java.lang.Void>)

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,
                                boolean ordered)

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(T) 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 runOnContext(io.vertx.core.Handler<java.lang.Void>)

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

rxExecuteBlocking

public <T> Maybe<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
                                      boolean ordered)

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(T) 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 runOnContext(io.vertx.core.Handler<java.lang.Void>)

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

Returns:

executeBlocking

public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                Handler<AsyncResult<T>> resultHandler)

Invoke executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) with order = true.

Parameters:

blockingCodeHandler - handler representing the blocking code to run

resultHandler - handler that will be called when the blocking code is complete

executeBlocking

public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler)

Invoke executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) with order = true.

Parameters:

blockingCodeHandler - handler representing the blocking code to run

rxExecuteBlocking

public <T> Maybe<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)

Invoke executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) with order = true.

Parameters:

blockingCodeHandler - handler representing the blocking code to run

Returns:

deploymentID

public String deploymentID()

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()

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

processArgs

public List<String> processArgs()

The process args

Returns:

isEventLoopContext

public boolean isEventLoopContext()

Is the current context an event loop context?

NOTE! when running blocking code using Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) from a standard (not worker) verticle, the context will still an event loop context and this will return true.

Returns:

true if false otherwise

isWorkerContext

public boolean isWorkerContext()

Is the current context a worker context?

NOTE! when running blocking code using Vertx.executeBlocking(io.vertx.core.Handler<io.vertx.reactivex.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) from a standard (not worker) verticle, the context will still an event loop context and this will return false.

Returns:

true if the current context is a worker context, false otherwise

get

public <T> T get(String key)

Get some data from the context.

Parameters:

key - the key of the data

Returns:

the data

put

public void put(String key,
                Object value)

Put some data in the context.

This can be used to share data between different handlers that share a context

Parameters:

key - the key of the data

value - the data

remove

public boolean remove(String key)

Remove some data from the context.

Parameters:

key - the key to remove

Returns:

true if removed successfully, false otherwise

getLocal

public <T> T getLocal(String key)

Get some local data from the context.

Parameters:

key - the key of the data

Returns:

the data

putLocal

public void putLocal(String key,
                     Object value)

Put some local data in the context.

This can be used to share data between different handlers that share a context

Parameters:

key - the key of the data

value - the data

removeLocal

public boolean removeLocal(String key)

Remove some local data from the context.

Parameters:

key - the key to remove

Returns:

true if removed successfully, false otherwise

owner

public Vertx owner()

Returns:

The Vertx instance that created the 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

exceptionHandler

public 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.

Parameters:

handler - the exception handler

Returns:

a reference to this, so the API can be used fluently

newInstance

public static Context newInstance(Context arg)