The scheduler Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The scheduler Reference Manual

This is the scheduler Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Wed Oct 13 12:27:44 2021 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Instinct Engine Scheduler

Module is designed for regular tasks which need to be performed on specific date or on regular basis. For now main component client is reporting module, but it may be used for scheduling calculation refresh, regular cleanups and similar.

Specifying a task

Task should be added in a format similar to the one used in cron tables. There are a few note-worthy differences. Each entry is composed of six fields separated by space:

MINUTE HOUR DAY-OF-MONTH MONTH DAY-OF-WEEK SEXPRESSION

To specify multiple values for one field, the following operators are available. In the order of precedence,

Examples:

# make report every fifteen minutes (perhaps at :07, :22, :37, :52)
H/15 * * * * (ie-reports:make-report "foo" "bar" "zzzur")

# refresh data every ten minutes in the first half of every hour (three times, perhaps at :04, :14, :24)
H(0-29)/10 * * * * (grc:refresh-data)

# once every two hours at 45 minutes past the hour starting at 9:45 AM and finishing at 3:45 PM every weekday.
45 9-16/2 * * 1-5 (grc:restart)

# once in every two hours slot between 9 AM and 5 PM every weekday (perhaps at 10:38 AM, 12:38 PM, 2:38 PM, 4:38 PM)
H H(9-16)/2 * * 1-5 (grc:restart)

# once a day on the 1st and 15th of every month except December
H H 1,15 1-11 * nil

Specifying a task with a function

For convenience it is possible to specify a task as a cons of the time spec (a string time specification and a function with no arguments). Such tasks will be harder to serialize, however they should be fine for systems that doesn't require serialization.

> (scheduler:create-scheduler-task *scheduler*
   (cons "* * * * *" (lambda () (print :minute))))

Using scheduler

Using scheduler is fairly simple. First user has to create a scheduler instance of desired class[^1]. Then add some tasks to it. The last task is to stop the scheduler in the first or in the second minute (depends on whenever we have started it on even or odd minute).

