sparrow/services/timer-service/internal/scheduler.go

package internal

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/container/gmap"
	"github.com/gogf/gf/v2/os/gcron"
	"sparrow/pkg/rule"
	"sparrow/pkg/server"
)

// TaskSchedule task schedule 任务调度
type TaskSchedule struct {
	tasks *gmap.HashMap // 保存任务名称与任务实体的映射
}

func NewTaskSchedule() *TaskSchedule {
	return &TaskSchedule{
		tasks: gmap.NewHashMap(true),
	}
}

func (t *TaskSchedule) AddTask(msg []byte) error {
	var task rule.TimerTaskMessage
	err := json.Unmarshal([]byte(msg), &task)
	if err != nil {
		return err
	}
	fmt.Printf("task_id:%s,corn:%s,actions:%v,", task.TaskId, task.Cron, task.Actions)
	fmt.Printf("tasks:%s", t.tasks)
	// 如果已经存在相同任务Id
	if t.tasks.Contains(task.TaskId) {
		return nil
	}
	// 创建任务
	entity, err := gcron.Add(context.Background(), task.Cron, func(ctx context.Context) {
		if err = NewTaskExecutor(task.Actions).Do(); err != nil {
			server.Log.Errorf("do taskid :%s error:%s", task.TaskId, err.Error())
		}
	}, task.TaskId)
	if err != nil {
		return err
	}
	fmt.Println("-----------------------")
	t.tasks.Set(task.TaskId, entity)
	server.Log.Debugf("add a new timer task :%s", task.TaskId)
	return nil
}

func (t *TaskSchedule) AddMessageHandle(msg *rule.TaskLifecycleMessage) error {
	return nil
}

func (t *TaskSchedule) RemoveMessageHandle(msg *rule.TaskLifecycleMessage) error {

	gcron.Remove(msg.TaskId)
	_ = t.tasks.Remove(msg.TaskId)
	server.Log.Debugf("RemoveMessageHandle :%s", msg.TaskId)
	return nil
}

func (t *TaskSchedule) UpdateMessageHandle(msg *rule.TaskLifecycleMessage) error {

	gcron.Remove(msg.TaskId)

	var task rule.TimerTaskMessage
	_ = json.Unmarshal([]byte(msg.Data), &task)
	entity, err := gcron.Add(context.Background(), task.Cron, func(ctx context.Context) {
		if err := NewTaskExecutor(task.Actions).Do(); err != nil {
			server.Log.Errorf("do taskid :%s error:%s", task.TaskId, err.Error())
		}
	}, task.TaskId)
	if err != nil {
		return err
	}

	t.tasks.Set(task.TaskId, entity)
	server.Log.Debugf("UpdateMessageHandle :%s", task.TaskId)
	return nil
}

func (t *TaskSchedule) SnapMessageHandle(msg *rule.TaskLifecycleMessage) error {
	gcron.Stop(msg.TaskId)

	server.Log.Debugf("SnapMessageHandle :%s", msg.TaskId)
	return nil
}