class TaskScheduler[Task <: TimedTask] extends NamedLogging with FlagCloseableAsync

The task scheduler manages tasks with associated timestamps and sequencer counters. Tasks may be inserted in any order; they will be executed nevertheless in the correct order given by the timestamps.

The tasks execute sequentially in scala.concurrent.Future.

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TaskScheduler
  2. FlagCloseableAsync
  3. FlagCloseable
  4. AutoCloseable
  5. NamedLogging
  6. AnyRef
  7. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new TaskScheduler(initSc: SequencerCounter, initTimestamp: CantonTimestamp, equalTimestampTaskOrdering: Ordering[Task], metrics: TaskSchedulerMetrics, timeouts: ProcessingTimeout, loggerFactory: NamedLoggerFactory)(ecForTaskChaining: ExecutionContext)

    initSc

    The first sequencer counter to be processed

    initTimestamp

    Only timestamps after this timestamp can be used

    equalTimestampTaskOrdering

    The ordering for tasks with the same timestamps; tasks that are smaller w.r.t this order are processed earlier.

    ecForTaskChaining

    Execution context used to sequence the task scala.concurrent.Futures

Type Members

  1. case class ReaderState(count: Int, readers: MultiSet[String]) extends Product with Serializable
    Definition Classes
    FlagCloseable

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def addTick(sequencerCounter: SequencerCounter, timestamp: CantonTimestamp)(implicit traceContext: TraceContext): Unit

    Signals that the sequence counter with the given timestamp has been observed.

    Signals that the sequence counter with the given timestamp has been observed.

    Eventually, all sequencer counters above initSc must be added with their timestamp using this method. Every sequencer counter must be added once and timestamps must strictly increase with sequencer counters.

    If all sequencer counters between initSc and sequencerCounter have been added, then the tasks up to timestamp will be performed, unless there is a task that could not complete. In that case, task processing stops with the unfinished task.

    Exceptions thrown

    • If the sequencerCounter has not been inserted, but all sequencer counters up to timestamp have been inserted.
    • If the sequencerCounter is the first sequencer counter to be processed and the timestamp is not after the timestamp given to the constructor.
    • If the sequencerCounter has been inserted with a different timestamp.
    • If the timestamp is at most the timestamp of a smaller sequencer counter, or if the timestamp is at least the timestamp of a larger sequencer counter.
    • If the sequencerCounter is Long.MaxValue.
    See also

    TaskScheduler.runTasks()

  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  7. final def close(): Unit

    Blocks until all earlier tasks have completed and then prevents further tasks from being run.

    Blocks until all earlier tasks have completed and then prevents further tasks from being run.

    Definition Classes
    FlagCloseable → AutoCloseable
    Annotations
    @SuppressWarnings()
  8. def closeAsync(): Seq[AsyncOrSyncCloseable]

    closeAsync asynchronously releases resources held by a future

    closeAsync asynchronously releases resources held by a future

    returns

    an ordered sequence of async and sync closeables with async closeables made up of future and timeout

    Definition Classes
    TaskSchedulerFlagCloseableAsync
  9. def closingTimeout: FiniteDuration
    Attributes
    protected
    Definition Classes
    FlagCloseable
  10. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  11. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  12. def flush(): Future[Unit]

    The returned future completes after all tasks that can be currently performed have completed.

    The returned future completes after all tasks that can be currently performed have completed. Never fails.

    Annotations
    @VisibleForTesting()
  13. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  14. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  15. def internalPerformUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): UnlessShutdown[Future[A]]
    Attributes
    protected
    Definition Classes
    FlagCloseable
  16. def isClosing: Boolean

    Check whether we're closing.

    Check whether we're closing. Susceptible to race conditions; unless you're using using this as a flag to the retry lib or you really know what you're doing, prefer performUnlessClosing and friends.

    Definition Classes
    FlagCloseable
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. def keepTrackOfOpenFutures: Boolean

    track running futures on shutdown

    track running futures on shutdown

    set to true to get detailed information about all futures that did not complete during shutdown. if set to false, we don't do anything.

    Attributes
    protected
    Definition Classes
    FlagCloseable
  19. def logger: TracedLogger
    Attributes
    protected
    Definition Classes
    NamedLogging
  20. val loggerFactory: NamedLoggerFactory
    Attributes
    protected
    Definition Classes
    TaskSchedulerNamedLogging
  21. implicit def loggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
    Attributes
    protected
    Definition Classes
    NamedLogging
  22. def maxSleepMillis: Long
    Attributes
    protected
    Definition Classes
    FlagCloseable
  23. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  24. def noTracingLogger: Logger
    Attributes
    protected
    Definition Classes
    NamedLogging
  25. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  26. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  27. final def onClosed(): Unit
    Definition Classes
    FlagCloseableAsyncFlagCloseable
  28. def performUnlessClosing[A](name: String)(f: => A)(implicit traceContext: TraceContext): UnlessShutdown[A]

    Performs the task given by f unless a shutdown has been initiated.

    Performs the task given by f unless a shutdown has been initiated. The shutdown will only begin after f completes, but other tasks may execute concurrently with f, if started using this function, or one of the other variants (performUnlessClosingF and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.

    DO NOT CALL this.close as part of f, because it will result in a deadlock.

    f

    The task to perform

    returns

    scala.None$ if a shutdown has been initiated. Otherwise the result of the task.

    Definition Classes
    FlagCloseable
  29. def performUnlessClosingEitherT[E, R](name: String, onClosing: => E)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, R]

    Performs the EitherT[Future] given by etf unless a shutdown has been initiated, in which case the provided error is returned instead.

    Performs the EitherT[Future] given by etf unless a shutdown has been initiated, in which case the provided error is returned instead. Both etf and the error are lazy; etf is only evaluated if there is no shutdown, the error only if we're shutting down. The shutdown will only begin after etf completes, but other tasks may execute concurrently with etf, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingF). The tasks are assumed to take less than closingTimeout to complete.

    DO NOT CALL this.close as part of etf, because it will result in a deadlock.

    etf

    The task to perform

    Definition Classes
    FlagCloseable
  30. def performUnlessClosingEitherTF[E, R](name: String, onClosing: => E)(etf: => EitherT[Future, E, Future[R]])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, Future[R]]
    Definition Classes
    FlagCloseable
  31. def performUnlessClosingEitherU[E, R](name: String)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
    Definition Classes
    FlagCloseable
  32. def performUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]

    Performs the Future given by f unless a shutdown has been initiated.

    Performs the Future given by f unless a shutdown has been initiated. The future is lazy and not evaluated during shutdown. The shutdown will only begin after f completes, but other tasks may execute concurrently with f, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.

    DO NOT CALL this.close as part of f, because it will result in a deadlock.

    f

    The task to perform

    returns

    The future completes with com.digitalasset.canton.lifecycle.UnlessShutdown.AbortedDueToShutdown if a shutdown has been initiated. Otherwise the result of the task wrapped in com.digitalasset.canton.lifecycle.UnlessShutdown.Outcome.

    Definition Classes
    FlagCloseable
  33. def readSequencerCounterQueue: (SequencerCounter) => AssociatedValue[CantonTimestamp]

    Used to inspect the state of the sequencerCounterQueue, for testing purposes.

    Used to inspect the state of the sequencerCounterQueue, for testing purposes.

    Annotations
    @VisibleForTesting()
  34. def runOnShutdown[T](task: RunOnShutdown)(implicit traceContext: TraceContext): Unit

    Register a task that will run onClose after all "performUnlessShutdown" tasks have finished

    Register a task that will run onClose after all "performUnlessShutdown" tasks have finished

    Definition Classes
    FlagCloseable
  35. def runStateChanged(waitingState: Boolean = false): Unit
    Attributes
    protected
    Definition Classes
    FlagCloseable
    Annotations
    @VisibleForTesting()
  36. def scheduleBarrier(timestamp: CantonTimestamp): Option[Future[Unit]]

    Schedules a new barrier at the given timestamp.

    Schedules a new barrier at the given timestamp.

    returns

    A future that completes when all sequencer counters up to the given timestamp have been signalled. scala.None$ if all sequencer counters up to the given timestamp have already been signalled.

  37. def scheduleTask(task: Task)(implicit traceContext: TraceContext): Unit

    Adds a new task to be executed at the given timestamp and with the associated sequencer counter.

    Adds a new task to be executed at the given timestamp and with the associated sequencer counter. This method does not register the timestamp as being observed. So addTick must be called separately if desired.

    task

    The task to execute.

    Exceptions thrown

    java.lang.IllegalArgumentException if the timestamp or sequencer counter of the task is earlier than to where the task scheduler has already progressed

  38. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  39. val timeouts: ProcessingTimeout
    Attributes
    protected
    Definition Classes
    TaskSchedulerFlagCloseable
  40. def toString(): String
    Definition Classes
    AnyRef → Any
  41. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  42. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  43. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  44. object ReaderState extends Serializable
    Definition Classes
    FlagCloseable

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from FlagCloseableAsync

Inherited from FlagCloseable

Inherited from AutoCloseable

Inherited from NamedLogging

Inherited from AnyRef

Inherited from Any

Ungrouped