Index

Modules: metronome, metronome/cron/cron, metronome/cron/expr, metronome/cron/field, metronome/cron/parser, metronome/scheduler, timers, timezones.

API symbols

`$`:

• expr: proc `$`(expr: Expr): string
• scheduler: proc `$`(beater: Beater): string

Beater:

• scheduler: type Beater

BeaterAsyncProc:

• scheduler: type BeaterAsyncProc

BeaterKind:

• scheduler: enum BeaterKind

BeaterState:

• scheduler: enum BeaterState

BeaterThreadProc:

• scheduler: type BeaterThreadProc

CalendarTimer:

• timers: object CalendarTimer

Cron:

• cron: object Cron

ekAll:

• expr: ExprKind.ekAll

ekAny:

• expr: ExprKind.ekAny

ekHash:

• expr: ExprKind.ekHash

ekIndex:

• expr: ExprKind.ekIndex

ekLast:

• expr: ExprKind.ekLast

ekLastN:

• expr: ExprKind.ekLastN

ekNearest:

• expr: ExprKind.ekNearest

ekNum:

• expr: ExprKind.ekNum

ekRange:

• expr: ExprKind.ekRange

ekSeq:

• expr: ExprKind.ekSeq

ekStep:

• expr: ExprKind.ekStep

Expr:

• expr: type Expr

ExprKind:

• expr: enum ExprKind

failures:

• scheduler: proc failures(beater: Beater): int
• scheduler: proc failures(self: Scheduler; id: string): int

Field:

• field: type Field

FieldKind:

• field: enum FieldKind

fire:

• scheduler: proc fire(self: Beater; errorHandler: JobErrorHandler = nil): owned(Future[void])

fireTime:

• scheduler: proc fireTime(self: Beater; prev: Option[DateTime]; now: DateTime): Option[DateTime]

fkDayOfMonth:

• field: FieldKind.fkDayOfMonth

fkDayOfWeek:

• field: FieldKind.fkDayOfWeek

fkHour:

• field: FieldKind.fkHour

fkMinute:

• field: FieldKind.fkMinute

fkMonth:

• field: FieldKind.fkMonth

fkSecond:

• field: FieldKind.fkSecond

fkYear:

• field: FieldKind.fkYear

getMinIter:

• cron: proc getMinIter(expr: Expr; field: Field; dt: DateTime): Option[int]

getNext:

• cron: proc getNext(cron: Cron; dt: DateTime): Option[DateTime]
• cron: proc getNext(expr: Expr; field: Field; dt: DateTime): Option[int]
• cron: proc getNext(field: Field; dt: DateTime): Option[int]
• timers: proc getNext(timer: CalendarTimer; current: DateTime): Option[DateTime]

getNextForAll:

