generator

type Finite interface {
	// Remaining returns how many packets are left, or -1 when unbounded.
	Remaining() int
}

type Flow struct {
	SrcIP   netip.Addr
	DstIP   netip.Addr
	SrcPort uint16
	DstPort uint16
}

type FlowSpec struct {
	SrcIP netip.Addr   // fixed for every flow
	Dst   netip.Prefix // /32 for a single destination; wider to cycle
	// SrcPort is the first source port; flow n uses SrcPort+n.
	SrcPort uint16
	// DstPort is the destination port. It is fixed unless VaryDstPort is set,
	// because the usual test points many flows at one server port.
	DstPort     uint16
	VaryDstPort bool
	// Flows is how many distinct flows exist. Must be at least 1.
	Flows int
	// Scatter walks the flow space in a scrambled order instead of counting
	// through it. The set of flows is identical either way, and the order is
	// still completely deterministic — it just stops consecutive packets
	// carrying consecutive ports, which some receivers hash badly.
	Scatter bool
	// contains filtered or unexported fields
}

type FrameSource interface {
	// Len is how many frames the capture holds.
	Len() int
	// Frame returns the i-th frame's bytes and the gap since the frame before
	// it (zero for the first). The returned slice must not be modified.
	Frame(i int) (data []byte, gap time.Duration)
	// MaxLen and MeanLen are the largest and mean frame lengths in bytes.
	MaxLen() int
	MeanLen() int
	// Describe summarises the capture for the review screen.
	Describe() string
	// Warnings lists anything about the capture worth telling the user before
	// replaying it, such as packets truncated by the capture's snaplen.
	Warnings() []string
}

type Generator interface {
	// Next writes the next packet into frame and returns how many bytes it
	// wrote — the Ethernet frame length excluding the FCS the NIC appends —
	// along with the protocol class for statistics.
	Next(frame []byte) (int, stats.Class)

	// AvgWireBytes is the mean on-the-wire size of a packet, including the 20
	// bytes of preamble, start-frame delimiter and interframe gap. The rate
	// limiter charges this per packet up front and reconciles against the real
	// sizes afterwards, so it only has to be a good estimate.
	AvgWireBytes() int

	// MaxFrameLen is the largest frame this generator can emit, so the
	// dataplane can check it fits in a UMEM frame before attaching anything.
	MaxFrameLen() int

	// Describe is a short human-readable summary of the packet-size behaviour,
	// e.g. "fixed 64-byte frames" or "IMIX 7:4:1 (64/594/1518B)".
	Describe() string
}

type MixEntry struct {
	// Size is the total Ethernet frame size in bytes, including the 4-byte
	// FCS — the same units as --packet-size.
	Size int
	// Weight is how many packets of this size appear per cycle.
	Weight int
}

type Pacer interface {
	// Delay is how long to wait before producing the next packet.
	Delay() time.Duration
}

type Spec struct {
	Cfg    *config.Config
	SrcMAC [6]byte
	DstMAC [6]byte
	SrcIP  netip.Addr
	Dst    netip.Prefix

	// Queue and Queues place this generator in the flow space.
	Queue, Queues int

	// Frames is the PCAP replay source, required for config.ModePCAP.
	Frames FrameSource
}