I am very confused about that why I go get this pkg in my ci,the branch which be download is v3 branch not the master,my cronjob works did't work for 3 days,the most important thing is i don't know why.so could you please give me the reason about that,why!!!!!!!

With some test code:

package main

import (
    "fmt"
    "cron"
    "time"
)

func main() {
    c := cron.New()
    j1, _ := c.AddFunc("* * * * * *", func() { fmt.Println("1") })
    j2, _ := c.AddFunc("* * * * * *", func() { fmt.Println("2") })
    j3, _ := c.AddFunc("* * * * * *", func() { fmt.Println("3") })
    j4, _ := c.AddFunc("* * * * * *", func() { fmt.Println("4") })
    fmt.Println(j1, j2, j3, j4)
    c.RemoveFunc(j2)
    fmt.Println("j2 removed")

    c.Start()

    time.Sleep(time.Second * 5)
    c.RemoveFunc(j1)
    fmt.Println("j1 removed")

    time.Sleep(time.Second * 5)
    c.PauseFunc(j4)
    fmt.Println("j4 paused")

    time.Sleep(time.Second * 5)
    c.ResumeFunc(j4)
    fmt.Println("j4 resumed")
    select {}
}

And the output of the code above:

1 2 3 4
j2 removed
1
3
4
1
3
4
1
3
4
1
3
4
1
3
4
j1 removed
3
4
3
4
3
4
3
4
3
4
j4 paused
3
3
3
3
3
j4 resumed
3
4
3
4
3
4
3
4
3
4

I'm sorry I don't know how to exclude the .gitignore from the pull request, please just ignore it.

when using

c:=cron.New()
c.Start()
time.Sleep(5*time.Second)
c.AddFunc("* * * * * *",myfunc)

the myfunc is

