An example request-reply based client application. More...

#include <TCPBasicClientApp.h>

Inheritance diagram for inet::TCPBasicClientApp:

Public Member Functions
	TCPBasicClientApp ()

virtual	~TCPBasicClientApp ()

Public Member Functions inherited from inet::TCPSocket::CallbackInterface
virtual	~CallbackInterface ()

virtual void	socketDeleted (int connId, void *yourPtr)

Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Member Functions
virtual void	sendRequest ()

virtual void	rescheduleOrDeleteTimer (simtime_t d, short int msgKind)

virtual int	numInitStages () const override

virtual void	initialize (int stage) override

virtual void	handleTimer (cMessage *msg) override

virtual void	socketEstablished (int connId, void *yourPtr) override

virtual void	socketDataArrived (int connId, void yourPtr, cPacket msg, bool urgent) override

virtual void	socketClosed (int connId, void *yourPtr) override

virtual void	socketFailure (int connId, void *yourPtr, int code) override

virtual bool	isNodeUp ()

virtual bool	handleOperationStage (LifecycleOperation operation, int stage, IDoneCallback doneCallback) override
	Perform one stage of a lifecycle operation. More...

Protected Member Functions inherited from inet::TCPAppBase
virtual void	handleMessage (cMessage *msg) override

virtual void	finish () override

virtual void	refreshDisplay () const override

virtual void	connect ()

virtual void	close ()

virtual void	sendPacket (cPacket *pkt)

virtual void	socketPeerClosed (int connId, void *yourPtr) override

virtual void	socketStatusArrived (int connId, void yourPtr, TCPStatusInfo status) override

Protected Attributes
cMessage *	timeoutMsg = nullptr

NodeStatus *	nodeStatus = nullptr

bool	earlySend = false

int	numRequestsToSend = 0

simtime_t	startTime

simtime_t	stopTime

Protected Attributes inherited from inet::TCPAppBase
TCPSocket	socket

int	numSessions

int	numBroken

int	packetsSent

int	packetsRcvd

int	bytesSent

int	bytesRcvd

Additional Inherited Members
Static Protected Attributes inherited from inet::TCPAppBase
static simsignal_t	connectSignal = registerSignal("connect")

static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")

static simsignal_t	sentPkSignal = registerSignal("sentPk")

Detailed Description

An example request-reply based client application.

Constructor & Destructor Documentation

inet::TCPBasicClientApp::TCPBasicClientApp ( )

inline

56 {}

inet::TCPBasicClientApp::~TCPBasicClientApp ( )

virtual

 {
     cancelAndDelete(timeoutMsg);
 }

Member Function Documentation

bool inet::TCPBasicClientApp::handleOperationStage	(	LifecycleOperation *	operation,
		int	stage,
		IDoneCallback *	doneCallback
	)

overrideprotectedvirtual

Perform one stage of a lifecycle operation.

Processing may be done entirely within this method, or may be a longer process that involves nonzero simulation time or several events, and is triggered by this method call.

Return value: true = "done"; false = "not yet done, will invoke doneCallback when done"

Implements inet::ILifecycle.

 {
     Enter_Method_Silent();
     if (dynamic_cast<NodeStartOperation *>(operation)) {
         if ((NodeStartOperation::Stage)stage == NodeStartOperation::STAGE_APPLICATION_LAYER) {
             simtime_t now = simTime();
             simtime_t start = std::max(startTime, now);
             if (timeoutMsg && ((stopTime < SIMTIME_ZERO) || (start < stopTime) || (start == stopTime && startTime == stopTime))) {
                 timeoutMsg->setKind(MSGKIND_CONNECT);
                 scheduleAt(start, timeoutMsg);
             }
         }
     }
     else if (dynamic_cast<NodeShutdownOperation *>(operation)) {
         if ((NodeShutdownOperation::Stage)stage == NodeShutdownOperation::STAGE_APPLICATION_LAYER) {
             cancelEvent(timeoutMsg);
             if (socket.getState() == TCPSocket::CONNECTED || socket.getState() == TCPSocket::CONNECTING || socket.getState() == TCPSocket::PEER_CLOSED)
                 close();
             // TODO: wait until socket is closed
         }
     }
     else if (dynamic_cast<NodeCrashOperation *>(operation)) {
         if ((NodeCrashOperation::Stage)stage == NodeCrashOperation::STAGE_CRASH)
             cancelEvent(timeoutMsg);
     }
     else
         throw cRuntimeError("Unsupported lifecycle operation '%s'", operation->getClassName());
     return true;
 }

void inet::TCPBasicClientApp::handleTimer ( cMessage * msg )

overrideprotectedvirtual

Implements inet::TCPAppBase.

 {
     switch (msg->getKind()) {
         case MSGKIND_CONNECT:
             connect();    // active OPEN
 
             // significance of earlySend: if true, data will be sent already
             // in the ACK of SYN, otherwise only in a separate packet (but still
             // immediately)
             if (earlySend)
                 sendRequest();
             break;
 
         case MSGKIND_SEND:
             sendRequest();
             numRequestsToSend--;
             // no scheduleAt(): next request will be sent when reply to this one
             // arrives (see socketDataArrived())
             break;
 
         default:
             throw cRuntimeError("Invalid timer msg: kind=%d", msg->getKind());
     }
 }

