fault

type NetworkDirection int

type NetworkInterruption struct {
	ContainerID, NetworkName string
	OriginalAddress          netip.Addr
	// contains filtered or unexported fields
}

type NetworkPacketFault struct {
	// Percent is the probability that a packet is affected, from more than 0
	// to 100. Zero, with a zero Correlation, means no fault.
	Percent float64
	// Correlation, from 0 to 100, makes each packet's random decision this
	// percentage dependent on the previous packet's, so affected packets
	// come in runs. It needs a Percent.
	Correlation float64
}

type NetworkPeer struct {
	Addr netip.Addr
	Port uint16
}

type NetworkPhase int

type NetworkProfile struct {
	// HelperImage is the netem helper image: NetemHelperImage, or another image
	// that meets contract 1 of the netem extension. Required.
	HelperImage string
	// Plane selects the bridge whose endpoint of the target is delayed.
	Plane ceph.NetworkPlane
	// Delay is added to every packet that leaves the target through that
	// endpoint: at least 1ms and at most MaxNetworkDelay, in whole
	// microseconds. With a Loss, a Rate, a Duplicate or a Corrupt it may be
	// zero.
	Delay time.Duration
	// Jitter varies each packet's delay uniformly within ±Jitter. It is at
	// most Delay, in whole microseconds.
	Jitter time.Duration
	// Peer, when set, limits the delay to the packets that the target sends
	// to this address through the endpoint; every other packet leaves
	// without delay. It is an IPv4 address, or an IPv6 address for an
	// endpoint that has one, such as a daemon's address from
	// DaemonAddresses on the same plane. Only packets that leave the target
	// are selected, unless Direction also shapes the peer's side.
	Peer netip.Addr
	// PeerPort, with Peer, limits the delay further to TCP packets to this
	// destination port, such as one of the peer's Messenger ports, and on
	// the peer's side of an Inbound delay to its packets from that port. Zero
	// selects every packet to Peer. An IPv6 packet with extension headers
	// before its TCP header is not selected.
	PeerPort uint16
	// Peers, instead of Peer and PeerPort, limits the delay to the packets
	// that the target sends to any of these peers, each with its own
	// optional TCP destination port, such as several OSDs of a daemon.
	// Every packet that one of them selects gets the same delay and loss;
	// every other packet leaves without delay. It holds at most
	// MaxNetworkPeers distinct entries, of either family.
	Peers []NetworkPeer
	// Direction selects which side of the paths to the selected peers is
	// shaped: Outbound (the zero value) what the target sends, Inbound what
	// the peers send to the target, BothDirections both. Inbound and
	// BothDirections need a Peer or Peers; see NetworkDirection.
	Direction NetworkDirection
	// Phase selects which packets of a selected path are shaped: AllPackets
	// (the zero value), or ConnectionSetup, only TCP segments with SYN set.
	// ConnectionSetup needs a Peer or Peers; see NetworkPhase.
	Phase NetworkPhase
	// Loss drops this percentage of the packets that the delay applies to,
	// at random and independently, from more than 0 to 100. With 100 every
	// selected packet is dropped: with a Peer or Peers, the target's packets
	// to those peers, and only those, never arrive. Zero drops nothing.
	Loss float64
	// Rate, when set, limits the selected packets to this bandwidth, from
	// MinNetworkRate to MaxNetworkRate in whole bytes per second (a multiple
	// of 8 bit/s), with netem's rate in the same qdisc as the Delay and Loss.
	// netem sends each packet only after the previous one has taken its
	// length over the rate, so there is no burst: a packet counts with its
	// Ethernet header, as the kernel queues it, and a TCP segmentation
	// offload packet counts with all of its segments. The packets waiting
	// for the rate, and for the Delay, share one queue of QueueLimit
	// packets; one that arrives at a full queue is dropped and counted in
	// NetworkProfileStatus.Drops. Zero sets no limit. With a Loss, netem
	// drops first, then delays, then paces what is left. With Direction
	// Outbound it shapes only what the target sends; Inbound and
	// BothDirections apply the same Rate at each peer's endpoint. What an application
	// achieves through it is less, and is for the caller to measure; the
	// status's Rate and counters are configuration and counts, not a
	// throughput. The preflight adds and removes a netem qdisc with a rate on
	// its loopback and checks what the kernel reports, so a tc or kernel
	// without netem's rate is refused before the target changes.
	Rate NetworkRate
	// QueueLimit, with a Rate, is the netem queue in packets, from 1 to
	// MaxNetworkQueueLimit; zero means DefaultNetworkQueueLimit.
	QueueLimit int
	// Reorder, when set, sends this percentage of the selected packets at
	// once, ahead of the packets that wait for the Delay, so they arrive out
	// of order. It needs a Delay, which every other selected packet gets, and
	// takes no Jitter, which reorders packets by itself, and no Rate, which
	// the packets sent at once would bypass. netem's gap is 1: every packet
	// may be reordered.
	Reorder NetworkPacketFault
	// Duplicate, when set, sends a second copy of this percentage of the
	// selected packets. iproute2 6.1, the tc of NetemHelperImage, sends a
	// duplicate's correlation only together with a delay's correlation, so
	// with a Duplicate.Correlation the lease passes the delay with a zero
	// correlation (delay 0us 0us 0% without a Delay), the kernel's state
	// without one.
	Duplicate NetworkPacketFault
	// Corrupt, when set, flips one random bit in this percentage of the
	// selected packets, within the part of the packet that the kernel holds
	// in its first buffer: the headers, and the first payload bytes when they
	// are there too. netem first computes a checksum that the device would
	// have offloaded, so the receiver's checksum check sees the flipped bit,
	// and splits a segmentation offload packet, corrupting one segment.
	// netem decides per queued packet, for every fault: a percentage of
	// packets is not a percentage of TCP segments.
	Corrupt NetworkPacketFault
}

