inet::TcpServerHostApp Class Reference

Hosts a server application, to be subclassed from TCPServerProcess (which is a sSimpleModule). More...

#include <TcpServerHostApp.h>

Inheritance diagram for inet::TcpServerHostApp:

Public Member Functions
virtual	~TcpServerHostApp ()
virtual void	removeThread (TcpServerThreadBase *thread)
virtual void	threadClosed (TcpServerThreadBase *thread)
Public Member Functions inherited from inet::ApplicationBase
	ApplicationBase ()
Public Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual	~OperationalMixin ()
	}@ More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
Public Member Functions inherited from inet::TcpSocket::ICallback
virtual	~ICallback ()

Protected Types
typedef std::set< TcpServerThreadBase * >	ThreadSet
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual void	socketDataArrived (TcpSocket *socket, Packet *packet, bool urgent) override
	Notifies about data arrival, packet ownership is transferred to the callee. More...
virtual void	socketAvailable (TcpSocket *socket, TcpAvailableInfo *availableInfo) override
virtual void	socketEstablished (TcpSocket *socket) override
virtual void	socketPeerClosed (TcpSocket *socket) override
virtual void	socketClosed (TcpSocket *socket) override
virtual void	socketFailure (TcpSocket *socket, int code) override
virtual void	socketStatusArrived (TcpSocket *socket, TcpStatusInfo *status) override
virtual void	socketDeleted (TcpSocket *socket) override
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
Protected Member Functions inherited from inet::ApplicationBase
virtual bool	isInitializeStage (int stage) const override
virtual bool	isModuleStartStage (int stage) const override
virtual bool	isModuleStopStage (int stage) const override
Protected Member Functions inherited from inet::OperationalMixin< cSimpleModule >
virtual int	numInitStages () const override
virtual void	refreshDisplay () const override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual State	getInitialOperationalState () const
	Returns initial operational state: OPERATING or NOT_OPERATING. More...
virtual void	handleActiveOperationTimeout (cMessage *message)
virtual bool	isUp () const
	utility functions More...
virtual bool	isDown () const
virtual void	setOperationalState (State newState)
virtual void	scheduleOperationTimeout (simtime_t timeout)
virtual void	setupActiveOperation (LifecycleOperation *operation, IDoneCallback *doneCallback, State)
virtual void	delayActiveOperationFinish (simtime_t timeout)
virtual void	startActiveOperationExtraTime (simtime_t delay=SIMTIME_ZERO)
virtual void	startActiveOperationExtraTimeOrFinish (simtime_t extraTime)
virtual void	finishActiveOperation ()

Protected Attributes
TcpSocket	serverSocket
SocketMap	socketMap
ThreadSet	threadSet
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Friends
class	TcpServerThreadBase

Detailed Description

Hosts a server application, to be subclassed from TCPServerProcess (which is a sSimpleModule).

Creates one instance (using dynamic module creation) for each incoming connection. More info in the corresponding NED file.

Member Typedef Documentation

ThreadSet

typedef std::set<TcpServerThreadBase *> inet::TcpServerHostApp::ThreadSet

protected

Constructor & Destructor Documentation

~TcpServerHostApp()

virtual inet::TcpServerHostApp::~TcpServerHostApp ( )

inlinevirtual

{ socketMap.deleteSockets(); }

Member Function Documentation

finish()

void inet::TcpServerHostApp::finish ( )

overrideprotectedvirtual

Reimplemented in inet::TcpEchoApp, and inet::TcpSinkApp.

{
    // remove and delete threads
    while (!threadSet.empty())
        removeThread(*threadSet.begin());
}

Referenced by inet::TcpSinkApp::finish(), and inet::TcpEchoApp::finish().

handleCrashOperation()

void inet::TcpServerHostApp::handleCrashOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    // remove and delete threads
    while (!threadSet.empty()) {
        auto thread = *threadSet.begin();
        // TODO destroy!!!
        thread->getSocket()->close();
        removeThread(thread);
    }
    // TODO always?
    if (operation->getRootModule() != getContainingNode(this))
        serverSocket.destroy();
}

handleMessageWhenUp()

void inet::TcpServerHostApp::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage()) {
        TcpServerThreadBase *thread = (TcpServerThreadBase *)msg->getContextPointer();
        if (!contains(threadSet, thread))
            throw cRuntimeError("Invalid thread pointer in the timer (msg->contextPointer is invalid)");
        thread->timerExpired(msg);
    }
    else {
        TcpSocket *socket = check_and_cast_nullable<TcpSocket *>(socketMap.findSocketFor(msg));
        if (socket)
            socket->processMessage(msg);
        else if (serverSocket.belongsToSocket(msg))
            serverSocket.processMessage(msg);
        else {
//            throw cRuntimeError("Unknown incoming message: '%s'", msg->getName());
            EV_ERROR << "message " << msg->getFullName() << "(" << msg->getClassName() << ") arrived for unknown socket \n";
            delete msg;
        }
    }
}

handleStartOperation()

void inet::TcpServerHostApp::handleStartOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    const char *localAddress = par("localAddress");
    int localPort = par("localPort");
 
    serverSocket.setOutputGate(gate("socketOut"));
    serverSocket.setCallback(this);
    serverSocket.bind(localAddress[0] ? L3Address(localAddress) : L3Address(), localPort);
    serverSocket.listen();
}