func myfunc(){
fmt.Println(time.Unix(time.Now().Unix(), 0).Format("2006-01-02 15:04:05"))

the output is:(current time is 15:16:07)

2015-11-23 15:16:07  <- first in sleep 5
2015-11-23 15:16:07  <- 2nd in sleep 5
2015-11-23 15:16:07  <- 3rd in sleep 5
2015-11-23 15:16:07  <- 4th in sleep 5
2015-11-23 15:16:07  <- 5th in sleep 5
2015-11-23 15:16:07  <- truely the first second
2015-11-23 15:16:08  <- truely the second second
2015-11-23 15:16:09  <- truely the third second

However,modify cron.go from

// Run the scheduler.. this is private just due to the need to synchronize
// access to the 'running' state variable.
func (c *Cron) Run() {
    // Figure out the next activation times for each entry.
    now := time.Now().Local()
    for _, entry := range c.entries {
        entry.Next = entry.Schedule.Next(now)
    }

    for {

        // Determine the next entry to run.
        sort.Sort(byTime(c.entries))

To

// Run the scheduler.. this is private just due to the need to synchronize
// access to the 'running' state variable.
func (c *Cron) Run() {
    // Figure out the next activation times for each entry.
-   now := time.Now().Local()                                 <--------------assigned 'new' before the for loop
-   for _, entry := range c.entries {                      
-       entry.Next = entry.Schedule.Next(now)
-   }                                                                     

    for {
+       now := time.Now().Local()                     
+       for _, entry := range c.entries {              
+           entry.Next = entry.Schedule.Next(now) 
+       }                                                                      

        // Determine the next entry to run.
        sort.Sort(byTime(c.entries))

may solve this problem.

1. Seconds field is now optional and Dow field is mandatory to support standard GNU/Linux crontab format.

2. An optional TZ= clause (ex : TZ=Europe/London) in the beginning of cron spec to support specification of cron times in that location rather than in the local timezone

Sample usage : c := cron.New() c.AddFunc("TZ=Europe/London 07 21 * * *", func() { fmt.Println("Runs at 21:07 London time") }, "London test") c.Start()

3. Added a function NextNTimes for Entry struct which returns next (upto) N activation times.

4. Added DST support and test cases from github.com/lukescott/cron feature-dst branch

5. Added safe Remove() and its test cases.

This was obviously an error on my part, but discovered that calling Stop without calling Start will block since nothing is receiving c.stop <- struct{}{}. This is definitely a programmer error, I suggest panicking if the cron is not running.

// Stop the cron scheduler.
func (c *Cron) Stop() {
    if !c.running {
        panic("cron: not running")
    }
    c.stop <- struct{}{}
    c.running = false
}

go: downloading github.com/robfig/cron/v3 v3.0.0 go: downloading github.com/robfig/cron v1.2.0 verifying github.com/robfig/cron/[email protected]: github.com/robfig/cron/[email protected]: Get https://sum.golang.org/lookup/github.com/robfig/cron/[email protected]: dial tcp 172.217.24.17:443: connectex: A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond.

08:28:31.667 [trace] entity.go:106 | ##########################1, 1=>[1681,ls /] start run########################## 08:28:31.667 [trace] entity.go:106 | ##########################2, 2=>[1681,ls /] start run########################## 08:28:31.667 [trace] entity.go:106 | ##########################3, 3=>[1681,ls /] start run########################## 08:28:31.674 [trace] entity.go:106 | ##########################4, 4=>[1681,ls /] start run########################## 08:28:31.675 [trace] entity.go:106 | ##########################5, 5=>[1681,ls /] start run########################## 08:28:31.688 [trace] entity.go:106 | ##########################6, 6=>[1681,ls /] start run########################## 08:28:31.701 [trace] entity.go:114 | ##########################1, 1=>[1681,ls /] run end########################## 08:28:31.701 [trace] entity.go:114 | ##########################2, 2=>[1681,ls /] run end########################## 08:28:31.703 [trace] entity.go:114 | ##########################4, 4=>[1681,ls /] run end########################## 08:28:31.710 [trace] entity.go:114 | ##########################6, 6=>[1681,ls /] run end########################## 08:28:31.721 [trace] entity.go:114 | ##########################3, 3=>[1681,ls /] run end##########################

cron set: data := make(url.Values) data.Add("cron_set", "*/1 * * * * *") data.Add("command", "ls /") data.Add("remark", "") data.Add("stop", "0") data.Add("start_time", "0") data.Add("end_time", "0") data.Add("is_mutex", "0")

try to add 4 at the same time, 1681 cron is run many times at one second~

... developer is only ever evaluating static cron specs that aren't configured dynamically. If I wanted to utilize the Parse function in this library, and manage crons through some type of configuration interface, I would have no way to recover from parsing an improperly-formatted spec, other than deferred recover. There is a reason we don't see this practice inside the stdlib. Using errors allows me to recover from that scenario with ease.

// "github.com/robfig/cron/v3"

func main() {
  c := cron.New()
  c.AddFunc("* * * * * *", func() {
    fmt.Println("working")
  })
  c.Start()
  
  select {}
}

use the latest version v3.0.1 and 3.0.0 is also not working, my useage was wrong?

Usage: I'm using package "github.com/robfig/cron/v3" to validate a cron schedule string.

Problem: When I give input as "0 0 * * 0" (for weekly) it returns with error saying invalid schedule. As per your document, v3 supports the standards as per cron wiki page.

This cron schedule was working fine few days ago but has started giving error recently.

Expected outcome: The string should be considered as valid and the code should proceed.

Hello, I think that when Stop() is called on a not running cron, it block the program. Is there a when to know if cron is started ? running is private.

Hi! When using go-cron to work, multiple services are started at the same time, and multiple cron tasks will be executed at the same time? What can be done to ensure that the cron task is only executed once?

This PR uses https://github.com/benbjohnson/clock to mock the time. Adding support for using mock clock with cron will be helpful to write test cases and verify cron behaviour.

Similar to this PR https://github.com/robfig/cron/pull/327 but uses a more up to date mock clock

PR also contains fix for flaky unit tests on windows and minor linting fixes

I would like to be able to remove a job from within the job itself.

A workaround is welcome too :)

If you have an idea on how to implement, I would love to make the PR myself if needed.

Thank you for this amazing package!

First of all, thans for your great cron job. I read dayMatches code in spec.go but did not figure out why you check starBit before return result. Why use || operation when both starBit of dom and dow is 0. I think we always need use && to get result. Could youhelp to explain some details of this? Thanks in advance :)

// dayMatches returns true if the schedule's day-of-week and day-of-month
// restrictions are satisfied by the given time.
func dayMatches(s *SpecSchedule, t time.Time) bool {
	var (
		domMatch bool = 1<<uint(t.Day())&s.Dom > 0
		dowMatch bool = 1<<uint(t.Weekday())&s.Dow > 0
	)
	if s.Dom&starBit > 0 || s.Dow&starBit > 0 {
		return domMatch && dowMatch
	}
	return domMatch || dowMatch
}

Crash

panic: runtime error: slice bounds out of range [:-1]

Crash Log

github.com/robfig/cron/v3.Parser.Parse({0x125d130}, {0x116435c, 0x9}) /Users/ljc/go/pkg/mod/github.com/robfig/cron/[email protected]/parser.go:99 +0x7bc github.com/robfig/cron/v3.ParseStandard(...) /Users/ljc/go/pkg/mod/github.com/robfig/cron/[email protected]/parser.go:230

PoC

cron.ParseStandard("TZ=TZ=TZ=")

When passing the following for AddFunc:

_, err = reportingCron.AddFunc("0 7 * * *", func() { } An entry is registered in cron, when printing out said entry you receive a default time: logrus: time="2022-10-04T13:35:31-07:00" level=info msg="{1 0xc0001e0700 0001-01-01 00:00:00 +0000 UTC 0001-01-01 00:00:00 +0000 UTC 0x8bdd40 0x8bdd40}" fmt.Println: {1 0xc0001e0700 0001-01-01 00:00:00 +0000 UTC 0001-01-01 00:00:00 +0000 UTC 0x8bdd40 0x8bdd40}