IActivePacketSource

module interface

Interface for active packet source modules. An active packet source, also called a producer, has one output that must be connected to a passive packet sink module. The active packet source is expected to push packets into the connected passive packet sink over time.

Inheritance diagram

The following diagram shows inheritance relationships for this type. Unresolved types are missing from the diagram.

Implemented by

Name	Type	Description
ActivePacketSource	simple module	An active packet source which pushes packets into the connected module. It pushes whole packets through the out gate at every production interval. It pushes the first packet after the initial production offset.
AsynchronousShaper	compound module	Implements an asynchronous shaper. The queue sorts packets based on the transmission eligibility time (~EligibilityTimeTag) attached to each packet. The gate prevents packets from being transmitted earlier than the attached transmission eligibility time.
BurstyPacketProducer	compound module	Mixes two different packet sources to generate bursty traffic.
CreditBasedShaper	compound module	Implements a credit-based shaper using a gate submodule to manage the number of credits.
DiffservTrafficConditioner	compound module	TODO documentation
EmptyPacketSource	simple module	An active/passive empty packet source. It doesn't push packets into the connected module, and it doesn't allow packets to be pulled from it by the connected module. The output gate generates backpressure for pull packet operations.
EthernetCutthroughBarrier	simple module	(no description)
InstantServer	simple module	Repeatedly pulls packets from the connected packet provider and pushes the packet into the connected packet consumer without delay.
LeakyBucket	compound module	Implements a parameterizable leaky bucket algorithm.
MultiPacketPolicing	compound module	Combines multiple packet policing modules into one.
OmittedPacketDelayer	compound module	Implements the given module interface and can be used as an optional module that removes itself from the module hierarchy during initialization.
OmittedPacketServer	compound module	Implements the given interface and can be used as an optional module that removes itself from the module hierarchy during initialization.
OmittedTrafficConditioner	compound module	Implements the given module interface and can be used as an omitted optional module that removes itself from the module hierarchy during initialization.
PacketDelayer	simple module	Connects one packet producer to one packet consumer. It can be pushed with packets from the connected packet producer. When this happens, the packet is delayed and eventually pushed to the output. Note that the order of packets may change if the delay parameter is configured to be a distribution.
PacketDuplicator	simple module	Connects one packet producer to one packet consumer. It can be pushed with packets from the connected packet producer. When this happens, one or more copies of the packet are pushed to the output gate.
PacketHistory	compound module	Connects one packet producer to one packet consumer. It can be pushed with packets from the connected packet producer. It keeps a copy of the last N packets pushed into its input. The packets are available in the runtime user interface (Qtenv) for inspection.
PacketMultiplexer	simple module	Connects multiple packet producers to one packet consumer. When a packet is pushed by one of the connected packet producers, then the multiplexer simply pushes the packet to the connected packet consumer.
PacketPolicing	compound module	Combines a packet meter and a packet filter into a packet policing module. The meter measures the packet flow that is passing through and attaches some meta information to the packets. The filter drops the packets that do not match the implemented filter criteria.
PacketSendToPush	simple module	Adapter module that converts packet sending to packet pushing. When it receives a packet as a message through its input gate, it pushes the packet to the connected consumer module through its output gate. Serves as a bridge between different packet handling mechanisms in protocol stacks and packet processing pipelines.
PacketServer	simple module	Repeatedly pulls packets from the connected packet provider and after a processing delay, it pushes the packet into the connected packet consumer. The processing delay is `processingTime` + `packetLength` / `processingBitrate`.
PacketShaper	compound module	Combines a packet queue and a packet gate into a packet shaper module. The queue stores the packets sorted according to its ordering and the gate decides when the first packet can be pulled from the queue.
PcapFilePacketProducer	simple module	An active packet source which pushes packets into the connected packet consumer. All pushed packets are read from a PCAP file.
PreemptingServer	simple module	(no description)
PriorityShaper	compound module	Combines a classifier, a scheduler, and several traffic shapers into a single packet shaper. Packets are classified into one of the traffic shapers, and the scheduler prioritizes among them.
QueueFiller	compound module	Produces packets in order to prevent a queue from becoming empty.
QueueingPacketDelayer	compound module	Compound module that delays packets for a specified amount of time while preserving their order. Implements the IPacketDelayer interface using a queue and server architecture. The queue stores packets while they wait, and the server processes each packet with a processing time equal to the configured delay. Note that the actual packet delay will be the sum of the queueing time and the configured delay. Unlike the simple PacketDelayer module, this implementation always maintains packet order regardless of delay distribution.
ResponseProducer	compound module	Generates several different streams of packets, one after the other. For each traffic category, the packets are produced by a separate token-based server. The traffic stream can be started by adding tokens to the corresponding server module. The packet data, packet length, and timing distributions can be configured in the corresponding packet provider.
StreamSplitter	simple module	Duplicates incoming packets based on the stream they are part of. The stream is determined by the `StreamReq` tag that is attached to the packet. The number of outgoing packets is determined by the mapping parameter. Each outgoing packet will have an attached `StreamReq` with the tag name taken from the mapping parameter.
TC1	compound module	Traffic conditioner used in Experiments 1.1-1.6 and 5.1.
TC2	compound module	Traffic conditioner used in Experiment 3.1.
TC3	compound module	Traffic conditioner used in Experiment 3.2.
TimeAwareShaper	compound module	Implements a time-aware shaper using a gate submodule that opens and closes according to a time-based schedule.
TokenBasedServer	simple module	Repeatedly pulls packets from the connected packet provider and it pushes them into the connected packet consumer. The packets are processed in zero simulation time, and the process continues until the available number of tokens is not sufficient anymore.
TokenBucket	compound module	Implements a parameterizable token bucket algorithm.
TrafficConditioner	compound module	TODO documentation

