#include <BaseLookup.h>
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 FindNodeCall * | createRpcMessage (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 | |
BaseLookup * | lookup |
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 |
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 }
bool BasePathLookup::accepts | ( | int | rpcId | ) | [protected] |
void BasePathLookup::add | ( | const NodeHandle & | handle, | |
const NodeHandle & | source = NodeHandle::UNSPECIFIED_NODE | |||
) | [protected] |
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.
findNodeExt | Pointer to a optional cMessage, that may contain overlay specific data to be attached to FindNode RPCs and BaseRouteMessages |
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 }
friend class BaseLookup [friend] |
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] |