Struct ethrecv::Controller
source · pub struct Controller<E> { /* private fields */ }
Expand description
A controller that can be used to interact with the receiver thread.
Implementations§
source§impl<E> Controller<E>where
E: 'static,
impl<E> Controller<E>where
E: 'static,
sourcepub fn signal_inspect(&mut self) -> Result<(), Error<E>>
Available on crate feature inspect
only.
pub fn signal_inspect(&mut self) -> Result<(), Error<E>>
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?
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
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();
}
sourcepub fn inspect(&self) -> Result<RecvInfo, Error<E>>
Available on crate feature inspect
only.
pub fn inspect(&self) -> Result<RecvInfo, Error<E>>
inspect
only.Examples found in repository?
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
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();
}
sourcepub fn signal_shutdown(&self) -> Result<(), Error<E>>
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.
sourcepub fn wait(self) -> Result<(), Error<E>>
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.
sourcepub fn shutdown(self) -> Result<(), Error<E>>
pub fn shutdown(self) -> Result<(), Error<E>>
Tell receiver thread to terminate and wait for for it to end.
Examples found in repository?
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
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();
}