Gia.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 __GIA_H_
#define __GIA_H_


#include <vector>

#include <omnetpp.h>

#include <UDPAppBase.h>
#include <IPvXAddress.h>

#include <GlobalNodeList.h>
#include <UnderlayConfigurator.h>
#include <OverlayKey.h>
#include <NodeHandle.h>
#include <CommonMessages_m.h>
#include <BaseOverlay.h>

#include "GiaMessage_m.h"
#include "GiaKeyListModule.h"
#include "GiaKeyList.h"
#include "GiaNeighbors.h"
#include "GiaTokenFactory.h"
#include "GiaNode.h"
#include "GiaNeighborCandidateList.h"
#include "GiaMessageBookkeeping.h"


class Gia : public BaseOverlay
{
  public:
    void initializeOverlay(int stage);

    void finishOverlay();

    virtual void changeState(int toStage);

    void updateTooltip();
    //virtual void setBootstrapedIcon();

    // Gia
    ~Gia();

    void handleTimerEvent(cMessage* msg);

    void handleUDPMessage(BaseOverlayMessage* msg);

    // API for structured P2P overlays

    virtual void getRoute(const OverlayKey& key, CompType destComp,
                       CompType srcComp, cPacket* msg,
                       const std::vector<TransportAddress>& sourceRoute
                           = TransportAddress::UNSPECIFIED_NODES,
                       RoutingType routingType = DEFAULT_ROUTING);

    void handleAppMessage(cMessage* msg);

    void sendToken(const GiaNode& dst);

  protected:
    // parameters from OMNeT.ini
    uint32_t maxNeighbors; 
    uint32_t minNeighbors; 
    uint32_t maxTopAdaptionInterval; 
    uint32_t topAdaptionAggressiveness; 
    double maxLevelOfSatisfaction; 
    double updateDelay; 
    uint32_t maxHopCount; 
    uint32_t messageTimeout; 
    uint32_t neighborTimeout; 
    uint32_t sendTokenTimeout; 
    uint32_t tokenWaitTime; 
    double keyListDelay; 
    bool outputNodeDetails; 
    bool optimizeReversePath; 
    double levelOfSatisfaction; 
    unsigned int connectionDegree;
    unsigned int receivedTokens;
    unsigned int sentTokens;

    // node references
    GiaNode thisGiaNode; 
    NodeHandle bootstrapNode; 
    GiaMessageBookkeeping* msgBookkeepingList; 
    // statistics
    uint32_t stat_joinCount; 
    uint32_t stat_joinBytesSent; 
    uint32_t stat_joinREQ; 
    uint32_t stat_joinREQBytesSent;  
    uint32_t stat_joinRSP; 
    uint32_t stat_joinRSPBytesSent; 
    uint32_t stat_joinACK; 
    uint32_t stat_joinACKBytesSent; 
    uint32_t stat_joinDNY; 
    uint32_t stat_joinDNYBytesSent; 
    uint32_t stat_disconnectMessages; 
    uint32_t stat_disconnectMessagesBytesSent; 
    uint32_t stat_updateMessages; 
    uint32_t stat_updateMessagesBytesSent; 
    uint32_t stat_tokenMessages; 
    uint32_t stat_tokenMessagesBytesSent; 
    uint32_t stat_keyListMessages; 
    uint32_t stat_keyListMessagesBytesSent; 
    uint32_t stat_routeMessages; 
    uint32_t stat_routeMessagesBytesSent; 
    uint32_t stat_maxNeighbors; 
    uint32_t stat_addedNeighbors; 
    uint32_t stat_removedNeighbors; 
    uint32_t stat_numSatisfactionMessages; 
    double stat_sumLevelOfSatisfaction; 
    double stat_maxLevelOfSatisfaction; 
    // self-messages
    cMessage* satisfaction_timer; 
    cMessage* update_timer; 
    cMessage* timedoutMessages_timer; 
    cMessage* timedoutNeighbors_timer; 
    cMessage* sendKeyList_timer; 
    cMessage* sendToken_timer; 
    // module references
    GiaKeyListModule* keyListModule; 
    GiaNeighbors* neighbors; 
    GiaTokenFactory* tokenFactory; 
    // internal
    GiaNeighborCandidateList neighCand; 
    GiaNeighborCandidateList knownNodes; 
    GiaKeyList keyList; 
    // internal methodes

    void joinOverlay();

    bool acceptNode(const GiaNode& newNode, unsigned int degree);

    void addNeighbor(GiaNode& newNode, unsigned int degree);

    void removeNeighbor(const GiaNode& newNode);

    double calculateLevelOfSatisfaction();

    void sendMessage_JOIN_REQ(const NodeHandle& dst);

    void sendMessage_JOIN_RSP(const NodeHandle& dst);

    void sendMessage_JOIN_ACK(const NodeHandle& dst);

    void sendMessage_JOIN_DNY(const NodeHandle& dst);

    void sendMessage_DISCONNECT(const NodeHandle& dst);

    void sendMessage_UPDATE(const NodeHandle& dst);

    void sendKeyListToNeighbor(const NodeHandle& dst);

    void updateNeighborList(GiaMessage* msg);

    void forwardSearchResponseMessage(SearchResponseMessage* msg);

    void forwardMessage(GiaIDMessage* msg, bool fromApplication);

    void processSearchMessage(SearchMessage* msg, bool fromApplication);

    void sendSearchResponseMessage(const GiaNode& srcNode, SearchMessage* msg);

    void deliverSearchResult(SearchResponseMessage* msg);
};

#endif