package cron

Import Path
	github.com/robfig/cron/v3 (on go.dev)

Dependency Relation
	imports 12 packages, and imported by one package

Involved Source Files

	    chain.go
	    constantdelay.go
	    cron.go
	  d doc.go
		Package cron implements a cron spec parser and job runner.
		
		Installation
		
		To download the specific tagged release, run:
		
			go get github.com/robfig/cron/v3@v3.0.0
		
		Import it in your program as:
		
			import "github.com/robfig/cron/v3"
		
		It requires Go 1.11 or later due to usage of Go Modules.
		
		Usage
		
		Callers may register Funcs to be invoked on a given schedule.  Cron will run
		them in their own goroutines.
		
			c := cron.New()
			c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
			c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println(".. in the range 3-6am, 8-11pm") })
			c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })
			c.AddFunc("@hourly",      func() { fmt.Println("Every hour, starting an hour from now") })
			c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })
			c.Start()
			..
			// Funcs are invoked in their own goroutine, asynchronously.
			...
			// Funcs may also be added to a running Cron
			c.AddFunc("@daily", func() { fmt.Println("Every day") })
			..
			// Inspect the cron job entries' next and previous run times.
			inspect(c.Entries())
			..
			c.Stop()  // Stop the scheduler (does not stop any jobs already running).
		
		CRON Expression Format
		
		A cron expression represents a set of times, using 5 space-separated fields.
		
			Field name   | Mandatory? | Allowed values  | Allowed special characters
			----------   | ---------- | --------------  | --------------------------
			Minutes      | Yes        | 0-59            | * / , -
			Hours        | Yes        | 0-23            | * / , -
			Day of month | Yes        | 1-31            | * / , - ?
			Month        | Yes        | 1-12 or JAN-DEC | * / , -
			Day of week  | Yes        | 0-6 or SUN-SAT  | * / , - ?
		
		Month and Day-of-week field values are case insensitive.  "SUN", "Sun", and
		"sun" are equally accepted.
		
		The specific interpretation of the format is based on the Cron Wikipedia page:
		https://en.wikipedia.org/wiki/Cron
		
		Alternative Formats
		
		Alternative Cron expression formats support other fields like seconds. You can
		implement that by creating a custom Parser as follows.
		
			cron.New(
				cron.WithParser(
					cron.NewParser(
						cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)))
		
		Since adding Seconds is the most common modification to the standard cron spec,
		cron provides a builtin function to do that, which is equivalent to the custom
		parser you saw earlier, except that its seconds field is REQUIRED:
		
			cron.New(cron.WithSeconds())
		
		That emulates Quartz, the most popular alternative Cron schedule format:
		http://www.quartz-scheduler.org/documentation/quartz-2.x/tutorials/crontrigger.html
		
		Special Characters
		
		Asterisk ( * )
		
		The asterisk indicates that the cron expression will match for all values of the
		field; e.g., using an asterisk in the 5th field (month) would indicate every
		month.
		
		Slash ( / )
		
		Slashes are used to describe increments of ranges. For example 3-59/15 in the
		1st field (minutes) would indicate the 3rd minute of the hour and every 15
		minutes thereafter. The form "*\/..." is equivalent to the form "first-last/...",
		that is, an increment over the largest possible range of the field.  The form
		"N/..." is accepted as meaning "N-MAX/...", that is, starting at N, use the
		increment until the end of that specific range.  It does not wrap around.
		
		Comma ( , )
		
		Commas are used to separate items of a list. For example, using "MON,WED,FRI" in
		the 5th field (day of week) would mean Mondays, Wednesdays and Fridays.
		
		Hyphen ( - )
		
		Hyphens are used to define ranges. For example, 9-17 would indicate every
		hour between 9am and 5pm inclusive.
		
		Question mark ( ? )
		
		Question mark may be used instead of '*' for leaving either day-of-month or
		day-of-week blank.
		
		Predefined schedules
		
		You may use one of several pre-defined schedules in place of a cron expression.
		
			Entry                  | Description                                | Equivalent To
			-----                  | -----------                                | -------------
			@yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *
			@monthly               | Run once a month, midnight, first of month | 0 0 1 * *
			@weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0
			@daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *
			@hourly                | Run once an hour, beginning of hour        | 0 * * * *
		
		Intervals
		
		You may also schedule a job to execute at fixed intervals, starting at the time it's added
		or cron is run. This is supported by formatting the cron spec like this:
		
		    @every <duration>
		
		where "duration" is a string accepted by time.ParseDuration
		(http://golang.org/pkg/time/#ParseDuration).
		
		For example, "@every 1h30m10s" would indicate a schedule that activates after
		1 hour, 30 minutes, 10 seconds, and then every interval after that.
		
		Note: The interval does not take the job runtime into account.  For example,
		if a job takes 3 minutes to run, and it is scheduled to run every 5 minutes,
		it will have only 2 minutes of idle time between each run.
		
		Time zones
		
		By default, all interpretation and scheduling is done in the machine's local
		time zone (time.Local). You can specify a different time zone on construction:
		
		      cron.New(
		          cron.WithLocation(time.UTC))
		
		Individual cron schedules may also override the time zone they are to be
		interpreted in by providing an additional space-separated field at the beginning
		of the cron spec, of the form "CRON_TZ=Asia/Tokyo".
		
		For example:
		
			# Runs at 6am in time.Local
			cron.New().AddFunc("0 6 * * ?", ...)
		
			# Runs at 6am in America/New_York
			nyc, _ := time.LoadLocation("America/New_York")
			c := cron.New(cron.WithLocation(nyc))
			c.AddFunc("0 6 * * ?", ...)
		
			# Runs at 6am in Asia/Tokyo
			cron.New().AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", ...)
		
			# Runs at 6am in Asia/Tokyo
			c := cron.New(cron.WithLocation(nyc))
			c.SetLocation("America/New_York")
			c.AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", ...)
		
		The prefix "TZ=(TIME ZONE)" is also supported for legacy compatibility.
		
		Be aware that jobs scheduled during daylight-savings leap-ahead transitions will
		not be run!
		
		Job Wrappers
		
		A Cron runner may be configured with a chain of job wrappers to add
		cross-cutting functionality to all submitted jobs. For example, they may be used
		to achieve the following effects:
		
		  - Recover any panics from jobs (activated by default)
		  - Delay a job's execution if the previous run hasn't completed yet
		  - Skip a job's execution if the previous run hasn't completed yet
		  - Log each job's invocations
		
		Install wrappers for all jobs added to a cron using the `cron.WithChain` option:
		
			cron.New(cron.WithChain(
				cron.SkipIfStillRunning(logger),
			))
		
		Install wrappers for individual jobs by explicitly wrapping them:
		
			job = cron.NewChain(
				cron.SkipIfStillRunning(logger),
			).Then(job)
		
		Thread safety
		
		Since the Cron service runs concurrently with the calling code, some amount of
		care must be taken to ensure proper synchronization.
		
		All cron methods are designed to be correctly synchronized as long as the caller
		ensures that invocations have a clear happens-before ordering between them.
		
		Logging
		
		Cron defines a Logger interface that is a subset of the one defined in
		github.com/go-logr/logr. It has two logging levels (Info and Error), and
		parameters are key/value pairs. This makes it possible for cron logging to plug
		into structured logging systems. An adapter, [Verbose]PrintfLogger, is provided
		to wrap the standard library *log.Logger.
		
		For additional insight into Cron operations, verbose logging may be activated
		which will record job runs, scheduling decisions, and added or removed jobs.
		Activate it with a one-off logger as follows:
		
			cron.New(
				cron.WithLogger(
					cron.VerbosePrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))))
		
		Implementation
		
		Cron entries are stored in an array, sorted by their next activation time.  Cron
		sleeps until the next job is due to be run.
		
		Upon waking:
		 - it runs each entry that is active on that second
		 - it calculates the next run times for the jobs that were run
		 - it re-sorts the array of entries by next activation time.
		 - it goes to sleep until the soonest job.

	    logger.go
	    option.go
	    parser.go
	    spec.go