void inet::TCPBasicClientApp::initialize ( int stage )

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

 {
     TCPAppBase::initialize(stage);
     if (stage == INITSTAGE_LOCAL) {
         numRequestsToSend = 0;
         earlySend = false;    // TBD make it parameter
         WATCH(numRequestsToSend);
         WATCH(earlySend);
 
         startTime = par("startTime");
         stopTime = par("stopTime");
         if (stopTime >= SIMTIME_ZERO && stopTime < startTime)
             throw cRuntimeError("Invalid startTime/stopTime parameters");
     }
     else if (stage == INITSTAGE_APPLICATION_LAYER) {
         timeoutMsg = new cMessage("timer");
         nodeStatus = dynamic_cast<NodeStatus *>(findContainingNode(this)->getSubmodule("status"));
 
         if (isNodeUp()) {
             timeoutMsg->setKind(MSGKIND_CONNECT);
             scheduleAt(startTime, timeoutMsg);
         }
     }
 }

bool inet::TCPBasicClientApp::isNodeUp ( )

protectedvirtual

Referenced by initialize().

 {
     return !nodeStatus || nodeStatus->getState() == NodeStatus::UP;
 }

virtual int inet::TCPBasicClientApp::numInitStages ( ) const

inlineoverrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

45 { return NUM_INIT_STAGES; }

inet::NUM_INIT_STAGES

The number of initialization stages.

Definition: InitStages.h:116

void inet::TCPBasicClientApp::rescheduleOrDeleteTimer	(	simtime_t	d,
		short int	msgKind
	)

protectedvirtual

Referenced by socketClosed(), socketDataArrived(), and socketFailure().

 {
     cancelEvent(timeoutMsg);
 
     if (stopTime < SIMTIME_ZERO || d < stopTime) {
         timeoutMsg->setKind(msgKind);
         scheduleAt(d, timeoutMsg);
     }
     else {
         delete timeoutMsg;
         timeoutMsg = nullptr;
     }
 }

void inet::TCPBasicClientApp::sendRequest ( )

protectedvirtual

Referenced by handleTimer(), and socketEstablished().

 {
     long requestLength = par("requestLength");
     long replyLength = par("replyLength");
     if (requestLength < 1)
         requestLength = 1;
     if (replyLength < 1)
         replyLength = 1;
 
     GenericAppMsg *msg = new GenericAppMsg("data");
     msg->setByteLength(requestLength);
     msg->setExpectedReplyLength(replyLength);
     msg->setServerClose(false);
 
     EV_INFO << "sending request with " << requestLength << " bytes, expected reply length " << replyLength << " bytes,"
             << "remaining " << numRequestsToSend - 1 << " request\n";
 
     sendPacket(msg);
 }

void inet::TCPBasicClientApp::socketClosed	(	int	connId,
		void *	yourPtr
	)

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

 {
     TCPAppBase::socketClosed(connId, ptr);
 
     // start another session after a delay
     if (timeoutMsg) {
         simtime_t d = simTime() + (simtime_t)par("idleInterval");
         rescheduleOrDeleteTimer(d, MSGKIND_CONNECT);
     }
 }

void inet::TCPBasicClientApp::socketDataArrived	(	int	connId,
		void *	yourPtr,
		cPacket *	msg,
		bool	urgent
	)

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

 {
     TCPAppBase::socketDataArrived(connId, ptr, msg, urgent);
 
     if (numRequestsToSend > 0) {
         EV_INFO << "reply arrived\n";
 
         if (timeoutMsg) {
             simtime_t d = simTime() + (simtime_t)par("thinkTime");
             rescheduleOrDeleteTimer(d, MSGKIND_SEND);
         }
     }
     else if (socket.getState() != TCPSocket::LOCALLY_CLOSED) {
         EV_INFO << "reply to last request arrived, closing session\n";
         close();
     }
 }

void inet::TCPBasicClientApp::socketEstablished	(	int	connId,
		void *	yourPtr
	)

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

 {
     TCPAppBase::socketEstablished(connId, ptr);
 
     // determine number of requests in this session
     numRequestsToSend = par("numRequestsPerSession").longValue();
     if (numRequestsToSend < 1)
         numRequestsToSend = 1;
 
     // perform first request if not already done (next one will be sent when reply arrives)
     if (!earlySend)
         sendRequest();
 
     numRequestsToSend--;
 }

void inet::TCPBasicClientApp::socketFailure	(	int	connId,
		void *	yourPtr,
		int	code
	)

overrideprotectedvirtual

Reimplemented from inet::TCPAppBase.

 {
     TCPAppBase::socketFailure(connId, ptr, code);
 
     // reconnect after a delay
     if (timeoutMsg) {
         simtime_t d = simTime() + (simtime_t)par("reconnectInterval");
         rescheduleOrDeleteTimer(d, MSGKIND_CONNECT);
     }
 }