Struct Chronon 

pub struct Chronon {
    pub store: Arc<dyn SchedulerStore>,
    pub scheduler: Arc<Scheduler>,
    pub executor: Arc<Executor>,
    pub coordinator: CoordinatorService,
    pub deployment: DeploymentShape,
    /* private fields */
}

Assembled Chronon runtime: store, scheduler, executor, and deployment loops.

Built via ChrononBuilder. Hosts typically:

1. Upsert jobs through Self::coordinator_service (or HTTP / remote client).
2. Call Self::run to start shape-specific loops (or Self::tick_once in tests).
3. Call Self::shutdown on exit.

DeploymentShape	Self::run behavior
Embedded	Tick + worker in this process
CoordinatorOnly	Tick + partitions only
Worker(pool)	Claim + execute for pool
RemoteClient(_)	Error — use crate::RemoteCoordinatorClient

Examples

use std::sync::Arc;
use chronon_backend_mem::InMemorySchedulerStore;
use chronon_runtime::{ChrononBuilder, DeploymentShape};

let chronon = ChrononBuilder::new()
    .scheduler_store(Arc::new(InMemorySchedulerStore::new()))
    .embedded()
    .build()
    .unwrap();
assert_eq!(chronon.deployment, DeploymentShape::Embedded);
let _ = chronon.coordinator_service();

Fields

store: Arc<dyn SchedulerStore>

Shared persistence for jobs, runs, partitions, and workers.

scheduler: Arc<Scheduler>

Tick engine and partition assigner handle.

executor: Arc<Executor>

Script registry and async dispatch.

coordinator: CoordinatorService

Job/run CRUD facade over Self::store.

deployment: DeploymentShape

Deployment shape selected at build time.

Implementations

impl Chronon

pub fn shutdown(&self)

Signal all runtime loops to stop.

pub fn shutdown_handle(&self) -> Arc<Notify>

Shared shutdown signal for background Self::run tasks (testkit / host wiring).

pub async fn run(&mut self) -> Result<(), ChrononError>

Run deployment loops until Self::shutdown is called.

Dispatches on Self::deployment:

• DeploymentShape::Embedded — tick + worker
• DeploymentShape::CoordinatorOnly — tick only
• DeploymentShape::Worker — claim + execute
• DeploymentShape::RemoteClient — returns ChrononError::Internal; use crate::RemoteCoordinatorClient instead

Call scheduler.init_partitions().await before Self::run on coordinator / embedded shapes so partition ownership is ready.

Examples

Embedded: init partitions, then run until shutdown:

use std::sync::Arc;
use chronon_backend_mem::InMemorySchedulerStore;
use chronon_runtime::ChrononBuilder;

let mut chronon = ChrononBuilder::new()
    .scheduler_store(Arc::new(InMemorySchedulerStore::new()))
    .embedded()
    .build()?;
chronon.scheduler.init_partitions().await;
// chronon.run().await?;  // blocks until chronon.shutdown()

Runnable daemons: cargo run -p uf-chronon --example coordinator_daemon --features postgres,redis and worker_daemon.

pub async fn tick_once(&self) -> Result<TickResult, ChrononError>

Advance the scheduler by one tick (tests and manual stepping).

pub fn coordinator_service(&self) -> &CoordinatorService

Job and run CRUD for HTTP handlers and host integration.

pub fn executor(&self) -> &Executor

Script executor (registry + dispatch).