Struct VmiTerminationHandler 

pub struct VmiTerminationHandler<Handler> { /* private fields */ }

Handler that interrupts another handler at a deadline or once a termination flag is set.

VmiHandlerExt adds it to any handler, for example with VmiHandlerExt::with_deadline. The wrapped handler is interrupted through VmiHandler::handle_interrupted, as if by a signal.

If the guest causes no events, the event loop wakes up only once per wait timeout. The deadline, the termination flag and the termination timeout can then take effect up to one wait timeout late.

The output is None if the event loop ended without the output of the wrapped handler, after it was interrupted.

Implementations

impl<Handler> VmiTerminationHandler<Handler>

pub fn new(handler: Handler) -> Self

Creates a new termination handler with the given handler.

pub fn with_deadline(self, deadline: Instant) -> Self

Sets the time at which the handler is interrupted.

pub fn with_termination_flag(self, termination_flag: Arc<AtomicBool>) -> Self

Installs a flag that interrupts the handler once it becomes true.

pub fn with_termination_timeout(self, termination_timeout: Duration) -> Self

Sets the time the handler has to finish once interrupted, by a signal, the deadline or the termination flag. When the time runs out, the event loop ends without the output of the handler.

Trait Implementations

impl<Os, Handler> VmiHandler<Os> for VmiTerminationHandler<Handler>

where Os: VmiOs, Handler: VmiHandler<Os>,

type Output = Option<<Handler as VmiHandler<Os>>::Output>

The output type of the handler.

fn handle_event( &mut self, vmi: VmiContext<'_, Os>, ) -> VmiEventResponse<Os::Architecture>

Called for each VMI event.

fn handle_timeout(&mut self, session: &VmiSession<'_, Os>)

Called when the event loop times out waiting for the next event.

fn handle_interrupted( &mut self, session: &VmiSession<'_, Os>, ) -> ControlFlow<()>

Called when the event loop is interrupted by a signal.

fn cleanup(&mut self, session: &VmiSession<'_, Os>)

Called once before the session tears down monitoring.

fn poll(&mut self) -> Option<Self::Output>

Checks if the handler has completed.