feat(automations): 自动化引擎（cron 调度 + 事件触发 + AI 管线动作 + 提醒调度，bus automation.result/reminder.trigger）
This commit is contained in:
Aska committed
1 parent
a3f6f4f687
commit
ff34b62079
10 files changed
+1818
No files matched your search
@@ -0,0 +1,208 @@
|
||||
package automations
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"git.yeij.top/AskaEth/Cyrene_v2/internal/bus"
|
||||
"github.com/robfig/cron/v3"
|
||||
)
|
||||
|
||||
// schedulerStopWait bounds how long Stop waits for in-flight schedule jobs to
|
||||
// finish before giving up and returning. It prevents a blocked job from leaking
|
||||
// the Stop caller.
|
||||
const schedulerStopWait = 5 * time.Second
|
||||
|
||||
// ScheduleID aliases the cron entry id so callers only need this package's type.
|
||||
type ScheduleID = cron.EntryID
|
||||
|
||||
// parserFor builds the cron spec parser matching cfg. When WithSeconds is set the
|
||||
// parser accepts a leading seconds field (6-field specs); otherwise it accepts
|
||||
// the standard 5-field format. Both accept descriptors such as "@every".
|
||||
func parserFor(cfg Config) cron.Parser {
|
||||
if cfg.WithSeconds {
|
||||
return cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
|
||||
}
|
||||
return cron.NewParser(cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor)
|
||||
}
|
||||
|
||||
// cronLogger adapts an *slog.Logger to the cron.Logger interface so cron's own
|
||||
// operational messages carry the "services/automations" source tag.
|
||||
type cronLogger struct {
|
||||
log *slog.Logger
|
||||
}
|
||||
|
||||
func (c cronLogger) Info(msg string, keysAndValues ...any) { c.log.Info(msg, keysAndValues...) }
|
||||
|
||||
func (c cronLogger) Error(err error, msg string, keysAndValues ...any) {
|
||||
c.log.Error(msg, append([]any{"error", err}, keysAndValues...)...)
|
||||
}
|
||||
|
||||
// Scheduler is the cron-driven automation scheduler. It wraps a robfig/cron/v3
|
||||
// scheduler and runs a registered Action each time its cron expression fires,
|
||||
// publishing the outcome to the bus. It is safe for concurrent use.
|
||||
type Scheduler struct {
|
||||
cfg Config
|
||||
bus bus.Bus
|
||||
log *slog.Logger
|
||||
cron *cron.Cron
|
||||
|
||||
mu sync.RWMutex
|
||||
ctx context.Context
|
||||
cancel context.CancelFunc
|
||||
started bool
|
||||
}
|
||||
|
||||
// New builds a Scheduler. The bus in deps is required; a nil bus returns an error
|
||||
// wrapping ErrNilBus. cfg.Location defaults to time.Local.
|
||||
func New(cfg Config, deps Deps) (*Scheduler, error) {
|
||||
if deps.Bus == nil {
|
||||
return nil, fmt.Errorf("automations: new scheduler: %w", ErrNilBus)
|
||||
}
|
||||
loc := cfg.Location
|
||||
if loc == nil {
|
||||
loc = time.Local
|
||||
}
|
||||
log := sourcedLog(deps.Log)
|
||||
s := &Scheduler{
|
||||
cfg: cfg,
|
||||
bus: deps.Bus,
|
||||
log: log,
|
||||
cron: cron.New(
|
||||
cron.WithLocation(loc),
|
||||
cron.WithParser(parserFor(cfg)),
|
||||
cron.WithLogger(cronLogger{log: log}),
|
||||
),
|
||||
}
|
||||
return s, nil
|
||||
}
|
||||
|
||||
// ValidateCron reports whether expr is a valid cron expression for this
|
||||
// scheduler's configured parser. A parse failure is wrapped with ErrInvalidCron.
|
||||
func (s *Scheduler) ValidateCron(expr string) error {
|
||||
if _, err := parserFor(s.cfg).Parse(expr); err != nil {
|
||||
return fmt.Errorf("automations: invalid cron %q: %w: %v", expr, ErrInvalidCron, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// AddSchedule registers action to run whenever cronExpr fires, returning its
|
||||
// schedule id. The cron expression is validated against the scheduler's parser;
|
||||
// an invalid expression returns an error wrapping ErrInvalidCron. ctx is used
|
||||
// only to bound this call; it does not govern later fires which use the
|
||||
// scheduler's own live context.
|
||||
func (s *Scheduler) AddSchedule(ctx context.Context, cronExpr string, action Action) (ScheduleID, error) {
|
||||
if action == nil {
|
||||
return 0, fmt.Errorf("automations: add schedule: %w", ErrNilAction)
|
||||
}
|
||||
if _, err := parserFor(s.cfg).Parse(cronExpr); err != nil {
|
||||
return 0, fmt.Errorf("automations: add schedule %q: %w: %v", cronExpr, ErrInvalidCron, err)
|
||||
}
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
if err := ctx.Err(); err != nil {
|
||||
return 0, fmt.Errorf("automations: add schedule %q: %w", cronExpr, err)
|
||||
}
|
||||
id, err := s.cron.AddFunc(cronExpr, func() { s.fire(cronExpr, action) })
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("automations: add schedule %q: %w: %v", cronExpr, ErrInvalidCron, err)
|
||||
}
|
||||
s.log.Info("schedule added", "expr", cronExpr, "action", action.Name(), "id", id)
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// RemoveSchedule removes a previously added schedule by id. It is safe to call on
|
||||
// an unknown id.
|
||||
func (s *Scheduler) RemoveSchedule(id ScheduleID) {
|
||||
s.cron.Remove(id)
|
||||
s.log.Info("schedule removed", "id", id)
|
||||
}
|
||||
|
||||
// Entries returns a snapshot of the registered schedules, ordered by the next run
|
||||
// time. It is only populated once the scheduler has been started.
|
||||
func (s *Scheduler) Entries() []cron.Entry {
|
||||
return s.cron.Entries()
|
||||
}
|
||||
|
||||
// Entry returns the schedule registered under id, or the zero Entry when the id
|
||||
// is unknown.
|
||||
func (s *Scheduler) Entry(id ScheduleID) cron.Entry {
|
||||
return s.cron.Entry(id)
|
||||
}
|
||||
|
||||
// Start begins firing registered schedules. Start derives the scheduler's live
|
||||
// context from ctx; cancelling ctx (or calling Stop) stops the scheduler and
|
||||
// cancels in-flight jobs. Start is idempotent.
|
||||
func (s *Scheduler) Start(ctx context.Context) error {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
s.mu.Lock()
|
||||
if s.started {
|
||||
s.mu.Unlock()
|
||||
return nil
|
||||
}
|
||||
s.ctx, s.cancel = context.WithCancel(ctx)
|
||||
s.started = true
|
||||
s.mu.Unlock()
|
||||
s.cron.Start()
|
||||
s.log.Info("scheduler started")
|
||||
return nil
|
||||
}
|
||||
|
||||
// Stop stops the scheduler, cancels in-flight jobs and waits (bounded by
|
||||
// schedulerStopWait) for them to finish. It is idempotent.
|
||||
func (s *Scheduler) Stop(ctx context.Context) error {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
s.mu.Lock()
|
||||
if !s.started {
|
||||
s.mu.Unlock()
|
||||
return nil
|
||||
}
|
||||
s.started = false
|
||||
if s.cancel != nil {
|
||||
s.cancel()
|
||||
s.cancel = nil
|
||||
}
|
||||
s.mu.Unlock()
|
||||
|
||||
done := s.cron.Stop()
|
||||
select {
|
||||
case <-done.Done():
|
||||
s.log.Info("scheduler stopped")
|
||||
return nil
|
||||
case <-ctx.Done():
|
||||
return fmt.Errorf("automations: scheduler stop: %w", ctx.Err())
|
||||
case <-time.After(schedulerStopWait):
|
||||
s.log.Warn("scheduler stop timed out")
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// liveCtx returns the scheduler's live context, or Background before Start.
|
||||
func (s *Scheduler) liveCtx() context.Context {
|
||||
s.mu.RLock()
|
||||
defer s.mu.RUnlock()
|
||||
if s.ctx != nil {
|
||||
return s.ctx
|
||||
}
|
||||
return context.Background()
|
||||
}
|
||||
|
||||
// fire runs one scheduled action. It recovers panics so a misbehaving action
|
||||
// cannot take down the cron scheduler goroutine, and reports its outcome to the
|
||||
// bus through runAction.
|
||||
func (s *Scheduler) fire(cronExpr string, action Action) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
s.log.Error("schedule job panicked", "expr", cronExpr, "panic", r)
|
||||
}
|
||||
}()
|
||||
runAction(s.liveCtx(), s.cfg, s.bus, s.log, "schedule", cronExpr, action, nil)
|
||||
}
|
||||
Reference in new issue
Block a user