Class TaskManager

Hierarchy

  • CreateDestroyStartStop
    • TaskManager

Constructors

constructor

Properties

[initLock] activeLimit activePromises db generateTaskId handlers logger queueLogger queuingLock queuingLockReleaser? queuingLoop schedulerLogger schedulingLock schedulingLockReleaser? schedulingLoop schedulingTimer taskEvents taskPromises tasksActiveDbPath tasksDbPath tasksLastTaskIdPath tasksPathDbPath tasksQueuedDbPath tasksScheduledDbPath tasksTaskDbPath

Accessors

[destroyed] [eventHandled] [eventHandlers] [eventTarget] [handleEventError] [running] [statusP] [status] activeCount

Methods

addEventListener cancelTask deregisterHandler destroy dispatchEvent gcTask getHandler getHandlers getLastTaskId getTask getTaskPromise getTasks isProcessing lockLastTaskId lockTask queueTask registerHandler removeEventListener repairDanglingTasks requeueTask scheduleTask start startProcessing startQueueing startScheduling startTask stop stopProcessing stopQueueing stopScheduling stopTasks triggerQueuing triggerScheduling updateTask createTaskManager

Constructors

constructor

  • Parameters

    • __namedParameters: {
          activeLimit: number;
          db: DB;
          logger: Logger;
      }
      • activeLimit: number
      • db: DB
      • logger: Logger

    Returns TaskManager

Properties

Readonly [initLock]

[initLock]: RWLockWriter

Protected activeLimit

activeLimit: number

Protected activePromises

activePromises: Map<TaskIdEncoded, PromiseCancellable<any>> = ...

Protected db

db: DB

Protected generateTaskId

generateTaskId: (() => TaskId)

Type declaration

Protected handlers

handlers: Map<TaskHandlerId, TaskHandler> = ...

Protected logger

logger: Logger

Protected queueLogger

queueLogger: Logger

Protected queuingLock

queuingLock: Lock = ...

Lock controls whether to run an iteration of the queuing loop

Protected Optional queuingLockReleaser

queuingLockReleaser?: ResourceRelease

Releases the queuing lock On the first iteration of the queuing loop the lock may not be acquired yet, and therefore releaser is not set

Protected queuingLoop

queuingLoop: null | PromiseCancellable<void> = null

Asynchronous queuing loop This is blocked by the queuingLock The null indicates that the queuing loop isn't running

Protected schedulerLogger

schedulerLogger: Logger

Protected schedulingLock

schedulingLock: Lock = ...

Lock controls whether to run an iteration of the scheduling loop

Protected Optional schedulingLockReleaser

schedulingLockReleaser?: ResourceRelease

Releases the scheduling lock On the first iteration of the scheduling loop the lock may not be acquired yet, and therefore releaser is not set

Protected schedulingLoop

schedulingLoop: null | PromiseCancellable<void> = null

Asynchronous scheduling loop This is blocked by the schedulingLock The null indicates that the scheduling loop isn't running

Protected schedulingTimer

schedulingTimer: null | Timer<void> = null

Timer used to unblock the scheduling loop This releases the schedulingLock if it is locked The null indicates there is no timer running

Protected taskEvents

taskEvents: EventTarget = ...

Protected taskPromises

taskPromises: Map<TaskIdEncoded, PromiseCancellable<any>> = ...

Protected tasksActiveDbPath

tasksActiveDbPath: readonly (string | Buffer)[] = ...

Tracks actively running tasks Tasks/active/{TaskId} -> null

Protected tasksDbPath

tasksDbPath: readonly (string | Buffer)[] = ...

Protected tasksLastTaskIdPath

tasksLastTaskIdPath: readonly (string | Buffer)[] = ...

Maintain last Task ID to preserve monotonicity across process restarts Tasks/lastTaskId -> {raw(TaskId)}

Protected tasksPathDbPath

tasksPathDbPath: readonly (string | Buffer)[] = ...

Tasks indexed path Tasks/path/{...TaskPath}/{TaskId} -> null

Protected tasksQueuedDbPath

tasksQueuedDbPath: readonly (string | Buffer)[] = ...

Queued Tasks This is indexed by TaskId at the end to avoid conflicts Tasks/queued/{lexi(TaskPriority)}/{lexi(TaskTimestamp + TaskDelay)}/{TaskId} -> null

Protected tasksScheduledDbPath

tasksScheduledDbPath: readonly (string | Buffer)[] = ...

Scheduled Tasks This is indexed by TaskId at the end to avoid conflicts Tasks/scheduled/{lexi(TaskTimestamp + TaskDelay)}/{TaskId} -> null

Protected tasksTaskDbPath

tasksTaskDbPath: readonly (string | Buffer)[] = ...

Tasks collection Tasks/tasks/{TaskId} -> {json(TaskData)}

Accessors

[destroyed]

  • get [destroyed](): boolean

  • Returns boolean

[eventHandled]

  • get [eventHandled](): ReadonlyWeakSet<Event>

  • Returns ReadonlyWeakSet<Event>

[eventHandlers]

  • get [eventHandlers](): ReadonlyMap<string, Set<EventHandlerInfo>>

  • Returns ReadonlyMap<string, Set<EventHandlerInfo>>

