SimpleScheduler (ODE :: BPEL Scheduler Simple 1.3.5-wso2v21 API)

java.lang.Object
- org.apache.ode.scheduler.simple.SimpleScheduler

All Implemented Interfaces:

Scheduler
```
public class SimpleScheduler
extends java.lang.Object
implements Scheduler
```
A reliable and relatively simple scheduler that uses a database to persist information about scheduled tasks. The challenge is to achieve high performance in a small memory footprint without loss of reliability while supporting distributed/clustered configurations. The design is based around three time horizons: "immediate", "near future", and "everything else". Immediate jobs (i.e. jobs that are about to be up) are written to the database and kept in an in-memory priority queue. When they execute, they are removed from the database. Near future jobs are placed in the database and assigned to the current node, however they are not stored in memory. Periodically jobs are "upgraded" from near-future to immediate status, at which point they get loaded into memory. Jobs that are further out in time, are placed in the database without a node identifer; when they are ready to be "upgraded" to near-future jobs they are assigned to one of the known live nodes. Recovery is rather straighforward, with stale node identifiers being reassigned to known good nodes.

Author:

Maciej Szefler ( m s z e f l e r @ g m a i l . c o m )

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.ode.bpel.iapi.Scheduler
  Scheduler.JobDetails, Scheduler.JobInfo, Scheduler.JobProcessor, Scheduler.JobProcessorException, Scheduler.JobType, Scheduler.MapSerializableRunnable, Scheduler.Synchronizer

Constructor Summary

Constructors
Constructor and Description

SimpleScheduler(java.lang.String nodeId, DatabaseDelegate del, java.util.Properties conf)

Constructors
Constructor and Description
`SimpleScheduler(java.lang.String nodeId, DatabaseDelegate del, java.util.Properties conf)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`acquireTransactionLocks()` run method of old ode clustering implementation BPS-675 public void run() { _todo.enqueue(new CheckStaleNodes(System.currentTimeMillis() + _staleInterval)); __log.debug("CHECK STALE NODES started"); for (String nodeId : _knownNodes) { Long lastSeen = _lastHeartBeat.get(nodeId); if ((lastSeen == null \|\| (System.currentTimeMillis() - lastSeen) > _staleInterval) && !_nodeId.equals(nodeId)) { recoverStaleNode(nodeId); } } }
`void`	`cancelJob(java.lang.String jobId)`
`<T> java.util.concurrent.Future<T>`	`execIsolatedTransaction(java.util.concurrent.Callable<T> transaction)`
`<T> T`	`execTransaction(java.util.concurrent.Callable<T> transaction)`
`<T> T`	`execTransaction(java.util.concurrent.Callable<T> transaction, int timeout)`
`boolean`	`isTransacted()`
`void`	`registerSynchronizer(Scheduler.Synchronizer synch)`
`protected void`	`runJob(org.apache.ode.scheduler.simple.Job job)` Run a job in the current thread.
`protected void`	`runPolledRunnable(org.apache.ode.scheduler.simple.Job job)` Run a job from a polled runnable thread.
`void`	`runTask(org.apache.ode.scheduler.simple.Task task)`
`java.lang.String`	`scheduleMapSerializableRunnable(Scheduler.MapSerializableRunnable runnable, java.util.Date when)`
`java.lang.String`	`schedulePersistedJob(Scheduler.JobDetails jobDetail, java.util.Date when)`
`java.lang.String`	`scheduleVolatileJob(boolean transacted, Scheduler.JobDetails jobDetail)`
`java.lang.String`	`scheduleVolatileJob(boolean transacted, Scheduler.JobDetails jobDetail, java.util.Date when)`
`void`	`setCluster(ODECluster cluster)` Related to New ODE clustering implementation-BPS-675
`void`	`setDatabaseDelegate(DatabaseDelegate dbd)`
`void`	`setExecutorService(java.util.concurrent.ExecutorService executorService)`
`void`	`setImmediateInterval(long immediateInterval)`
`void`	`setJobProcessor(Scheduler.JobProcessor processor)`
`void`	`setNearFutureInterval(long nearFutureInterval)`
`void`	`setNodeId(java.lang.String nodeId)`
`void`	`setPolledRunnableProcesser(Scheduler.JobProcessor polledRunnableProcessor)`
`void`	`setPollIntervalForPolledRunnable(long pollIntervalForPolledRunnable)`
`void`	`setRollbackOnly()`
`void`	`setStaleInterval(long staleInterval)`
`void`	`setTransactionManager(javax.transaction.TransactionManager txm)`
`void`	`setTransactionsPerSecond(int tps)`
`void`	`shutdown()`
`void`	`start()`
`void`	`stop()`
`void`	`updateHeartBeat(java.lang.String nodeId)` Deprecated.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SimpleScheduler

public SimpleScheduler(java.lang.String nodeId,
                       DatabaseDelegate del,
                       java.util.Properties conf)

Method Detail
- setPollIntervalForPolledRunnable
```
public void setPollIntervalForPolledRunnable(long pollIntervalForPolledRunnable)
```
- setNodeId
```
public void setNodeId(java.lang.String nodeId)
```
- setStaleInterval
```
public void setStaleInterval(long staleInterval)
```
- setImmediateInterval
```
public void setImmediateInterval(long immediateInterval)
```
- setNearFutureInterval
```
public void setNearFutureInterval(long nearFutureInterval)
```
- setTransactionsPerSecond
```
public void setTransactionsPerSecond(int tps)
```
- setTransactionManager
```
public void setTransactionManager(javax.transaction.TransactionManager txm)
```
- setDatabaseDelegate
```
public void setDatabaseDelegate(DatabaseDelegate dbd)
```
- setExecutorService
```
public void setExecutorService(java.util.concurrent.ExecutorService executorService)
```
- setPolledRunnableProcesser
```
public void setPolledRunnableProcesser(Scheduler.JobProcessor polledRunnableProcessor)
```
  Specified by:
  
  setPolledRunnableProcesser in interface Scheduler
- setCluster
```
public void setCluster(ODECluster cluster)
```
  Related to New ODE clustering implementation-BPS-675
- cancelJob
```
public void cancelJob(java.lang.String jobId)
               throws ContextException
