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.

<b>See also:</b> ~TcpServerApp, ~TcpServerListener

Usage diagram

The following diagram shows usage relationships between types. Unresolved types are missing from the diagram.

Inheritance diagram

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

Known subclasses

Name	Type	Description
TcpRequestResponseApp	compound module	A generic request/response based server application. For each request it receives, it generates a different traffic based on the data the request contains. The client application can be any source that is capable of generating packets with different data. The first byte of the packet data determines the response traffic, which can be configured to produce complex streams of packets with various data and timing distributions.

Properties

Name	Value	Description
application
display	i=block/cogwheel

Gates

Name	Direction	Size	Description
socketIn	input
socketOut	output

Unassigned submodule parameters

Name	Type	Default value	Description
io.displayStringTextFormat	string	""	Determines the text that is written on top of the submodule, supports displaying pars, watches, and module-specific information
io.readSize	int	-1B	Used only with autoRead==false
io.readDelay	double	-1s	Used only with autoRead==false; delay for issuing a READ command after previous READ was satisfied; -1 means immediately, 0 means zero delay

Source code

//
// 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.
//
// @see ~TcpServerApp, ~TcpServerListener
//
module TcpServerConnection like IApp
{
    parameters:
        @application;
        @display("i=block/cogwheel");
    gates:
        input socketIn;
        output socketOut;
    submodules:
        source: <default("ActivePacketSource")> like IActivePacketSource if typename != "" {
            parameters:
                @display("p=200,150");
        }
        tagger: <default("")> like IPacketFlow {
            parameters:
                @display("p=200,300");
        }
        measurementStarter: <default("")> like IPacketFlow {
            parameters:
                @display("p=200,450");
        }
        sink: <default("PassivePacketSink")> like IPassivePacketSink if typename != "" {
            parameters:
                @display("p=500,150");
        }
        measurementRecorder: <default("")> like IPacketFlow {
            parameters:
                @display("p=500,450");
        }
        io: TcpServerSocketIo {
            parameters:
                @display("p=350,600");
        }
    connections allowunconnected:
        source.out --> tagger.in if exists(source);
        tagger.out --> measurementStarter.in;
        measurementStarter.out --> io.trafficIn;
        io.socketOut --> { @display("m=s"); } --> socketOut;

        socketIn --> { @display("m=s"); } --> io.socketIn;
        io.trafficOut --> measurementRecorder.in;
        measurementRecorder.out --> sink.in if exists(sink);
}

File: src/inet/applications/tcpapp/TcpServerConnection.ned