Used in compound modules

Name	Type	Description
ClientApp	compound module	(no description)
EthernetApp	compound module	Generates traffic as an Ethernet application. The traffic source and traffic sink modules can be built from queueing model elements.
Ieee8022LlcApp	compound module	Generates traffic as an IEEE 802.2 LLC application. The traffic source and traffic sink modules can be built from queueing model elements.
IpApp	compound module	Generates traffic for a IP application. The traffic source and traffic sink modules can be built from queueing model elements.
SourceApp	compound module	Implements a generic source application.
TcpClientApp	compound module	A generic, very modular TCP client application, similar to ~TcpServerApp. The traffic source and traffic sink modules can be built from queueing model elements.
TcpServerConnection	compound module	This is a pre-assembled module type to be used in ~TcpServerApp. One instance of this module type is launched by ~TcpServerListener for each incoming connection. It is composed of a traffic source, a traffic sink, a socket I/O and other modules, and most of the module types are parametric. The traffic source and traffic sink modules can be built from queueing model elements.
TelnetClientApp	compound module	This client application contains a configurable pre-composed telnet traffic source and traffic sink.
TelnetClientTraffic	compound module	(no description)
UdpApp	compound module	Generates traffic for a UDP application. The traffic source and traffic sink modules can be built from queueing model elements.

Known subclasses

Name	Type	Description
IPacketDelayer	module interface	Interface for packet delayers.
IPacketPolicing	module interface	Interface for packet policing modules. A packet policing connects one input to one output. It operates in passive mode on its input and in active mode on its output. These modules usually meter various traffic properties and drop packets, but they never modify, delay or reorder packets.
IPacketPusher	module interface	Interface for packet pushers. A packet pusher connects one input to one output. Packets can be pushed into its input and it pushes packets into its output.
IPacketServer	module interface	Interface for packet server modules. A packet server is an active module which has one active input and one active output. Packets are pulled from the connected input module and pushed into the connected output module with an optional delay but without reordering.
IPacketShaper	module interface	Interface for packet shaper modules. A packet shaper connects one input to one output. It operates in passive mode both on its input and its output. These modules may delay and reorder packets but they never modify or drop packets.
ITrafficConditioner	module interface	Interface for traffic conditioner modules. A traffic conditioner connects one input to one output. It operates in passive mode on its input and in active mode on its output. Packets can be pushed into its input and packets can be pulled from its output. A traffic conditioner can drop, delay, and reorder packets, but it doesn't modify packets in any way.

Properties

Name	Value	Description
display	i=block/source

Source code

//
// Interface for active packet source modules.
// An active packet source, also called a producer, has one output that must
// be connected to a passive packet sink module. The active packet source is
// expected to push packets into the connected passive packet sink over time.
//
// @see ~PassivePacketSink, ~PacketServer, ~PacketClassifier, ~IPassivePacketSink
//
moduleinterface IActivePacketSource
{
    parameters:
        @display("i=block/source");
    gates:
        output out @labels(push);
}

File: src/inet/queueing/contract/IActivePacketSource.ned