UnderlayConfigurator.h

Go to the documentation of this file.

//
// Copyright (C) 2006 Institut fuer Telematik, Universitaet Karlsruhe (TH)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//

#ifndef _UNDERLAYCONFIGURATOR_H_
#define _UNDERLAYCONFIGURATOR_H_

#include <omnetpp.h>

class PeerInfo;
class ChurnGenerator;
class NodeType;
class TransportAddress;
class GlobalNodeList;
class GlobalStatistics;

#ifndef timersub
# define timersub(a, b, result)                                               \
do {                                                                        \
    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                             \
    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                          \
    if ((result)->tv_usec < 0) {                                              \
        --(result)->tv_sec;                                                     \
       (result)->tv_usec += 1000000;                                           \
    }                                                                         \
} while (0)
#endif

class UnderlayConfigurator : public cSimpleModule
{
public:

    UnderlayConfigurator();
    virtual ~UnderlayConfigurator();

    bool isInInitPhase() { return init; };

    bool isSimulationEndingSoon() { return simulationEndingSoon; };

    simtime_t getGracefulLeaveDelay() { return gracefulLeaveDelay; };


    bool isTransitionTimeFinished() { return transitionTimeFinished; };

    virtual TransportAddress* createNode(NodeType type, bool initialize=false) = 0;

    virtual void preKillNode(NodeType type, TransportAddress* addr=NULL) = 0;

    virtual void migrateNode(NodeType type, TransportAddress* addr=NULL) = 0;

    void initFinished();

    ChurnGenerator* getChurnGenerator(int typeID);

    uint8_t getChurnGeneratorNum();

    int getOverlayTerminalCount(){ return overlayTerminalCount;}

protected:

    int numInitStages() const;

    virtual void initialize(int stage);

    virtual void initializeUnderlay(int stage) = 0;

    virtual void handleTimerEvent(cMessage* msg);

    void finish();

    virtual void finishUnderlay();

    virtual void setDisplayString() = 0;

    void handleMessage(cMessage* msg);

    int overlayTerminalCount; 
    int firstNodeId; 
    simtime_t gracefulLeaveDelay; 
    double gracefulLeaveProbability; 

    GlobalNodeList* globalNodeList; 
    GlobalStatistics* globalStatistics; 
    std::vector<ChurnGenerator*> churnGenerator; 

    cMessage* endSimulationTimer; 
    cMessage* endSimulationNotificationTimer; 
    cMessage* endTransitionTimer; 

    struct timeval initFinishedTime; 
    struct timeval initStartTime; 

    simtime_t transitionTime; 
    simtime_t measurementTime; 

    static const int NUM_COLORS;
    static const char* colorNames[];

private:
    bool init;
    bool simulationEndingSoon;
    bool transitionTimeFinished;
    unsigned int initCounter;

    void consoleOut(const std::string& text);
};

#endif