Package-Level Type Names (total 15)

	/* sort by: alphabet | popularity */
	 type Chain (struct)
		Chain is a sequence of JobWrappers that decorates submitted jobs with
		cross-cutting behaviors like logging or synchronization.

		Methods (only one)
			( Chain) Then(j Job) Job
				Then decorates the given job with all JobWrappers in the chain.
				
				This:
				    NewChain(m1, m2, m3).Then(job)
				is equivalent to:
				    m1(m2(m3(job)))

		As Outputs Of (at least one exported)
			func NewChain(c ...JobWrapper) Chain

	 type ConstantDelaySchedule (struct)
		ConstantDelaySchedule represents a simple recurring duty cycle, e.g. "Every 5 minutes".
		It does not support jobs more frequent than once a second.

		Fields (only one)
			Delay time.Duration
		Methods (only one)
			( ConstantDelaySchedule) Next(t time.Time) time.Time
				Next returns the next time this should be run.
				This rounds so that the next activation time will be on the second.

		Implements (at least one exported)
			 ConstantDelaySchedule : Schedule
		As Outputs Of (at least one exported)
			func Every(duration time.Duration) ConstantDelaySchedule

	 type Cron (struct)
		Cron keeps track of any number of entries, invoking the associated func as
		specified by the schedule. It may be started, stopped, and the entries may
		be inspected while running.

		Methods (total 10)
			(*Cron) AddFunc(spec string, cmd func()) (EntryID, error)
				AddFunc adds a func to the Cron to be run on the given schedule.
				The spec is parsed using the time zone of this Cron instance as the default.
				An opaque ID is returned that can be used to later remove it.

			(*Cron) AddJob(spec string, cmd Job) (EntryID, error)
				AddJob adds a Job to the Cron to be run on the given schedule.
				The spec is parsed using the time zone of this Cron instance as the default.
				An opaque ID is returned that can be used to later remove it.

			(*Cron) Entries() []Entry
				Entries returns a snapshot of the cron entries.

			(*Cron) Entry(id EntryID) Entry
				Entry returns a snapshot of the given entry, or nil if it couldn't be found.

			(*Cron) Location() *time.Location
				Location gets the time zone location

			(*Cron) Remove(id EntryID)
				Remove an entry from being run in the future.

			(*Cron) Run()
				Run the cron scheduler, or no-op if already running.

			(*Cron) Schedule(schedule Schedule, cmd Job) EntryID
				Schedule adds a Job to the Cron to be run on the given schedule.
				The job is wrapped with the configured Chain.

			(*Cron) Start()
				Start the cron scheduler in its own goroutine, or no-op if already started.

			(*Cron) Stop() context.Context
				Stop stops the cron scheduler if it is running; otherwise it does nothing.
				A context is returned so the caller can wait for running jobs to complete.

		Implements (at least one exported)
			*Cron : Job
		As Outputs Of (at least one exported)
			func New(opts ...Option) *Cron

	 type Entry (struct)
		Entry consists of a schedule and the func to execute on that schedule.

		Fields (total 6)
			ID EntryID
				ID is the cron-assigned ID of this entry, which may be used to look up a
				snapshot or remove it.

			Job Job
				Job is the thing that was submitted to cron.
				It is kept around so that user code that needs to get at the job later,
				e.g. via Entries() can do so.

			Next time.Time
				Next time the job will run, or the zero time if Cron has not been
				started or this entry's schedule is unsatisfiable

			Prev time.Time
				Prev is the last time this job was run, or the zero time if never.

			Schedule Schedule
				Schedule on which this job should be run.

			WrappedJob Job
				WrappedJob is the thing to run when the Schedule is activated.

		Methods (only one)
			( Entry) Valid() bool
				Valid returns true if this is not the zero entry.

		As Outputs Of (at least 2)
			func (*Cron).Entries() []Entry
			func (*Cron).Entry(id EntryID) Entry

	 type EntryID int (basic type)
		EntryID identifies an entry within a Cron instance

		As Outputs Of (at least 3)
			func (*Cron).AddFunc(spec string, cmd func()) (EntryID, error)
			func (*Cron).AddJob(spec string, cmd Job) (EntryID, error)
			func (*Cron).Schedule(schedule Schedule, cmd Job) EntryID
		As Inputs Of (at least 2)
			func (*Cron).Entry(id EntryID) Entry
			func (*Cron).Remove(id EntryID)

	 type FuncJob (func)
		FuncJob is a wrapper that turns a func() into a cron.Job

		Methods (only one)
			( FuncJob) Run()
		Implements (at least one exported)
			 FuncJob : Job

	 type Job (interface)
		Job is an interface for submitted cron jobs.

		Methods (only one)
			( Job) Run()
		Implemented By (at least 2)
			*Cron
			 FuncJob
		As Outputs Of (at least one exported)
			func Chain.Then(j Job) Job
		As Inputs Of (at least 3)
			func Chain.Then(j Job) Job
			func (*Cron).AddJob(spec string, cmd Job) (EntryID, error)
			func (*Cron).Schedule(schedule Schedule, cmd Job) EntryID

	 type JobWrapper (func)
		JobWrapper decorates the given Job with some behavior.

		As Outputs Of (at least 3)
			func DelayIfStillRunning(logger Logger) JobWrapper
			func Recover(logger Logger) JobWrapper
			func SkipIfStillRunning(logger Logger) JobWrapper
		As Inputs Of (at least 2)
			func NewChain(c ...JobWrapper) Chain
			func WithChain(wrappers ...JobWrapper) Option

	 type Logger (interface)
		Logger is the interface used in this package for logging, so that any backend
		can be plugged in. It is a subset of the github.com/go-logr/logr interface.

		Methods (total 2)
			( Logger) Error(err error, msg string, keysAndValues ...interface{})
				Error logs an error condition.

			( Logger) Info(msg string, keysAndValues ...interface{})
				Info logs routine messages about cron's operation.

		As Outputs Of (at least 2)
			func PrintfLogger(l interface{Printf(string, ...interface{})}) Logger
			func VerbosePrintfLogger(l interface{Printf(string, ...interface{})}) Logger
		As Inputs Of (at least 4)
			func DelayIfStillRunning(logger Logger) JobWrapper
			func Recover(logger Logger) JobWrapper
			func SkipIfStillRunning(logger Logger) JobWrapper
			func WithLogger(logger Logger) Option
		As Types Of (total 2)
			  var DefaultLogger
			  var DiscardLogger

	 type Option (func)
		Option represents a modification to the default behavior of a Cron.

		As Outputs Of (at least 5)
			func WithChain(wrappers ...JobWrapper) Option
			func WithLocation(loc *time.Location) Option
			func WithLogger(logger Logger) Option
			func WithParser(p ScheduleParser) Option
			func WithSeconds() Option
		As Inputs Of (at least one exported)
			func New(opts ...Option) *Cron

	 type ParseOption int (basic type)
		Configuration options for creating a parser. Most options specify which
		fields should be included, while others enable features. If a field is not
		included the parser will assume a default value. These options do not change
		the order fields are parse in.

		As Inputs Of (at least one exported)
			func NewParser(options ParseOption) Parser
		As Types Of (total 9)
			const Descriptor
			const Dom
			const Dow
			const DowOptional
			const Hour
			const Minute
			const Month
			const Second
			const SecondOptional

	 type Parser (struct)
		A custom Parser that can be configured.

		Methods (only one)
			( Parser) Parse(spec string) (Schedule, error)
				Parse returns a new crontab schedule representing the given spec.
				It returns a descriptive error if the spec is not valid.
				It accepts crontab specs and features configured by NewParser.

		Implements (at least one exported)
			 Parser : ScheduleParser
		As Outputs Of (at least one exported)
			func NewParser(options ParseOption) Parser

	 type Schedule (interface)
		Schedule describes a job's duty cycle.

		Methods (only one)
			( Schedule) Next(time.Time) time.Time
				Next returns the next activation time, later than the given time.
				Next is invoked initially, and then each time the job is run.

		Implemented By (at least 2)
			 ConstantDelaySchedule
			*SpecSchedule
		As Outputs Of (at least 3)
			func ParseStandard(standardSpec string) (Schedule, error)
			func Parser.Parse(spec string) (Schedule, error)
			func ScheduleParser.Parse(spec string) (Schedule, error)
		As Inputs Of (at least one exported)
			func (*Cron).Schedule(schedule Schedule, cmd Job) EntryID

	 type ScheduleParser (interface)
		ScheduleParser is an interface for schedule spec parsers that return a Schedule

		Methods (only one)
			( ScheduleParser) Parse(spec string) (Schedule, error)
		Implemented By (at least one exported)
			 Parser
		As Inputs Of (at least one exported)
			func WithParser(p ScheduleParser) Option

	 type SpecSchedule (struct)
		SpecSchedule specifies a duty cycle (to the second granularity), based on a
		traditional crontab specification. It is computed initially and stored as bit sets.

		Fields (total 7)
			Dom uint64
			Dow uint64
			Hour uint64
			Location *time.Location
				Override location for this schedule.

			Minute uint64
			Month uint64
			Second uint64
		Methods (only one)
			(*SpecSchedule) Next(t time.Time) time.Time
				Next returns the next time this schedule is activated, greater than the given
				time.  If no time can be found to satisfy the schedule, return the zero time.

		Implements (at least one exported)
			*SpecSchedule : Schedule