```
  Specified by:
  
  cancelJob in interface Scheduler
  
  Throws:
  
  ContextException
- execIsolatedTransaction
```
public <T> java.util.concurrent.Future<T> execIsolatedTransaction(java.util.concurrent.Callable<T> transaction)
                                                           throws java.lang.Exception,
                                                                  ContextException
```
  Specified by:
  
  execIsolatedTransaction in interface Scheduler
  
  Throws:
  
  java.lang.Exception
  
  ContextException
- execTransaction
```
public <T> T execTransaction(java.util.concurrent.Callable<T> transaction)
                      throws java.lang.Exception,
                             ContextException
```
  Specified by:
  
  execTransaction in interface Scheduler
  
  Throws:
  
  java.lang.Exception
  
  ContextException
- execTransaction
```
public <T> T execTransaction(java.util.concurrent.Callable<T> transaction,
                             int timeout)
                      throws java.lang.Exception,
                             ContextException
```
  Specified by:
  
  execTransaction in interface Scheduler
  
  Throws:
  
  java.lang.Exception
  
  ContextException
- setRollbackOnly
```
public void setRollbackOnly()
                     throws java.lang.Exception
```
  Specified by:
  
  setRollbackOnly in interface Scheduler
  
  Throws:
  
  java.lang.Exception
- registerSynchronizer
```
public void registerSynchronizer(Scheduler.Synchronizer synch)
                          throws ContextException
```
  Specified by:
  
  registerSynchronizer in interface Scheduler
  
  Throws:
  
  ContextException
- schedulePersistedJob
```
public java.lang.String schedulePersistedJob(Scheduler.JobDetails jobDetail,
                                             java.util.Date when)
                                      throws ContextException
```
  Specified by:
  
  schedulePersistedJob in interface Scheduler
  
  Throws:
  
  ContextException
- scheduleMapSerializableRunnable
```
public java.lang.String scheduleMapSerializableRunnable(Scheduler.MapSerializableRunnable runnable,
                                                        java.util.Date when)
                                                 throws ContextException
