Struct Controller

pub struct Controller<D, V>
where
    D: DataDeliveryPolicy + Clone + Send + Sync + 'static,
    V: Send + Sync + 'static,
{ /* private fields */ }

Controller, used to manage workers and their context

Generic parameter D is the message type for the controller’s Hub messages. Generic parameter V is the type of shared variables. If shared variables are not required, it can be set to ().

Implementations

impl<D, V> Controller<D, V>

where D: DataDeliveryPolicy + Clone + Send + Sync + 'static, V: Send + Sync + 'static,

pub fn new() -> Self

where V: Default,

Creates a new controller instance, variables MUST implement Default trait

pub fn new_with_variables(variables: V) -> Self

Creates a new controller instance with a pre-defined variables object

pub fn spawn_worker<W: Worker<D, V> + WorkerOptions + 'static>( &mut self, worker: W, ) -> Result<()>

Spawns a worker

pub fn spawn_task<F>(&mut self, name: &str, f: F) -> Result<()>

where F: FnOnce() + Send + 'static,

Spawns a task thread (non-real-time) with the default options

pub fn register_signals(&mut self, shutdown_timeout: Duration) -> Result<()>

Registers SIGINT, SIGTERM and SIGUSR2 signals to a thread which terminates the controller with dummy handlers (see Controller::register_signals_with_handlers()).

pub fn register_signals_with_handlers<SH, RH>( &mut self, shutdown_handler_fn: SH, reload_handler_fn: RH, shutdown_timeout: Duration, ) -> Result<()>

where SH: Fn(&Context<D, V>) + Send + Sync + 'static, RH: Fn(&Context<D, V>) -> HandlerResult + Send + Sync + 'static,

Registers SIGINT, SIGUSR2 and SIGTERM signals to a thread which terminates the controller.

The signals SIGINT and SIGTERM are used to gracefully terminate the controller. The SIGUSR2 signal is used to perform a live reload of the executable.

Note: to properly terminate all workers must either periodically check the controller state with Context::is_online() or be marked as blocking by overriding WorkerOptions::worker_is_blocking() (or setting blocking to true in WorkerOpts derive macro).

Workers that listen to hub messages may also receive a custom termination message and gracefully shut themselves down. For such functionality a custom signal handler should be implemented (See https://github.com/roboplc/roboplc/blob/main/examples/shutdown.rs).

The thread is automatically spawned with FIFO scheduling and the highest priority on CPU 0 or falled back to non-realtime.

If the reload handler function returns error, the reload process is aborted. Otherwise, the executable is reloaded (see crate::reload_executable()).

pub fn block(&mut self)

Blocks until all non-blocking tasks/workers are finished. In case if signals are registered, the controller is blocked until a signal is received, despite all worker tasks are finished. Use Controller::block_while_online() instead to let controller workers shut down the controller.

pub fn block_while_online(&self)

Blocks until the controller goes into stopping/stopped

pub fn is_online(&self)

Is the controller online (starting or running)

pub fn terminate(&mut self)

Sets controller state to Stopping

pub fn state(&self) -> &State

State beacon

pub fn hub(&self) -> &Hub<D>

Controller Hub instance

pub fn supervisor(&self) -> &Supervisor<()>

Controller Supervisor instance

pub fn variables(&self) -> &Arc<V>

Controller shared variables

Trait Implementations

impl<D, V> Default for Controller<D, V>

where D: DataDeliveryPolicy + Clone + Send + Sync + 'static, V: Send + Sync + 'static + Default,

fn default() -> Self

Returns the “default value” for a type.