Struct NetworkEngine 

pub struct NetworkEngine { /* private fields */ }

The guest-visible network state of one record or replay run.

Implementations

impl NetworkEngine

pub fn new_record(epoch: DateTime<Utc>) -> Self

Start recording; epoch is the run’s configured epoch.

pub fn new_replay(trace: NetworkTraceV2) -> Self

Replay trace, which must already have passed validation.

pub fn is_record(&self) -> bool

pub fn is_channel(&self, id: OpenFileId) -> bool

Whether the guest connected id as a network channel.

pub fn record_connect( &mut self, id: OpenFileId, peer: NetworkAddressV1, local: Option<NetworkAddressV1>, errno: i32, nonblocking: bool, ) -> Result<i32, NetworkEngineError>

Record a connect the runtime performed on the host. errno is 0 on success, and local is the host-assigned local address.

pub fn replay_connect( &mut self, id: OpenFileId, peer: &NetworkAddressV1, nonblocking: bool, ) -> Result<i32, NetworkEngineError>

Replay the recorded connect of id, which must target the recorded peer.

pub fn addresses( &self, id: OpenFileId, ) -> Option<(Option<&NetworkAddressV1>, &NetworkAddressV1)>

The local and peer addresses of a connected channel, for getsockname and getpeername.

pub fn needs_pull(&self, id: OpenFileId) -> bool

Whether the recorder should pull more input for id from the host.

pub fn record_arrival( &mut self, id: OpenFileId, now: LogicalTime, arrival: NetworkArrival, ) -> Result<(), NetworkEngineError>

Record what the runtime pulled from the host for id at global time now, and make it visible to the guest at once.

pub fn recv( &mut self, id: OpenFileId, now: LogicalTime, max_len: usize, target: usize, peek: bool, ) -> Result<NetworkRecvOutcome, NetworkEngineError>

A guest receive of at most max_len bytes at global time now.

target is the byte count that completes a blocking receive: min(SO_RCVLOWAT, max_len), or max_len under MSG_WAITALL. A nonblocking receive, or one whose timeout expired, passes 1. With peek the bytes stay queued.

pub fn readiness( &mut self, id: OpenFileId, now: LogicalTime, lowat: usize, ) -> Result<i16, NetworkEngineError>

The poll events id reports at global time now, before masking with the requested events. Mirrors Linux tcp_poll; lowat is the socket’s SO_RCVLOWAT, which the guest may set before it connects.

pub fn take_error( &mut self, id: OpenFileId, now: LogicalTime, ) -> Result<i32, NetworkEngineError>

Consume and return the pending socket error at global time now, as SO_ERROR does; 0 when there is none. Inputs due by now are released first, so the first observer of a recorded error sees it whichever operation it uses.

pub fn send_failure( &mut self, id: OpenFileId, now: LogicalTime, ) -> Result<Option<i32>, NetworkEngineError>

The errno a guest send at global time now fails with before transmitting anything, or None when the send may proceed. Inputs due by now are released first. A pending error is consumed first; otherwise a socket shut down for writing fails with EPIPE.

pub fn record_send( &mut self, id: OpenFileId, sent: &[u8], at: Option<SendMark>, now: LogicalTime, waits: u64, ) -> Result<SendMark, NetworkEngineError>

Record the bytes a host send accepted at now and return where they left the stream. Empty sent records nothing and returns the current mark, which a blocking send takes before its first wait. at is the mark of a send that then waited for buffer space; any output event on the channel in the meantime, accepted or refused, is refused, because replay would order the two the other way. waits counts the send’s waits since it started or since its previous accepted chunk; when it is nonzero the fragment records that count and now, so that replay accepts it only after waiting as long.

pub fn record_refused_send( &mut self, id: OpenFileId, ) -> Result<(), NetworkEngineError>

Record a nonblocking send that the host refused with EAGAIN, as an empty fragment at the current stream offset.

pub fn replay_send( &mut self, id: OpenFileId, bytes: &[u8], nonblocking: bool, now: LogicalTime, waits: u64, ) -> Result<ReplaySendOutcome, NetworkEngineError>

Match a guest send at now against the recording and return how many bytes it transmits: the bytes left in the current recorded fragment, at most bytes.len(). A recorded short write therefore replays as the same short write. ReplaySendOutcome::WouldBlock is a nonblocking send that the recording refused with EAGAIN; a blocking send at that point diverged.

A fragment that the recording accepted only after its send waited is due once this send has waited waits times as many and now has reached the recorded acceptance time; before that the send gets ReplaySendOutcome::NotYet and waits again. The check and the consumption happen in this one call, so nothing can run between them.

pub fn shutdown( &mut self, id: OpenFileId, how: i32, ) -> Result<i32, NetworkEngineError>

Apply shutdown(how); returns 0 or the errno the guest sees.

pub fn apply( &mut self, now: LogicalTime, request: NetworkRequest, ) -> Result<NetworkReply, NetworkEngineError>

Perform request at global time now.

pub fn finish_replay(self) -> Result<(), NetworkEngineError>

End a replay: fail if the guest left part of the recording unused, by never connecting a recorded socket, by sending fewer bytes than the recording holds, or by never making a recorded refused send. Inputs the guest never read are not checked: when an input is released depends on the schedule, so a replay may end before a final input the recording happened to observe.

pub fn finish(self) -> Result<NetworkTraceV2, NetworkEngineError>

The trace of a record run. Fails if the run was a replay or the recording does not validate.

Trait Implementations

impl Debug for NetworkEngine

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

Formats the value using the given formatter.