const std = @import("std"); const Allocator = std.mem.Allocator; const Io = std.Io; const log = @import("logging.zig"); const event_persister_mod = @import("services/event_persister.zig"); const event_broadcaster_mod = @import("services/event_broadcaster.zig"); const log_broadcaster_mod = @import("services/log_broadcaster.zig"); const scheduler_mod = @import("services/scheduler.zig"); const lease_cleanup_mod = @import("services/lease_cleanup.zig"); const late_runs_mod = @import("services/late_runs.zig"); const automations_mod = @import("services/automations.zig"); const actions_executor_mod = @import("services/actions_executor.zig"); const task_run_recorder_mod = @import("services/task_run_recorder.zig"); const docket_worker_mod = @import("services/docket_worker.zig"); const cancellation_cleanup_mod = @import("services/cancellation_cleanup.zig"); const pause_expirations_mod = @import("services/pause_expirations.zig"); const foreman_mod = @import("services/foreman.zig"); const db_vacuum_mod = @import("services/db_vacuum.zig"); // re-export module namespaces so call sites (e.g., events.zig reaching for // event_broadcaster.addSubscriber) keep working. pub const event_persister = event_persister_mod; pub const event_broadcaster = event_broadcaster_mod; pub const log_broadcaster = log_broadcaster_mod; pub const scheduler = scheduler_mod; pub const lease_cleanup = lease_cleanup_mod; pub const late_runs = late_runs_mod; pub const automations = automations_mod; pub const actions_executor = actions_executor_mod; pub const task_run_recorder = task_run_recorder_mod; pub const docket_worker = docket_worker_mod; pub const cancellation_cleanup = cancellation_cleanup_mod; pub const pause_expirations = pause_expirations_mod; pub const foreman = foreman_mod; pub const db_vacuum = db_vacuum_mod; /// Three-tier service taxonomy, mirroring python prefect's /// `RunInWebservers` / `RunInEphemeralServers` / `Service` markers /// (see prefect/server/services/base.py:128 and api/server.py:912). /// /// .webserver_only — runs in every HA webapp replica. ONLY services that /// fan out to LOCALLY-connected WebSocket subscribers. /// They must be in-process with the WS connections. /// .ephemeral — single-binary mode: webserver-tier + broker-consumer /// "batch" services (event_persister, task_run_recorder). /// Skips the loop-driven services (scheduler, late_runs). /// .all — services-worker mode: every service runs. pub const Tier = enum { webserver_only, ephemeral, all, /// Does this tier include the given tier as a subset? /// `.all` includes `.ephemeral` includes `.webserver_only`. fn includes(self: Tier, other: Tier) bool { return @backingInt(self) >= @backingInt(other); } }; pub const Services = struct { tier: Tier, // webserver-tier (always present) event_broadcaster: event_broadcaster_mod.EventBroadcaster, log_broadcaster: log_broadcaster_mod.LogBroadcaster, // ephemeral-tier (broker-consumer batch services) event_persister: event_persister_mod.EventPersister, task_run_recorder: task_run_recorder_mod.TaskRunRecorder, // services-only tier (loop-driven scheduling/automations + docket worker) scheduler: scheduler_mod.Scheduler, lease_cleanup: lease_cleanup_mod.LeaseCleanup, late_runs: late_runs_mod.LateRuns, automations: automations_mod.Automations, actions_executor: actions_executor_mod.ActionsExecutor, docket_worker: docket_worker_mod.DocketWorker, cancellation_cleanup: cancellation_cleanup_mod.CancellationCleanup, pause_expirations: pause_expirations_mod.PauseExpirations, foreman: foreman_mod.Foreman, db_vacuum: db_vacuum_mod.DbVacuum, pub fn init(allocator: Allocator, io: Io, tier: Tier) Services { return .{ .tier = tier, .event_broadcaster = event_broadcaster_mod.EventBroadcaster.init(allocator, io), .log_broadcaster = log_broadcaster_mod.LogBroadcaster.init(allocator, io), .event_persister = event_persister_mod.EventPersister.init(allocator, io), .task_run_recorder = task_run_recorder_mod.TaskRunRecorder.init(allocator, io), .scheduler = scheduler_mod.Scheduler.init(allocator, io), .lease_cleanup = lease_cleanup_mod.LeaseCleanup.init(allocator, io), .late_runs = late_runs_mod.LateRuns.init(allocator, io), .automations = automations_mod.Automations.init(allocator, io), .actions_executor = actions_executor_mod.ActionsExecutor.init(allocator, io), .docket_worker = docket_worker_mod.DocketWorker.init(allocator, io), .cancellation_cleanup = cancellation_cleanup_mod.CancellationCleanup.init(allocator, io), .pause_expirations = pause_expirations_mod.PauseExpirations.init(allocator, io), .foreman = foreman_mod.Foreman.init(allocator, io), .db_vacuum = db_vacuum_mod.DbVacuum.init(allocator, io), }; } pub fn startAll(self: *Services) !void { log.info("services", "tier={s}", .{@tagName(self.tier)}); // webserver tier — runs in every mode log.startupComponent("event_broadcaster"); try self.event_broadcaster.start(); log.startupComponentDone("event_broadcaster"); log.startupComponent("log_broadcaster"); try self.log_broadcaster.start(); log.startupComponentDone("log_broadcaster"); if (!self.tier.includes(.ephemeral)) return; // ephemeral tier — broker-consumer batch services log.startupComponent("event_persister"); try self.event_persister.start(); log.startupComponentDone("event_persister"); log.startupComponent("task_run_recorder"); try self.task_run_recorder.start(); log.startupComponentDone("task_run_recorder"); if (!self.tier.includes(.all)) return; // services-only tier — loop-driven scheduling + docket log.startupComponent("scheduler"); try self.scheduler.start(); log.startupComponentDone("scheduler"); log.startupComponent("lease_cleanup"); try self.lease_cleanup.start(); log.startupComponentDone("lease_cleanup"); log.startupComponent("late_runs"); try self.late_runs.start(); log.startupComponentDone("late_runs"); log.startupComponent("automations"); try self.automations.start(); log.startupComponentDone("automations"); log.startupComponent("actions_executor"); try self.actions_executor.start(); log.startupComponentDone("actions_executor"); log.startupComponent("cancellation_cleanup"); try self.cancellation_cleanup.start(); log.startupComponentDone("cancellation_cleanup"); log.startupComponent("pause_expirations"); try self.pause_expirations.start(); log.startupComponentDone("pause_expirations"); log.startupComponent("foreman"); try self.foreman.start(); log.startupComponentDone("foreman"); log.startupComponent("db_vacuum"); try self.db_vacuum.start(); log.startupComponentDone("db_vacuum"); log.startupComponent("docket_worker"); try self.docket_worker.start(); log.startupComponentDone("docket_worker"); } pub fn stopAll(self: *Services) void { log.shutdownProgress(.orchestration, "stopping services", false); // Each service.stop() is safe to call even if start() never ran // (it short-circuits on !running). So we always walk the full list. // Reverse start order: loop services first, then batch consumers, // then webserver tier last. log.shutdownComponent("db_vacuum", false); self.db_vacuum.stop(); log.shutdownComponent("db_vacuum", true); log.shutdownComponent("foreman", false); self.foreman.stop(); log.shutdownComponent("foreman", true); log.shutdownComponent("pause_expirations", false); self.pause_expirations.stop(); log.shutdownComponent("pause_expirations", true); log.shutdownComponent("cancellation_cleanup", false); self.cancellation_cleanup.stop(); log.shutdownComponent("cancellation_cleanup", true); log.shutdownComponent("actions_executor", false); self.actions_executor.stop(); log.shutdownComponent("actions_executor", true); log.shutdownComponent("automations", false); self.automations.stop(); log.shutdownComponent("automations", true); log.shutdownComponent("late_runs", false); self.late_runs.stop(); log.shutdownComponent("late_runs", true); log.shutdownComponent("lease_cleanup", false); self.lease_cleanup.stop(); log.shutdownComponent("lease_cleanup", true); log.shutdownComponent("scheduler", false); self.scheduler.stop(); log.shutdownComponent("scheduler", true); log.shutdownComponent("docket_worker", false); self.docket_worker.stop(); log.shutdownComponent("docket_worker", true); log.shutdownComponent("task_run_recorder", false); self.task_run_recorder.stop(); log.shutdownComponent("task_run_recorder", true); log.shutdownComponent("event_persister", false); self.event_persister.stop(); log.shutdownComponent("event_persister", true); log.shutdownComponent("log_broadcaster", false); self.log_broadcaster.stop(); log.shutdownComponent("log_broadcaster", true); log.shutdownComponent("event_broadcaster", false); self.event_broadcaster.stop(); log.shutdownComponent("event_broadcaster", true); log.shutdownProgress(.orchestration, "services stopped", true); } };