org.apache.ode.scheduler.simple

## Class SimpleScheduler

- 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.

- - ### 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)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `acquireTransactionLocks()`
    `void` | `cancelJob(java.lang.String jobId)` Make a good effort to cancel the job.
    `<T> java.util.concurrent.Future<T>` | `execIsolatedTransaction(java.util.concurrent.Callable<T> transaction)` Same as execTransaction but executes in a different thread to guarantee isolation from the main execution thread.
    `<T> T` | `execTransaction(java.util.concurrent.Callable<T> transaction)` Execute a `Callable` in a transactional context.
    `<T> T` | `execTransaction(java.util.concurrent.Callable<T> transaction, int timeout)` Execute a `Callable` in a transactional context.
    `boolean` | `isTransacted()`
    `void` | `registerSynchronizer(Scheduler.Synchronizer synch)` Register a transaction synchronizer.
    `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)` Schedule a Runnable that will be executed on a dedicated thread pool.
    `java.lang.String` | `schedulePersistedJob(Scheduler.JobDetails jobDetail, java.util.Date when)` Schedule a persisted job.
    `java.lang.String` | `scheduleVolatileJob(boolean transacted, Scheduler.JobDetails jobDetail)` Schedule a volatile job for right now
    `java.lang.String` | `scheduleVolatileJob(boolean transacted, Scheduler.JobDetails jobDetail, java.util.Date when)` Schedule a volatile (non-persisted) job.
    `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)`

    - ### 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`

    - #### cancelJob

          public void cancelJob(java.lang.String jobId)
                         throws ContextException

      Description copied from interface: `Scheduler`
      Make a good effort to cancel the job. If its already running no big deal.
      Specified by:
        `cancelJob` in interface `Scheduler`
      Parameters:
        `jobId` - job identifier of the job
      Throws:
        `ContextException`

    - #### execIsolatedTransaction

          public <T> java.util.concurrent.Future<T> execIsolatedTransaction(java.util.concurrent.Callable<T> transaction)
                                                                     throws java.lang.Exception,
                                                                            ContextException

      Description copied from interface: `Scheduler`
      Same as execTransaction but executes in a different thread to guarantee isolation from the main execution thread.
      Specified by:
        `execIsolatedTransaction` in interface `Scheduler`
      Returns:
      Throws:
        `java.lang.Exception`
        `ContextException`

    - #### execTransaction

          public <T> T execTransaction(java.util.concurrent.Callable<T> transaction)
                                throws java.lang.Exception,
                                       ContextException

      Description copied from interface: `Scheduler`
      Execute a `Callable` in a transactional context. If the callable throws an exception, then the transaction will be rolled back, otherwise the transaction will commit.
      Specified by:
        `execTransaction` in interface `Scheduler`
      Type Parameters:
        `T` - return type
      Parameters:
        `transaction` - transaction to execute
      Returns:
        result
      Throws:
        `java.lang.Exception`
        `ContextException`

    - #### execTransaction

          public <T> T execTransaction(java.util.concurrent.Callable<T> transaction,
                                       int timeout)
                                throws java.lang.Exception,
                                       ContextException

      Description copied from interface: `Scheduler`
      Execute a `Callable` in a transactional context. If the callable throws an exception, then the transaction will be rolled back, otherwise the transaction will commit. Also, modify the value of the timeout value that is associated with the transactions started by the current thread.
      Specified by:
        `execTransaction` in interface `Scheduler`
      Type Parameters:
        `T` - return type
      Parameters:
        `transaction` - transaction to execute
      Returns:
        result
      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

      Description copied from interface: `Scheduler`
      Register a transaction synchronizer.
      Specified by:
        `registerSynchronizer` in interface `Scheduler`
      Parameters:
        `synch` - synchronizer
      Throws:
        `ContextException`

    - #### schedulePersistedJob

          public java.lang.String schedulePersistedJob(Scheduler.JobDetails jobDetail,
                                                       java.util.Date when)
                                                throws ContextException

      Description copied from interface: `Scheduler`
      Schedule a persisted job. Persisted jobs MUST survive system failure. They also must not be scheduled unless the transaction associated with the calling thread commits.
      Specified by:
        `schedulePersistedJob` in interface `Scheduler`
      Parameters:
        `jobDetail` - information about the job
        `when` - when the job should run (`null` means now)
      Returns:
        unique job identifier
      Throws:
        `ContextException`

    - #### scheduleMapSerializableRunnable

          public java.lang.String scheduleMapSerializableRunnable(Scheduler.MapSerializableRunnable runnable,
                                                                  java.util.Date when)
                                                           throws ContextException

      Description copied from interface: `Scheduler`
      Schedule a Runnable that will be executed on a dedicated thread pool.
      Specified by:
        `scheduleMapSerializableRunnable` in interface `Scheduler`
      Returns:
      Throws:
        `ContextException`

    - #### scheduleVolatileJob

          public java.lang.String scheduleVolatileJob(boolean transacted,
                                                      Scheduler.JobDetails jobDetail)
                                               throws ContextException

      Description copied from interface: `Scheduler`
      Schedule a volatile job for right now
      Specified by:
        `scheduleVolatileJob` in interface `Scheduler`
      Throws:
        `ContextException`
      See Also:
        `#scheduleVolatileJob(boolean, java.util.Map, java.util.Date)`

    - #### scheduleVolatileJob

          public java.lang.String scheduleVolatileJob(boolean transacted,
                                                      Scheduler.JobDetails jobDetail,
                                                      java.util.Date when)
                                               throws ContextException

      Description copied from interface: `Scheduler`
      Schedule a volatile (non-persisted) job. Volatile jobs should not be saved in the database and should not survive system crash. Volatile jobs scheduled from a transactional context should be scheduled regardless of whether the transaction commits.
      Specified by:
        `scheduleVolatileJob` in interface `Scheduler`
      Parameters:
        `transacted` - should the job be executed in a transaction?
        `jobDetail` - information about the job
        `when` - does the job should be executed?
      Returns:
        unique (as far as the scheduler is concerned) job identifier
      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`
      Returns:
        true if the current thread is associated with a transaction.

    - #### runTask

          public void runTask(org.apache.ode.scheduler.simple.Task task)

    - #### updateHeartBeat

          public void updateHeartBeat(java.lang.String nodeId)

    - #### acquireTransactionLocks

          public void acquireTransactionLocks()

      Specified by:
        `acquireTransactionLocks` in interface `Scheduler`