BasePathLookup Class Reference

#include <BaseLookup.h>

List of all members.


Detailed Description

This class implements a path lookup.

Author:
Sebastian Mies


Protected Member Functions

bool accepts (int rpcId)
void handleResponse (FindNodeResponse *msg)
void handleTimeout (BaseCallMessage *msg, const TransportAddress &dest, int rpcId)
void handleFailedNodeResponse (const NodeHandle &src, cMessage *findNodeExt, bool retry)
 BasePathLookup (BaseLookup *lookup)
virtual ~BasePathLookup ()
virtual FindNodeCallcreateRpcMessage (cMessage *findNodeExt=NULL)
 Creates a find node call message.
void add (const NodeHandle &handle, const NodeHandle &source=NodeHandle::UNSPECIFIED_NODE)
 Adds a NodeHandle to next hops.

Protected Attributes

BaseLookuplookup
int hops
int step
int pendingRpcs
bool finished
bool success
NodePairVector nextHops
std::map< TransportAddress,
NodeHandle
oldNextHops

Private Member Functions

void sendRpc (int num, cMessage *FindNodeExt=NULL)

Friends

class BaseLookup


Constructor & Destructor Documentation

BasePathLookup::BasePathLookup ( BaseLookup lookup  )  [protected]

00469 {
00470     this->lookup = lookup;
00471     this->hops = 0;
00472     this->step = 0;
00473     this->pendingRpcs = 0;
00474     this->finished = false;
00475     this->success = false;
00476     this->nextHops = NodePairVector( lookup->config.numNextHops, lookup );
00477 }

BasePathLookup::~BasePathLookup (  )  [protected, virtual]

00480 {}


Member Function Documentation

bool BasePathLookup::accepts ( int  rpcId  )  [protected]

00483 {
00484     bool accept = ( rpcId == step ) && !finished;
00485     return accept;
00486 }

void BasePathLookup::add ( const NodeHandle handle,
const NodeHandle source = NodeHandle::UNSPECIFIED_NODE 
) [protected]

Adds a NodeHandle to next hops.

00701 {
00702     if ( lookup->config.merge )
00703         nextHops.add( std::pair<NodeHandle, NodeHandle>(handle, source) );
00704     else
00705         nextHops.push_back( std::pair<NodeHandle, NodeHandle>(handle, source) );
00706 }

FindNodeCall * BasePathLookup::createRpcMessage ( cMessage *  findNodeExt = NULL  )  [protected, virtual]

Creates a find node call message.

This method can be overridden to add some additional state information to the FindNodeCall message.

Parameters:
findNodeExt Pointer to a optional cMessage, that may contain overlay specific data to be attached to FindNode RPCs and BaseRouteMessages
Returns:
Pointer to a new FindNodeCall message.
00685 {
00686     // create default find node call message
00687     FindNodeCall* call = new FindNodeCall( "FindNodeCall" );
00688     call->setLookupKey( lookup->key );
00689     call->setLength( FINDNODECALL_L(call) );
00690 
00691     // duplicate extension object
00692     if ( findNodeExt != NULL ) {
00693         call->addObject( (cObject*)findNodeExt->dup() );
00694         call->addLength( findNodeExt->length() );
00695     }
00696 
00697     return call;
00698 }

void BasePathLookup::handleFailedNodeResponse ( const NodeHandle src,
cMessage *  findNodeExt,
bool  retry 
) [protected]

00615 {
00616     if (finished) return;
00617     
00618     std::map<TransportAddress, NodeHandle>::iterator oldPos;
00619     for (oldPos = oldNextHops.begin(); oldPos != oldNextHops.end(); oldPos++)
00620         if ((! oldPos->second.isUnspecified()) &&
00621                 (oldPos->second == src)) break;
00622 
00623     if (oldPos == oldNextHops.end()) return;
00624     if (retry)
00625     {
00626         lookup->sendRpc(src, createRpcMessage(findNodeExt), this, hops);
00627     }
00628     else
00629     {
00630         pendingRpcs--;
00631     }
00632 
00633     oldNextHops.erase(oldPos);
00634 
00635     // last rpc? yes-> send next rpc
00636     if ( pendingRpcs == 0 )
00637         sendRpc( 1 );
00638 }

void BasePathLookup::handleResponse ( FindNodeResponse msg  )  [protected]

