gron, Cron Jobs in Go.

roylee0704

Last update: Dec 20, 2022

Overview

gron

Gron provides a clear syntax for writing and deploying cron jobs.

Goals

Minimalist APIs for scheduling jobs.
Thread safety.
Customizable Job Type.
Customizable Schedule.

Installation

$ go get github.com/roylee0704/gron

Usage

Create schedule.go

package main

import (
	"fmt"
	"time"
	"github.com/roylee0704/gron"
)

func main() {
	c := gron.New()
	c.AddFunc(gron.Every(1*time.Hour), func() {
		fmt.Println("runs every hour.")
	})
	c.Start()
}

Schedule Parameters

All scheduling is done in the machine's local time zone (as provided by the Go time package).

Setup basic periodic schedule with gron.Every().

gron.Every(1*time.Second)
gron.Every(1*time.Minute)
gron.Every(1*time.Hour)

Also support Day, Week by importing gron/xtime:

import "github.com/roylee0704/gron/xtime"

gron.Every(1 * xtime.Day)
gron.Every(1 * xtime.Week)

Schedule to run at specific time with .At(hh:mm)

gron.Every(30 * xtime.Day).At("00:00")
gron.Every(1 * xtime.Week).At("23:59")

Custom Job Type

You may define custom job types by implementing gron.Job interface: Run().

For example:

type Reminder struct {
	Msg string
}

func (r Reminder) Run() {
  fmt.Println(r.Msg)
}

After job has defined, instantiate it and schedule to run in Gron.

c := gron.New()
r := Reminder{ "Feed the baby!" }
c.Add(gron.Every(8*time.Hour), r)
c.Start()

Custom Job Func

You may register Funcs to be executed on a given schedule. Gron will run them in their own goroutines, asynchronously.

c := gron.New()
c.AddFunc(gron.Every(1*time.Second), func() {
	fmt.Println("runs every second")
})
c.Start()

Custom Schedule

Schedule is the interface that wraps the basic Next method: Next(p time.Duration) time.Time

In gron, the interface value Schedule has the following concrete types:

periodicSchedule. adds time instant t to underlying period p.
atSchedule. reoccurs every period p, at time components(hh:mm).

For more info, checkout schedule.go.

Full Example

package main

import (
	"fmt"
	"github.com/roylee0704/gron"
	"github.com/roylee0704/gron/xtime"
)

type PrintJob struct{ Msg string }

func (p PrintJob) Run() {
	fmt.Println(p.Msg)
}

func main() {

	var (
		// schedules
		daily     = gron.Every(1 * xtime.Day)
		weekly    = gron.Every(1 * xtime.Week)
		monthly   = gron.Every(30 * xtime.Day)
		yearly    = gron.Every(365 * xtime.Day)

		// contrived jobs
		purgeTask = func() { fmt.Println("purge aged records") }
		printFoo  = printJob{"Foo"}
		printBar  = printJob{"Bar"}
	)

	c := gron.New()

	c.Add(daily.At("12:30"), printFoo)
	c.AddFunc(weekly, func() { fmt.Println("Every week") })
	c.Start()

	// Jobs may also be added to a running Gron
	c.Add(monthly, printBar)
	c.AddFunc(yearly, purgeTask)

	// Stop Gron (running jobs are not halted).
	c.Stop()
}

Comments

Run Every hour at a specific time

gron.Every(1 * time.Hour).At("00:30"), func() { fmt.Println("Every hour on the half hour") })

crontab: 0 30 * * * *

My use case is that I want to run every hour: job1 at 00:30 job2 at 00:40

opened by hexadecy 5
Fix data race in Add method

It uses a mutex lock on the global variables 'running' and 'entries'.

Defines a new method 'isActive' to deal with re-entrant lock issue.

In reference to the issue #3.

opened by pravj 0
UTC time using in AtSchedule

Hi， You mentioned ‘All scheduling is done in the machine's local time zone (as provided by the Go time package).’ in the REAMME.md.

In the implementation of AtSchedule a UTC time is used in reset() function. Shouldn't that be time.Local?

opened by TechieYork 1

Data race in Add method

Using channel based synchronization in Add method prevents the data races when the cron instance is running.

Although, it can't stop them when the cron instance is inactive.

package main

import (
  "fmt"
  "time"
  "github.com/roylee0704/gron"
)

func main() {
  blocker := make(chan int)
  g := gron.New()

  g.AddFunc(gron.Every(4*time.Second), func() {
    fmt.Println("J-1/4")
  })
  g.AddFunc(gron.Every(3*time.Second), func() {
    fmt.Println("J-2/3")
  })

  // this will access (write) the shared state 'entries' concurrently
  go func() {
    g.AddFunc(gron.Every(2*time.Second), func() {
      fmt.Println("J-3/2")
    })
  }()

  g.Start()

  <-blocker
}

Running this with Golang's Race Detector will report the data race.

$ go run -race main.go

I propose to use Mutex for this particular case.

cc @roylee0704

opened by pravj 0

use local time instead of utc for atScheduling

I got GMT+3 time zone, so when i write gron.Every(1 * xtime.Day).At("19:32") i expect function will be triggered at 19:32 local time, not UTC time (which is 3 hours difference in my case). Tests are green, looks like no side effects.

opened by postromantic 1

Owner

roylee0704

Software Engineer

GitHub

Gron - gron transforms JSON into discrete assignments to make it easier to grep for what you want and see the absolute 'path' to it

gron Make JSON greppable! gron transforms JSON into discrete assignments to make

0 Feb 14, 2022

Run Jobs on a schedule, supports fixed interval, timely, and cron-expression timers; Instrument your processes and expose metrics for each job.

A simple process manager that allows you to specify a Schedule that execute a Job based on a Timer. Schedule manage the state of this job allowing you to start/stop/restart in concurrent safe way. Schedule also instrument this Job and gather metrics and optionally expose them via uber-go/tally scope.

58 Dec 8, 2022

Graceful shutdown with repeating "cron" jobs (running at a regular interval) in Go

Graceful shutdown with repeating "cron" jobs (running at a regular interval) in Go Illustrates how to implement the following in Go: run functions ("j

1 May 30, 2022

Gron transforms JSON into discrete assignments to make it easier to grep

gron Make JSON greppable! gron transforms JSON into discrete assignments to make it easier to grep for what you want and see the absolute 'path' to it

0 Nov 11, 2021

A simple Cron library for go that can execute closures or functions at varying intervals, from once a second to once a year on a specific date and time. Primarily for web applications and long running daemons.

Cron.go This is a simple library to handle scheduled tasks. Tasks can be run in a minimum delay of once a second--for which Cron isn't actually design