org.wildfly.extension.requestcontroller

Class ControlPoint

java.lang.Object

org.wildfly.extension.requestcontroller.ControlPoint

public class ControlPoint
extends Object

A representation of an entry point into the application server, represented as both a deployment name and an entry point name.

This should only be created using the top level name, as it does not generally make sense to shut down individual parts of a deployment.

Note that requests are tracked at two levels, both at the entry point level and the request controller level. This allows for individual deployments/interfaces to be gracefully suspended, and also allows for the global request controller to limit the total number of active requests.

Author:

Stuart Douglas

Method Summary

Modifier and Type	Method and Description
RunResult	beginRequest() All tasks entering the system via this entry point must call this method.
RunResult	forceBeginRequest() This task should only be called by a thread that has already been accepted from an entry point.
void	forceQueueTask(Runnable task, Executor taskExecutor) Queues a task to run when the request controller allows it.
int	getActiveRequestCount()
String	getDeployment()
String	getEntryPoint()
boolean	isPaused()
void	pause(ServerActivityCallback requestCountListener) Pause the current entry point, and invoke the provided listener when all current requests have finished.
void	queueTask(Runnable task, Executor taskExecutor, long timeout, Runnable timeoutTask, boolean rejectOnSuspend) Queues a task to run when the request controller allows it.
void	requestComplete() Method that should be invoked once (and only once) to signify that a request has finished.
void	resume() Cancel the pause operation

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getEntryPoint

public String getEntryPoint()

getDeployment

public String getDeployment()

pause

public void pause(ServerActivityCallback requestCountListener)

Pause the current entry point, and invoke the provided listener when all current requests have finished. If individual control point tracking is not enabled then the listener will be invoked straight away

Parameters:

requestCountListener - The listener to invoke

resume

public void resume()

Cancel the pause operation

beginRequest

public RunResult beginRequest()
                       throws Exception

All tasks entering the system via this entry point must call this method. If it returns REJECTED then the task cannot be run, and its failure should be signaled back to the originator.

If it returns RUN then the task should proceed as normal, and the requestComplete() method must be called once the task is complete, usually via a try/finally construct.

Throws:

Exception

forceBeginRequest

public RunResult forceBeginRequest()
                            throws Exception

This task should only be called by a thread that has already been accepted from an entry point. It is used when an existing running thread is about to offload to another thread, such as an executor service or async EJB.

Note that this can still be rejected if the global request limit has been hit.

If it returns RUN then the task should proceed as normal, and the requestComplete() method must be called once the task is complete, usually via a try/finally construct.

Throws:

Exception

requestComplete

public void requestComplete()

Method that should be invoked once (and only once) to signify that a request has finished.

This cannot be done automatically when the handleRequest method completes, as some

queueTask

public void queueTask(Runnable task,
                      Executor taskExecutor,
                      long timeout,
                      Runnable timeoutTask,
                      boolean rejectOnSuspend)

Queues a task to run when the request controller allows it. There are two use cases for this:

1. This allows for requests to be queued instead of dropped when the request limit has been hit
2. Timed jobs that are supposed to execute while the container is suspended can be queued to execute when it resumes

Note that the task will be run within the context of a beginRequest() call, if the task is executed there is no need to invoke on the control point again.

Parameters:

task - The task to run

timeout - The timeout in milliseconds, if this is larger than zero the task will be timed out after this much time has elapsed

timeoutTask - The task that is run on timeout

rejectOnSuspend - If the task should be rejected if the container is suspended, if this happens the timeout task is invoked immediately

forceQueueTask

public void forceQueueTask(Runnable task,
                           Executor taskExecutor)

Queues a task to run when the request controller allows it. This allows tasks not to be dropped when the max request limit has been hit. If the container has been suspended then this

Note that the task will be run withing the context of a beginRequest() call, if the task is executed there is no need to invoke on the control point again.

Parameters:

task - The task to run

taskExecutor - The executor to run the task in

isPaused

public boolean isPaused()

getActiveRequestCount

public int getActiveRequestCount()