Struct ethrecv::Controller

pub struct Controller<E> { /* private fields */ }

A controller that can be used to interact with the receiver thread.

Implementations

impl<E> Controller<E>

where E: 'static,

pub fn signal_inspect(&mut self) -> Result<(), Error<E>>

Available on crate feature inspect only.

Signal the receiver thread that it should call the PacketHandler::inspect() callback.

This call is asynchronous with regards to the callback; the call may return to the caller before the receiver has received the request.

Examples found in repository

examples/simple-demo.rs (line 55)

fn main() {
  let args: Vec<String> = env::args().skip(1).collect();

  let rt = RecvThread::new(&args[0]);

  #[cfg(feature = "idle")]
  let rt = rt.idle_duration(std::time::Duration::from_secs(4));

  let pp = PktProc::default();

  #[cfg(feature = "inspect")]
  let mut ctrl = rt.run(pp).unwrap();

  #[cfg(not(feature = "inspect"))]
  let ctrl = rt.run(pp).unwrap();

  std::thread::sleep(std::time::Duration::from_secs(10));

  #[cfg(feature = "inspect")]
  ctrl.signal_inspect().unwrap();

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  std::thread::sleep(std::time::Duration::from_secs(30));

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  println!("Killing receiver thread..");

  ctrl.shutdown().unwrap();
}

pub fn inspect(&self) -> Result<RecvInfo, Error<E>>

Available on crate feature inspect only.

Examples found in repository

examples/simple-demo.rs (line 59)

fn main() {
  let args: Vec<String> = env::args().skip(1).collect();

  let rt = RecvThread::new(&args[0]);

  #[cfg(feature = "idle")]
  let rt = rt.idle_duration(std::time::Duration::from_secs(4));

  let pp = PktProc::default();

  #[cfg(feature = "inspect")]
  let mut ctrl = rt.run(pp).unwrap();

  #[cfg(not(feature = "inspect"))]
  let ctrl = rt.run(pp).unwrap();

  std::thread::sleep(std::time::Duration::from_secs(10));

  #[cfg(feature = "inspect")]
  ctrl.signal_inspect().unwrap();

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  std::thread::sleep(std::time::Duration::from_secs(30));

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  println!("Killing receiver thread..");

  ctrl.shutdown().unwrap();
}

pub fn signal_shutdown(&self) -> Result<(), Error<E>>

Signal receiver thread to terminate.

This call is asynchronous; at the time this function returns to the caller the termination request may not have reached the receiver thread.

A call to this method should be followed by a call to Controller::wait() to wait for the receiver to report termination.

pub fn wait(self) -> Result<(), Error<E>>

Wait for receiver to shut down.

Blocks the calling thread, and assumes that the receiver will be killed by another source.

Use Controller::signal_shutdown() to signal the receiver thread to shut down before calling Controller::wait().

To avoid having the application need perform the two-stage shutdown, use Controller::shutdown() instead.

pub fn shutdown(self) -> Result<(), Error<E>>

Tell receiver thread to terminate and wait for for it to end.

Examples found in repository

examples/simple-demo.rs (line 73)

fn main() {
  let args: Vec<String> = env::args().skip(1).collect();

  let rt = RecvThread::new(&args[0]);

  #[cfg(feature = "idle")]
  let rt = rt.idle_duration(std::time::Duration::from_secs(4));

  let pp = PktProc::default();

  #[cfg(feature = "inspect")]
  let mut ctrl = rt.run(pp).unwrap();

  #[cfg(not(feature = "inspect"))]
  let ctrl = rt.run(pp).unwrap();

  std::thread::sleep(std::time::Duration::from_secs(10));

  #[cfg(feature = "inspect")]
  ctrl.signal_inspect().unwrap();

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  std::thread::sleep(std::time::Duration::from_secs(30));

  #[cfg(feature = "inspect")]
  {
    let stats = ctrl.inspect().unwrap();
    println!("{stats:#?}");
  }

  println!("Killing receiver thread..");

  ctrl.shutdown().unwrap();
}

Trait Implementations

impl<E> Drop for Controller<E>

fn drop(&mut self)

Executes the destructor for this type.