processmanager 0.6.0

manage process lifecycles, graceful shutdown and process faults
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! A no-op [`Runnable`] that idles until it receives a shutdown request.
//!
//! `IdleProcess` is useful as a *tombstone* child for a [`ProcessManager`] that
//! would otherwise terminate immediately because it has no real children.
//! Registering an `IdleProcess` keeps the supervisor alive until an external
//! caller broadcasts [`ProcessControlHandler::shutdown`].
//!
//! # Example
//! ```no_run
//! use processmanager::{IdleProcess, ProcessManagerBuilder};
//!
//! // Supervisor without real children that should stay alive.
//! let _mgr = ProcessManagerBuilder::default()
//!     .pre_insert(IdleProcess::default())
//!     .build();
//! ```
use std::{sync::Arc, time::Duration};

use crate::{
    ProcFuture, ProcessControlHandler, ProcessOperation, Runnable, RuntimeControlMessage,
    RuntimeGuard,
};

/// A *tombstone* process that simply waits for a shutdown request.
///
/// It performs no work and exists solely to keep its parent
/// [`ProcessManager`] alive until an explicit shutdown is broadcast.
#[derive(Debug, Default)]
pub struct IdleProcess {
    runtime_guard: RuntimeGuard,
}

impl IdleProcess {
    /// Construct a fresh idle process. Equivalent to [`Default::default`].
    pub fn new() -> Self {
        Self {
            runtime_guard: RuntimeGuard::default(),
        }
    }
}
impl Runnable for IdleProcess {
    fn process_start(&self) -> ProcFuture<'_> {
        Box::pin(async {
            let ticker = self.runtime_guard.runtime_ticker().await;

            loop {
                // Sleep for a long time; the ticker wakes us early when a control message arrives.
                let sleep = tokio::time::sleep(Duration::from_secs(3600));

                match ticker.tick(sleep).await {
                    ProcessOperation::Next(_) => continue,
                    ProcessOperation::Control(RuntimeControlMessage::Shutdown) => break,
                    ProcessOperation::Control(_) => continue,
                }
            }

            Ok(())
        })
    }

    fn process_handle(&self) -> Arc<dyn ProcessControlHandler> {
        self.runtime_guard.handle()
    }

    fn process_name(&self) -> std::borrow::Cow<'static, str> {
        std::borrow::Cow::Borrowed("IdleProcess")
    }
}