Struct hydra::ChildSpec

pub struct ChildSpec { /* private fields */ }

The child specification describes how the supervisor starts, shuts down, and restarts child processes.

Implementations

impl ChildSpec

pub fn new<T: Into<String>>(id: T) -> Self

Constructs a new instance of ChildSpec with the given id.

Examples found in repository

examples/supervisor.rs (line 66)

    pub fn child_spec(self) -> ChildSpec {
        ChildSpec::new("MyServer")
            .start(move || MyServer::start_link(MyServer, GenServerOptions::new()))
    }

examples/registry.rs (line 72)

    async fn start(&self) -> Result<Pid, ExitReason> {
        // Spawn a registry that will take care of registering 'MySpace'.
        let children = [
            Registry::new("space-registry")
                .with_start(|key| {
                    let RegistryKey::String(id) = key else {
                        panic!()
                    };

                    MySpace::new(id).start_link(GenServerOptions::new())
                })
                .with_shutdown(Shutdown::Infinity)
                .child_spec(RegistryOptions::new())
                .id("space-registry"),
            ChildSpec::new("test-registry")
                .start(move || async { Ok(Process::spawn(test_registry())) }),
        ];

        // Restart only the terminated child.
        Supervisor::with_children(children)
            .strategy(SupervisionStrategy::OneForOne)
            .start_link(SupervisorOptions::new())
            .await
    }

pub fn id<T: Into<String>>(self, id: T) -> Self

Sets a new id for this ChildSpec.

Examples found in repository

examples/supervisor.rs (line 33)

    async fn start(&self) -> Result<Pid, ExitReason> {
        // Spawn two instances of `MyServer` with their own unique ids.
        let children = [
            MyServer::new().child_spec().id("server1"),
            MyServer::new().child_spec().id("server2"),
        ];

        // Restart only the terminated child.
        Supervisor::with_children(children)
            .strategy(SupervisionStrategy::OneForOne)
            .start_link(SupervisorOptions::new())
            .await
    }

examples/registry.rs (line 71)

    async fn start(&self) -> Result<Pid, ExitReason> {
        // Spawn a registry that will take care of registering 'MySpace'.
        let children = [
            Registry::new("space-registry")
                .with_start(|key| {
                    let RegistryKey::String(id) = key else {
                        panic!()
                    };

                    MySpace::new(id).start_link(GenServerOptions::new())
                })
                .with_shutdown(Shutdown::Infinity)
                .child_spec(RegistryOptions::new())
                .id("space-registry"),
            ChildSpec::new("test-registry")
                .start(move || async { Ok(Process::spawn(test_registry())) }),
        ];

        // Restart only the terminated child.
        Supervisor::with_children(children)
            .strategy(SupervisionStrategy::OneForOne)
            .start_link(SupervisorOptions::new())
            .await
    }

pub fn start<T, F>(self, start: T) -> Self

where T: Fn() -> F + Send + Sync + 'static, F: Future<Output = Result<Pid, ExitReason>> + Send + Sync + 'static,

The method invoked to start the child process.

Must return a future that resolves to Result<Pid, ExitReason>.

Examples found in repository

examples/supervisor.rs (line 67)

    pub fn child_spec(self) -> ChildSpec {
        ChildSpec::new("MyServer")
            .start(move || MyServer::start_link(MyServer, GenServerOptions::new()))
    }

examples/registry.rs (line 73)

    async fn start(&self) -> Result<Pid, ExitReason> {
        // Spawn a registry that will take care of registering 'MySpace'.
        let children = [
            Registry::new("space-registry")
                .with_start(|key| {
                    let RegistryKey::String(id) = key else {
                        panic!()
                    };

                    MySpace::new(id).start_link(GenServerOptions::new())
                })
                .with_shutdown(Shutdown::Infinity)
                .child_spec(RegistryOptions::new())
                .id("space-registry"),
            ChildSpec::new("test-registry")
                .start(move || async { Ok(Process::spawn(test_registry())) }),
        ];

        // Restart only the terminated child.
        Supervisor::with_children(children)
            .strategy(SupervisionStrategy::OneForOne)
            .start_link(SupervisorOptions::new())
            .await
    }

pub const fn restart(self, restart: Restart) -> Self

Defines when a terminated child process should be restarted.

Defaults to Restart::Permanent.

pub fn shutdown<T: Into<Shutdown>>(self, shutdown: T) -> Self

Defines how a process should be terminated, specifically how long to wait before forcefully killing it.

Defaults to 5s if the type is worker or infinity if the type is supervisor.

pub const fn child_type(self, child_type: ChildType) -> Self

Specifies the type of child process.

pub const fn significant(self, significant: bool) -> Self

A boolean indicating if the child process should be considered significant with regard to automatic shutdown.

Only transient and temporary child processes can be marked as significant.

Defaults to false.

Trait Implementations

impl Clone for ChildSpec

fn clone(&self) -> ChildSpec

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.