Package-Level Functions (total 15)

	 func DelayIfStillRunning(logger Logger) JobWrapper
		DelayIfStillRunning serializes jobs, delaying subsequent runs until the
		previous one is complete. Jobs running after a delay of more than a minute
		have the delay logged at Info.

	 func Every(duration time.Duration) ConstantDelaySchedule
		Every returns a crontab Schedule that activates once every duration.
		Delays of less than a second are not supported (will round up to 1 second).
		Any fields less than a Second are truncated.

	 func New(opts ...Option) *Cron
		New returns a new Cron job runner, modified by the given options.
		
		Available Settings
		
		  Time Zone
		    Description: The time zone in which schedules are interpreted
		    Default:     time.Local
		
		  Parser
		    Description: Parser converts cron spec strings into cron.Schedules.
		    Default:     Accepts this spec: https://en.wikipedia.org/wiki/Cron
		
		  Chain
		    Description: Wrap submitted jobs to customize behavior.
		    Default:     A chain that recovers panics and logs them to stderr.
		
		See "cron.With*" to modify the default behavior.

	 func NewChain(c ...JobWrapper) Chain
		NewChain returns a Chain consisting of the given JobWrappers.

	 func NewParser(options ParseOption) Parser
		NewParser creates a Parser with custom options.
		
		It panics if more than one Optional is given, since it would be impossible to
		correctly infer which optional is provided or missing in general.
		
		Examples
		
		 // Standard parser without descriptors
		 specParser := NewParser(Minute | Hour | Dom | Month | Dow)
		 sched, err := specParser.Parse("0 0 15 */3 *")
		
		 // Same as above, just excludes time fields
		 subsParser := NewParser(Dom | Month | Dow)
		 sched, err := specParser.Parse("15 */3 *")
		
		 // Same as above, just makes Dow optional
		 subsParser := NewParser(Dom | Month | DowOptional)
		 sched, err := specParser.Parse("15 */3")

	 func ParseStandard(standardSpec string) (Schedule, error)
		ParseStandard returns a new crontab schedule representing the given
		standardSpec (https://en.wikipedia.org/wiki/Cron). It requires 5 entries
		representing: minute, hour, day of month, month and day of week, in that
		order. It returns a descriptive error if the spec is not valid.
		
		It accepts
		  - Standard crontab specs, e.g. "* * * * ?"
		  - Descriptors, e.g. "@midnight", "@every 1h30m"

	 func PrintfLogger(l interface{Printf(string, ...interface{})}) Logger
		PrintfLogger wraps a Printf-based logger (such as the standard library "log")
		into an implementation of the Logger interface which logs errors only.

	 func Recover(logger Logger) JobWrapper
		Recover panics in wrapped jobs and log them with the provided logger.

	 func SkipIfStillRunning(logger Logger) JobWrapper
		SkipIfStillRunning skips an invocation of the Job if a previous invocation is
		still running. It logs skips to the given logger at Info level.

	 func VerbosePrintfLogger(l interface{Printf(string, ...interface{})}) Logger
		VerbosePrintfLogger wraps a Printf-based logger (such as the standard library
		"log") into an implementation of the Logger interface which logs everything.

	 func WithChain(wrappers ...JobWrapper) Option
		WithChain specifies Job wrappers to apply to all jobs added to this cron.
		Refer to the Chain* functions in this package for provided wrappers.

	 func WithLocation(loc *time.Location) Option
		WithLocation overrides the timezone of the cron instance.

	 func WithLogger(logger Logger) Option
		WithLogger uses the provided logger.

	 func WithParser(p ScheduleParser) Option
		WithParser overrides the parser used for interpreting job schedules.

	 func WithSeconds() Option
		WithSeconds overrides the parser used for interpreting job schedules to
		include a seconds field as the first one.


Package-Level Variables (total 2)

	  var DefaultLogger Logger
		DefaultLogger is used by Cron if none is specified.

	  var DiscardLogger Logger
		DiscardLogger can be used by callers to discard all log messages.


Package-Level Constants (total 9)

	const Descriptor ParseOption = 256 // Allow descriptors such as @monthly, @weekly, etc.
	const Dom ParseOption = 16 // Day of month field, default *
	const Dow ParseOption = 64 // Day of week field, default *
	const DowOptional ParseOption = 128 // Optional day of week field, default *
	const Hour ParseOption = 8 // Hours field, default 0
	const Minute ParseOption = 4 // Minutes field, default 0
	const Month ParseOption = 32 // Month field, default *
	const Second ParseOption = 1 // Seconds field, default 0
	const SecondOptional ParseOption = 2 // Optional seconds field, default 0

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.