types

type CronTrigger ¶

type CronTrigger struct {
	// contains filtered or unexported fields
}

CronTrigger fires on a robfig/cron v3 6-field cron schedule (seconds minute hour dom month dow), e.g. "0 30 9 * * 1-5" for weekdays at 09:30:00.

robfig/cron v3 defaults to 5-field (no seconds); WithSeconds() is used to enable the 6-field format with seconds as the first field.

NOTE: This trigger is used by the internal system job scheduler. User-defined task schedules use 5-field cron expressions without seconds, parsed via cron.ParseStandard() in the task schedule dispatcher.

func NewCronTrigger(expr string) (*CronTrigger, error)

func (t *CronTrigger) Description() string

func (t *CronTrigger) Emit(ctx context.Context, ch chan<- Event)

type Event ¶

type Event struct {
	Type    EventType
	Payload any
}

Event carries a type and an arbitrary payload.

type EventTrigger ¶

type EventTrigger struct {
	// contains filtered or unexported fields
}

EventTrigger forwards events from an external channel. It is the bridge between an event source (e.g. a poller that detects leaks) and the scheduler pipeline. The caller owns the source channel and controls its lifetime; closing it exhausts the trigger.

func NewEventTrigger(ch <-chan Event) *EventTrigger

func (t *EventTrigger) Description() string

func (t *EventTrigger) Emit(ctx context.Context, ch chan<- Event)

type EventType ¶

type EventType string

EventType identifies the kind of event.

const (
	EventLeakDetected EventType = "leak.detected"
)

type IntervalTrigger ¶

type IntervalTrigger struct {
	// contains filtered or unexported fields
}

IntervalTrigger fires on a fixed time interval.

func NewIntervalTrigger(interval time.Duration) (*IntervalTrigger, error)

func (t *IntervalTrigger) Description() string

func (t *IntervalTrigger) Emit(ctx context.Context, ch chan<- Event)

type Job ¶

type Job interface {
	Name() string
	Run(ctx context.Context, ev Event) error
}

Job is the unit of work executed by the scheduler.

type OnceTrigger ¶

type OnceTrigger struct{}

OnceTrigger fires exactly once, immediately when Emit is called. It is useful for jobs that should run once at scheduler startup (e.g. an initial sync before the periodic interval takes over).

func NewOnceTrigger() *OnceTrigger

func (t *OnceTrigger) Description() string

func (t *OnceTrigger) Emit(ctx context.Context, ch chan<- Event)

type Policy ¶

type Policy int

Policy controls what happens when a trigger fires while a job is running.

const (
	// Skip drops the new event if the worker is busy. Default.
	Skip Policy = iota
	// Queue keeps only the latest pending event; delivers it when the worker
	// is free. Earlier events are discarded.
	Queue
	// QueueAll buffers every event and delivers them in FIFO order.
	// Use this when each event carries unique data that must not be dropped.
	QueueAll
	// Replace cancels the current job and starts a new one.
	Replace
)

type Trigger ¶

type Trigger interface {
	// Description returns a human-readable name for logging.
	Description() string

	// Emit writes events into ch until ctx is cancelled or the trigger
	// is exhausted. The scheduler closes ch after Emit returns.
	Emit(ctx context.Context, ch chan<- Event)
}

Trigger defines when events are emitted to the scheduler. Implementations are called in a dedicated goroutine by the scheduler.