Examples with WorkEvent javax.resource.spi.work.WorkEvent used on opensource projects

Example 1 with WorkEvent

use of javax.resource.spi.work.WorkEvent in project spring-framework by spring-projects.

the class SimpleTaskWorkManager method executeWork.

/**
	 * Execute the given Work on the specified TaskExecutor.
	 * @param taskExecutor the TaskExecutor to use
	 * @param work the Work to execute
	 * @param startTimeout the time duration within which the Work is supposed to start
	 * @param blockUntilStarted whether to block until the Work has started
	 * @param executionContext the JCA ExecutionContext for the given Work
	 * @param workListener the WorkListener to clal for the given Work
	 * @return the time elapsed from Work acceptance until start of execution
	 * (or -1 if not applicable or not known)
	 * @throws WorkException if the TaskExecutor did not accept the Work
	 */
protected long executeWork(TaskExecutor taskExecutor, Work work, long startTimeout, boolean blockUntilStarted, ExecutionContext executionContext, WorkListener workListener) throws WorkException {
    if (executionContext != null && executionContext.getXid() != null) {
        throw new WorkException("SimpleTaskWorkManager does not supported imported XIDs: " + executionContext.getXid());
    }
    WorkListener workListenerToUse = workListener;
    if (workListenerToUse == null) {
        workListenerToUse = new WorkAdapter();
    }
    boolean isAsync = (taskExecutor instanceof AsyncTaskExecutor);
    DelegatingWorkAdapter workHandle = new DelegatingWorkAdapter(work, workListenerToUse, !isAsync);
    try {
        if (isAsync) {
            ((AsyncTaskExecutor) taskExecutor).execute(workHandle, startTimeout);
        } else {
            taskExecutor.execute(workHandle);
        }
    } catch (TaskTimeoutException ex) {
        WorkException wex = new WorkRejectedException("TaskExecutor rejected Work because of timeout: " + work, ex);
        wex.setErrorCode(WorkException.START_TIMED_OUT);
        workListenerToUse.workRejected(new WorkEvent(this, WorkEvent.WORK_REJECTED, work, wex));
        throw wex;
    } catch (TaskRejectedException ex) {
        WorkException wex = new WorkRejectedException("TaskExecutor rejected Work: " + work, ex);
        wex.setErrorCode(WorkException.INTERNAL);
        workListenerToUse.workRejected(new WorkEvent(this, WorkEvent.WORK_REJECTED, work, wex));
        throw wex;
    } catch (Throwable ex) {
        WorkException wex = new WorkException("TaskExecutor failed to execute Work: " + work, ex);
        wex.setErrorCode(WorkException.INTERNAL);
        throw wex;
    }
    if (isAsync) {
        workListenerToUse.workAccepted(new WorkEvent(this, WorkEvent.WORK_ACCEPTED, work, null));
    }
    if (blockUntilStarted) {
        long acceptanceTime = System.currentTimeMillis();
        synchronized (workHandle.monitor) {
            try {
                while (!workHandle.started) {
                    workHandle.monitor.wait();
                }
            } catch (InterruptedException ex) {
                Thread.currentThread().interrupt();
            }
        }
        return (System.currentTimeMillis() - acceptanceTime);
    } else {
        return WorkManager.UNKNOWN;
    }
}

Example 2 with WorkEvent

use of javax.resource.spi.work.WorkEvent in project tomee by apache.

the class SimpleWorkManager method executeWork.

private long executeWork(final WorkType workType, final Work work, final long startTimeout, final ExecutionContext executionContext, WorkListener workListener) throws WorkException {
    // assure we have a work listener
    if (workListener == null) {
        workListener = new LoggingWorkListener(workType);
    }
    // reject work with an XID
    if (executionContext != null && executionContext.getXid() != null) {
        final WorkRejectedException workRejectedException = new WorkRejectedException("SimpleWorkManager can not import an XID", WorkException.TX_RECREATE_FAILED);
        workListener.workRejected(new WorkEvent(this, WorkEvent.WORK_REJECTED, work, workRejectedException));
        throw workRejectedException;
    }
    // accecpt all other work
    workListener.workAccepted(new WorkEvent(this, WorkEvent.WORK_ACCEPTED, work, null));
    // execute work
    final Worker worker = new Worker(work, workListener, startTimeout);
    executor.execute(worker);
    if (workType == WorkType.DO) {
        // wait for completion
        try {
            worker.waitForCompletion();
        } catch (final InterruptedException e) {
            final WorkException workException = new WorkException("Work submission thread was interrupted", e);
            workException.setErrorCode(WorkException.INTERNAL);
            throw workException;
        }
        // if work threw an exception, rethrow it
        final WorkException workCompletedException = worker.getWorkException();
        if (workCompletedException != null) {
            throw workCompletedException;
        }
    } else if (workType == WorkType.START) {
        // wait for work to start
        try {
            worker.waitForStart();
        } catch (final InterruptedException e) {
            final WorkException workException = new WorkException("Work submission thread was interrupted", e);
            workException.setErrorCode(WorkException.INTERNAL);
            throw workException;
        }
        // if work threw a rejection exception, rethrow it (it is the exception for timeout) 
        final WorkException workCompletedException = worker.getWorkException();
        if (workCompletedException instanceof WorkRejectedException) {
            throw workCompletedException;
        }
    }
    return worker.getStartDelay();
}