org.apache.ode.il

## Class MockScheduler

- java.lang.Object
- - org.apache.ode.il.MockScheduler

- All Implemented Interfaces:
    Scheduler

      public class MockScheduler
      extends java.lang.Object
      implements Scheduler

- - ### 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
    `MockScheduler()`
    `MockScheduler(javax.transaction.TransactionManager txm)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `acquireTransactionLocks()`
    `boolean` | `amICoordinator()`
    `void` | `beginTransaction()`
    `void` | `cancelJob(java.lang.String arg0)` Make a good effort to cancel the job.
    `void` | `commitTransaction()`
    `<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.
    `void` | `rollbackTransaction()`
    `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 detail, java.util.Date date)` 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 detail, java.util.Date date)` Schedule a volatile (non-persisted) job.
    `void` | `setExecutorSvc(java.util.concurrent.ExecutorService executorSvc)`
    `void` | `setJobProcessor(Scheduler.JobProcessor processor)`
    `void` | `setPolledRunnableProcesser(Scheduler.JobProcessor delegatedRunnableProcessor)`
    `void` | `setRollbackOnly()`
    `void` | `shutdown()`
    `void` | `start()`
    `void` | `stop()`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### MockScheduler

          public MockScheduler()

    - #### MockScheduler

          public MockScheduler(javax.transaction.TransactionManager txm)

  - ### Method Detail

    - #### schedulePersistedJob

          public java.lang.String schedulePersistedJob(Scheduler.JobDetails detail,
                                              java.util.Date date)
                                                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:
        `detail` - information about the job
        `date` - when the job should run (`null` means now)
      Returns:
        unique job identifier
      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 detail,
                                             java.util.Date date)
                                               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?
        `detail` - information about the job
        `date` - does the job should be executed?
      Returns:
        unique (as far as the scheduler is concerned) 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`

    - #### cancelJob

          public void cancelJob(java.lang.String arg0)
                         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:
        `arg0` - job identifier of the job
      Throws:
        `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`

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

    - #### isTransacted

          public boolean isTransacted()

      Specified by:
        `isTransacted` in interface `Scheduler`
      Returns:
        true if the current thread is associated with a transaction.

    - #### start

          public void start()

      Specified by:
        `start` in interface `Scheduler`

    - #### stop

          public void stop()

      Specified by:
        `stop` in interface `Scheduler`

    - #### shutdown

          public void shutdown()

      Specified by:
        `shutdown` in interface `Scheduler`

    - #### acquireTransactionLocks

          public void acquireTransactionLocks()

      Specified by:
        `acquireTransactionLocks` in interface `Scheduler`

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

    - #### beginTransaction

          public void beginTransaction()

    - #### commitTransaction

          public void commitTransaction()

    - #### rollbackTransaction

          public void rollbackTransaction()

    - #### setJobProcessor

          public void setJobProcessor(Scheduler.JobProcessor processor)
                               throws ContextException

      Specified by:
        `setJobProcessor` in interface `Scheduler`
      Throws:
        `ContextException`

    - #### setExecutorSvc

          public void setExecutorSvc(java.util.concurrent.ExecutorService executorSvc)

    - #### setPolledRunnableProcesser

          public void setPolledRunnableProcesser(Scheduler.JobProcessor delegatedRunnableProcessor)

      Specified by:
        `setPolledRunnableProcesser` in interface `Scheduler`

    - #### amICoordinator

          public boolean amICoordinator()