```
  Specified by:
  
  scheduleMapSerializableRunnable in interface Scheduler
  
  Throws:
  
  ContextException
- scheduleVolatileJob
```
public java.lang.String scheduleVolatileJob(boolean transacted,
                                            Scheduler.JobDetails jobDetail)
                                     throws ContextException
```
  Specified by:
  
  scheduleVolatileJob in interface Scheduler
  
  Throws:
  
  ContextException
- scheduleVolatileJob
```
public java.lang.String scheduleVolatileJob(boolean transacted,
                                            Scheduler.JobDetails jobDetail,
                                            java.util.Date when)
                                     throws ContextException
```
  Specified by:
  
  scheduleVolatileJob in interface Scheduler
  
  Throws:
  
  ContextException
- setJobProcessor
```
public void setJobProcessor(Scheduler.JobProcessor processor)
                     throws ContextException
```
  Specified by:
  
  setJobProcessor in interface Scheduler
  
  Throws:
  
  ContextException
- shutdown
```
public void shutdown()
```
  Specified by:
  
  shutdown in interface Scheduler
- start
```
public void start()
```
  Specified by:
  
  start in interface Scheduler
- stop
```
public void stop()
```
  Specified by:
  
  stop in interface Scheduler
- runJob
```
protected void runJob(org.apache.ode.scheduler.simple.Job job)
```
  Run a job in the current thread.
  
  Parameters:
  
  job - job to run.
- runPolledRunnable
```
protected void runPolledRunnable(org.apache.ode.scheduler.simple.Job job)
```
  Run a job from a polled runnable thread. The runnable is not persistent, however, the poller is persistent and wakes up every given interval to check the status of the runnable.
  - 1. The runnable is being scheduled; the poller persistent job dispatches the runnable to a runnable delegate thread and schedules itself to a later time.
  - 2. The runnable is running; the poller job re-schedules itself every time it sees the runnable is not completed.
  - 3. The runnable failed; the poller job passes the exception thrown on the runnable down, and the standard scheduler retries happen.
  - 4. The runnable completes; the poller persistent does not re-schedule itself.
  - 5. System powered off and restarts; the poller job does not know what the status of the runnable. This is handled just like the case #1.
  There is at least one re-scheduling of the poller job. Since, the runnable's state is not persisted, and the same runnable may be tried again after system failure, the runnable that's used with this polling should be repeatable.
  Parameters:
  
  job - job to run.
- isTransacted
```
public boolean isTransacted()
```
  Specified by:
  
  isTransacted in interface Scheduler
- runTask
```
public void runTask(org.apache.ode.scheduler.simple.Task task)
```
- updateHeartBeat
```
@Deprecated
public void updateHeartBeat(java.lang.String nodeId)
```
  Deprecated.
- acquireTransactionLocks
```
public void acquireTransactionLocks()
```
  run method of old ode clustering implementation BPS-675 public void run() { _todo.enqueue(new CheckStaleNodes(System.currentTimeMillis() + _staleInterval)); __log.debug("CHECK STALE NODES started"); for (String nodeId : _knownNodes) { Long lastSeen = _lastHeartBeat.get(nodeId); if ((lastSeen == null || (System.currentTimeMillis() - lastSeen) > _staleInterval) && !_nodeId.equals(nodeId)) { recoverStaleNode(nodeId); } } }
  
  Specified by:
  
  acquireTransactionLocks in interface Scheduler

Class SimpleScheduler

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.ode.bpel.iapi.Scheduler

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SimpleScheduler

Method Detail

setPollIntervalForPolledRunnable

setNodeId

setStaleInterval

setImmediateInterval

setNearFutureInterval

setTransactionsPerSecond

setTransactionManager

setDatabaseDelegate

setExecutorService

setPolledRunnableProcesser

setCluster

cancelJob

execIsolatedTransaction

execTransaction

execTransaction

setRollbackOnly

registerSynchronizer

schedulePersistedJob

scheduleMapSerializableRunnable

scheduleVolatileJob

scheduleVolatileJob

setJobProcessor

shutdown

start

stop

runJob

runPolledRunnable

isTransacted

runTask

updateHeartBeat

acquireTransactionLocks