Struct Prox 

pub struct Prox {
    pub config: Config,
    pub procs: Vec<Proc>,
    pub signal_rx: Option<Receiver<ProxSignal>>,
    pub status_refs: Arc<DashMap<String, ProcStatus>>,
    /* private fields */
}

Process manager that handles multiple processes

Fields

config: Config

procs: Vec<Proc>

signal_rx: Option<Receiver<ProxSignal>>

status_refs: Arc<DashMap<String, ProcStatus>>

Implementations

impl Prox

pub fn config(&self) -> &Config

Get a reference to the configuration

pub fn procs(&self) -> &[Proc]

Get a reference to the processes

pub fn setup_event_rx(&mut self) -> Result<Receiver<ProxEvent>>

pub fn start(&mut self) -> Result<()>

Start all processes

Examples found in repository

examples/basic_usage.rs (line 59)

fn main() -> anyhow::Result<()> {
    // Example: Simple process manager with multiple services
    let mut manager = Prox::builder()
        .config(
            Config::builder()
                .readiness_fallback_timeout(Duration::from_secs(15))
                .build(),
        )
        .procs(
            [
                Proc::builder()
                    .name("api".into())
                    .command("cargo".into())
                    .args(vec!["run".into(), "--bin".into(), "api".into()])
                    .working_dir(PathBuf::from("./api"))
                    .readiness_pattern("Server listening".into())
                    .watch(vec![
                        PathBuf::from("./api/src"),
                        PathBuf::from("./shared/src"),
                    ])
                    .env(HashMap::from_iter([("LOG_LEVEL".into(), "debug".into())]))
                    .color(AnsiColors::BrightGreen)
                    .build(),
                Proc::builder()
                    .name("database".into())
                    .command("docker".into())
                    .args(["run".into()].into())
                    .env(
                        [
                            ("POSTGRES_DB".into(), "myapp".into()),
                            ("POSTGRES_PASSWORD".into(), "password".into()),
                        ]
                        .into(),
                    )
                    .readiness_pattern("database system is ready to accept connections".into())
                    .build(),
                Proc::builder()
                    .name("frontend".into())
                    .command("npm".into())
                    .args(vec!["run".into(), "dev".into()])
                    .working_dir(PathBuf::from("./frontend"))
                    .readiness_pattern("Local:".into())
                    .watch(vec![PathBuf::from("./frontend/src")])
                    .color(AnsiColors::BrightYellow)
                    .build(),
            ]
            .into(),
        )
        .build();

    println!("Starting development environment...");

    // Start all processes - this will block until Ctrl+C or a process exits
    manager.start()?;

    Ok(())
}

pub fn load_toml<P: AsRef<Path>>(path: P) -> Result<Prox>

Load configuration from TOML file

pub fn load_yaml<P: AsRef<Path>>(path: P) -> Result<Prox>

Load configuration from YAML file

pub fn load_json<P: AsRef<Path>>(path: P) -> Result<Prox>

Load configuration from JSON file

impl Prox

pub fn builder() -> ProxBuilder<((), (), ())>

Create a builder for building Prox. On the builder, call .config(...)(optional), .procs(...), .signal_rx(...)(optional) to set the values of the fields. Finally, call .build() to create the instance of Prox.

Examples found in repository

examples/basic_usage.rs (line 8)

fn main() -> anyhow::Result<()> {
    // Example: Simple process manager with multiple services
    let mut manager = Prox::builder()
        .config(
            Config::builder()
                .readiness_fallback_timeout(Duration::from_secs(15))
                .build(),
        )
        .procs(
            [
                Proc::builder()
                    .name("api".into())
                    .command("cargo".into())
                    .args(vec!["run".into(), "--bin".into(), "api".into()])
                    .working_dir(PathBuf::from("./api"))
                    .readiness_pattern("Server listening".into())
                    .watch(vec![
                        PathBuf::from("./api/src"),
                        PathBuf::from("./shared/src"),
                    ])
                    .env(HashMap::from_iter([("LOG_LEVEL".into(), "debug".into())]))
                    .color(AnsiColors::BrightGreen)
                    .build(),
                Proc::builder()
                    .name("database".into())
                    .command("docker".into())
                    .args(["run".into()].into())
                    .env(
                        [
                            ("POSTGRES_DB".into(), "myapp".into()),
                            ("POSTGRES_PASSWORD".into(), "password".into()),
                        ]
                        .into(),
                    )
                    .readiness_pattern("database system is ready to accept connections".into())
                    .build(),
                Proc::builder()
                    .name("frontend".into())
                    .command("npm".into())
                    .args(vec!["run".into(), "dev".into()])
                    .working_dir(PathBuf::from("./frontend"))
                    .readiness_pattern("Local:".into())
                    .watch(vec![PathBuf::from("./frontend/src")])
                    .color(AnsiColors::BrightYellow)
                    .build(),
            ]
            .into(),
        )
        .build();

    println!("Starting development environment...");

    // Start all processes - this will block until Ctrl+C or a process exits
    manager.start()?;

    Ok(())
}

Trait Implementations

impl Debug for Prox

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Prox

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Prox

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.