Struct ProcessSet

pub struct ProcessSet<K> { /* private fields */ }

Implementations

impl<K> ProcessSet<K>

pub fn new() -> Self

Examples found in repository

examples/sleep.rs (line 12)

fn main() {
  let mut procs = ProcessSet::new();
  procs.add_command(3, sleep_cmd(3));
  procs.add_command(1, sleep_cmd(1));
  procs.add_command(2, sleep_cmd(2));

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process {} finished: {:?}", id, r);
      }
    }
  }
}

pub fn with_concurrency_limit(limit: usize) -> Self

Examples found in repository

examples/concurrency_limit.rs (line 16)

fn main() {
  let mut procs = ProcessSet::with_concurrency_limit(3);
  for i in 0..5 {
    procs.add_command((1, i), make_cmd(1));
  }
  for i in 0..5 {
    procs.add_command((2, i), make_cmd(2));
  }
  for i in 0..5 {
    procs.add_command((3, i), make_cmd(3));
  }

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process \"sleep {} # {}\" finished: {:?}", id.1, id.0, r);
      }
    }
  }
}

impl<K: Hash + Eq + Clone> ProcessSet<K>

pub fn add_command(&mut self, key: K, command: Command)

Examples found in repository

examples/sleep.rs (line 13)

fn main() {
  let mut procs = ProcessSet::new();
  procs.add_command(3, sleep_cmd(3));
  procs.add_command(1, sleep_cmd(1));
  procs.add_command(2, sleep_cmd(2));

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process {} finished: {:?}", id, r);
      }
    }
  }
}

examples/concurrency_limit.rs (line 18)

fn main() {
  let mut procs = ProcessSet::with_concurrency_limit(3);
  for i in 0..5 {
    procs.add_command((1, i), make_cmd(1));
  }
  for i in 0..5 {
    procs.add_command((2, i), make_cmd(2));
  }
  for i in 0..5 {
    procs.add_command((3, i), make_cmd(3));
  }

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process \"sleep {} # {}\" finished: {:?}", id.1, id.0, r);
      }
    }
  }
}

pub fn wait_any( &mut self, signal_handler: &mut SignalHandler, ) -> WaitAnyResult<K>

Wait for any process to finish, and return the corrosponding key and resulting child (or error).

Takes in a signal handler from outside which can be created with SignalHandler::default(). This ensures that signals between waits are not missed.

If multiple processes have finished, this will only return one of them. Call this function in a loop to wait for all processes to finish.

If no process has finished, this will pause the current thread.

If there are no processes running, this will return NoProcessesRunning.

If, during the middle of waiting, the current process gets a SIGINT or SIGTERM, this will return ReceivedTerminationSignal(signal_number). More signals can be added via SignalHandler::add_termination_signal.

Examples found in repository

examples/sleep.rs (line 19)

fn main() {
  let mut procs = ProcessSet::new();
  procs.add_command(3, sleep_cmd(3));
  procs.add_command(1, sleep_cmd(1));
  procs.add_command(2, sleep_cmd(2));

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process {} finished: {:?}", id, r);
      }
    }
  }
}

examples/concurrency_limit.rs (line 29)

fn main() {
  let mut procs = ProcessSet::with_concurrency_limit(3);
  for i in 0..5 {
    procs.add_command((1, i), make_cmd(1));
  }
  for i in 0..5 {
    procs.add_command((2, i), make_cmd(2));
  }
  for i in 0..5 {
    procs.add_command((3, i), make_cmd(3));
  }

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process \"sleep {} # {}\" finished: {:?}", id.1, id.0, r);
      }
    }
  }
}

pub fn try_wait_any(&mut self) -> Option<WaitAnyResult<K>>

Non-blocking version of wait_any. If no process has finished, this will just return None.

Will never return WaitAnyResult::ReceivedTerminationSignal.

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

Kills all subprocesses.

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

Send a SIGINT to all subprocesses and return immediately.

pub fn sigint_all_and_wait( &mut self, signal_handler: &mut SignalHandler, ) -> Result<()>

Send a SIGINT to all subprocesses and wait for them to finish.

Examples found in repository

examples/sleep.rs (line 26)

fn main() {
  let mut procs = ProcessSet::new();
  procs.add_command(3, sleep_cmd(3));
  procs.add_command(1, sleep_cmd(1));
  procs.add_command(2, sleep_cmd(2));

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process {} finished: {:?}", id, r);
      }
    }
  }
}

examples/concurrency_limit.rs (line 36)

fn main() {
  let mut procs = ProcessSet::with_concurrency_limit(3);
  for i in 0..5 {
    procs.add_command((1, i), make_cmd(1));
  }
  for i in 0..5 {
    procs.add_command((2, i), make_cmd(2));
  }
  for i in 0..5 {
    procs.add_command((3, i), make_cmd(3));
  }

  let mut sh = SignalHandler::default();
  loop {
    match procs.wait_any(&mut sh) {
      WaitAnyResult::NoProcessesRunning => {
        println!("All done");
        return;
      }
      WaitAnyResult::ReceivedTerminationSignal(_) => {
        println!("Terminating");
        procs.sigint_all_and_wait(&mut sh).unwrap();
        return;
      }
      WaitAnyResult::Subprocess(id, r) => {
        println!("Process \"sleep {} # {}\" finished: {:?}", id.1, id.0, r);
      }
    }
  }
}

Trait Implementations

impl<K: Debug> Debug for ProcessSet<K>

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

Formats the value using the given formatter.

impl<K> Default for ProcessSet<K>

fn default() -> Self

Returns the “default value” for a type.