add scheduled cron

Author: zhufuyi

pkg/gocron/README.md

@@ -0,0 +1,57 @@
+## gocron
+
+Scheduled task library encapsulated on [cron v3](github.com/robfig/cron).
+
+<br>
+
+### Example of use
+
+```go
+package main
+
+import (
+    "fmt"
+    "time"
+
+    "github.com/zhufuyi/sponge/pkg/gocron"
+)
+
+var task1 = func() {
+     fmt.Println("this is task1")
+     fmt.Println("running task list:", gocron.GetRunningTasks())
+}
+
+var taskOnce = func() {
+	taskName := "taskOnce"
+    fmt.Println("this is taskOnce")
+    gocron.DeleteTask(taskName)
+}
+
+func main() {
+    err := gocron.Init()
+    if err != nil {
+        panic(err)
+    }
+	
+    gocron.Run([]*gocron.Task{
+        {
+            Name:     "task1",
+            TimeSpec: "@every 2s",
+            Fn:       task1,
+        },
+        {
+            Name:     "taskOnce",
+            TimeSpec: "@every 5s",
+            Fn:       taskOnce,
+        },
+    }...)
+
+    time.Sleep(time.Minute)
+
+    // delete task1
+    gocron.DeleteTask("task1")
+
+    // view running tasks
+    fmt.Println("running task list:", gocron.GetRunningTasks())
+}
+```

pkg/gocron/cron.go

@@ -0,0 +1,134 @@
+package gocron
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/robfig/cron/v3"
+)
+
+var (
+	c *cron.Cron
+	// task name and id mapping, used to add, delete, modify and query tasks
+	nameID = sync.Map{}
+	// id and task name mapping, used in log printing
+	idName = sync.Map{}
+)
+
+// Task scheduled task
+type Task struct {
+	// seconds (0-59) minutes (0- 59) hours (0-23) days (1-31) months (1-12) weeks (0-6)
+	// "*/5 * * * * *"  means every five seconds.
+	// "0 15,45 9-12 * * * "  indicates execution at the 15th and 45th minutes from 9 a.m. to 12 a.m. each day
+	TimeSpec string
+
+	Name string // task name
+	Fn   func() // task
+}
+
+// Init initialize and start timed tasks
+func Init(opts ...Option) error {
+	o := defaultOptions()
+	o.apply(opts...)
+
+	log := &zapLog{zapLog: o.zapLog}
+	cronOpts := []cron.Option{
+		cron.WithSeconds(), // second-level granularity, default is minute-level granularity
+		cron.WithLogger(log),
+		cron.WithChain(
+			cron.Recover(log),
+		),
+	}
+
+	c = cron.New(cronOpts...)
+	c.Start()
+
+	return nil
+}
+
+// Run the tasks
+func Run(tasks ...*Task) error {
+	if c == nil {
+		return errors.New("cron is not initialized")
+	}
+
+	var errs []string
+	for _, task := range tasks {
+		if IsRunningTask(task.Name) {
+			errs = append(errs, fmt.Sprintf("task '%s' is already exists", task.Name))
+			continue
+		}
+
+		id, err := c.AddFunc(task.TimeSpec, task.Fn)
+		if err != nil {
+			errs = append(errs, fmt.Sprintf("run task '%s' error: %v", task.Name, err))
+			continue
+		}
+		idName.Store(id, task.Name)
+		nameID.Store(task.Name, id)
+	}
+
+	if len(errs) > 0 {
+		return errors.New(strings.Join(errs, " || "))
+	}
+
+	return nil
+}
+
+// IsRunningTask determine if the task is running
+func IsRunningTask(name string) bool {
+	_, ok := nameID.Load(name)
+	return ok
+}
+
+// GetRunningTasks gets a list of running task names
+func GetRunningTasks() []string {
+	var names []string
+	nameID.Range(func(key, value interface{}) bool {
+		names = append(names, key.(string))
+		return true
+	})
+	return names
+}
+
+// DeleteTask delete task
+func DeleteTask(name string) {
+	if id, ok := nameID.Load(name); ok {
+		entryID, isOk := id.(cron.EntryID)
+		if !isOk {
+			return
+		}
+		c.Remove(entryID)
+		nameID.Delete(name)
+		idName.Delete(entryID)
+	}
+}
+
+// Stop scheduled task
+func Stop() {
+	if c != nil {
+		c.Stop()
+	}
+}
+
+// EverySecond executed every size second (1~59)
+func EverySecond(size int) string {
+	return fmt.Sprintf("@every %ds", size)
+}
+
+// EveryMinute every size minute (1~59)
+func EveryMinute(size int) string {
+	return fmt.Sprintf("@every %dm", size)
+}
+
+// EveryHour every size hour (1~23)
+func EveryHour(size int) string {
+	return fmt.Sprintf("@every %dh", size)
+}
+
+// EveryDay every size day (1~31)
+func EveryDay(size int) string {
+	return fmt.Sprintf("@every %dd", size)
+}

pkg/gocron/cron_test.go

@@ -0,0 +1,124 @@
+package gocron
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestInitAndRun(t *testing.T) {
+	count := 0
+	task1 := func() {
+		fmt.Println("running task list:", GetRunningTasks())
+	}
+	task2 := func() {
+		time.Sleep(time.Second)
+	}
+	task3 := func() {
+		count++
+		if count%3 == 0 {
+			panic("trigger panic")
+		}
+	}
+
+	tasks := []*Task{
+		{
+			Name:     "task1",
+			TimeSpec: "@every 1s",
+			Fn:       task1,
+		},
+		{
+			Name:     "task2",
+			TimeSpec: "@every 2s",
+			Fn:       task2,
+		},
+		{
+			Name:     "task3",
+			TimeSpec: "@every 3s",
+			Fn:       task3,
+		},
+	}
+
+	err := Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = Run(tasks...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	time.Sleep(time.Second * 7)
+}
+
+func TestRunOnce(t *testing.T) {
+	myTask := func() {
+		taskName := "myTask"
+		fmt.Println("running task list:", GetRunningTasks())
+		fmt.Printf("the task '%s' is executed only once\n", taskName)
+		DeleteTask(taskName)
+		fmt.Println("running task list:", GetRunningTasks())
+	}
+
+	tasks := []*Task{
+		{
+			Name:     "myTask",
+			Fn:       myTask,
+			TimeSpec: "@every 2s",
+		},
+	}
+
+	err := Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = Run(tasks...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	time.Sleep(time.Second * 5)
+	Stop()
+}
+
+func TestEvery(t *testing.T) {
+	task_1 := func() {
+		fmt.Println("this is task_1")
+		fmt.Println("running task list:", GetRunningTasks())
+	}
+	task_2 := func() {
+		fmt.Println("this is task_2")
+	}
+	task_3 := func() {
+		fmt.Println("this is task_3")
+	}
+
+	tasks := []*Task{
+		{
+			TimeSpec: EverySecond(5),
+			Name:     "task_1",
+			Fn:       task_1,
+		},
+		{
+			TimeSpec: EveryMinute(1),
+			Name:     "task_2",
+			Fn:       task_2,
+		},
+		{
+			TimeSpec: EveryHour(1),
+			Name:     "task_3",
+			Fn:       task_3,
+		},
+	}
+
+	err := Init()
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = Run(tasks...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	time.Sleep(time.Second * 7)
+}