00489 {
00490     if (finished)
00491         return;
00492 
00493     const NodeHandle& source = msg->getSrcNode();
00494     std::map<TransportAddress, NodeHandle>::iterator oldPos;
00495     oldPos = oldNextHops.find(source);
00496     if (oldPos != oldNextHops.end()) oldNextHops.erase(oldPos);
00497 
00498     // increase hops: FIXME don't count local hops
00499     if (lookup->overlay->getThisNode() != source)
00500         hops++;
00501     step++;
00502 
00503     // decrease pending rpcs
00504     pendingRpcs--;
00505 
00506     // mode: merge or replace
00507     if (!lookup->config.merge) {
00508         nextHops.clear();
00509     }
00510 
00511     // add new next hops
00512     for ( uint i=0; i < msg->getClosestNodesArraySize(); i++ ) {
00513         const NodeHandle& handle = msg->getClosestNodes(i);
00514 
00515         // add NodeHandle to next hops and neighborhood
00516         add( handle, source ); 
00517 
00518         // check if node was found
00519         if ( handle.key == lookup->key && !lookup->config.secure ) {
00520             lookup->addNeighbor( handle );
00521 
00522             // TODO: definition of hop count for iterative lookups is unclear
00523             // don't count local hops
00524             if (lookup->overlay->getThisNode() != msg->getSrcNode()) {
00525 //                        && (lookup->key != msg->getSrcNode().key)) {
00526                 hops++;
00527             }
00528             finished = true;
00529             success = true;
00530             return;
00531         } else
00532         if (lookup->numNeighbors != 0 && !lookup->config.secure && msg->getNeighbors() )
00533             lookup->addNeighbor( handle );
00534 
00535     }
00536 
00537     // check if neighborlookup is finished
00538     if ( msg->getNeighbors() && msg->getClosestNodesArraySize() != 0 &&
00539             lookup->numNeighbors != 0 && !lookup->config.secure ) {
00540 
00541         finished = true;
00542         success = true;
00543         return;
00544     }
00545 
00546     // extract find node extension object
00547     cMessage* findNodeExt = NULL;
00548     if (msg->hasObject("findNodeExt"))
00549         findNodeExt = (cMessage*)msg->removeObject("findNodeExt");
00550 
00551     // send next rpcs
00552     sendRpc( lookup->config.parallelRpcs, findNodeExt );
00553 
00554     // ...
00555     delete findNodeExt;
00556 }

void BasePathLookup::handleTimeout ( BaseCallMessage msg,
const TransportAddress dest,
int  rpcId 
) [protected]

00561 {
00562     if (finished)
00563         return;
00564 
00565     EV << "BasePathLookup: Timeout of RPC " << rpcId << endl;
00566     
00567     std::map<TransportAddress, NodeHandle>::iterator oldPos;
00568     oldPos = oldNextHops.find(dest);
00569 
00570     if (oldPos == oldNextHops.end())
00571     {
00572         // decrease pending rpcs
00573         pendingRpcs--;
00574 
00575         // last rpc? yes-> send next rpc
00576         if (pendingRpcs==0) sendRpc(1);
00577     }
00578     else
00579     {
00580         cObject* findNodeExt = NULL;
00581         if (msg && msg->hasObject("findNodeExt")) {
00582             findNodeExt = msg->removeObject("findNodeExt");
00583         }
00584 
00585         if (oldPos->second.isUnspecified())
00586         {
00587             delete findNodeExt;
00588             pendingRpcs--;
00589             FindNodeCall* findNodeCall = dynamic_cast<FindNodeCall*>(msg);
00590             // answer was from local findNode()
00591             if (findNodeCall && lookup->overlay->handleFailedNode(dest))
00592             {
00593                 NodeVector* retry = lookup->overlay->findNode(
00594                         findNodeCall->getLookupKey());
00595                 for (NodeVector::iterator i = retry->begin();
00596                         i != retry->end(); i++)
00597                     nextHops.add(std::pair<NodeHandle, NodeHandle>(
00598                                 *i, NodeHandle::UNSPECIFIED_NODE));
00599                 delete(retry);
00600             }
00601             if (pendingRpcs==0) sendRpc(1);
00602         }
00603         else
00604         {
00605             FailedNodeCall* call = new FailedNodeCall("FailedNodeCall");
00606             call->setFailedNode(dest);
00607             if (findNodeExt) call->addObject(findNodeExt);
00608             lookup->overlay->sendRpcMessage(oldPos->second, call, lookup);
00609         }
00610     }
00611 }

void BasePathLookup::sendRpc ( int  num,
cMessage *  FindNodeExt = NULL 
) [private]

00641 {
00642     // path finished? yes -> quit
00643     if (finished)
00644         return;
00645 
00646     // check for maximum hop count
00647     if (lookup->hopCountMax && (hops >= lookup->hopCountMax)) {
00648         EV << "BasePathLookup::sendRpc(): Max hop count exceeded - "
00649            << "lookup failed!" << endl;
00650         finished = true;
00651         success = false;
00652         return;
00653     }
00654 
00655     // send rpc messages
00656 
00657     while ( num >= 0 && nextHops.size() != 0 ) {
00658 
00659         // get top node pair
00660         const std::pair<NodeHandle, NodeHandle>& pair = nextHops.front();
00661 
00662         // check if node has already been visited? no ->
00663 //      if ( !lookup->getVisited( pair.first ) ) {
00664 
00665             // send rpc to node increase pending rpcs
00666             pendingRpcs++;
00667             num--;
00668             lookup->sendRpc( pair.first, createRpcMessage( findNodeExt ),
00669                              this, step );
00670             oldNextHops[pair.first] = pair.second;
00671 //      }
00672 
00673         // delete first element and continue
00674         nextHops.erase( nextHops.begin() );
00675     }
00676 
00677     // no rpc sent and no pending rpcs? -> failed
00678     if ( pendingRpcs == 0 ) {
00679         finished = true;
00680         success = false;
00681     }
00682 }


Friends And Related Function Documentation

friend class BaseLookup [friend]


Member Data Documentation

bool BasePathLookup::finished [protected]

int BasePathLookup::hops [protected]

BaseLookup* BasePathLookup::lookup [protected]

NodePairVector BasePathLookup::nextHops [protected]

std::map<TransportAddress, NodeHandle> BasePathLookup::oldNextHops [protected]

int BasePathLookup::pendingRpcs [protected]

int BasePathLookup::step [protected]

bool BasePathLookup::success [protected]


The documentation for this class was generated from the following files:
Generated on Fri May 11 14:52:39 2007 for ITM OverSim by  doxygen 1.4.7