[eventTarget]

  • get [eventTarget](): EventTarget

  • Returns EventTarget

[handleEventError]

  • get [handleEventError](): ((evt) => void)

  • Returns ((evt) => void)

      • (evt): void

      • Parameters

        • evt: EventError

        Returns void

[running]

  • get [running](): boolean

  • Returns boolean

[statusP]

  • get [statusP](): Promise<Status>

  • Returns Promise<Status>

[status]

  • get [status](): Status

  • Returns Status

activeCount

Methods

addEventListener

  • Parameters

    • type: string
    • callback: null | EventListenerOrEventListenerObject
    • Optional options: boolean | AddEventListenerOptions

    Returns void

Protected cancelTask

deregisterHandler

destroy

dispatchEvent

  • Parameters

    • event: Event

    Returns boolean

Protected gcTask

  • This is used to garbage collect tasks that have settled Explicit removal of tasks can only be done through task cancellation

    Parameters

    • taskId: TaskId
    • Optional tran: DBTransaction

    Returns Promise<void>

getHandler

getHandlers

getLastTaskId

getTask

getTaskPromise

  • Parameters

    • taskId: TaskId
    • Optional tran: DBTransaction

    Returns PromiseCancellable<any>

getTasks

  • Parameters

    • order: "asc" | "desc" = 'asc'
    • lazy: boolean = false
    • Optional path: TaskPath
    • Optional tran: DBTransaction

    Returns AsyncGenerator<Task, any, unknown>

isProcessing

Protected lockLastTaskId

  • Mutually exclude last task ID mutation Prevents "counter racing" for the last task ID

    Parameters

    • tran: DBTransaction

    Returns Promise<void>

Protected lockTask

  • Mutual exclusion for task mutation Used to lock:

    • this.updateTask
    • this.queueTask
    • this.startTask
    • this.gcTask
    • this.requeueTask

    Parameters

    • tran: DBTransaction
    • taskId: TaskId

    Returns Promise<void>

Protected queueTask

  • Transition from scheduled to queued If the task is cancelled, then this does nothing

    Parameters

    Returns Promise<void>

registerHandler

removeEventListener

  • Parameters

    • type: string
    • callback: null | EventListenerOrEventListenerObject
    • Optional options: boolean | EventListenerOptions

    Returns void

Protected repairDanglingTasks

  • If the process was killed ungracefully then we may need to repair active dangling tasks by moving them back to the queued index

    Returns Promise<void>

Protected requeueTask

scheduleTask

  • Schedules a task If this.schedulingLoop isn't running, then this will not attempt to reset the this.schedulingTimer

    Parameters

    • __namedParameters: {
          deadline?: number;
          delay?: number;
          handlerId: TaskHandlerId;
          lazy?: boolean;
          parameters?: TaskParameters;
          path?: TaskPath;
          priority?: number;
      }
      • Optional deadline?: number
      • Optional delay?: number
      • handlerId: TaskHandlerId
      • Optional lazy?: boolean
      • Optional parameters?: TaskParameters
      • Optional path?: TaskPath
      • Optional priority?: number
    • Optional tran: DBTransaction

    Returns Promise<Task>

start

  • Parameters

    Returns Promise<void>

startProcessing

  • Start scheduling and queuing loop This call is idempotent Use this when Tasks is started in lazy mode

    Returns Promise<void>

Protected startQueueing

Protected startScheduling

Protected startTask

  • Transition from queued to active If the task is cancelled, then this does nothing

    Parameters

    Returns Promise<void>

stop

stopProcessing

  • Stop the scheduling and queuing loop This call is idempotent

    Returns Promise<void>

Protected stopQueueing

Protected stopScheduling

stopTasks

Protected triggerQueuing

  • Same idea as triggerScheduling But this time unlocking the queue to proceed If already unlocked, subsequent unlocking is idempotent The unlocking of the scheduling is delayed Whereas this unlocking is not Remember the queuing just keeps running until finished

    Returns void

Protected triggerScheduling

  • Triggers the scheduler on a delayed basis If the delay is 0, the scheduler is triggered immediately The scheduling timer is a singleton that can be set by both this.schedulingLoop and this.scheduleTask This ensures that the timer is set to the earliest scheduled task

    Parameters

    • scheduleTime: number

    Returns void

updateTask

  • Parameters

    • taskId: TaskId
    • taskPatch: Partial<{
          deadline: number;
          delay: number;
          handlerId: TaskHandlerId;
          parameters: TaskParameters;
          path: TaskPath;
          priority: number;
      }>
    • Optional tran: DBTransaction

    Returns Promise<void>

Static createTaskManager

  • Parameters

    • __namedParameters: {
          activeLimit?: number;
          db: DB;
          fresh?: boolean;
          handlers?: Record<TaskHandlerId, TaskHandler>;
          lazy?: boolean;
          logger?: Logger;
      }
      • Optional activeLimit?: number
      • db: DB
      • Optional fresh?: boolean
      • Optional handlers?: Record<TaskHandlerId, TaskHandler>
      • Optional lazy?: boolean
      • Optional logger?: Logger

    Returns Promise<TaskManager>

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc