io.vertx.core.impl

Interface ContextInternal

All Superinterfaces:

Context

All Known Implementing Classes:

EventLoopContext, WorkerContext

public interface ContextInternal
extends Context

This interface provides an api for vert.x core internal use only It is not part of the public API and should not be used by developers creating vert.x applications

Author:

Julien Viet

Method Summary

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()
ConcurrentMap<Object,Object>	contextData()
static ContextInternal	current()
<E> void	dispatch(E event, Handler<E> handler) Dispatch an event to the handler on this context.
void	dispatch(Handler<Void> handler)
void	dispatch(Runnable handler)
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 beginDispatch()
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, 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 executeBlockingInternal(Handler, Handler) but returns a Future of the asynchronous result
<T> Future<T>	executeBlockingInternal(Handler<Promise<T>> action, boolean ordered) Like 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)
Deployment	getDeployment()
boolean	isDeployment()
boolean	isRunningOnContext()
ConcurrentMap<Object,Object>	localContextData()
io.netty.channel.EventLoop	nettyEventLoop() Return the Netty EventLoop used by this Context.
VertxInternal	owner()
<T> PromiseInternal<T>	promise()
<T> PromiseInternal<T>	promise(Handler<AsyncResult<T>> handler)
void	removeCloseHook(Closeable hook) Remove a close hook.
void	reportException(Throwable t) Report an exception to this context synchronously.
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 interface io.vertx.core.Context

config, deploymentID, exceptionHandler, exceptionHandler, executeBlocking, executeBlocking, executeBlocking, executeBlocking, get, getInstanceCount, getLocal, isEventLoopContext, isOnEventLoopThread, isOnVertxThread, isOnWorkerThread, isWorkerContext, processArgs, put, putLocal, remove, removeLocal, runOnContext

Method Detail

current

static ContextInternal current()

Returns:

the current context

nettyEventLoop

io.netty.channel.EventLoop nettyEventLoop()

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

promise

<T> PromiseInternal<T> promise()

Returns:

a Promise associated with this context

promise

<T> PromiseInternal<T> promise(Handler<AsyncResult<T>> handler)

Returns:

a Promise associated with this context or the handler if that handler is already an instance of PromiseInternal

succeededFuture

<T> Future<T> succeededFuture()

Returns:

an empty succeeded Future associated with this context

succeededFuture

<T> Future<T> succeededFuture(T result)

Returns:

a succeeded Future of the result associated with this context

failedFuture

<T> Future<T> failedFuture(Throwable failure)

Returns:

a Future failed with the failure associated with this context

failedFuture

<T> Future<T> failedFuture(String message)

Returns:

a Future failed with the message associated with this context

executeBlocking

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

executeBlocking

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

executeBlockingInternal

<T> void executeBlockingInternal(Handler<Promise<T>> action,
                                 Handler<AsyncResult<T>> resultHandler)

Execute an internal task on the internal blocking ordered executor.

executeBlockingInternal

<T> void executeBlockingInternal(Handler<Promise<T>> action,
                                 boolean ordered,
                                 Handler<AsyncResult<T>> resultHandler)

executeBlockingInternal

<T> Future<T> executeBlockingInternal(Handler<Promise<T>> action)

Like executeBlockingInternal(Handler, Handler) but returns a Future of the asynchronous result

executeBlockingInternal

<T> Future<T> executeBlockingInternal(Handler<Promise<T>> action,
                                      boolean ordered)

Like executeBlockingInternal(Handler, boolean, Handler) but returns a Future of the asynchronous result

getDeployment

Deployment getDeployment()

Returns:

the deployment associated with this context or null

owner

VertxInternal owner()

Specified by:

owner in interface Context

Returns:

The Vertx instance that created the context

emit

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

emit

void emit(Handler<Void> task)

See Also:

emit(Object, Handler)

execute

void execute(Handler<Void> task)

See Also:

execute(Object, Handler)

execute

void execute(Runnable task)

Execute the task on this context, it will be executed according to the context concurrency model.

Parameters:

task - the task to execute

execute

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

Parameters:

argument - the task argument

task - the task to execute

isRunningOnContext

boolean isRunningOnContext()

Returns:

whether the current thread is running on this context

dispatch

void dispatch(Runnable handler)

See Also:

dispatch(Handler)

dispatch

void dispatch(Handler<Void> handler)

See Also:

dispatch(Object, Handler)

dispatch

<E> void dispatch(E event,
                  Handler<E> handler)

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.

Parameters:

event - the event for the handler

handler - the handler to execute with the event

beginDispatch

ContextInternal beginDispatch()

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 dispatch(Object, Handler)

Returns:

the previous context that shall be restored after or null if there is none

Throws:

IllegalStateException - when the current thread of execution cannot execute this task

endDispatch

void endDispatch(ContextInternal previous)

End the execution of a task on this context, see beginDispatch()

You should not use this API directly, instead you should use dispatch(Object, Handler)

Parameters:

previous - the previous context to restore or null if there is none

Throws:

IllegalStateException - when the current thread of execution cannot execute this task

reportException

void reportException(Throwable t)

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

contextData

ConcurrentMap<Object,Object> contextData()

Returns:

the ConcurrentMap used to store context data

See Also:

Context.get(String), Context.put(String, Object)

localContextData

ConcurrentMap<Object,Object> localContextData()

Returns:

the ConcurrentMap used to store local context data

classLoader

ClassLoader classLoader()

Returns:

the classloader associated with this context

workerPool

WorkerPool workerPool()

Returns:

the context worker pool

tracer

VertxTracer tracer()

Returns:

the tracer for this context

duplicate

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

The duplicate context has its own

• local context data
• worker task queue

Returns:

a duplicate of this context

setPeriodic

long setPeriodic(long delay,
                 Handler<Long> handler)

Like Vertx.setPeriodic(long, Handler) except the periodic timer will fire on this context.

setTimer

long setTimer(long delay,
              Handler<Long> handler)

Like Vertx.setTimer(long, Handler) except the timer will fire on this context.

isDeployment

boolean isDeployment()

Returns:

true when the context is associated with a deployment

addCloseHook

void addCloseHook(Closeable hook)

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

removeCloseHook

void removeCloseHook(Closeable hook)

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