> (defvar *scheduler* (make-instance 'scheduler:in-memory-scheduler))
> (scheduler:create-scheduler-task *scheduler* "@reboot (print :reboot)")
> (scheduler:create-scheduler-task *scheduler* "@shutdown (print :shutdown)")
> (scheduler:create-scheduler-task *scheduler* "* * * * * (print :minute)")
> (scheduler:create-scheduler-task *scheduler* "*/2 * * * * (scheduler:stop-scheduler *scheduler*)")

Important note regarding the last task. It assumes, that start-scheduler is run in the same package as *scheduler* is defined. Listing tasks is also very easy. Same goes for starting the scheduler loop:

> (scheduler:list-scheduler-tasks *scheduler*)
(#<SCHEDULER-IMPLEMENTATION::SCHEDULER-TASK {10035E67C3}>
 #<SCHEDULER-IMPLEMENTATION::SCHEDULER-TASK {10035E16F3}>
 #<SCHEDULER-IMPLEMENTATION::SCHEDULER-TASK {1003501F03}>
 #<SCHEDULER-IMPLEMENTATION::SCHEDULER-TASK {10034FF883}>)
> (scheduler:start-scheduler *scheduler*)
;; Starting scheduler.
;; :REBOOT
;; :MINUTE
;; :SHUTDOWN
;; Exiting scheduler
:STOPPED

Since we have started scheduler in the same thread we should see output in the same console we have started it. If it were started in a separate thread *standard-output* would be bound to wherever *inferior-lisp* output is.

Remember, to add package prefixes to commands. Also keep in mind, that we have no means in the cron specification to set a second of occurance (this may be done with update-scheduler-task) and by default seconds are assigned to a random value between 0-59 (to distribute tasks on the timeline a little).

Now let us update the task which stops the scheduler so it ends in 5 minutes from now:

> (let ((task (find "(scheduler:stop-scheduler *scheduler*)"
                    (scheduler:list-scheduler-tasks *scheduler*)
                    :key #'scheduler:command :test #'equal)))
    (scheduler:update-scheduler-task
     *scheduler* task
     :start-at (local-time:timestamp+ (local-time:now) 5 :minute)))
#<SCHEDULER-IMPLEMENTATION::SCHEDULER-TASK {10032FD393}>
> (scheduler:start-scheduler *scheduler*)
;; Starting scheduler.
;; :REBOOT
;; :MINUTE
;; :MINUTE
;; :MINUTE
;; :MINUTE
;; :SHUTDOWN
;; Exiting scheduler.
:STOPPED

This illustrates a capability of the scheduler to postpone the first occurance of the event. After shutdown is triggered, next occurance is recomputed from the stored time specification.

Another interesting aspect of having next occurance precomputed is a capability of running tasks, which was missed (i.e computer was down, or scheduler wasn't running). If the scheduler encounters task with its activation time set in the past it will start it at some point in the future[^2].

Note, that the missing task will be performed only once even if more calls were missed. With our scheduler, if we have waited at least two minutes after last invocation and start the scheduler once more it stopped immedietely after start:

> (scheduler:start-scheduler *scheduler*)
;; Starting scheduler.
;; ; missed (scheduler:stop-scheduler *scheduler*) is called
;; :MINUTE ; <- another missed task, we go through full loop iteration before exit
;; :REBOOT ; <- "ordinary" reboot task
;; :SHUTDOWN ; <- "ordinary" shutdown task
;; Exiting scheduler.
:STOPPED

In this case scheduler loop will exit immedietely. It is an important clue, that it is unwise to schedule stop-scheduler call in scheduler, but rather call this function asynchronously.

Extending Scheduler

This is extensible software. Scheduler is arranged around a simple protocol based on CRUD(L) principle. Reference implementation in-memory-scheduler is provided for conveniance and testing.

More advanced backends may be written by subclassing scheduler class for task storage. Optionally scheduler-task may be subclassed to extend tasks.

Each scheduler must have implemented the following methods: create-scheduler-task, read-scheduler-task, update-scheduler-task, delete-scheduler-task and list-scheduler-tasks. Methods implementation should be fairly straightforward.

Each task must obey the protocol based on the following methods: last-occurance, next-occurance, time-specs and command. Methods create-scheduler-task and update-scheduler-task must be aware of the scheduler-task implementation to be able to manipulate its internal structure.

last-occurance and next-occurance should be set on update-scheduler-task invocation according to key parameters last-run and start-at (when present). Format of these dates is an instance of local-time:timestamp and that's what these methods should return.

time-spec is a property list, which stores occurance time specification. It may be a symbol indicating some supported event, like :reboot and :shootdown or a property list.

Property list must have keys :minute :hour :day-of-month :month day-of-week, which values are lists with integer values when task should be repeated, or a keyword :every. For example:

(list :minute (30)
      :hour (1)
      :day-of-month (7 14)
      :month :every
      :day-of-week :every)

Command is a string, which will be read and evaluated each time the task is executed.

Reference manual

SCHEDULER:SCHEDULER                                              [class]

Abstract class from which each driver has to inherit. Thread-safety of
CRUDL operations is implemented in :AROUND methods. Class should not
have direct instances.
SCHEDULER:IN-MEMORY-SCHEDULER                                   [class]
base-class: SCHEDULER

Reference implementation of a scheduler. Data is kept in a
memory. Class may be instationalized.
SCHEDULER:SCHEDULER-TASK                                         [class]
readers: TIME-SPECS, COMMAND, LAST-OCCURANCE, NEXT-OCCURANCE

Class representing a single task. All scheduler entries added by
CREATE-SCHEDUELR-TASK should be instances of this class.
SCHEDULER:CREATE-SCHEDULER-TASK                       [generic function]
args: SCHEDULER CRON-ENTRY

Creates and returns scheduler task instance of class SCHEDULER-TASK.
SCHEDULER:READ-SCHEDULER-TASK                         [generic function]
args: SCHEDULER TASK

Look for a task in scheduler entries. Programmer may specialize second
argument on other types like UUID.
SCHEDULER:UPDATE-SCHEDULER-TASK                      [generic function]
args: SCHEDULER TASK &key CRON-ENTRY START-AT &allow-other-keys

Updates TASK. CRON-ENTRY contains TIME-SPECS and command as described
earlier in this document. START-AT is LOCAL-TIME:TIMESTAMP instance
used to set a date of the first task invocation.

If a key argument is not supplied then slot is not updated. Remember,
that you shouldn't use direct slot write, because scheduler driver may
store data in a database or in a file. Always update tasks with this
function.
SCHEDULER:DELETE-SCHEDULER-TASK                      [generic function]
args: SCHEDULER TASK

Removes task from the scheduler so it is not invoked when it's next
occurance time comes.
SCHEDULER:LIST-SCHEDULER-TASKS                       [generic function]
args: SCHEDULER

Returns a list of all tasks associated with the scheduler. List
elements are instances of class SCHEDULER-TASK.
SCHEDULER:START-SCHEDULER                                    [function]
args: SCHEDULER

Starts scheduler in a loop. Function blocks until STOP-SCHEDULER is
called, so it may be wise to start it in another thread. All tasks are
evaluated in the package this function is invoked in. NB: if function
is started with

  (bt:make-thread (lambda () (scheduler:start-scheduler *s*)))
  
the package is CL-USER because that is how BORDEAUX-THREADS is
implemented.

If scheduler loop encounters task which was missed (it was meant to be
started in the past) it will schedule this tasks by itself in the near
future (when exactly is not specified). After each task activation
next activation date is recomputed automatically and updated with
UPDATE-SCHEDULER-TASK.
SCHEDULER:STOP-SCHEDULER                                     [function]
args: SCHEDULER

Stops scheduler. Scheduler main function should stop after finishing
currently pending task loop iteration.

[^1]: Currently only reference scheduler is implemented called in-memory-scheduler. It should be fairly usable for scheduling tasks in running software, but for persistance it may be necessary to write a new backend.

[^2]: In this case - immedietely, but it is not specifed to allow task distribution to balance the load after


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 scheduler

Author

Daniel Kochmański <daniel@turtleware.eu>

License

BSD-2-Clause

Description

Extensible task scheduler.

Dependencies
Source

scheduler.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Next: , Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

3.1.1 scheduler.asd

Location

scheduler.asd

Systems

scheduler (system)


Previous: , Up: Lisp files   [Contents][Index]

3.1.2 scheduler/scheduler.lisp

Parent

scheduler (system)

Location

scheduler.lisp

Packages
Exported Definitions
Internal Definitions

Previous: , Up: Files   [Contents][Index]

3.2 Static


Next: , Previous: , Up: Static files   [Contents][Index]

3.2.1 scheduler/README.md

Parent

scheduler (system)

Location

README.md


Previous: , Up: Static files   [Contents][Index]

3.2.2 scheduler/LICENSE

Parent

scheduler (system)

Location

LICENSE


Next: , Previous: , Up: Top   [Contents][Index]

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 scheduler-implementation

Source

scheduler.lisp (file)

Use List
Exported Definitions
Internal Definitions

Previous: , Up: Packages   [Contents][Index]

4.2 scheduler

Source

scheduler.lisp (file)

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.1 Functions

Function: start-scheduler SCHEDULER
Package

scheduler

Source

scheduler.lisp (file)

Function: stop-scheduler SCHEDULER
Package

scheduler

Source

scheduler.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

5.1.2 Generic functions

Generic Function: create-scheduler-task SCHEDULER TIME-ENTRY &key START-AFTER &allow-other-keys
Package

scheduler

Source

scheduler.lisp (file)

Methods
Method: create-scheduler-task (SCHEDULER in-memory-scheduler) (TASK task) &key &allow-other-keys
Method: create-scheduler-task (SCHEDULER scheduler) ENTRY &key &allow-other-keys around
Method: create-scheduler-task SCHEDULER (CRON-ENTRY string) &key START-AFTER &allow-other-keys
Method: create-scheduler-task SCHEDULER (CRON-ENTRY-AND-LAMBDA cons) &key START-AFTER &allow-other-keys
Generic Function: delete-scheduler-task SCHEDULER TASK
Package

scheduler

Source

scheduler.lisp (file)

Methods
Method: delete-scheduler-task (SCHEDULER in-memory-scheduler) (TASK task)
Method: delete-scheduler-task (SCHEDULER scheduler) TASK around
Generic Function: execute-task TASK
Package

scheduler-implementation

Methods
Method: execute-task (TASK lambda-task)
Source

scheduler.lisp (file)

Method: execute-task (TASK task)
Source

scheduler.lisp (file)

Generic Function: list-scheduler-tasks SCHEDULER

Lists all tasks registered with the scheduler.

Package

scheduler

Source

scheduler.lisp (file)

Writer

(setf list-scheduler-tasks) (generic function)

Methods
Method: list-scheduler-tasks (IN-MEMORY-SCHEDULER in-memory-scheduler)

automatically generated reader method

Method: list-scheduler-tasks (SCHEDULER scheduler) around
Generic Function: (setf list-scheduler-tasks) NEW-VALUE OBJECT
Package

scheduler

Reader

list-scheduler-tasks (generic function)

Methods
Method: (setf list-scheduler-tasks) NEW-VALUE (IN-MEMORY-SCHEDULER in-memory-scheduler)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: parse-entry ENTRY

Parses entry to return two values: the time spec and command.

Package

scheduler-implementation

Source

scheduler.lisp (file)

Methods
Method: parse-entry (ENTRY cron-entry) &aux SPEC
Generic Function: read-scheduler-task SCHEDULER TASK
Package

scheduler

Source

scheduler.lisp (file)

Methods
Method: read-scheduler-task (SCHEDULER in-memory-scheduler) (TASK task)
Method: read-scheduler-task (SCHEDULER scheduler) TASK around
Generic Function: task-command OBJECT
Generic Function: (setf task-command) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: task-command (TASK task)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf task-command) NEW-VALUE (TASK task)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: task-last-execution OBJECT
Generic Function: (setf task-last-execution) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: task-last-execution (TASK task)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf task-last-execution) NEW-VALUE (TASK task)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: task-next-execution OBJECT
Generic Function: (setf task-next-execution) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: task-next-execution (TASK task)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf task-next-execution) NEW-VALUE (TASK task)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: task-source-entry OBJECT
Generic Function: (setf task-source-entry) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: task-source-entry (TASK task)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf task-source-entry) NEW-VALUE (TASK task)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: task-time-specs OBJECT
Generic Function: (setf task-time-specs) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: task-time-specs (TASK task)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf task-time-specs) NEW-VALUE (TASK task)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: update-scheduler-task SCHEDULER TASK &key CRON-ENTRY START-AT LAST-RUN &allow-other-keys
Package

scheduler

Source

scheduler.lisp (file)

Methods
Method: update-scheduler-task (SCHEDULER in-memory-scheduler) (TASK task) &key CRON-ENTRY LAST-RUN START-AT
Method: update-scheduler-task (SCHEDULER scheduler) TASK &key around

Previous: , Up: Exported definitions   [Contents][Index]

5.1.3 Classes

Class: cron-entry ()
Package

scheduler-implementation

Source

scheduler.lisp (file)

Direct superclasses

scheduler-entry (class)

Direct methods
Direct slots
Slot: string
Initargs

:string

Readers

cron-entry-string (generic function)

Class: in-memory-scheduler ()
Package

scheduler

Source

scheduler.lisp (file)

Direct superclasses

scheduler (class)

Direct methods
Direct slots
Slot: tasks
Readers

list-scheduler-tasks (generic function)

Writers

(setf list-scheduler-tasks) (generic function)

Class: scheduler ()

Thread-safe abstract scheduler class.

Package

scheduler

Source

scheduler.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

in-memory-scheduler (class)

Direct methods
Direct slots
Slot: %state
Initform

:stopped

Readers

scheduler-state (generic function)

Writers

(setf scheduler-state) (generic function)

Slot: %lock
Initform

(bordeaux-threads:make-recursive-lock "scheduler lock")

Readers

scheduler-lock (generic function)

Writers

(setf scheduler-lock) (generic function)

Class: scheduler-entry ()
Package

scheduler-implementation

Source

scheduler.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

cron-entry (class)

Class: task ()
Package

scheduler-implementation

Source

scheduler.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

lambda-task (class)

Direct methods
Direct slots
Slot: time-specs
Initargs

:time-specs

Readers

task-time-specs (generic function)

Writers

(setf task-time-specs) (generic function)

Slot: command
Initargs

:command

Readers

task-command (generic function)

Writers

(setf task-command) (generic function)

Slot: last-execution
Initargs

:last-execution

Readers

task-last-execution (generic function)

Writers

(setf task-last-execution) (generic function)

Slot: next-execution
Initargs

:next-execution

Readers

task-next-execution (generic function)

Writers

(setf task-next-execution) (generic function)

Slot: source-entry
Initargs

:source-entry

Readers

task-source-entry (generic function)

Writers

(setf task-source-entry) (generic function)


Previous: , Up: Definitions   [Contents][Index]

5.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.1 Macros

Macro: ^if TEST IF-TRUE IF-FALSE
Package

scheduler-implementation

Source

scheduler.lisp (file)

Macro: db LAMBDA-LIST EXPRESSION &body BODY
Package

scheduler-implementation

Source

scheduler.lisp (file)

Macro: mvb LAMBDA-LIST EXPRESSION &body BODY
Package

scheduler-implementation

Source

scheduler.lisp (file)

Macro: ss &rest ARGS
Package

scheduler-implementation

Source

scheduler.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.2 Functions

Function: %parse-cron-time-1/no-step SPEC RANGE
Package

scheduler-implementation

Source

scheduler.lisp (file)

Function: %parse-cron-time-1/step SPEC RANGE STEP
Package

scheduler-implementation

Source

scheduler.lisp (file)

Function: compute-next-occurance SPEC &optional TIME
Package

scheduler-implementation

Source

scheduler.lisp (file)

Function: parse-cron-entry SPEC
Package

scheduler-implementation

Source

scheduler.lisp (file)

Function: parse-cron-spec LINE
Package

scheduler-implementation

Source

scheduler.lisp (file)

Function: parse-cron-time-1 SPEC RANGE
Package

scheduler-implementation

Source

scheduler.lisp (file)

Function: seed-random-state SEED

Returns a new random state seeded with ‘object’.

Package

scheduler-implementation

Source

scheduler.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

5.2.3 Generic functions

Generic Function: cron-entry-string OBJECT
Package

scheduler-implementation

Methods
Method: cron-entry-string (CRON-ENTRY cron-entry)

automatically generated reader method

Source

scheduler.lisp (file)

Generic Function: scheduler-lock OBJECT
Generic Function: (setf scheduler-lock) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: scheduler-lock (SCHEDULER scheduler)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf scheduler-lock) NEW-VALUE (SCHEDULER scheduler)

automatically generated writer method

Source

scheduler.lisp (file)

Generic Function: scheduler-state OBJECT
Generic Function: (setf scheduler-state) NEW-VALUE OBJECT
Package

scheduler-implementation

Methods
Method: scheduler-state (SCHEDULER scheduler)

automatically generated reader method

Source

scheduler.lisp (file)

Method: (setf scheduler-state) NEW-VALUE (SCHEDULER scheduler)

automatically generated writer method

Source

scheduler.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

5.2.4 Classes

Class: lambda-task ()
Package

scheduler-implementation

Source

scheduler.lisp (file)

Direct superclasses

task (class)

Direct methods

Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   S  
Index Entry  Section

F
File, Lisp, scheduler.asd: The scheduler․asd file
File, Lisp, scheduler/scheduler.lisp: The scheduler/scheduler․lisp file
File, static, scheduler/LICENSE: The scheduler/license file
File, static, scheduler/README.md: The scheduler/readme․md file

L
Lisp File, scheduler.asd: The scheduler․asd file
Lisp File, scheduler/scheduler.lisp: The scheduler/scheduler․lisp file

S
scheduler.asd: The scheduler․asd file
scheduler/LICENSE: The scheduler/license file
scheduler/README.md: The scheduler/readme․md file
scheduler/scheduler.lisp: The scheduler/scheduler․lisp file
Static File, scheduler/LICENSE: The scheduler/license file
Static File, scheduler/README.md: The scheduler/readme․md file

Jump to:   F   L   S  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (   ^  
C   D   E   F   G   L   M   P   R   S   T   U  
Index Entry  Section

%
%parse-cron-time-1/no-step: Internal functions
%parse-cron-time-1/step: Internal functions

(
(setf list-scheduler-tasks): Exported generic functions
(setf list-scheduler-tasks): Exported generic functions
(setf scheduler-lock): Internal generic functions
(setf scheduler-lock): Internal generic functions
(setf scheduler-state): Internal generic functions
(setf scheduler-state): Internal generic functions
(setf task-command): Exported generic functions
(setf task-command): Exported generic functions
(setf task-last-execution): Exported generic functions
(setf task-last-execution): Exported generic functions
(setf task-next-execution): Exported generic functions
(setf task-next-execution): Exported generic functions
(setf task-source-entry): Exported generic functions
(setf task-source-entry): Exported generic functions
(setf task-time-specs): Exported generic functions
(setf task-time-specs): Exported generic functions

^
^if: Internal macros

C
compute-next-occurance: Internal functions
create-scheduler-task: Exported generic functions
create-scheduler-task: Exported generic functions
create-scheduler-task: Exported generic functions
create-scheduler-task: Exported generic functions
create-scheduler-task: Exported generic functions
cron-entry-string: Internal generic functions
cron-entry-string: Internal generic functions

D
db: Internal macros
delete-scheduler-task: Exported generic functions
delete-scheduler-task: Exported generic functions
delete-scheduler-task: Exported generic functions

E
execute-task: Exported generic functions
execute-task: Exported generic functions
execute-task: Exported generic functions

F
Function, %parse-cron-time-1/no-step: Internal functions
Function, %parse-cron-time-1/step: Internal functions
Function, compute-next-occurance: Internal functions
Function, parse-cron-entry: Internal functions
Function, parse-cron-spec: Internal functions
Function, parse-cron-time-1: Internal functions
Function, seed-random-state: Internal functions
Function, start-scheduler: Exported functions
Function, stop-scheduler: Exported functions

G
Generic Function, (setf list-scheduler-tasks): Exported generic functions
Generic Function, (setf scheduler-lock): Internal generic functions
Generic Function, (setf scheduler-state): Internal generic functions
Generic Function, (setf task-command): Exported generic functions
Generic Function, (setf task-last-execution): Exported generic functions
Generic Function, (setf task-next-execution): Exported generic functions
Generic Function, (setf task-source-entry): Exported generic functions
Generic Function, (setf task-time-specs): Exported generic functions
Generic Function, create-scheduler-task: Exported generic functions
Generic Function, cron-entry-string: Internal generic functions
Generic Function, delete-scheduler-task: Exported generic functions
Generic Function, execute-task: Exported generic functions
Generic Function, list-scheduler-tasks: Exported generic functions
Generic Function, parse-entry: Exported generic functions
Generic Function, read-scheduler-task: Exported generic functions
Generic Function, scheduler-lock: Internal generic functions
Generic Function, scheduler-state: Internal generic functions
Generic Function, task-command: Exported generic functions
Generic Function, task-last-execution: Exported generic functions
Generic Function, task-next-execution: Exported generic functions
Generic Function, task-source-entry: Exported generic functions
Generic Function, task-time-specs: Exported generic functions
Generic Function, update-scheduler-task: Exported generic functions

L
list-scheduler-tasks: Exported generic functions
list-scheduler-tasks: Exported generic functions
list-scheduler-tasks: Exported generic functions

M
Macro, db: Internal macros
Macro, mvb: Internal macros
Macro, ss: Internal macros
Macro, ^if: Internal macros
Method, (setf list-scheduler-tasks): Exported generic functions
Method, (setf scheduler-lock): Internal generic functions
Method, (setf scheduler-state): Internal generic functions
Method, (setf task-command): Exported generic functions
Method, (setf task-last-execution): Exported generic functions
Method, (setf task-next-execution): Exported generic functions
Method, (setf task-source-entry): Exported generic functions
Method, (setf task-time-specs): Exported generic functions
Method, create-scheduler-task: Exported generic functions
Method, create-scheduler-task: Exported generic functions
Method, create-scheduler-task: Exported generic functions
Method, create-scheduler-task: Exported generic functions
Method, cron-entry-string: Internal generic functions
Method, delete-scheduler-task: Exported generic functions
Method, delete-scheduler-task: Exported generic functions
Method, execute-task: Exported generic functions
Method, execute-task: Exported generic functions
Method, list-scheduler-tasks: Exported generic functions
Method, list-scheduler-tasks: Exported generic functions
Method, parse-entry: Exported generic functions
Method, read-scheduler-task: Exported generic functions
Method, read-scheduler-task: Exported generic functions
Method, scheduler-lock: Internal generic functions
Method, scheduler-state: Internal generic functions
Method, task-command: Exported generic functions
Method, task-last-execution: Exported generic functions
Method, task-next-execution: Exported generic functions
Method, task-source-entry: Exported generic functions
Method, task-time-specs: Exported generic functions
Method, update-scheduler-task: Exported generic functions
Method, update-scheduler-task: Exported generic functions
mvb: Internal macros

P
parse-cron-entry: Internal functions
parse-cron-spec: Internal functions
parse-cron-time-1: Internal functions
parse-entry: Exported generic functions
parse-entry: Exported generic functions

R
read-scheduler-task: Exported generic functions
read-scheduler-task: Exported generic functions
read-scheduler-task: Exported generic functions

S
scheduler-lock: Internal generic functions
scheduler-lock: Internal generic functions
scheduler-state: Internal generic functions
scheduler-state: Internal generic functions
seed-random-state: Internal functions
ss: Internal macros
start-scheduler: Exported functions
stop-scheduler: Exported functions

T
task-command: Exported generic functions
task-command: Exported generic functions
task-last-execution: Exported generic functions
task-last-execution: Exported generic functions
task-next-execution: Exported generic functions
task-next-execution: Exported generic functions
task-source-entry: Exported generic functions
task-source-entry: Exported generic functions
task-time-specs: Exported generic functions
task-time-specs: Exported generic functions

U
update-scheduler-task: Exported generic functions
update-scheduler-task: Exported generic functions
update-scheduler-task: Exported generic functions

Jump to:   %   (   ^  
C   D   E   F   G   L   M   P   R   S   T   U  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   %  
C   L   N   S   T  
Index Entry  Section

%
%lock: Exported classes
%state: Exported classes

C
command: Exported classes

L
last-execution: Exported classes

N
next-execution: Exported classes

S
Slot, %lock: Exported classes
Slot, %state: Exported classes
Slot, command: Exported classes
Slot, last-execution: Exported classes
Slot, next-execution: Exported classes
Slot, source-entry: Exported classes
Slot, string: Exported classes
Slot, tasks: Exported classes
Slot, time-specs: Exported classes
source-entry: Exported classes
string: Exported classes

T
tasks: Exported classes
time-specs: Exported classes

Jump to:   %  
C   L   N   S   T  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   I   L   P   S   T  
Index Entry  Section

C
Class, cron-entry: Exported classes
Class, in-memory-scheduler: Exported classes
Class, lambda-task: Internal classes
Class, scheduler: Exported classes
Class, scheduler-entry: Exported classes
Class, task: Exported classes
cron-entry: Exported classes

I
in-memory-scheduler: Exported classes

L
lambda-task: Internal classes

P
Package, scheduler: The scheduler package
Package, scheduler-implementation: The scheduler-implementation package

S
scheduler: The scheduler system
scheduler: The scheduler package
scheduler: Exported classes
scheduler-entry: Exported classes
scheduler-implementation: The scheduler-implementation package
System, scheduler: The scheduler system

T
task: Exported classes

Jump to:   C   I   L   P   S   T