er.extensions.concurrency

Class ERXLongResponseTask.DefaultImplementation

java.lang.Object

er.extensions.concurrency.ERXLongResponseTask.DefaultImplementation

All Implemented Interfaces:

ERXLongResponseTask, Runnable

Enclosing interface:

ERXLongResponseTask

public abstract static class ERXLongResponseTask.DefaultImplementation
extends Object
implements Runnable, ERXLongResponseTask

Nested Class Summary

Nested classes/interfaces inherited from interface er.extensions.concurrency.ERXLongResponseTask

ERXLongResponseTask.DefaultImplementation, ERXLongResponseTask.WorkerThread

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	_cancelled Holds the cancel flag
protected boolean	_done Holds the done flag
protected Exception	_exception Exception code
protected ERXLongResponse	_longResponse Refresh page that controls this task
protected Object	_result Result code
protected Object	_status Status code
protected Thread	_thread Hold the thread that performs the task
org.apache.log4j.Logger	log logging support

Constructor Summary

Constructors

Constructor and Description
DefaultImplementation() Constructor

Method Summary

Modifier and Type	Method and Description
protected void	_finishInitialization() Sets up the object.
protected WOComponent	cancelPageForStatus(Object aStatus) Override this to return a sensible page to show after the task was stopped.
protected Exception	exception() Returns the exception that may have occurred in the run() method.
protected boolean	isCancelled() Checks if the task was stopped externally.
boolean	isDone() (non-Javadoc)
ERXLongResponse	longResponse() Returns the long response for this task.
protected EOEditingContext	newEditingContext() You must manually lock and unlock the editing context returned by this method. It is not recommended that you depend on auto locking in background threads.
WOComponent	nextPage() Default implementation that controls the pages returned on each iteration.
protected WOComponent	pageForException(Exception exception) Override this to return an exception page suitable for the given exception.
protected WOComponent	pageForResult(Object aResult) Override this to return the page after the task was completed without beeing stopped.
protected EOObjectStore	parentObjectStore() See Effective Java item #71 for explanation of this threadsafe lazy initialization technique
abstract Object	performAction() You need to override this and perform your long running task.
protected WOComponent	refreshPageForStatus(Object aStatus) Override this to return and modify the refresh page.
protected Object	result() The abstract result object that has been returned by performAction().
void	run() Implementation of the Runnable interface.
protected void	setException(Exception anObject) Use this method to flag if an exception page should get displayed after finishing the current step.
void	setLongResponse(ERXLongResponse sender) Sets the long response that controls this task.
void	setParentObjectStore(EOObjectStore parentObjectStore)
protected void	setResult(Object anObject) Abstract result object that will get set when the task is finished.
protected void	setStatus(Object anObject)
void	start() Default implementation of the ERXLongResponseTask.start() method.
Object	status() Returns a current status.
void	stop() Stops the task.
protected long	taskEditingContextTimestampLag() By design EOEditingContext's have a fetch timestamp (default is 1 hour) that effectively creates an in-memory caching system for EOs.

Methods inherited from class java.lang.Object

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

Field Detail

log

public org.apache.log4j.Logger log

logging support

_longResponse

protected ERXLongResponse _longResponse

Refresh page that controls this task

_status

protected Object _status

Status code

_result

protected Object _result

Result code

_exception

protected Exception _exception

Exception code

_cancelled

protected boolean _cancelled

Holds the cancel flag

_done

protected boolean _done

Holds the done flag

_thread

protected Thread _thread

Hold the thread that performs the task

Constructor Detail

DefaultImplementation

public DefaultImplementation()

Constructor

Method Detail

_finishInitialization

protected void _finishInitialization()

Sets up the object.

setLongResponse

public void setLongResponse(ERXLongResponse sender)

Sets the long response that controls this task.

Specified by:

setLongResponse in interface ERXLongResponseTask

longResponse

public ERXLongResponse longResponse()

Returns the long response for this task.

run

public void run()

Implementation of the Runnable interface.

Specified by:

run in interface Runnable

status

public Object status()

Returns a current status. This can be any object and will given again to you to divine the next step.

setStatus

protected void setStatus(Object anObject)

exception

protected Exception exception()

Returns the exception that may have occurred in the run() method.

setException

protected void setException(Exception anObject)

