Files
pages/internal/store/event_jobs.go
T
Anya Tokugawa a36934e72c
Build and publish container images / images (push) Successful in 16m17s
Release container images / release (push) Successful in 39s
Fix event log writer contention and report persistence failures safely
Take the SQLite writer lock before reading job/policy facts, bound acquisition and cancellation, preserve atomic raw logs and counters, and avoid replaying successful business operations on logging failure. Tested the isolated nine-file release slice with the full Go suite, race tests and go vet.
2026-11-01 19:40:26 +09:00

717 lines
26 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package store
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"time"
"github.com/google/uuid"
"pageswiki/internal/dregarnuhr"
)
// EventJob retains the existing public JSON shape and source compatibility.
type EventJob = dregarnuhr.Job
type EventDefinition struct {
UUID string `json:"uuid"`
Name string `json:"name"`
EventType string `json:"event_type"`
EventKey string `json:"event_key"`
Payload string `json:"payload"`
ScheduleKind string `json:"schedule_kind"`
IntervalSeconds int64 `json:"interval_seconds"`
NextRunAtMS int64 `json:"next_run_at_ms"`
Enabled bool `json:"enabled"`
Priority int `json:"priority"`
MaxAttempts int `json:"max_attempts"`
CreatedAtMS int64 `json:"created_at_ms"`
UpdatedAtMS int64 `json:"updated_at_ms"`
}
type EventLog struct {
ID int64 `json:"id"`
JobUUID string `json:"job_uuid"`
EventUUID string `json:"event_uuid,omitempty"`
EventType string `json:"event_type,omitempty"`
Level string `json:"level"`
Message string `json:"message"`
CreatedAtMS int64 `json:"created_at_ms"`
}
type EventLogPolicy struct {
EventType string `json:"event_type"`
RetentionHours int `json:"retention_hours"`
AggregateAfterHours int `json:"aggregate_after_hours"`
BucketSeconds int `json:"bucket_seconds"`
MaxRows int `json:"max_rows"`
}
type EventLogTrend struct {
EventType string `json:"event_type"`
BucketStartMS int64 `json:"bucket_start_ms"`
Level string `json:"level"`
Count int64 `json:"count"`
FirstAtMS int64 `json:"first_at_ms"`
LastAtMS int64 `json:"last_at_ms"`
SampleMessage string `json:"sample_message,omitempty"`
}
type QueueSettings = dregarnuhr.Settings
type EventJobStats struct {
Queued int `json:"queued"`
Running int `json:"running"`
Succeeded int `json:"succeeded"`
Skipped int `json:"skipped"`
Failed int `json:"failed"`
Cancelled int `json:"cancelled"`
}
var ErrEventSkipped = dregarnuhr.ErrSkipped
func (s *Store) EnsureEventJobsSchema() error {
if err := s.ensureSchemaComponent("event-jobs"); err != nil {
return err
}
return s.recoverInterruptedEventJobs()
}
// Startup recovery mutates runtime state, not schema. Never call it from
// status/preflight, read-only standby or a migration rehearsal.
func (s *Store) recoverInterruptedEventJobs() error {
now := time.Now().UnixMilli()
if _, err := s.DB.Exec(`UPDATE event_jobs SET status='queued',
error=CASE WHEN error='' THEN 'execution interrupted by process restart' ELSE error END,
run_at_ms=?, started_at_ms=0, updated_at_ms=?
WHERE status='running'`, now, now); err != nil {
return err
}
return nil
}
func (s *Store) EnqueueEvent(eventType, eventKey, payload string, runAt time.Time) (bool, error) {
return s.EnqueueEventWithOptions("", eventType, eventKey, payload, runAt, 0, 3)
}
func (s *Store) EnqueueEventWithOptions(eventUUID, eventType, eventKey, payload string, runAt time.Time, priority, maxAttempts int) (bool, error) {
settings, err := s.GetQueueSettings()
if err != nil {
return false, err
}
var depth int
if err := s.DB.QueryRow(`SELECT COUNT(*) FROM event_jobs WHERE status IN ('queued','running')`).Scan(&depth); err != nil {
return false, err
}
if depth >= settings.MaxDepth {
return false, fmt.Errorf("event queue is full (%d)", settings.MaxDepth)
}
if maxAttempts < 1 {
maxAttempts = 1
}
now := time.Now().UnixMilli()
result, err := s.DB.Exec(`
INSERT INTO event_jobs (
uuid, event_uuid, event_type, event_key, payload, status, priority,
attempts, max_attempts, run_at_ms, error, created_at_ms, updated_at_ms
)
SELECT ?, ?, ?, ?, ?, 'queued', ?, 0, ?, ?, '', ?, ?
WHERE NOT EXISTS (
SELECT 1 FROM event_jobs WHERE event_type = ? AND event_key = ?
AND status IN ('queued', 'running')
)`,
uuid.NewString(), eventUUID, eventType, eventKey, payload, priority,
maxAttempts, runAt.UnixMilli(), now, now, eventType, eventKey,
)
if err != nil {
return false, err
}
count, err := result.RowsAffected()
return count > 0, err
}
func scanEventJob(scanner interface{ Scan(...any) error }) (*EventJob, error) {
var job EventJob
var cancelled int
err := scanner.Scan(
&job.UUID, &job.EventUUID, &job.Type, &job.Key, &job.Payload,
&job.Status, &job.Priority, &job.Attempts, &job.MaxAttempts,
&job.RunAtMS, &job.StartedAtMS, &job.FinishedAtMS, &cancelled,
&job.Error, &job.CreatedAt, &job.UpdatedAt,
)
job.CancelRequested = cancelled != 0
return &job, err
}
const eventJobColumns = `uuid, event_uuid, event_type, event_key, payload,
status, priority, attempts, max_attempts, run_at_ms, started_at_ms,
finished_at_ms, cancel_requested, error, created_at_ms, updated_at_ms`
func (s *Store) ClaimDueEvent() (*EventJob, error) {
return s.ClaimDueEventAt(context.Background(), time.Now())
}
// ClaimDueEventAt keeps selection and claim in one statement; injected time
// allows scheduler tests without real sleeps or production data.
func (s *Store) ClaimDueEventAt(ctx context.Context, at time.Time) (*EventJob, error) {
if s.ReadOnly {
return nil, ErrReadOnly
}
now := at.UnixMilli()
// A deferred SELECT transaction cannot always upgrade its WAL snapshot to a
// writer (SQLITE_BUSY[_SNAPSHOT]), even with busy_timeout. Select and claim in
// one write statement instead. SQLite serializes concurrent claimers; RETURNING
// gives the committed attempt/status/timestamps, not the pre-claim snapshot.
return scanEventJob(s.DB.QueryRowContext(ctx, `
UPDATE event_jobs SET status='running', attempts=attempts+1,
started_at_ms=?, updated_at_ms=?
WHERE uuid=(SELECT uuid FROM event_jobs
WHERE status='queued' AND run_at_ms<=?
ORDER BY priority DESC,run_at_ms,created_at_ms,uuid LIMIT 1)
AND status='queued'
RETURNING `+eventJobColumns, now, now, now))
}
func (s *Store) FinishEvent(uuid string, runErr error) error {
return s.FinishEventAt(context.Background(), uuid, runErr, time.Now())
}
func (s *Store) FinishEventAt(ctx context.Context, uuid string, runErr error, at time.Time) error {
job, err := scanEventJob(s.DB.QueryRowContext(ctx, `SELECT `+eventJobColumns+` FROM event_jobs WHERE uuid=?`, uuid))
if err != nil {
return err
}
base := 1
if runErr != nil && !errors.Is(runErr, ErrEventSkipped) && !job.CancelRequested && job.Attempts < job.MaxAttempts {
settings, err := s.GetQueueSettings()
if err != nil {
return err
}
base = settings.RetryBaseSeconds
}
outcome := dregarnuhr.Complete(*job, runErr, base, at)
if outcome.Status == "queued" {
_, err = s.DB.ExecContext(ctx, `UPDATE event_jobs SET status='queued', error=?,
run_at_ms=?, finished_at_ms=0, updated_at_ms=? WHERE uuid=?`,
outcome.Message, outcome.RetryAt.UnixMilli(), at.UnixMilli(), uuid)
if err == nil {
err = s.addEventCompletionLog(ctx, uuid, job.EventUUID, outcome.Level, "execution failed; retry scheduled: "+outcome.Message)
}
return err
}
_, err = s.DB.ExecContext(ctx, `UPDATE event_jobs SET status=?, error=?,
finished_at_ms=?, updated_at_ms=? WHERE uuid=?`,
outcome.Status, outcome.Message, at.UnixMilli(), at.UnixMilli(), uuid)
message := outcome.Status
if outcome.Message != "" {
message += ": " + outcome.Message
}
if err == nil {
err = s.addEventCompletionLog(ctx, uuid, job.EventUUID, outcome.Level, message)
}
return err
}
func (s *Store) EventStats() (EventJobStats, error) {
return s.eventStats(`SELECT status, COUNT(*) FROM event_jobs GROUP BY status`)
}
// Live monitoring must not count the entire retained execution history every
// few seconds. The status index restricts this to the active queue.
func (s *Store) ActiveEventStats() (EventJobStats, error) {
return s.eventStats(`SELECT status, COUNT(*) FROM event_jobs WHERE status IN ('queued','running') GROUP BY status`)
}
func (s *Store) eventStats(query string) (EventJobStats, error) {
var stats EventJobStats
rows, err := s.DB.Query(query)
if err != nil {
return stats, err
}
defer rows.Close()
for rows.Next() {
var status string
var count int
if err := rows.Scan(&status, &count); err != nil {
return stats, err
}
switch status {
case "queued":
stats.Queued = count
case "running":
stats.Running = count
case "succeeded":
stats.Succeeded = count
case "skipped":
stats.Skipped = count
case "failed":
stats.Failed = count
case "cancelled":
stats.Cancelled = count
}
}
return stats, rows.Err()
}
func (s *Store) ListEventJobs(limit int) ([]EventJob, error) {
if limit < 1 || limit > 500 {
limit = 100
}
rows, err := s.DB.Query(`SELECT `+eventJobColumns+` FROM event_jobs ORDER BY created_at_ms DESC LIMIT ?`, limit)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]EventJob, 0)
for rows.Next() {
job, err := scanEventJob(rows)
if err != nil {
return nil, err
}
out = append(out, *job)
}
return out, rows.Err()
}
func (s *Store) CancelEventJob(jobUUID string) error {
result, err := s.DB.Exec(`UPDATE event_jobs SET
status=CASE WHEN status='queued' THEN 'cancelled' ELSE status END,
cancel_requested=1, finished_at_ms=CASE WHEN status='queued' THEN ? ELSE finished_at_ms END,
updated_at_ms=? WHERE uuid=? AND status IN ('queued','running')`,
time.Now().UnixMilli(), time.Now().UnixMilli(), jobUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
return s.AddEventLog(jobUUID, "", "warning", "cancellation requested")
}
// CancelEventJobsByTypeKey is used when the resource that owns queued work is
// deleted. Historical jobs are retained; queued jobs become cancelled and a
// running worker observes cancel_requested before committing its result.
func (s *Store) CancelEventJobsByTypeKey(eventType, eventKey string) error {
now := time.Now().UnixMilli()
_, err := s.DB.Exec(`UPDATE event_jobs SET
status=CASE WHEN status='queued' THEN 'cancelled' ELSE status END,
cancel_requested=1,
finished_at_ms=CASE WHEN status='queued' THEN ? ELSE finished_at_ms END,
updated_at_ms=?
WHERE event_type=? AND event_key=? AND status IN ('queued','running')`,
now, now, eventType, eventKey)
return err
}
func (s *Store) RetryEventJob(jobUUID string) error {
result, err := s.DB.Exec(`UPDATE event_jobs SET status='queued', attempts=0,
cancel_requested=0, error='', run_at_ms=?, started_at_ms=0,
finished_at_ms=0, updated_at_ms=? WHERE uuid=?
AND status IN ('failed','cancelled','skipped')`,
time.Now().UnixMilli(), time.Now().UnixMilli(), jobUUID)
if err != nil {
return err
}
count, _ := result.RowsAffected()
if count == 0 {
return sql.ErrNoRows
}
return s.AddEventLog(jobUUID, "", "info", "manually requeued")
}
func (s *Store) EventCancellationRequested(jobUUID string) bool {
requested, err := s.EventCancellationState(context.Background(), jobUUID)
return err == nil && requested
}
// EventCancellationState lets the runner distinguish a read failure from a
// confirmed absence of cancellation. The boolean compatibility API stays.
func (s *Store) EventCancellationState(ctx context.Context, jobUUID string) (bool, error) {
var requested int
err := s.DB.QueryRowContext(ctx, `SELECT cancel_requested FROM event_jobs WHERE uuid=?`, jobUUID).Scan(&requested)
return requested != 0, err
}
func (s *Store) PurgeEventHistory(retentionHours int) error {
if retentionHours < 1 {
return errors.New("retention hours must be positive")
}
cutoff := time.Now().Add(-time.Duration(retentionHours) * time.Hour).UnixMilli()
// Keep explicit event policies authoritative. The wildcard policy and
// unknown jobs use the queue-level retention as their fallback.
if _, err := s.DB.Exec(`DELETE FROM event_logs AS l WHERE l.created_at_ms < ? AND NOT EXISTS (
SELECT 1 FROM event_jobs j JOIN event_log_policies p ON p.event_type=j.event_type
WHERE (j.uuid=l.job_uuid OR (j.event_uuid<>'' AND j.event_uuid=l.event_uuid))
)`, cutoff); err != nil {
return err
}
if _, err := s.DB.Exec(`DELETE FROM event_log_buckets AS b WHERE b.bucket_start_ms < ? AND NOT EXISTS (
SELECT 1 FROM event_log_policies p WHERE p.event_type=b.event_type AND p.event_type<>'*'
)`, cutoff); err != nil {
return err
}
policies, err := s.ListEventLogPolicies()
if err != nil {
return err
}
now := time.Now()
for _, policy := range policies {
if policy.EventType == "*" {
continue
}
policyCutoff := now.Add(-time.Duration(policy.RetentionHours) * time.Hour).UnixMilli()
if policy.AggregateAfterHours > 0 {
aggregateCutoff := now.Add(-time.Duration(policy.AggregateAfterHours) * time.Hour).UnixMilli()
if aggregateCutoff > policyCutoff {
policyCutoff = aggregateCutoff
}
}
if _, err := s.DB.Exec(`DELETE FROM event_logs AS l WHERE l.created_at_ms < ? AND EXISTS (
SELECT 1 FROM event_jobs j WHERE (j.uuid=l.job_uuid OR (j.event_uuid<>'' AND j.event_uuid=l.event_uuid)) AND j.event_type=?)`, policyCutoff, policy.EventType); err != nil {
return err
}
if policy.MaxRows > 0 {
if _, err := s.DB.Exec(`DELETE FROM event_logs WHERE id IN (
SELECT l.id FROM event_logs l JOIN event_jobs j ON (j.uuid=l.job_uuid OR (j.event_uuid<>'' AND j.event_uuid=l.event_uuid))
WHERE j.event_type=? ORDER BY l.created_at_ms DESC,l.id DESC LIMIT -1 OFFSET ?)`, policy.EventType, policy.MaxRows); err != nil {
return err
}
}
if _, err := s.DB.Exec(`DELETE FROM event_log_buckets WHERE event_type=? AND bucket_start_ms < ?`, policy.EventType, now.Add(-time.Duration(policy.RetentionHours)*time.Hour).UnixMilli()); err != nil {
return err
}
}
_, err = s.DB.Exec(`DELETE FROM event_jobs WHERE updated_at_ms < ?
AND status IN ('succeeded','skipped','failed','cancelled')`, cutoff)
return err
}
func (s *Store) GetQueueSettings() (QueueSettings, error) {
var q QueueSettings
var paused int
err := s.DB.QueryRow(`SELECT paused, concurrency, max_depth,
retry_base_seconds, retention_hours FROM event_queue_settings WHERE id=1`).
Scan(&paused, &q.Concurrency, &q.MaxDepth, &q.RetryBaseSeconds, &q.RetentionHours)
q.Paused = paused != 0
return q, err
}
func (s *Store) SetQueueSettings(q QueueSettings) error {
if q.Concurrency < 1 || q.Concurrency > 32 || q.MaxDepth < 1 ||
q.RetryBaseSeconds < 1 || q.RetentionHours < 1 {
return errors.New("invalid queue settings")
}
_, err := s.DB.Exec(`UPDATE event_queue_settings SET paused=?, concurrency=?,
max_depth=?, retry_base_seconds=?, retention_hours=? WHERE id=1`,
q.Paused, q.Concurrency, q.MaxDepth, q.RetryBaseSeconds, q.RetentionHours)
return err
}
func (s *Store) AddEventLog(jobUUID, eventUUID, level, message string) error {
return s.AddEventLogContext(context.Background(), jobUUID, eventUUID, level, message)
}
func (s *Store) addEventCompletionLog(ctx context.Context, jobUUID, eventUUID, level, message string) error {
if err := s.AddEventLogContext(ctx, jobUUID, eventUUID, level, message); err != nil {
return errors.Join(ErrEventCompletionLog, err)
}
return nil
}
// AddEventLogContext atomically persists a raw log and its trend counter. The
// caller's earlier deadline wins; even Background callers have a finite budget.
func (s *Store) AddEventLogContext(ctx context.Context, jobUUID, eventUUID, level, message string) error {
if s.ReadOnly {
return ErrReadOnly
}
ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
defer cancel()
return s.withEventLogWriter(ctx, func(tx *sql.Conn) error {
eventType := "unknown"
// The common path is a primary-key lookup, not OR + sorting the retained
// job history while holding the writer lock. Keep event-only fallback.
err := tx.QueryRowContext(ctx, eventLogJobTypeSQL, jobUUID).Scan(&eventType)
if errors.Is(err, sql.ErrNoRows) && eventUUID != "" {
err = tx.QueryRowContext(ctx, `SELECT event_type FROM event_jobs WHERE event_uuid=? LIMIT 1`, eventUUID).Scan(&eventType)
}
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if eventType == "" {
eventType = "unknown"
}
policy := EventLogPolicy{EventType: "*", RetentionHours: 168, AggregateAfterHours: 24, BucketSeconds: 60, MaxRows: 5000}
var specific EventLogPolicy
if err := scanEventLogPolicy(tx.QueryRowContext(ctx, `SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type=?`, eventType), &specific); err == nil {
policy = specific
} else if errors.Is(err, sql.ErrNoRows) {
if err := scanEventLogPolicy(tx.QueryRowContext(ctx, `SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type='*'`), &policy); err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
} else {
return err
}
now := time.Now().UnixMilli()
if _, err := tx.ExecContext(ctx, `INSERT INTO event_logs(job_uuid,event_uuid,level,message,created_at_ms) VALUES(?,?,?,?,?)`, jobUUID, eventUUID, level, message, now); err != nil {
return err
}
bucket := int64(policy.BucketSeconds)
if bucket < 1 {
bucket = 60
}
bucketStart := now - (now % (bucket * 1000))
if _, err := tx.ExecContext(ctx, `INSERT INTO event_log_buckets(event_type,bucket_start_ms,level,count,first_at_ms,last_at_ms,sample_message)
VALUES(?,?,?,1,?,?,?) ON CONFLICT(event_type,bucket_start_ms,level) DO UPDATE SET count=count+1,last_at_ms=excluded.last_at_ms`, eventType, bucketStart, level, now, now, message); err != nil {
return err
}
return nil
})
}
func scanEventLogPolicy(scanner interface{ Scan(...any) error }, policy *EventLogPolicy) error {
return scanner.Scan(&policy.EventType, &policy.RetentionHours, &policy.AggregateAfterHours, &policy.BucketSeconds, &policy.MaxRows)
}
func (s *Store) ListEventLogPolicies() ([]EventLogPolicy, error) {
rows, err := s.DB.Query(`SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies ORDER BY event_type`)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]EventLogPolicy, 0)
for rows.Next() {
var item EventLogPolicy
if err := scanEventLogPolicy(rows, &item); err != nil {
return nil, err
}
items = append(items, item)
}
return items, rows.Err()
}
func (s *Store) SetEventLogPolicy(policy EventLogPolicy) error {
policy.EventType = strings.TrimSpace(policy.EventType)
if policy.EventType == "" || policy.RetentionHours < 1 || policy.RetentionHours > 24*3650 ||
policy.AggregateAfterHours < 0 || policy.AggregateAfterHours > 24*3650 || policy.BucketSeconds < 10 || policy.BucketSeconds > 86400 ||
policy.MaxRows < 100 || policy.MaxRows > 10000000 {
return errors.New("invalid event log policy")
}
_, err := s.DB.Exec(`INSERT INTO event_log_policies(event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows)
VALUES(?,?,?,?,?) ON CONFLICT(event_type) DO UPDATE SET retention_hours=excluded.retention_hours,
aggregate_after_hours=excluded.aggregate_after_hours,bucket_seconds=excluded.bucket_seconds,max_rows=excluded.max_rows`,
policy.EventType, policy.RetentionHours, policy.AggregateAfterHours, policy.BucketSeconds, policy.MaxRows)
return err
}
func (s *Store) ListEventLogTrends(ctx context.Context, eventType string, sinceMS int64, limit int) ([]EventLogTrend, error) {
if limit < 1 || limit > 2000 {
limit = 500
}
if sinceMS < 0 {
sinceMS = 0
}
query := `SELECT event_type,bucket_start_ms,level,count,first_at_ms,last_at_ms,sample_message FROM event_log_buckets WHERE bucket_start_ms>=?`
args := []any{sinceMS}
if strings.TrimSpace(eventType) != "" {
query += ` AND event_type=?`
args = append(args, strings.TrimSpace(eventType))
}
query += ` ORDER BY bucket_start_ms DESC,event_type,level LIMIT ?`
args = append(args, limit)
rows, err := s.DB.QueryContext(ctx, query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
items := make([]EventLogTrend, 0, limit)
for rows.Next() {
var item EventLogTrend
if err := rows.Scan(&item.EventType, &item.BucketStartMS, &item.Level, &item.Count, &item.FirstAtMS, &item.LastAtMS, &item.SampleMessage); err != nil {
return nil, err
}
items = append(items, item)
}
return items, rows.Err()
}
func (s *Store) ListEventLogs(jobUUID string, limit int) ([]EventLog, error) {
return s.ListEventLogsBefore(jobUUID, limit, 0)
}
func (s *Store) ListEventLogsBefore(jobUUID string, limit int, beforeID int64) ([]EventLog, error) {
if limit < 1 || limit > 1000 {
limit = 200
}
query := `SELECT l.id,l.job_uuid,l.event_uuid,COALESCE(j.event_type,''),l.level,l.message,l.created_at_ms FROM event_logs l LEFT JOIN event_jobs j ON j.uuid=l.job_uuid WHERE 1=1`
args := []any{}
if jobUUID != "" {
query += ` AND job_uuid=?`
args = append(args, jobUUID)
}
if beforeID > 0 {
query += ` AND id < ?`
args = append(args, beforeID)
}
query += ` ORDER BY id DESC LIMIT ?`
args = append(args, limit)
rows, err := s.DB.Query(query, args...)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]EventLog, 0)
for rows.Next() {
var item EventLog
if err := rows.Scan(&item.ID, &item.JobUUID, &item.EventUUID, &item.EventType, &item.Level, &item.Message, &item.CreatedAtMS); err != nil {
return nil, err
}
out = append(out, item)
}
return out, rows.Err()
}
func validateEventDefinition(event EventDefinition) error {
if event.UUID == ResourceEventID || event.EventType == ResourceEventType {
if event.UUID != ResourceEventID || event.EventType != ResourceEventType || event.ScheduleKind != "interval" || event.IntervalSeconds < 30 || event.IntervalSeconds > 86400 {
return errors.New("builtin resource monitoring requires its fixed ID and an interval of 30–86400 seconds")
}
}
event.ScheduleKind = strings.ToLower(strings.TrimSpace(event.ScheduleKind))
if event.Name == "" || event.EventType == "" {
return errors.New("name and event_type are required")
}
switch event.ScheduleKind {
case "manual":
case "once":
if event.NextRunAtMS <= 0 {
return errors.New("next_run_at_ms is required for once schedule")
}
case "interval":
if event.IntervalSeconds < 1 {
return errors.New("interval_seconds must be positive")
}
default:
return errors.New("schedule_kind must be manual, once, or interval")
}
return nil
}
func (s *Store) SaveEventDefinition(event *EventDefinition) error {
if err := validateEventDefinition(*event); err != nil {
return err
}
now := time.Now().UnixMilli()
if event.UUID == "" {
event.UUID = uuid.NewString()
event.CreatedAtMS = now
}
if event.MaxAttempts < 1 {
event.MaxAttempts = 3
}
if event.ScheduleKind == "interval" && event.NextRunAtMS == 0 {
event.NextRunAtMS = time.Now().Add(time.Duration(event.IntervalSeconds) * time.Second).UnixMilli()
}
event.UpdatedAtMS = now
_, err := s.DB.Exec(`INSERT INTO event_definitions
(uuid,name,event_type,event_key,payload,schedule_kind,interval_seconds,
next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms)
VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?)
ON CONFLICT(uuid) DO UPDATE SET name=excluded.name,event_type=excluded.event_type,
event_key=excluded.event_key,payload=excluded.payload,schedule_kind=excluded.schedule_kind,
interval_seconds=excluded.interval_seconds,next_run_at_ms=excluded.next_run_at_ms,
enabled=excluded.enabled,priority=excluded.priority,max_attempts=excluded.max_attempts,
updated_at_ms=excluded.updated_at_ms`,
event.UUID, event.Name, event.EventType, event.EventKey, event.Payload,
event.ScheduleKind, event.IntervalSeconds, event.NextRunAtMS, event.Enabled,
event.Priority, event.MaxAttempts, event.CreatedAtMS, event.UpdatedAtMS)
return err
}
func (s *Store) ListEventDefinitions() ([]EventDefinition, error) {
rows, err := s.DB.Query(`SELECT uuid,name,event_type,event_key,payload,schedule_kind,
interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms
FROM event_definitions ORDER BY name`)
if err != nil {
return nil, err
}
defer rows.Close()
out := make([]EventDefinition, 0)
for rows.Next() {
var item EventDefinition
var enabled int
if err := rows.Scan(&item.UUID, &item.Name, &item.EventType, &item.EventKey,
&item.Payload, &item.ScheduleKind, &item.IntervalSeconds, &item.NextRunAtMS,
&enabled, &item.Priority, &item.MaxAttempts, &item.CreatedAtMS, &item.UpdatedAtMS); err != nil {
return nil, err
}
item.Enabled = enabled != 0
out = append(out, item)
}
return out, rows.Err()
}
func (s *Store) DeleteEventDefinition(eventUUID string) error {
if eventUUID == ResourceEventID {
return errors.New("disable the builtin resource event instead of deleting it")
}
_, err := s.DB.Exec(`DELETE FROM event_definitions WHERE uuid=?`, eventUUID)
return err
}
func (s *Store) RunEventDefinition(eventUUID string) (bool, error) {
var event EventDefinition
var enabled int
err := s.DB.QueryRow(`SELECT uuid,name,event_type,event_key,payload,schedule_kind,
interval_seconds,next_run_at_ms,enabled,priority,max_attempts,created_at_ms,updated_at_ms
FROM event_definitions WHERE uuid=?`, eventUUID).Scan(
&event.UUID, &event.Name, &event.EventType, &event.EventKey, &event.Payload,
&event.ScheduleKind, &event.IntervalSeconds, &event.NextRunAtMS, &enabled,
&event.Priority, &event.MaxAttempts, &event.CreatedAtMS, &event.UpdatedAtMS)
if err != nil {
return false, err
}
return s.EnqueueEventWithOptions(event.UUID, event.EventType,
event.EventKey+":"+uuid.NewString(), event.Payload, time.Now(), event.Priority, event.MaxAttempts)
}
func (s *Store) EnqueueDueDefinitions(now time.Time) (int, error) {
rows, err := s.DB.Query(`SELECT uuid FROM event_definitions WHERE enabled=1
AND schedule_kind IN ('once','interval') AND next_run_at_ms>0 AND next_run_at_ms<=?`,
now.UnixMilli())
if err != nil {
return 0, err
}
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return 0, err
}
ids = append(ids, id)
}
rows.Close()
count := 0
for _, id := range ids {
queued, err := s.RunEventDefinition(id)
if err != nil {
return count, err
}
if queued {
count++
}
_, err = s.DB.Exec(`UPDATE event_definitions SET
next_run_at_ms=CASE schedule_kind WHEN 'once' THEN 0
ELSE ? + interval_seconds*1000 END,
enabled=CASE schedule_kind WHEN 'once' THEN 0 ELSE enabled END,
updated_at_ms=? WHERE uuid=?`, now.UnixMilli(), now.UnixMilli(), id)
if err != nil {
return count, err
}
}
return count, nil
}