sirius.web.tasks

Interface ManagedTaskContext

All Superinterfaces:

sirius.kernel.async.TaskContextAdapter

public interface ManagedTaskContext
extends sirius.kernel.async.TaskContextAdapter

Provides an execution context for managed tasks.

Managed tasks are started via ManagedTasks.createManagedTaskSetup(String). The subsequently started task is given an instance of ManagedTaskContext to interact with the execution system.

See Also:

ManagedTask

Method Summary

Modifier and Type	Method and Description
void	addTiming(String counter, long millis) Increments the given performance counter by one and supplies a loop duration in milliseconds.
void	error(Object message) Adds an error to the task log.
void	fork(String category, Runnable runnable) Forks a sub task in the given executor (category).
List<TaskLogEntry>	getLastLogs() Returns the latest log entries.
List<sirius.kernel.commons.Tuple<String,String>>	getTimings() Returns a list of all recorded performance counters.
void	inc(String counter) Increments the given performance counter by one.
boolean	isErroneous() Determines if the current task is erroneous
void	logLimited(Object message) Logs the given message unless the method is called to frequently.
void	setLogWriter(Writer writer) Installs a writer into the running context which is supplied with all logged messages.
void	sleepMillis(long millis) Blocks the current task for the given number of milliseconds.
void	waitForForkedTasks() Blocks the current thread until all forked tasks have completed.
void	warn(Object message) Adds a warning to the task log.

Methods inherited from interface sirius.kernel.async.TaskContextAdapter

cancel, isActive, log, markErroneous, setState, trace

Method Detail

logLimited

void logLimited(Object message)

Logs the given message unless the method is called to frequently.

This method has an internal rate limit and can therefore be used by loops etc. to report the progress every now and then.

A caller can rely on the rate limit and therefore can invoke this method as often as desired. Howerver one must not rely on any message to be shown.

Parameters:

message - the message to add to the logs.

getLastLogs

List<TaskLogEntry> getLastLogs()

Returns the latest log entries.

The log is limited to a sane number of entries to pevent excessive memory usage.

Returns:

a list containing the last few log entries

setLogWriter

void setLogWriter(@Nullable
                  Writer writer)

Installs a writer into the running context which is supplied with all logged messages.

Parameters:

writer - the writer to print all logged messages to

inc

void inc(String counter)

Increments the given performance counter by one.

Parameters:

counter - the counter to increment

addTiming

void addTiming(String counter,
               long millis)

Increments the given performance counter by one and supplies a loop duration in milliseconds.

The avarage value will be computed for the given counter and gives the user a rough estimate what the current task is doing.

Parameters:

counter - the counter to increment

millis - the current duration for the block being counted

getTimings

List<sirius.kernel.commons.Tuple<String,String>> getTimings()

Returns a list of all recorded performance counters.

The first part of the tuple will be the name of the counter. The second will contain the counter value along with the avarage duration (if supplied).

Returns:

a list of tuples which contains all recorded performance counters

warn

void warn(Object message)

Adds a warning to the task log.

Parameters:

message - the message to log

error

void error(Object message)

Adds an error to the task log.

Parameters:

message - the message to log

sleepMillis

void sleepMillis(long millis)

Blocks the current task for the given number of milliseconds.

Parameters:

millis - the number of milliseconds to block

fork

void fork(String category,
          Runnable runnable)

Forks a sub task in the given executor (category). Note that the managed task will run as long as any forked task runs.

Parameters:

category - the category / executor to run the subtask in. Note that a deadlock can be created if the sub task is run in the same execute as the managed task as the managed task will wait until all sub tasks are finished!

runnable - the runnable to execute

waitForForkedTasks

void waitForForkedTasks()

Blocks the current thread until all forked tasks have completed.

isErroneous

boolean isErroneous()

Determines if the current task is erroneous

Returns:

true if the task is marked as erroneous, false otherwise.