Struct Wora

pub struct Wora<AppEv, AppMetric> {
    pub app_name: String,
    pub dirs: Dirs,
    pub initial_working_dir: PathBuf,
    pub host: Host,
    pub sender: Sender<Event<AppEv>>,
    pub receiver: Receiver<Event<AppEv>>,
    pub leadership: Leadership,
    pub o11y: O11yProcessorOptions<AppMetric>,
    /* private fields */
}

All workloads will be able to access the WORA API

Fields

app_name: String

application name

dirs: Dirs

common directories for all executors

initial_working_dir: PathBuf

current directory where the process was invoked (an executor will likely override this)

host: Host

host info/stats

sender: Sender<Event<AppEv>>

Event producer

receiver: Receiver<Event<AppEv>>

Event receiver

leadership: Leadership

leadership state

o11y: O11yProcessorOptions<AppMetric>

Implementations

impl<AppEv: Send + Sync + 'static, AppMetric: Send + Sync + 'static> Wora<AppEv, AppMetric>

WORA API

pub fn new( dirs: &Dirs, app_name: String, ev_buf_size: usize, o11y: O11yProcessorOptions<AppMetric>, ) -> Result<Wora<AppEv, AppMetric>, WoraSetupError>

pub fn stats_from_start(&self) -> &HostStats

Examples found in repository

examples/async_daemon.rs (line 85)

    async fn setup(
        &mut self,
        wora: &Wora<(), ()>,
        exec: impl AsyncExecutor<(), ()>,
        _fs: impl WFS,
        _o11y: Sender<O11yEvent<()>>,
    ) -> Result<Self::Setup, Box<dyn std::error::Error>> {
        debug!("{:?}", wora.stats_from_start());

        let args = DaemonArgs::parse();
        self.args = args;

        debug!("{:?}", exec.disable_core_dumps());

        Ok(())
    }

pub fn dirs(&self) -> &Dirs

pub async fn emit_event(&self, ev: Event<AppEv>)

pub fn host_os_name(&self) -> &str

pub fn host_os_version(&self) -> Option<String>

pub fn host_architecture(&self) -> Option<String>

pub fn host_hostname(&self) -> Option<String>

pub fn host_cpu_count(&self) -> usize

pub fn host_cpu_max(&self) -> usize

pub async fn schedule_event(&self, duration: Duration, ev: Event<AppEv>)

pub async fn schedule_task<F, Fut>( &self, duration: Duration, future: F, ) -> JoinHandle<TaskOp>

where F: Fn(Sender<O11yEvent<AppMetric>>) -> Fut + Send + 'static, Fut: Future<Output = TaskOp> + Send,