Execution

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit object ExecutionMonad extends Monad[Execution]

This is an instance of Monad for execution so it can be used in functions that apply to all Monads

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def from[T](t: ⇒ T): Execution[T]

This makes a constant execution that runs no job.

def fromFn[T](fn: (Config, Mode) ⇒ (FlowDef, (JobStats) ⇒ Future[T])): Execution[T]

This converts a function into an Execution monad.

def fromFuture[T](fn: (scala.concurrent.ExecutionContext) ⇒ Future[T]): Execution[T]

The call to fn will happen when the run method on the result is called.

final def getClass(): Class[_]

def getConfig: Execution[Config]

Use this to read the configuration, which may contain Args or options which describe input on which to run

def getConfigMode: Execution[(Config, Mode)]

Use this to get the config and mode.

def getMode: Execution[Mode]

Use this to get the mode, which may contain the job conf

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def run[C](flow: Flow[C]): Future[JobStats]

def sequence[T](exs: Seq[Execution[T]]): Execution[Seq[T]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def waitFor[C](flow: Flow[C]): Try[JobStats]

def withId[T](fn: (UniqueID) ⇒ Execution[T]): Execution[T]

Use this to use counters/stats with Execution.

def zip[A, B, C, D, E](ax: Execution[A], bx: Execution[B], cx: Execution[C], dx: Execution[D], ex: Execution[E]): Execution[(A, B, C, D, E)]

combine several executions and run them in parallel when .run is called

def zip[A, B, C, D](ax: Execution[A], bx: Execution[B], cx: Execution[C], dx: Execution[D]): Execution[(A, B, C, D)]

combine several executions and run them in parallel when .run is called

def zip[A, B, C](ax: Execution[A], bx: Execution[B], cx: Execution[C]): Execution[(A, B, C)]

combine several executions and run them in parallel when .run is called

def zip[A, B](ax: Execution[A], bx: Execution[B]): Execution[(A, B)]

combine several executions and run them in parallel when .run is called

def buildFlow[T](conf: Config, mode: Mode)(op: Reader[ExecutionContext, T]): (T, Try[Flow[_]])

This creates a new ExecutionContext, passes to the reader, builds the flow and cleans up the state of the FlowDef

def run[T](conf: Config, mode: Mode)(op: Reader[ExecutionContext, T]): (T, Future[JobStats])

def validateSources: Reader[ExecutionContext, Try[Unit]]

def waitFor[T](conf: Config, mode: Mode)(op: Reader[ExecutionContext, T]): (T, Try[JobStats])