BaseOverlay.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 __BASEOVERLAY_H_
#define __BASEOVERLAY_H_

#include <oversim_mapset.h>

#include <omnetpp.h>

#include <NodeVector.h>
#include <TopologyVis.h>
#include <INotifiable.h>
#include <BaseRpc.h>
#include <BaseTcpSupport.h>
#include <IterativeLookupConfiguration.h>
#include <RecursiveLookup.h>
#include <InitStages.h>

class GlobalNodeList;
class UnderlayConfigurator;
class BaseApp;
class NodeHandle;
class OverlayKey;
class NotificationBoard;
class AbstractLookup;
class BootstrapList;

class BaseOverlay : public INotifiable,
                    public BaseRpc,
                    public BaseTcpSupport,
                    public TopologyVis
{

    friend class IterativeLookup;
    friend class IterativePathLookup;
    friend class RecursiveLookup;
    friend class BootstrapList;
    friend class SendToKeyListener;

    //------------------------------------------------------------------------
    //--- Construction / Destruction -----------------------------------------
    //------------------------------------------------------------------------

public:

    BaseOverlay();

    virtual ~BaseOverlay();

    enum States {
        INIT      = 0,
        BOOTSTRAP = 1,
        DISCOVERY = 2,
        PREJOIN   = 3,
        JOIN      = 4,
        POSTJOIN  = 5,
        READY     = 6,
        REFRESH   = 7,
        SHUTDOWN  = 8,
        FAILED    = 9,

        //some aliases for compatibility
        RSET      = JOIN,
        BSET      = POSTJOIN
    };

    States getState() { return state; };

    class BaseOverlayContext : public cObject
    {
    public:
        BaseOverlayContext(const OverlayKey& key, bool malicious) : key(key), malicious(malicious) {};
        OverlayKey key;
        bool malicious;
    };


    //------------------------------------------------------------------------
    //--- Statistics ---------------------------------------------------------
    //------------------------------------------------------------------------

private://fields: statistics

    int numAppDataSent;   
    int bytesAppDataSent; 
    int numAppLookupSent;   
    int bytesAppLookupSent; 
    int numMaintenanceSent;   
    int bytesMaintenanceSent; 
    int numAppDataReceived;   
    int bytesAppDataReceived; 
    int numAppLookupReceived;   
    int bytesAppLookupReceived; 
    int numMaintenanceReceived;   
    int bytesMaintenanceReceived; 
    int numInternalSent;  
    int bytesInternalSent;  
    int numInternalReceived;  
    int bytesInternalReceived;  
    int bytesAuthBlockSent; 
    int joinRetries; 
protected:

    struct HopDelayRecord
    {
        int count;
        simtime_t val;
        HopDelayRecord() : count(0), val(0) {};
    };

    int numAppDataForwarded;   
    int bytesAppDataForwarded; 
    int numAppLookupForwarded;   
    int bytesAppLookupForwarded; 
    int numMaintenanceForwarded;   
    int bytesMaintenanceForwarded; 
    int numFindNodeSent; 
    int bytesFindNodeSent; 
    int numFindNodeResponseSent; 
    int bytesFindNodeResponseSent; 
    int numFailedNodeSent; 
    int bytesFailedNodeSent; 
    int numFailedNodeResponseSent; 
    int bytesFailedNodeResponseSent; 
    std::vector<HopDelayRecord*> singleHopDelays; 
    simtime_t creationTime; 
    //------------------------------------------------------------------------
    //--- Common Overlay Attributes & Global Module References ---------------
    //------------------------------------------------------------------------

protected://fields: overlay attributes



    // references to global modules
    GlobalNodeList* globalNodeList;           
    NotificationBoard* notificationBoard;       
    UnderlayConfigurator* underlayConfigurator; 
    BootstrapList* bootstrapList; 
    GlobalParameters* globalParameters; 
    // overlay common parameters
    uint32_t overlayId;              
    bool debugOutput;           
    RoutingType defaultRoutingType;
    bool useCommonAPIforward;   
    bool collectPerHopDelay;    
    bool routeMsgAcks;          
    uint32_t recNumRedundantNodes;  
    bool recordRoute;   
    bool drawOverlayTopology;
    bool rejoinOnFailure;
    bool sendRpcResponseToLastHop; 
    bool dropFindNodeAttack; 
    bool isSiblingAttack; 
    bool invalidNodesAttack; 
    bool dropRouteMessageAttack; 
    int localPort;              
    int hopCountMax;            
    bool measureAuthBlock; 
    bool restoreContext; 
    int numDropped;             
    int bytesDropped;           
    cOutVector delayVector;     
    cOutVector hopCountVector;  
    States state;

    //------------------------------------------------------------------------
    //--- Initialization & finishing -----------------------------------------
    //------------------------------------------------------------------------

private://methods: cSimpleModule initialization

    void initialize(int stage);

    void finish();

protected://methods: overlay initialization

    int numInitStages() const;

    virtual void initializeOverlay( int stage );

    virtual void finishOverlay();

private:
    virtual void setOwnNodeID();

    //------------------------------------------------------------------------
    //--- General Overlay Parameters (getter and setters) --------------------
    //------------------------------------------------------------------------

public://methods: getters and setters

    bool isMalicious();

    bool isInSimpleMultiOverlayHost();

    const simtime_t& getCreationTime() { return creationTime; };


    //------------------------------------------------------------------------
    //--- UDP functions copied from the INET framework .----------------------
    //------------------------------------------------------------------------

protected:
    void bindToPort(int port);


    //------------------------------------------------------------------------
    //--- Overlay Common API: Key-based Routing ------------------------------
    //------------------------------------------------------------------------

protected://methods: KBR

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

    void callDeliver( BaseOverlayMessage* msg,
                      const OverlayKey& destKey);

    void callForward( const OverlayKey& key, BaseRouteMessage* msg,
                      const NodeHandle& nextHopNode);

    void callUpdate(const NodeHandle& node, bool joined);

public:

    void join(const OverlayKey& nodeID = OverlayKey::UNSPECIFIED_KEY);

    virtual NodeVector* local_lookup(const OverlayKey& key, int num, bool safe);


    virtual NodeVector* neighborSet(int num);

    virtual bool isSiblingFor(const NodeHandle& node,
                              const OverlayKey& key, int numSiblings, bool* err);

    virtual int getMaxNumSiblings();

    virtual int getMaxNumRedundantNodes();

    //------------------------------------------------------------------------
    //--- Message Handlers ---------------------------------------------------
    //------------------------------------------------------------------------

protected://methods: message handling

    void handleMessage(cMessage* msg);


    void handleBaseOverlayMessage(BaseOverlayMessage* msg,
                                  const OverlayKey& destKey =
                                      OverlayKey::UNSPECIFIED_KEY);

protected://methods: message handling

    virtual void handleUDPMessage(BaseOverlayMessage* msg);

    //virtual void handleTimerEvent(cMessage* msg);

    virtual void handleAppMessage(cMessage* msg);

    virtual void receiveChangeNotification(int category,
                                           const cPolymorphic* details);

    virtual void handleTransportAddressChangedNotification();

    virtual void handleNodeLeaveNotification();

    virtual void handleNodeGracefulLeaveNotification();


    virtual void recordOverlaySentStats(BaseOverlayMessage* msg);

protected://methods: icons and ui support

    void setOverlayReady( bool ready );

    //------------------------------------------------------------------------
    //--- Messages -----------------------------------------------------------
    //------------------------------------------------------------------------

private://methods: sending packets over udp

    void sendRouteMessage(const TransportAddress& dest,
                          BaseRouteMessage* msg,
                          bool ack);

    bool checkFindNode(BaseRouteMessage* routeMsg);

public:
    void sendMessageToUDP(const TransportAddress& dest, cPacket* msg,
                          simtime_t delay = SIMTIME_ZERO);

    //------------------------------------------------------------------------
    //--- Basic Routing ------------------------------------------------------
    //------------------------------------------------------------------------

protected://fields: config
    IterativeLookupConfiguration iterativeLookupConfig;
    RecursiveLookupConfiguration recursiveLookupConfig;

    class lookupHashFcn
    {
    public:
        size_t operator()( const AbstractLookup* l1 ) const
        {
            return (size_t)l1;
        }
        bool operator()(const AbstractLookup* l1,
                        const AbstractLookup* l2) const
        {
            return (l1 == l2);
        }
    };

    typedef UNORDERED_SET<AbstractLookup*, lookupHashFcn, lookupHashFcn> LookupSet;

    LookupSet lookups;

private://methods: internal routing

    void initLookups();

    void finishLookups();

    virtual bool recursiveRoutingHook(const TransportAddress& dest,
                                      BaseRouteMessage* msg);

public://methods: basic message routing

    void sendToKey(const OverlayKey& key, BaseOverlayMessage* message,
                   int numSiblings = 1,
                   const std::vector<TransportAddress>& sourceRoute
                             = TransportAddress::UNSPECIFIED_NODES,
                   RoutingType routingType = DEFAULT_ROUTING);

    virtual OverlayKey distance(const OverlayKey& x,
                                const OverlayKey& y,
                                bool useAlternative = false) const;

protected://methods: routing class factory

    virtual AbstractLookup* createLookup(RoutingType routingType = DEFAULT_ROUTING,
                                         const BaseOverlayMessage* msg = NULL,
                                         const cPacket* findNodeExt = NULL,
                                         bool appLookup = false);

    virtual void removeLookup( AbstractLookup* lookup );

    virtual NodeVector* findNode( const OverlayKey& key,
                                  int numRedundantNodes,
                                  int numSiblings,
                                  BaseOverlayMessage* msg = NULL);


    virtual void joinOverlay();

    virtual void joinForeignPartition(const NodeHandle& node);

    virtual bool handleFailedNode(const TransportAddress& failed);

    virtual void lookupRpc(LookupCall* call);

    virtual void nextHopRpc(NextHopCall* call);

protected://methods: statistic helpers for IterativeLookup

    void countFindNodeCall(const FindNodeCall* call);
    void countFailedNodeCall(const FailedNodeCall* call);


    bool internalHandleRpcCall( BaseCallMessage* msg );
    void internalHandleRpcResponse(BaseResponseMessage* msg,
                                   cPolymorphic* context, int rpcId,
                                   simtime_t rtt);
    void internalHandleRpcTimeout(BaseCallMessage* msg,
                                  const TransportAddress& dest,
                                  cPolymorphic* context,
                                  int rpcId, const OverlayKey& destKey);

    // TODO rename to internalSendRouteRpcMessage()
    void internalSendRouteRpc(BaseRpcMessage* message,
                              const OverlayKey& destKey,
                              const std::vector<TransportAddress>&
                              sourceRoute,
                              RoutingType routingType);

    /*
     * Returns the component type of this module
     *
     * @return the component type
     */
    CompType getThisCompType();

    bool kbr; 
private:
    void internalSendRpcResponse(BaseCallMessage* call,
                                 BaseResponseMessage* response);

    const cGate* udpGate;
    const cGate* appGate;

public:
    /*
     * Register a new component at the overlay
     *
     * @param compType The compoment type (defined in CommonMessages.msg)
     * @param module The module pointer of the component
     */
    void registerComp(CompType compType, cModule *module);

    /*
     * Get the module pointer of a registered component
     *
     * @param compType The compoment type (defined in CommonMessages.msg)
     * @return The module pointer of the component
     */
    cModule* getCompModule(CompType compType);

    /*
     * Get the direct_in gate of a registered component
     *
     * @param compType The compoment type (defined in CommonMessages.msg)
     * @return The pointer to the direct_in gate of the component
     */
    cGate* getCompRpcGate(CompType compType);

    /*
     * Sends a message to all currently registered components, but the
     * source component
     *
     * @param msg The pointer to the message to send
     * @param srcComp The type of the originating component
     *
     */
    void sendMessageToAllComp(cMessage* msg, CompType srcComp);

    /*
     * Returns true, if the overlay is a structured overlay and
     * provides KBR services (e.g. route, lookup, ...).
     */
    bool providesKbr() { return kbr; };

    virtual uint8_t getBitsPerDigit() { return 1; };

    bool getMeasureAuthBlock() { return measureAuthBlock; }

    BootstrapList& getBootstrapList() const { return *bootstrapList;}

    virtual OverlayKey estimateMeanDistance();

    virtual uint32_t estimateOverlaySize();

private:
    void findNodeRpc( FindNodeCall* call );
    void failedNodeRpc( FailedNodeCall* call );

    typedef std::map<CompType, std::pair<cModule*, cGate*> > CompModuleList;
    CompModuleList compModuleList;
    bool internalReadyState; 
    int socketId;
};

#endif