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 { _ = s.AddEventLog(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 { _ = s.AddEventLog(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 { tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() eventType := "unknown" _ = tx.QueryRow(`SELECT event_type FROM event_jobs WHERE uuid=? OR event_uuid=? ORDER BY CASE WHEN uuid=? THEN 0 ELSE 1 END LIMIT 1`, jobUUID, eventUUID, jobUUID).Scan(&eventType) if eventType == "" { eventType = "unknown" } policy := EventLogPolicy{EventType: "*", RetentionHours: 168, AggregateAfterHours: 24, BucketSeconds: 60, MaxRows: 5000} var specific EventLogPolicy if err := scanEventLogPolicy(tx.QueryRow(`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 { _ = scanEventLogPolicy(tx.QueryRow(`SELECT event_type,retention_hours,aggregate_after_hours,bucket_seconds,max_rows FROM event_log_policies WHERE event_type='*'`), &policy) } now := time.Now().UnixMilli() if _, err := tx.Exec(`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.Exec(`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 tx.Commit() } 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 }