Service

Abstract Value Members

abstract def cancelAll(): UIO[Unit]

Cancel all tasks.
Cancel all tasks. If a task has not yet begun running, it will simply be cancelled. If a task is already running, it will be interrupted. (see ZIO.interrupt)
abstract def cancelTask(id: String): UIO[Unit]

Cancel the task with the given ID, and all currently queued or running tasks which were queued or started after the given task was queued or started.
abstract def list: UIO[List[TaskInfo]]

List all currently running tasks
abstract def queue[R <: CurrentTask, A, R1 >: R <: Has[_]](id: String, label: String = "", detail: String = "", errorWith: (Cause[Throwable]) ⇒ (TaskInfo) ⇒ TaskInfo = cause => _.failed(cause))(task: RIO[R, A])(implicit ev: <:<[R1 with CurrentTask, R]): RIO[R1, Task[A]]

Queue a task, which can access a reference to the TaskInfo and modify it to broadcast updates.
Queue a task, which can access a reference to the TaskInfo and modify it to broadcast updates. When the given task finishes, errors, or is interrupted, a completion message of the appropriate status will be broadcast.
Evaluating the returned outer Task results in queueing of the given task, which will eventually cause the given task to be evaluated. Evaluating the inner Task results in blocking (asynchronously) until the given task completes.
Interrupting the inner Task results in cancelling the queued task, or interrupting it if it's running.
Note that status updates are sent somewhat lazily, and for a series of rapid updates to the task status only the last update might get sent.
abstract def register(id: String, label: String = "", detail: String = "", parent: Option[String] = None, errorWith: DoneStatus = ErrorStatus)(cancelCallback: (((TaskInfo) ⇒ TaskInfo) ⇒ Unit) ⇒ ZIO[Logging, Nothing, Unit]): RIO[Blocking with Clock with Logging, Fiber[Throwable, Unit]]

Register an external task for status broadcasting and cancellation, by providing a function which will receive a function for modifying the TaskInfo and return a UIO that cancels the external task upon evaluation.
Register an external task for status broadcasting and cancellation, by providing a function which will receive a function for modifying the TaskInfo and return a UIO that cancels the external task upon evaluation. The cancellation task returned by the provided function may be evaluated even after the external task is finished.
The TaskInfo should be updated by invoking the function (TaskInfo => TaskInfo) => Unit, passing as an argument the function which updates the status (e.g. _.progress(0.5)).
The external task must report itself as being finished by updating the TaskInfo to a completed or failed state. All updates to the task reference will be broadcast. If cancelAll is run on this task manager, the given task will be interrupted (if it has not yet reported completion) using the return cancellation task.
Returns the Fiber which updates the task status. Interrupting this fiber results in the cancellation task returned from cancelCallback being evaluated.
abstract def run[R <: Has[_], A](id: String, label: String = "", detail: String = "", errorWith: (Cause[Throwable]) ⇒ (TaskInfo) ⇒ TaskInfo = cause => _.failed(cause))(task: RIO[CurrentTask with R, A]): RIO[R, A]

Run the given task.
Run the given task. The task will be independent of the task queue, but will have access to a TaskInfo reference; it can update this reference to broadcast task updates. The first update will be broadcast when the task is evaluated, and a completion update will be broadcast when it completes or fails.
abstract def runSubtask[R <: CurrentTask, A](id: String, label: String = "", detail: String = "", errorWith: (Cause[Throwable]) ⇒ (TaskInfo) ⇒ TaskInfo = cause => _.failed(cause))(task: RIO[R, A]): RIO[R, A]

Run the given task as a subtask of the current task.
Run the given task as a subtask of the current task.

See also
run
abstract def shutdown(): UIO[Unit]

Shut down the task manager and stop executing any tasks in the queue.
Shut down the task manager and stop executing any tasks in the queue. Cancels all running tasks (see cancelAll)

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def queue_[A, R <: Has[_]](id: String, label: String = "", detail: String = "")(task: RIO[R with CurrentTask, A]): RIO[R, Task[A]]

This overload is more useful if the return type needs to be inferred
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package TaskManager

trait Service extends AnyRef

Abstract Value Members

abstract def cancelAll(): UIO[Unit]

abstract def cancelTask(id: String): UIO[Unit]

abstract def list: UIO[List[TaskInfo]]

abstract def queue[R <: CurrentTask, A, R1 >: R <: Has[_]](id: String, label: String = "", detail: String = "", errorWith: (Cause[Throwable]) ⇒ (TaskInfo) ⇒ TaskInfo = cause => _.failed(cause))(task: RIO[R, A])(implicit ev: <:<[R1 with CurrentTask, R]): RIO[R1, Task[A]]

abstract def register(id: String, label: String = "", detail: String = "", parent: Option[String] = None, errorWith: DoneStatus = ErrorStatus)(cancelCallback: (((TaskInfo) ⇒ TaskInfo) ⇒ Unit) ⇒ ZIO[Logging, Nothing, Unit]): RIO[Blocking with Clock with Logging, Fiber[Throwable, Unit]]

abstract def run[R <: Has[_], A](id: String, label: String = "", detail: String = "", errorWith: (Cause[Throwable]) ⇒ (TaskInfo) ⇒ TaskInfo = cause => _.failed(cause))(task: RIO[CurrentTask with R, A]): RIO[R, A]

abstract def runSubtask[R <: CurrentTask, A](id: String, label: String = "", detail: String = "", errorWith: (Cause[Throwable]) ⇒ (TaskInfo) ⇒ TaskInfo = cause => _.failed(cause))(task: RIO[R, A]): RIO[R, A]

abstract def shutdown(): UIO[Unit]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def queue_[A, R <: Has[_]](id: String, label: String = "", detail: String = "")(task: RIO[R with CurrentTask, A]): RIO[R, Task[A]]

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

Inherited from AnyRef

Inherited from Any

Ungrouped