handleStopOperation()

void inet::TcpServerHostApp::handleStopOperation ( LifecycleOperation *  operation )

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    for (auto thread : threadSet)
        thread->getSocket()->close();
    serverSocket.close();
    delayActiveOperationFinish(par("stopOperationTimeout"));
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

Reimplemented in inet::TcpEchoApp, and inet::TcpSinkApp.

{
    ApplicationBase::initialize(stage);
}

Referenced by inet::TcpSinkApp::initialize(), and inet::TcpEchoApp::initialize().

numInitStages()

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

inlineoverrideprotectedvirtual

Reimplemented in inet::TcpEchoApp, and inet::TcpSinkApp.

{ return NUM_INIT_STAGES; }

refreshDisplay()

void inet::TcpServerHostApp::refreshDisplay ( ) const

overrideprotectedvirtual

Reimplemented in inet::TcpEchoApp, and inet::TcpSinkApp.

{
    ApplicationBase::refreshDisplay();
 
    char buf[32];
    sprintf(buf, "%d threads", socketMap.size());
    getDisplayString().setTagArg("t", 0, buf);
}

removeThread()

void inet::TcpServerHostApp::removeThread ( TcpServerThreadBase *  thread )

virtual

{
    // remove socket
    socketMap.removeSocket(thread->getSocket());
    threadSet.erase(thread);
 
    // remove thread object
    thread->deleteModule();
}

Referenced by inet::TcpServerThreadBase::failure(), finish(), and handleCrashOperation().

socketAvailable()

void inet::TcpServerHostApp::socketAvailable ( TcpSocket *  socket, TcpAvailableInfo *  availableInfo  )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    // new TCP connection -- create new socket object and server process
    TcpSocket *newSocket = new TcpSocket(availableInfo);
    newSocket->setOutputGate(gate("socketOut"));
 
    const char *serverThreadModuleType = par("serverThreadModuleType");
    cModuleType *moduleType = cModuleType::get(serverThreadModuleType);
    char name[80];
    sprintf(name, "thread_%i", newSocket->getSocketId());
    TcpServerThreadBase *proc = check_and_cast<TcpServerThreadBase *>(moduleType->create(name, this));
    proc->finalizeParameters();
    proc->callInitialize();
 
    newSocket->setCallback(proc);
    proc->init(this, newSocket);
 
    socketMap.addSocket(newSocket);
    threadSet.insert(proc);
 
    socket->accept(availableInfo->getNewSocketId());
}

socketClosed()

void inet::TcpServerHostApp::socketClosed ( TcpSocket *  socket )

overrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{
    if (operationalState == State::STOPPING_OPERATION && threadSet.empty() && !serverSocket.isOpen())
        startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
}

Referenced by threadClosed().

socketDataArrived()

virtual void inet::TcpServerHostApp::socketDataArrived ( TcpSocket *  socket, Packet *  packet, bool  urgent  )

inlineoverrideprotectedvirtual

Notifies about data arrival, packet ownership is transferred to the callee.

Implements inet::TcpSocket::ICallback.

{ throw cRuntimeError("Unexpected data"); }

socketDeleted()

virtual void inet::TcpServerHostApp::socketDeleted ( TcpSocket *  socket )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{ socketMap.removeSocket(socket); }

Referenced by inet::TcpServerThreadBase::socketDeleted().

socketEstablished()

virtual void inet::TcpServerHostApp::socketEstablished ( TcpSocket *  socket )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{}

socketFailure()

virtual void inet::TcpServerHostApp::socketFailure ( TcpSocket *  socket, int  code  )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{}

socketPeerClosed()

virtual void inet::TcpServerHostApp::socketPeerClosed ( TcpSocket *  socket )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{}

socketStatusArrived()

virtual void inet::TcpServerHostApp::socketStatusArrived ( TcpSocket *  socket, TcpStatusInfo *  status  )

inlineoverrideprotectedvirtual

Implements inet::TcpSocket::ICallback.

{}

threadClosed()

void inet::TcpServerHostApp::threadClosed ( TcpServerThreadBase *  thread )

virtual

{
    // remove socket
    socketMap.removeSocket(thread->getSocket());
    threadSet.erase(thread);
 
    socketClosed(thread->getSocket());
 
    // remove thread object
    thread->deleteModule();
}

Referenced by inet::TcpServerThreadBase::socketClosed().

Friends And Related Function Documentation

TcpServerThreadBase

friend class TcpServerThreadBase

friend

Member Data Documentation

serverSocket

TcpSocket inet::TcpServerHostApp::serverSocket

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleStartOperation(), handleStopOperation(), and socketClosed().

socketMap

SocketMap inet::TcpServerHostApp::socketMap

protected

Referenced by handleMessageWhenUp(), inet::TcpSinkApp::refreshDisplay(), inet::TcpEchoApp::refreshDisplay(), refreshDisplay(), removeThread(), socketAvailable(), and threadClosed().

threadSet

ThreadSet inet::TcpServerHostApp::threadSet

protected

Referenced by finish(), handleCrashOperation(), handleMessageWhenUp(), handleStopOperation(), removeThread(), socketAvailable(), socketClosed(), and threadClosed().

---

The documentation for this class was generated from the following files:

• TcpServerHostApp.h
• TcpServerHostApp.cc