Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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.JobInfo, Scheduler.JobProcessor, Scheduler.JobProcessorException, Scheduler.Synchronizer`

Constructor Summary
`MockScheduler()`
`MockScheduler(javax.transaction.TransactionManager txm)`

Method Summary
`void` | `begin()`
`void` | `cancelJob(java.lang.String arg0)` Make a good effort to cancel the job.
`void` | `commit()`
`
`<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.
`boolean` | `isTransacted()`
`void` | `registerSynchronizer(Scheduler.Synchronizer synch)` Register a transaction synchronizer.
`void` | `rollback()`
`java.lang.String` | `schedulePersistedJob(java.util.Map<java.lang.String,java.lang.Object> detail, java.util.Date date)` Schedule a persisted job.
`java.lang.String` | `scheduleVolatileJob(boolean transacted, java.util.Map<java.lang.String,java.lang.Object> detail)` Schedule a volatile (non-persisted) job.
`void` | `setExecutorSvc(java.util.concurrent.ExecutorService executorSvc)`
`void` | `setJobProcessor(Scheduler.JobProcessor processor)`
`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(java.util.Map<java.lang.String,java.lang.Object> 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,
                                                java.util.Map<java.lang.String,java.lang.Object> detail)
                                         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`
    `detail` - information about the job
  Returns:
    unique (as far as the scheduler is concerned) job identifier
  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`

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

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

### begin

    public void begin()

### commit

    public void commit()

### rollback

    public void rollback()

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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD