Broose.h

Go to the documentation of this file.

//
// Copyright (C) 2007 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 __BROOSE_H_
#define __BROOSE_H_

#include <omnetpp.h>
#include <BaseOverlay.h>
#include <RpcListener.h>
#include <OverlayKey.h>
#include "BrooseHandle.h"
#include "BrooseBucket.h"
#include "BrooseMessage_m.h"

#include <map>
#include <vector>

class BrooseBucket;

class Broose : public BaseOverlay
{
  public:
    Broose();
    ~Broose();

    // see BaseOverlay.h
    virtual void initializeOverlay(int stage);

    // see BaseOverlay.h
    virtual void finishOverlay();

    // see BaseOverlay.h
    virtual bool isSiblingFor(const NodeHandle& node,
                              const OverlayKey& key,
                              int numSiblings,
                              bool* err);

    // see BaseOverlay.h
    virtual void joinOverlay();

    // see BaseOverlay.h
    virtual void recordOverlaySentStats(BaseOverlayMessage* msg);

    // see BaseOverlay.h
    virtual bool handleRpcCall(BaseCallMessage* msg);

    // see BaseOverlay.h
    virtual void handleTimerEvent(cMessage* msg);

    void updateTooltip();

  protected:
    //parameter
    int chooseLookup; 
    simtime_t joinDelay; 
    int receivedJoinResponse; 
    int receivedBBucketLookup; 
    int numberBBucketLookup; 
    int receivedLBucketLookup; 
    int numberLBucketLookup;  
    int shiftingBits; 
    int powShiftingBits; 
    uint32_t bucketSize;  
    uint32_t rBucketSize; 
    int keyLength; 
    simtime_t refreshTime; 
    uint32_t userDist; 
    int numberRetries; 
    int bucketRetries; 
    bool stab1;
    bool stab2;

    //statistics
    int bucketCount; 
    int bucketBytesSent; 
    int numFailedPackets; 
    //module references
    BrooseBucket *lBucket, *bBucket;  
    BrooseBucket **rBucket;  
    std::vector<BrooseBucket*> bucketVector; 
    // timer
    cMessage* join_timer;  
    cMessage* bucket_timer; 
    //node handles
    TransportAddress bootstrapNode;  
    //functions

    void handleJoinTimerExpired(cMessage* msg);

    void handleBucketTimerExpired(cMessage* msg);

    int getRoutingDistance(const OverlayKey& key, const OverlayKey& node,
                           int dist);

    bool routingAdd(const NodeHandle& node, bool isAlive,
                    simtime_t rtt = MAXTIME);

    void changeState(int state);

    // see BaseOverlay.h
    NodeVector* findNode(const OverlayKey& key,
                         int numRedundantNodes,
                         int numSiblings,
                         BaseOverlayMessage* msg);

    // see BaseOverlay.h
    int getMaxNumSiblings();

    // see BaseOverlay.h
    int getMaxNumRedundantNodes();

    void displayBucketState();

    // see BaseOverlay.h
    void handleRpcResponse(BaseResponseMessage* msg,
                           const RpcState& rpcState,
                           simtime_t rtt);

    // see BaseOverlay.h
    void handleRpcTimeout(const RpcState& rpcState);

    void handleFindNodeTimeout(FindNodeCall* findNode,
                               const TransportAddress& dest,
                               const OverlayKey& destKey);

    void handleBucketRequestRpc(BucketCall* msg);

    void handleBucketResponseRpc(BucketResponse* msg, const RpcState& rpcState);

    void handleBucketTimeout(BucketCall* msg);

    void routingTimeout(const BrooseHandle& handle);

    // see BaseRpc.h
    virtual void pingResponse(PingResponse* pingResponse,
                              cPolymorphic* context, int rpcId,
                              simtime_t rtt);

    // see BaseRpc.h
    virtual void pingTimeout(PingCall* pingCall,
                             const TransportAddress& dest,
                             cPolymorphic* context,
                             int rpcId);

    void setLastSeen(const NodeHandle& node);

    void addNode(const NodeHandle& node);

    void resetFailedResponses(const NodeHandle& node);

    void setRTT(const NodeHandle& node, simtime_t rtt);

    friend class BrooseBucket;
};



#endif