GitHub - LouDnl/at-at: Ahead-of-time function scheduler

                                        ________
                                    _,.-Y  |  |  Y-._
                                .-~"   ||  |  |  |   "-.
                                I" ""=="|" !""! "|"[]""|     _____
                                L__  [] |..------|:   _[----I" .-{"-.
                               I___|  ..| l______|l_ [__L]_[I_/r(=}=-P
                              [L______L_[________]______j~  '-=c_]/=-^
                               \_I_j.--.\==I|I==_/.--L_]
                                 [_((==)[`-----"](==)j
                                    I--I"~~"""~~"I--I
                                    |[]|         |[]|
                                    l__j         l__j
                                    |!!|         |!!|
                                    |..|         |..|
                                    ([])         ([])
                                    ]--[         ]--[
                                    [_L]         [_L]  -Row
                                   /|..|\       /|..|\
                                  `=}--{='     `=}--{='
                                 .-^--r-^-.   .-^--r-^-.
                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                      __               __
                               ____ _/ /_       ____ _/ /_
                              / __ `/ __/______/ __ `/ __/
                             / /_/ / /_ /_____/ /_/ / /_
                             \__,_/\__/       \__,_/\__/

Project status

	Master	Develop

Build
Tests
Commit
Tag
License
Language
Issues

Install

Fetch at-at from github: https://github.com/LouDnl/at-at or pull from clojars:

at-at

Simple ahead-of-time function scheduler. Allows you to schedule the execution of an anonymous function for a point in the future.

Adaption and addition

This is an updated fork of overtone/at-at. All credits go to overtone.

Commits were cherry-picked from open pull-requests and forks.
Credits:

Unit testing

Run lein all test to run all unit tests

Basic Usage

First pull in the lib:

at-at uses ScheduledThreadPoolExecutors behind the scenes which use a thread pool to run the scheduled tasks. You therefore need create a pool before you can get going:

It is possible to pass in extra options :cpu-count, :stop-delayed? and :stop-periodic? to further configure your pool. See mk-pool's docstring for further info.

Next, schedule the function of your dreams. Here we schedule the function to execute in 1000 ms from now (i.e. 1 second):

(at (+ 1000 (now)) #(println "hello from the past!") my-pool)

You may also specify a description for the scheduled task with the optional :desc key.

Another way of achieving the same result is to use after which takes a delaty time in ms from now:

(after 1000 #(println "hello from the past!") my-pool)

If you want a scheduled function to be unique, it is possible to pass a uid string to both scheduled job functions.

Will throw an Exception error when you try to schedule a job with the same uid:

(after 10000 #(println "hello from the past!") my-pool :uid "my-unique-identifier") ; schedules function
(at (+ 10000 (now)) #(println "hello from the past!") my-pool :uid "my-unique-identifier") ; will throw an Execution error
; Execution error at overtone.at-at/at (at_at.clj:281).
; Error: Unable to schedule job with uid my-unique-identifier, job is already scheduled.0

You can also schedule functions to occur periodically. Here we schedule the function to execute every second:

(every 1000 #(println "I am cool!") my-pool)

This returns a scheduled-fn which may easily be stopped stop:

Or more forcefully killed with kill.

It's also possible to start a periodic repeating fn with an initial delay:

(every 1000 #(println "I am cool!") my-pool :initial-delay 2000)

Finally, you can also schedule tasks for a fixed delay (vs a rate):

(interspaced 1000 #(println "I am cool!") my-pool)

This means that it will wait 1000 ms after the task is completed before starting the next one.

Resetting a pool.

When necessary it's possible to stop and reset a given pool:

(stop-and-reset-pool! my-pool)

You may forcefully reset the pool using the :kill strategy:

(stop-and-reset-pool! my-pool :strategy :kill)

Viewing running scheduled tasks.

at-at keeps an eye on all the tasks you've scheduled. You can get a set of the current jobs (both scheduled and recurring) using scheduled-jobs and you can pretty-print a list of these job using show-schedule. The ids shown in the output of show-schedule are also accepted in kill and stop, provided you also specify the associated pool. See the kill and stop docstrings for more information.

(def tp (mk-pool))
(after 10000 #(println "hello") tp :desc "Hello printer")
(every 5000 #(println "I am still alive!") tp :desc "Alive task")
(show-schedule tp)
;; [6][RECUR] created: Thu 12:03:35s, period: 5000ms, desc: "Alive task
;; [5][SCHED] created: Thu 12:03:32s, starts at: Thu 12:03:42s, uid: "G__441", desc: "Hello printer

overtone.at-at.util

See UTIL.md for more information

History

at-at was extracted from the awesome music making wonder that is Overtone (http://github.com/overtone/overtone)

Authors

Sam Aaron
Jeff Rose
Michael Neale

(Ascii art borrowed from http://www.sanitarium.net/jokes/getjoke.cgi?132)