type NetworkProfileLease struct {
	// ContainerID and NetworkName identify the delayed endpoint.
	ContainerID, NetworkName string
	// SandboxID is the Docker network sandbox of the target when the delay
	// was applied, and Namespace the kernel's name of its network namespace.
	SandboxID, Namespace string
	// Interface, InterfaceIndex, MACAddress and Address identify the
	// delayed interface inside that namespace.
	Interface      string
	InterfaceIndex int
	MACAddress     string
	Address        netip.Addr
	// HelperImageID is the image of the helper that applied the delay.
	HelperImageID string
	// Delay and Jitter are the requested values.
	Delay, Jitter time.Duration
	// Peer and PeerPort are the requested Peer and PeerPort.
	Peer     netip.Addr
	PeerPort uint16
	// Peers is the whole selection: Peer and PeerPort as one entry, or the
	// requested Peers. Empty means the whole interface.
	Peers []NetworkPeer
	// Loss is the requested loss percentage.
	Loss float64
	// Rate is the requested rate, and QueueLimit the queue limit that the
	// lease installed with it: the requested one, or
	// DefaultNetworkQueueLimit. Both are zero without a Rate.
	Rate       NetworkRate
	QueueLimit int
	// Reorder, Duplicate and Corrupt are the requested packet faults.
	Reorder, Duplicate, Corrupt NetworkPacketFault
	// Direction and Phase are the requested ones.
	Direction NetworkDirection
	Phase     NetworkPhase
	// SourcePorts says that each of Peers' ports is the TCP source port of
	// what this endpoint sends, not the destination port: it is set on the
	// leases in PeerLeases, whose Peers are the target's addresses.
	SourcePorts bool
	// PeerLeases holds, for Inbound and BothDirections, one lease on each
	// selected peer's endpoint, shaping what that peer sends to the target.
	// Restore restores them with the rest; each has its own Status. With
	// Inbound alone the lease applies nothing to the target's endpoint, and
	// its own Status is refused.
	PeerLeases []*NetworkProfileLease
	// contains filtered or unexported fields
}

type NetworkProfileStatus struct {
	// Applied means that the delay's own netem qdisc is the root qdisc of the
	// interface it was applied to (with peers, that its own hierarchy is,
	// with one filter for each peer), and that nothing the lease did not add
	// is under that root.
	Applied bool
	// Gone means that the delayed interface no longer exists: the target
	// stopped, restarted, was removed or was disconnected from the network,
	// and the delay ended with it.
	Gone bool
	// Interface is the delayed interface's current name.
	Interface string
	// RootKind and RootHandle describe the interface's current root qdisc.
	RootKind, RootHandle string
	// Delay and Jitter are the kernel's values while Applied.
	Delay, Jitter time.Duration
	// Loss is the kernel's loss percentage while Applied.
	Loss float64
	// Rate and QueueLimit are the netem qdisc's configured rate and queue
	// limit while Applied: the kernel's configuration, not a throughput that
	// anything achieved. Rate is zero without a rate limit.
	Rate       NetworkRate
	QueueLimit int
	// Reorder, Duplicate and Corrupt are the netem qdisc's configured packet
	// faults while Applied, and Gap its reorder gap (1 with a Reorder): the
	// kernel's configuration. None of them shows that a packet was affected;
	// the receiver's transport counters can.
	Reorder, Duplicate, Corrupt NetworkPacketFault
	Gap                         int
	// Packets, Bytes and Drops are the netem qdisc's counters while Applied.
	// With peers they count only the selected packets, of all peers. Drops
	// includes the packets that Loss dropped and those that found the queue
	// full.
	Packets, Bytes, Drops uint64
	// Overlimits and Requeues are the netem qdisc's other counters, and
	// Backlog (bytes) and QueueLength (packets) what waits in its queue, all
	// while Applied. With a Reorder, Requeues counts the packets that netem
	// sent ahead. They are counters, not rates: to know a throughput,
	// measure the workload, or compare Bytes over a period you time.
	Overlimits, Requeues, Backlog, QueueLength uint64
	// Qdiscs is tc's JSON output for the interface.
	Qdiscs json.RawMessage
	// Filters is tc's egress filter output for the interface, with the keys
	// of each u32 filter under "matches".
	Filters json.RawMessage
	// contains filtered or unexported fields
}

type NetworkRate uint64

type PauseLease struct {
	ContainerID string
	// contains filtered or unexported fields
}