Use this method to flag if an exception page should get displayed after finishing the current step.

Parameters:

anObject -

result

protected Object result()

The abstract result object that has been returned by performAction().

setResult

protected void setResult(Object anObject)

Abstract result object that will get set when the task is finished.

Parameters:

anObject -

isCancelled

protected boolean isCancelled()

Checks if the task was stopped externally.

Returns:

true if stop() was called.

isDone

public boolean isDone()

(non-Javadoc)

Specified by:

isDone in interface ERXLongResponseTask

Returns:

true if the task is still running

See Also:

ERXLongResponseTask.isDone()

stop

public void stop()

Stops the task. This just sets the cancel flag. Its up to you to check in your task if you are interruptable. So you should check isCancelled() in your performAction().

Specified by:

stop in interface ERXLongResponseTask

start

public void start()

Default implementation of the ERXLongResponseTask.start() method. Creates a new thread unless there already exists one.

Specified by:

start in interface ERXLongResponseTask

pageForException

protected WOComponent pageForException(Exception exception)

Override this to return an exception page suitable for the given exception. This implementation just re-throws the exception.

Parameters:

exception -

Returns:

page for the exception

refreshPageForStatus

protected WOComponent refreshPageForStatus(Object aStatus)

Override this to return and modify the refresh page. This is called while the task is still running. Note that is the place where you can call ERXLongResponse.setRefreshInterval(int) to set the next refresh time.

Parameters:

aStatus -

pageForResult

protected WOComponent pageForResult(Object aResult)

Override this to return the page after the task was completed without beeing stopped. Whether or not this counts as a success should be divined from the result object. This is the same object you return after being asked for result().

Parameters:

aResult - some result object

Returns:

result page for successful completion

cancelPageForStatus

protected WOComponent cancelPageForStatus(Object aStatus)

Override this to return a sensible page to show after the task was stopped. The default implementation returns the refresh component's top-level page

Parameters:

aStatus - some status object

Returns:

result page for the cancelled task.

nextPage

public WOComponent nextPage()

Default implementation that controls the pages returned on each iteration.

Specified by:

nextPage in interface ERXLongResponseTask

Returns:

next page according to inner status.

performAction

public abstract Object performAction()

You need to override this and perform your long running task.

Returns:

result of performing the action

parentObjectStore

protected final EOObjectStore parentObjectStore()

See Effective Java item #71 for explanation of this threadsafe lazy initialization technique

Returns:

the parent, usually an EOObjectStoreCoordinator to partition the task's EOF intensive work form the rest of the app.

setParentObjectStore

public final void setParentObjectStore(EOObjectStore parentObjectStore)

Parameters:

parentObjectStore - the parent, usually an EOObjectStoreCoordinator to partition the task's EOF intensive work from the rest of the app. If you are going to manually set this, you should do it before starting the task.

newEditingContext

protected EOEditingContext newEditingContext()

You must manually lock and unlock the editing context returned by this method. It is not recommended that you depend on auto locking in background threads. Even though this method currently returns an auto-locking EC if auto-locking is turned on for the app, a future update is planned that will return a manually locking EC from this method even if auto-locking is turned on for regular ECs used in normal request-response execution.

Returns:

a new EOEditingContext.

taskEditingContextTimestampLag

protected long taskEditingContextTimestampLag()

By design EOEditingContext's have a fetch timestamp (default is 1 hour) that effectively creates an in-memory caching system for EOs. This works great for users browsing through pages in the app. However, experience has shown that background EOF tasks are performing updates based on the state of other EOs, and thus we want to This is a long-running task. The last thing I want to do is perform a long running task with stale EOs, so we lazily create a fetch timestamp of the current time when we create the first EC and thus ensure fresh data. Secondly, we continue, by default to use this timestamp for the duration of the task since experience has shown that by doing so we can prevent unnecessary database fetching especially when our task is adding lots of items to a single relationship in batches. However if you want fresh data each time you create an EC in your task, feel free to set the fetch time stamp to the current time in your task each time you create a new EC. For R-R ec's we prefer fresh data on new pages. However for long running tasks, it is often best pick a single point in time, usually when the first ec is created as the timestamp lag. This works well when we are iterating and making new ec's especially if we are adding 100's of items to a relationship and cycling ec's

Returns:

the timestamp lag to use for new ec's created in the task thread.