• cron: proc getNextForAll(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForIndex:

• cron: proc getNextForIndex(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForLastDayOfMonth:

• cron: proc getNextForLastDayOfMonth(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForLastDayOfWeek:

• cron: proc getNextForLastDayOfWeek(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForNum:

• cron: proc getNextForNum(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForRange:

• cron: proc getNextForRange(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForSeq:

• cron: proc getNextForSeq(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForStepAll:

• cron: proc getNextForStepAll(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForStepNum:

• cron: proc getNextForStepNum(expr: Expr; field: Field; dt: DateTime): Option[int]

getNextForStepRange:

• cron: proc getNextForStepRange(expr: Expr; field: Field; dt: DateTime): Option[int]

getValue:

• field: proc getValue(field: Field; dt: DateTime): int

id:

• scheduler: proc id(beater: Beater): string

idle:

• scheduler: proc idle(self: Scheduler): owned(Future[void])

initBeater:

• scheduler: proc initBeater(cron: Cron; asyncProc: BeaterAsyncProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil; timezone: Option[Timezone] = none(Timezone)): Beater
• scheduler: proc initBeater(cron: Cron; threadProc: BeaterThreadProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil; timezone: Option[Timezone] = none(Timezone)): Beater
• scheduler: proc initBeater(time: DateTime; asyncProc: BeaterAsyncProc; id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil): Beater
• scheduler: proc initBeater(time: DateTime; threadProc: BeaterThreadProc; id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil): Beater
• scheduler: proc initBeater(nextRunProc: NextRunProc; asyncProc: BeaterAsyncProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil): Beater
• scheduler: proc initBeater(nextRunProc: NextRunProc; threadProc: BeaterThreadProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil): Beater
• scheduler: proc initBeater(interval: TimeInterval; asyncProc: BeaterAsyncProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil; jitter: TimeInterval = initTimeInterval()): Beater
• scheduler: proc initBeater(interval: TimeInterval; threadProc: BeaterThreadProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil; jitter: TimeInterval = initTimeInterval()): Beater

initScheduler:

• scheduler: proc initScheduler(settings: Settings): Scheduler

initThrottler:

• scheduler: proc initThrottler(num: int = 1): Throttler

initTimerBeater:

• timers: proc initTimerBeater(timer: CalendarTimer; asyncProc: BeaterAsyncProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil): Beater
• timers: proc initTimerBeater(timer: CalendarTimer; threadProc: BeaterThreadProc; startTime: Option[DateTime] = none(DateTime); endTime: Option[DateTime] = none(DateTime); id: string = ""; throttleNum: int = 1; errorHandler: JobErrorHandler = nil): Beater

JobErrorHandler:

• scheduler: type JobErrorHandler

jobState:

• scheduler: proc jobState(self: Scheduler; id: string): Option[BeaterState]

lastError:

• scheduler: proc lastError(beater: Beater): ref Exception
• scheduler: proc lastError(self: Scheduler; id: string): ref Exception

lastErrorAt:

• scheduler: proc lastErrorAt(beater: Beater): Option[DateTime]
• scheduler: proc lastErrorAt(self: Scheduler; id: string): Option[DateTime]

lastRun:

• scheduler: proc lastRun(beater: Beater): Option[DateTime]
• scheduler: proc lastRun(self: Scheduler; id: string): Option[DateTime]

listJobs:

• scheduler: proc listJobs(self: Scheduler): seq[string]

logger:

• scheduler: var logger

maxValue:

• field: proc maxValue(field: Field; dt: DateTime): int

metronome:

• scheduler: macro metronome(body: untyped): untyped

minValue:

• field: proc minValue(field: Field; dt: DateTime): int

namedTimezone:

• timezones: proc namedTimezone(name: string): Timezone

newAllExpr:

• expr: proc newAllExpr(): Expr

newAnyExpr:

• expr: proc newAnyExpr(): Expr

newCron:

• cron: proc newCron(second: string = "*"; minute: string = "*"; hour: string = "*"; day_of_month: string = "*"; day_of_week: string = "*"; month: string = "*"; year: string = "*"): Cron

newHashExpr:

• expr: proc newHashExpr(): Expr

newIndexExpr:

• expr: proc newIndexExpr(indexer: int; index: int): Expr

newLastExpr:

• expr: proc newLastExpr(): Expr

newLastNExpr:

• expr: proc newLastNExpr(last: int): Expr

newNearestExpr:

• expr: proc newNearestExpr(nearest: int): Expr

newNumExpr:

• expr: proc newNumExpr(num: int): Expr

newRangeExpr:

• expr: proc newRangeExpr(start: int; stop: int): Expr

newSeqExpr:

• expr: proc newSeqExpr(exprs: seq[Expr]): Expr

newSettings:

• scheduler: proc newSettings(appName = ""; errorHandler: JobErrorHandler = nil): Settings

newStepExpr:

• expr: proc newStepExpr(expr: Expr; step: int): Expr

newTimer:

• timers: proc newTimer(onCalendar: openArray[string]): CalendarTimer
• timers: proc newTimer(onCalendar: string): CalendarTimer

nextRun:

• scheduler: proc nextRun(beater: Beater): Option[DateTime]
• scheduler: proc nextRun(self: Scheduler; id: string): Option[DateTime]

NextRunProc:

• scheduler: type NextRunProc

parseDayOfMonths:

• parser: proc parseDayOfMonths(s: string): Expr

parseDayOfWeeks:

• parser: proc parseDayOfWeeks(s: string): Expr

parseHours:

• parser: proc parseHours(s: string): Expr

parseMinutes:

• parser: proc parseMinutes(s: string): Expr

parseMonths:

• parser: proc parseMonths(s: string): Expr

parseSeconds:

• parser: proc parseSeconds(s: string): Expr

parseYears:

• parser: proc parseYears(s: string): Expr

pause:

• scheduler: proc pause(beater: Beater)
• scheduler: proc pause(self: Scheduler; id: string): bool

register:

• scheduler: proc register(self: Scheduler; beater: Beater)

resume:

• scheduler: proc resume(beater: Beater)
• scheduler: proc resume(self: Scheduler; id: string): bool

runningCount:

• scheduler: proc runningCount(beater: Beater): int
• scheduler: proc runningCount(self: Scheduler; id: string): int

Scheduler:

• scheduler: type Scheduler

scheduler:

• scheduler: macro scheduler(sched: untyped; body: untyped)

serve:

• scheduler: proc serve(self: Scheduler)

Settings:

• scheduler: type Settings

start:

• scheduler: proc start(self: Scheduler): owned(Future[void])

state:

• scheduler: proc state(beater: Beater): BeaterState

stop:

• scheduler: proc stop(beater: Beater)
• scheduler: proc stop(self: Scheduler; id: string): bool

stopAll:

• scheduler: proc stopAll(self: Scheduler)

submit:

• scheduler: proc submit(self: Throttler; fut: Future[void])

throttled:

• scheduler: proc throttled(self: Throttler): bool

Throttler:

• scheduler: type Throttler

timezoneDatabaseVersion:

• timezones: proc timezoneDatabaseVersion(): string

timezoneNames:

• timezones: proc timezoneNames(): seq[string]

waitFor:

• scheduler: proc waitFor(self: Scheduler)