#[cfg(feature = "deployment")]
use crate::context::DeploymentContext;
#[cfg(feature = "api")]
pub use appcore_api::{
ApiMethod, ApiRequest, ApiResponse, ApiRouter, CommandRequest, QueryEndpoint, QueryName,
QueryRequest, QueryResponse,
};
pub use appcore_core::{
AppFamily, AppId, CommandBus, CommandEnvelope, CommandHandler, CommandName, CommandRegistry,
CommandResult, DecisionEngine, DecisionNode, DecisionOutcome, DecisionRegistry, EventEnvelope,
EventName, EventRegistry, NodeId, RuntimeContext, RuntimeContractVersion, RuntimeError,
RuntimeIdentity, RuntimeResult, StateName, StateRegistry, SyncGroup,
};
#[cfg(feature = "scheduler")]
pub use appcore_scheduler::{RetryPolicy, ScheduledTask, TaskContext, TaskResult, TaskSchedule};
#[cfg(feature = "scheduler")]
use appcore_scheduler::{SchedulerError, TaskCallback};
#[cfg(feature = "scheduler")]
use std::sync::Arc;
pub trait Application: Send + Sync {
#[cfg(feature = "deployment")]
fn configure(&self, _deployment: &DeploymentContext) -> RuntimeResult<()> {
Ok(())
}
fn register_commands(&self, _registry: &mut CommandRegistry) -> RuntimeResult<()> {
Ok(())
}
fn register_events(&self, _registry: &mut EventRegistry) -> RuntimeResult<()> {
Ok(())
}
fn register_states(&self, _registry: &mut StateRegistry) -> RuntimeResult<()> {
Ok(())
}
fn register_decisions(&self, _registry: &mut DecisionRegistry) -> RuntimeResult<()> {
Ok(())
}
fn register_decision_nodes(&self, _engine: &mut DecisionEngine) -> RuntimeResult<()> {
Ok(())
}
fn register_handlers(&self, _bus: &mut CommandBus) -> RuntimeResult<()> {
Ok(())
}
#[cfg(feature = "api")]
fn register_queries(&self, _router: &mut ApiRouter) -> RuntimeResult<()> {
Ok(())
}
#[cfg(feature = "scheduler")]
fn register_tasks(&self, _registry: &mut ApplicationTaskRegistry) -> RuntimeResult<()> {
Ok(())
}
}
#[cfg(feature = "scheduler")]
#[derive(Default)]
pub struct ApplicationTaskRegistry {
tasks: Vec<RegisteredApplicationTask>,
}
#[cfg(feature = "scheduler")]
impl ApplicationTaskRegistry {
pub fn new() -> Self {
Self::default()
}
pub fn register<F>(&mut self, task: ScheduledTask, callback: F) -> RuntimeResult<()>
where
F: Fn(TaskContext) -> TaskResult + Send + Sync + 'static,
{
task.validate().map_err(invalid_task)?;
if self
.tasks
.iter()
.any(|registered| registered.definition.id == task.id)
{
return Err(RuntimeError::RegistryItemAlreadyRegistered {
kind: "application_task",
name: task.id,
});
}
self.tasks.push(RegisteredApplicationTask {
definition: task,
callback: Arc::new(callback),
});
Ok(())
}
pub fn len(&self) -> usize {
self.tasks.len()
}
pub fn is_empty(&self) -> bool {
self.tasks.is_empty()
}
#[doc(hidden)]
pub fn into_registered(self) -> Vec<RegisteredApplicationTask> {
self.tasks
}
}
#[cfg(feature = "scheduler")]
#[doc(hidden)]
#[derive(Clone)]
pub struct RegisteredApplicationTask {
definition: ScheduledTask,
callback: TaskCallback,
}
#[cfg(feature = "scheduler")]
impl RegisteredApplicationTask {
#[doc(hidden)]
pub fn definition(&self) -> &ScheduledTask {
&self.definition
}
#[doc(hidden)]
pub fn callback(&self) -> &TaskCallback {
&self.callback
}
}
#[cfg(feature = "scheduler")]
fn invalid_task(error: SchedulerError) -> RuntimeError {
RuntimeError::RegistryError(format!("invalid application task: {error}"))
}
#[cfg(all(test, feature = "scheduler"))]
mod tests {
use super::*;
use std::time::SystemTime;
#[test]
fn rejects_duplicate_task_identity() {
let task = || ScheduledTask {
id: "sdk.task".to_string(),
schedule: TaskSchedule::Once {
run_at: SystemTime::now(),
},
retry: RetryPolicy::default(),
priority: 0,
trace: None,
};
let mut registry = ApplicationTaskRegistry::new();
registry.register(task(), |_| Ok(())).expect("first task");
assert!(registry.register(task(), |_| Ok(())).is_err());
}
}