Publish ITWorx Pulse source

internal/workerruntime/schedule.go

@@ -0,0 +1,76 @@
+package workerruntime
+
+import (
+	"context"
+	"time"
+
+	"github.com/itworx/pulse/internal/systemstatus"
+)
+
+// The standard job schedule.
+//
+// Intervals are chosen from what each job observes and how expensive it is, and
+// every timeout stays well inside its lease so a slow run cannot be duplicated
+// by another worker before it finishes:
+//
+//   - discovery: inventory changes slowly and one pass reads a full container
+//     snapshot for up to 150 containers, so a minute is responsive enough
+//     without re-reading the same snapshot repeatedly;
+//   - alert evaluation: rules declare their own evaluation interval (5s
+//     minimum, 60s typically). Scanning every 15 seconds means a rule is picked
+//     up within 15 seconds of becoming due, while the per-rule lease keyed on
+//     the rule's own interval prevents evaluating it more often than declared;
+//   - probe execution: probe intervals start at 5 seconds, so a 15 second scan
+//     keeps a due probe close to its schedule; the batch itself is bounded to
+//     300 probes with bounded concurrency;
+//   - notification drain: the outbox retry backoff starts at one second, so a
+//     10 second drain delivers promptly without polling the database hard.
+const (
+	DiscoveryInterval        = time.Minute
+	DiscoveryTimeout         = 45 * time.Second
+	AlertEvaluationInterval  = 15 * time.Second
+	AlertEvaluationTimeout   = 60 * time.Second
+	ProbeExecutionInterval   = 15 * time.Second
+	ProbeExecutionTimeout    = 2 * time.Minute
+	NotificationInterval     = 10 * time.Second
+	NotificationDrainTimeout = DrainDeadline
+)
+
+// Job names, stable because they are persisted in job_runs.
+const (
+	JobDiscovery         = "discovery"
+	JobAlertEvaluation   = "alert-evaluation"
+	JobProbeExecution    = "probe-execution"
+	JobNotificationDrain = "notification-drain"
+)
+
+// ScheduleRuns holds the work each scheduled job performs. A nil entry is still
+// scheduled, but reports Disabled with a reason, so an unconfigured capability
+// is visible rather than silently absent.
+type ScheduleRuns struct {
+	Discovery         RunFunc
+	AlertEvaluation   RunFunc
+	ProbeExecution    RunFunc
+	NotificationDrain RunFunc
+}
+
+// Schedule returns the standard worker job set.
+func Schedule(runs ScheduleRuns) []Job {
+	return []Job{
+		{Name: JobDiscovery, Component: systemstatus.ComponentWorker, Interval: DiscoveryInterval, Timeout: DiscoveryTimeout,
+			Run: orDisabled(runs.Discovery, "discovery_not_configured")},
+		{Name: JobAlertEvaluation, Component: systemstatus.ComponentWorker, Interval: AlertEvaluationInterval, Timeout: AlertEvaluationTimeout,
+			Run: orDisabled(runs.AlertEvaluation, "alert_evaluation_not_configured")},
+		{Name: JobProbeExecution, Component: systemstatus.ComponentProbes, Interval: ProbeExecutionInterval, Timeout: ProbeExecutionTimeout,
+			Run: orDisabled(runs.ProbeExecution, "probe_execution_not_configured")},
+		{Name: JobNotificationDrain, Component: systemstatus.ComponentNotifications, Interval: NotificationInterval, Timeout: NotificationDrainTimeout,
+			Run: orDisabled(runs.NotificationDrain, "notifications_not_configured")},
+	}
+}
+
+func orDisabled(run RunFunc, reason string) RunFunc {
+	if run != nil {
+		return run
+	}
+	return func(context.Context) (Outcome, error) { return Outcome{Disabled: true, Reason: reason}, nil }
+}