Struct Proc 

pub struct Proc {
    pub name: String,
    pub command: OsString,
    pub args: Vec<OsString>,
    pub working_dir: Option<PathBuf>,
    pub readiness_pattern: Option<String>,
    pub watch: Vec<PathBuf>,
    pub watch_rel: Vec<PathBuf>,
    pub env: HashMap<OsString, OsString>,
    pub env_clear: bool,
    pub color: Option<AnsiColors>,
    pub cleanup_cmd: Option<Vec<OsString>>,
    pub cleanup_before_start: bool,
}

A single process configuration for prox

Fields

name: String

Name of the process (used in logs and events)

command: OsString

Command to run (e.g. “cargo”, “npm”, “python”, etc.)

args: Vec<OsString>

Arguments to pass to the command

working_dir: Option<PathBuf>

Working directory for the process (defaults to current directory)

readiness_pattern: Option<String>

Optional pattern to look for in stdout/stderr to consider the process “ready”

watch: Vec<PathBuf>

Paths to watch for changes to trigger a restart (relative to the config file/crate/workspace root)

watch_rel: Vec<PathBuf>

Paths to watch for changes to trigger a restart (relative to working_dir)

env: HashMap<OsString, OsString>

Environment variables to set for the process

env_clear: bool

Whether to clear the environment before applying env

color: Option<AnsiColors>

Override color for the process prefix (otherwise auto-assigned from Config)

cleanup_cmd: Option<Vec<OsString>>

Command to run on shutdown of Prox, and optionally before start/restart of process

cleanup_before_start: bool

Whether to run the cleanup_cmd before starting/restarting the process

Implementations

impl Proc

pub fn watch_abs(&self, config: &Config) -> Result<Vec<PathBuf>>

Resolve the watch and watch_rel paths to absolute canonical paths.

impl Proc

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

Create a builder for building Proc. On the builder, call .name(...), .command(...), .args(...)(optional), .working_dir(...)(optional), .readiness_pattern(...)(optional), .watch(...)(optional), .watch_rel(...)(optional), .env(...)(optional), .env_clear(...)(optional), .color(...)(optional), .cleanup_cmd(...)(optional), .cleanup_before_start(...)(optional) to set the values of the fields. Finally, call .build() to create the instance of Proc.

Examples found in repository

examples/basic_usage.rs (line 16)

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 Clone for Proc

fn clone(&self) -> Proc

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Proc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Proc

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.