wabot_feature_async/
lib.rs1pub mod command;
37pub mod cron_job;
38pub mod cron_scheduler;
39pub mod dedup;
40pub mod executor;
41pub mod handler;
42pub mod job;
43pub mod locker;
44pub mod registry;
45pub mod repository;
46pub mod runner;
47pub mod scheduler;
48pub mod types;
49
50pub use command::CommandData;
51pub use cron_job::{CronJob, CronJobData};
52pub use cron_scheduler::CronScheduler;
53pub use dedup::compute_dedup_key;
54pub use executor::JobExecutor;
55pub use handler::{CommandHandlerEntry, CommandInvokeFn, CronHandlerEntry, CronInvokeFn};
56pub use job::{Job, JobData};
57pub use locker::{InProcessLocker, Locker, LockerExt};
58pub use registry::{CommandRegistry, CronRegistry};
59pub use repository::{CronJobRepository, JobRepository};
60pub use runner::JobRunner;
61pub use scheduler::{
62 register_cron_job_repository, register_job_repository, register_locker, run_command,
63 run_scheduler_loop, schedule_command, schedule_job, AsyncRuntimeConfig, DynCronJobRepository,
64 DynJobRepository, DynLocker, ScheduleAt,
65};
66pub use types::{handler_error, AsyncError, AsyncResult, DedupConfig, JobOptions, MisfirePolicy};
67pub use watchdog::JobWatchdog;
68
69mod watchdog;
70
71use std::sync::Arc;
72
73use wabot_core::injection::Container;
74
75pub fn register_async_runtime(c: &Container) {
84 use wabot_core::injection::IsSingleton;
85 if !c.is_registered::<AsyncRuntimeConfig>() {
86 AsyncRuntimeConfig::register_in(c);
87 }
88 if !c.is_registered::<DynLocker>() {
89 register_locker(c, Arc::new(InProcessLocker::new()));
90 }
91 CommandRegistry::register_in(c);
92 CronRegistry::register_in(c);
93 JobRunner::register_in(c);
94 JobExecutor::register_in(c);
95 JobWatchdog::register_in(c);
96 CronScheduler::register_in(c);
97}
98
99pub async fn run_async_workers(
108 container: Container,
109 commands: Vec<CommandHandlerEntry>,
110 crons: Vec<CronHandlerEntry>,
111) -> Result<(), AsyncError> {
112 let registry: Arc<CommandRegistry> = container.resolve();
113 for entry in commands.iter().cloned() {
114 registry.register(entry);
115 }
116 let cron_registry: Arc<CronRegistry> = container.resolve();
117 for entry in crons.iter().cloned() {
118 registry.register(cron_command_entry(&entry));
123 cron_registry.register(entry);
124 }
125
126 let executor: Arc<JobExecutor> = container.resolve();
127 let watchdog: Arc<JobWatchdog> = container.resolve();
128 let cron_scheduler: Arc<CronScheduler> = container.resolve();
129
130 let mut all_command_names: Vec<String> =
131 commands.iter().map(|e| e.command_name.clone()).collect();
132 for cron in &crons {
133 if !all_command_names.contains(&cron.command_name) {
134 all_command_names.push(cron.command_name.clone());
135 }
136 }
137 for name in &all_command_names {
138 executor.add_command(name);
139 watchdog.add_command(name);
140 tracing::info!(command = %name, "config COMMAND");
141 }
142
143 cron_scheduler.reconcile(&crons).await?;
144
145 let config: Arc<AsyncRuntimeConfig> = container.resolve();
146 let cfg_for_scheduler = (*config).clone();
147 let cfg_for_watchdog = (*config).clone();
148 let cfg_for_cron = (*config).clone();
149
150 let repo = scheduler::resolve_job_repository(&container)?;
151 let locker = scheduler::resolve_locker(&container)?;
152
153 let container_for_scheduler = container.clone();
154 let executor_for_scheduler = executor.clone();
155 let scheduler_task = tokio::spawn(async move {
156 run_scheduler_loop(
157 container_for_scheduler,
158 repo,
159 executor_for_scheduler,
160 locker,
161 cfg_for_scheduler,
162 )
163 .await;
164 });
165
166 let watchdog_task = tokio::spawn(async move {
167 watchdog
168 .run_loop(cfg_for_watchdog.watchdog_interval_seconds)
169 .await;
170 });
171
172 let cron_task = tokio::spawn(async move {
173 cron_scheduler
174 .run_loop(cfg_for_cron.cron_interval_seconds)
175 .await;
176 });
177
178 tokio::select! {
180 _ = scheduler_task => {}
181 _ = watchdog_task => {}
182 _ = cron_task => {}
183 }
184 Ok(())
185}
186
187pub fn cron_command_entry(cron: &CronHandlerEntry) -> CommandHandlerEntry {
196 let cron_invoke = cron.invoke.clone();
197 let invoke: CommandInvokeFn = Arc::new(move |c, _payload| {
198 let cron_invoke = cron_invoke.clone();
199 Box::pin(async move { (cron_invoke)(c).await })
200 });
201 CommandHandlerEntry {
202 command_name: cron.command_name.clone(),
203 options: cron.options.clone(),
204 dedup: None,
205 invoke,
206 }
207}