P2pns Class Reference

#include <P2pns.h>

Inheritance diagram for P2pns:

BaseApp BaseRpc RpcListener

List of all members.


Detailed Description

Implementation of P2PNS: A distributed name service for P2PSIP.

Implementation of P2PNS: A distributed name service for P2PSIP

Public Member Functions

 P2pns ()
virtual ~P2pns ()

Private Member Functions

void initializeApp (int stage)
 initializes derived class-attributes
void finishApp ()
 collects statistical data of derived app
void handleTimerEvent (cMessage *msg)
 processes self-messages
bool handleRpc (BaseCallMessage *msg)
 Processes Remote-Procedure-Call invokation messages.
void handleRpcResponse (BaseResponseMessage *msg, int rpcId, simtime_t rtt)
 This method is called if an RPC response has been received.
void handleRpcTimeout (BaseCallMessage *msg, const TransportAddress &dest, int rpcId, const OverlayKey &destKey)
 This method is called if an RPC timeout has been reached.
void p2pnsRegisterRpc (P2pnsRegisterCall *registerCall)
void p2pnsResolveRpc (P2pnsResolveCall *registerCall)
void handleDHTputCAPIResponse (DHTputCAPIResponse *putResponse)
void handleDHTgetCAPIResponse (DHTgetCAPIResponse *gettResponse)
void handleLookupResponse (LookupResponse *lookupResponse)

Private Attributes

std::map< unsigned
int, BaseCallMessage * > 
rpcIdMap
 List of the Rpc Ids of the messages sent following the reception of an rpc request (the second member).
P2pnsCachep2pnsCache
 pointer to the name cache module
bool twoStageResolution
 Use the two stage name resolution (KBR/DHt).


Constructor & Destructor Documentation

P2pns::P2pns (  ) 

00031 {
00032     p2pnsCache = NULL;
00033 }

P2pns::~P2pns (  )  [virtual]

00036 {
00037     std::map<unsigned int, BaseCallMessage*>::iterator it = rpcIdMap.begin();
00038     while (it != rpcIdMap.end()) {
00039         cancelAndDelete(it->second);
00040         it++;
00041     }
00042     rpcIdMap.clear();
00043 }


Member Function Documentation

void P2pns::initializeApp ( int  stage  )  [private, virtual]

initializes derived class-attributes

Parameters:
stage the init stage

Reimplemented from BaseApp.

00046 {
00047     if (stage != MIN_STAGE_APP)
00048         return;
00049     
00050     twoStageResolution = par("twoStageResolution");
00051     
00052     p2pnsCache = check_and_cast<P2pnsCache*>
00053                      (parentModule()->submodule("p2pnsCache"));
00054 }

void P2pns::finishApp (  )  [private, virtual]

collects statistical data of derived app

Reimplemented from BaseApp.

00236 {
00237 }

void P2pns::handleTimerEvent ( cMessage *  msg  )  [private, virtual]

processes self-messages

method to handle self-messages should be overwritten in derived application if needed

Parameters:
msg self-message

Reimplemented from BaseApp.

00057 {
00058 }

bool P2pns::handleRpc ( BaseCallMessage *  msg  )  [private, virtual]

Processes Remote-Procedure-Call invokation messages.


This method should be overloaded when the overlay provides RPC functionality.

Returns:
true, if rpc has been handled

Reimplemented from BaseRpc.

00061 {
00062     // delegate messages
00063     RPC_SWITCH_START(msg)
00064     // RPC_DELEGATE( <messageName>[Call|Response], <methodToCall> )
00065     RPC_DELEGATE( P2pnsRegister, p2pnsRegisterRpc );
00066     RPC_DELEGATE( P2pnsResolve, p2pnsResolveRpc );
00067     RPC_SWITCH_END()
00068 
00069     return RPC_HANDLED;
00070 }

void P2pns::handleRpcResponse ( BaseResponseMessage *  msg,
int  rpcId,
simtime_t  rtt 
) [private, virtual]

This method is called if an RPC response has been received.

Parameters:
msg The response message.
rpcId The RPC id.
rtt The Round-Trip-Time of this RPC

Reimplemented from RpcListener.

00074 {
00075     RPC_SWITCH_START(msg)
00076     RPC_ON_RESPONSE( DHTputCAPI ) {
00077         EV << "DHTputCAPI RPC Response received: id=" << rpcId
00078         << " msg=" << *_DHTputCAPIResponse << " rtt=" << rtt << endl;
00079         handleDHTputCAPIResponse(_DHTputCAPIResponse);
00080         break;
00081     }
00082     RPC_ON_RESPONSE( DHTgetCAPI ) {
00083         EV << "DHTgetCAPI RPC Response received: id=" << rpcId
00084            << " msg=" << *_DHTgetCAPIResponse << " rtt=" << rtt << endl;
00085         handleDHTgetCAPIResponse(_DHTgetCAPIResponse);
00086         break;
00087     }
00088     RPC_ON_RESPONSE( Lookup ) {
00089             EV << "Lookup RPC Response received: id=" << rpcId
00090                << " msg=" << *_LookupResponse << " rtt=" << rtt << endl;
00091             handleLookupResponse(_LookupResponse);
00092             break;
00093     }
00094     RPC_SWITCH_END()
00095 }

void P2pns::handleRpcTimeout ( BaseCallMessage *  msg,
const TransportAddress dest,
int  rpcId,
const OverlayKey destKey 
) [private, virtual]

This method is called if an RPC timeout has been reached.

Parameters:
msg The original RPC message.
dest The destination node
rpcId The RPC id.
destKey the destination OverlayKey

Reimplemented from RpcListener.

00100 {
00101     opp_error("P2PNS::handleRpcTimeout(): Not implemented!");
00102 }

void P2pns::p2pnsRegisterRpc ( P2pnsRegisterCall *  registerCall  )  [private]

00105 {
00106     p2pnsCache->addData(registerCall->getName(),
00107                         registerCall->getAddress());
00108     
00109     DHTputCAPICall* dhtPutMsg = new DHTputCAPICall();
00110 
00111     dhtPutMsg->setKey(OverlayKey::sha1(registerCall->getName()));
00112     if (twoStageResolution) {
00113         dhtPutMsg->setValue(overlay->getThisNode().key.toString());
00114     } else {
00115         dhtPutMsg->setValue(registerCall->getAddress());
00116     }
00117     
00118     dhtPutMsg->setTtl(registerCall->getTtl());
00119     dhtPutMsg->setIsModifiable(true);
00120 
00121     int nonce = sendInternalRpcCall(TIER1_COMP, dhtPutMsg); 
00122 
00123     rpcIdMap.insert(make_pair(nonce, registerCall));
00124 }

void P2pns::p2pnsResolveRpc ( P2pnsResolveCall *  registerCall  )  [private]

00127 {
00128     DHTgetCAPICall* dhtGetMsg = new DHTgetCAPICall();
00129 
00130     dhtGetMsg->setKey(OverlayKey::sha1(resolveCall->getName()));
00131         
00132     int nonce = sendInternalRpcCall(TIER1_COMP, dhtGetMsg);
00133     
00134     rpcIdMap.insert(make_pair(nonce, resolveCall));
00135 }

void P2pns::handleDHTputCAPIResponse ( DHTputCAPIResponse *  putResponse  )  [private]

00138 {
00139     std::map<unsigned int, BaseCallMessage*>::iterator it =
00140             rpcIdMap.find(putResponse->getNonce());
00141     if (it == rpcIdMap.end() || it->second == NULL) {
00142         opp_error("P2PNS::handleDHTputCAPIResponse(): Unknown nonce!");
00143         return;
00144     }
00145 
00146     P2pnsRegisterCall* registerCall =
00147             check_and_cast<P2pnsRegisterCall*>(it->second);
00148 
00149     rpcIdMap.erase(putResponse->getNonce());
00150 
00151     P2pnsRegisterResponse* registerResponse = new P2pnsRegisterResponse();
00152     registerResponse->setName(registerCall->getName());
00153     registerResponse->setAddress(registerCall->getAddress());
00154     registerResponse->setIsSuccess(putResponse->getIsSuccess());
00155     sendRpcResponse(registerCall, registerResponse);
00156 }

void P2pns::handleDHTgetCAPIResponse ( DHTgetCAPIResponse *  gettResponse  )  [private]

00159 {
00160     std::map<unsigned int, BaseCallMessage*>::iterator it =
00161             rpcIdMap.find(getResponse->getNonce());
00162     if (it == rpcIdMap.end() || it->second == NULL) {
00163         opp_error("P2PNS::handleDHTgetCAPIResponse(): Unknown nonce!");
00164         return;
00165     }
00166 
00167     P2pnsResolveCall* resolveCall =
00168             check_and_cast<P2pnsResolveCall*>(it->second);
00169 
00170     rpcIdMap.erase(getResponse->getNonce());
00171     
00172     std::stringstream valueStream;
00173     valueStream << getResponse->getValue();
00174             
00175     if ((!getResponse->getIsSuccess())
00176             || (valueStream.str().size() == 0)) {
00177         P2pnsResolveResponse* resolveResponse = new P2pnsResolveResponse();
00178         resolveResponse->setName(resolveCall->getName());
00179         resolveResponse->setAddress(BinaryValue(""));
00180         resolveResponse->setIsSuccess(false);
00181         sendRpcResponse(resolveCall, resolveResponse);
00182         return;
00183     }
00184 
00185     p2pnsCache->addData(resolveCall->getName(),
00186                         getResponse->getValue());
00187 
00188     if (twoStageResolution) {
00189         OverlayKey key(valueStream.str(), 16);
00190         
00191         LookupCall* lookupCall = new LookupCall();
00192         
00193         lookupCall->setKey(key);
00194         lookupCall->setNumSiblings(1);
00195             
00196         int nonce = sendInternalRpcCall(OVERLAY_COMP, lookupCall);
00197         
00198         rpcIdMap.insert(make_pair(nonce, resolveCall));
00199         
00200         return;
00201     }
00202     
00203     P2pnsResolveResponse* resolveResponse = new P2pnsResolveResponse();
00204     resolveResponse->setName(resolveCall->getName());
00205     resolveResponse->setAddress(getResponse->getValue());
00206     resolveResponse->setIsSuccess(getResponse->getIsSuccess());
00207     sendRpcResponse(resolveCall, resolveResponse);
00208 }

void P2pns::handleLookupResponse ( LookupResponse *  lookupResponse  )  [private]

00211 {
00212     std::map<unsigned int, BaseCallMessage*>::iterator it =
00213             rpcIdMap.find(lookupResponse->getNonce());
00214     if (it == rpcIdMap.end() || it->second == NULL) {
00215         opp_error("P2PNS::handleLookupResponse(): Unknown nonce!");
00216         return;
00217     }
00218 
00219     P2pnsResolveCall* resolveCall =
00220             check_and_cast<P2pnsResolveCall*>(it->second);
00221 
00222     rpcIdMap.erase(lookupResponse->getNonce());
00223     
00224     stringstream sstream;
00225     sstream << lookupResponse->getSiblings(0);
00226     
00227     P2pnsResolveResponse* resolveResponse = new P2pnsResolveResponse();
00228     resolveResponse->setName(resolveCall->getName());
00229     resolveResponse->setAddress(sstream.str());
00230     resolveResponse->setIsSuccess(lookupResponse->getIsValid());
00231     sendRpcResponse(resolveCall, resolveResponse);
00232 }


Member Data Documentation

std::map<unsigned int, BaseCallMessage*> P2pns::rpcIdMap [private]

List of the Rpc Ids of the messages sent following the reception of an rpc request (the second member).

P2pnsCache* P2pns::p2pnsCache [private]

pointer to the name cache module

bool P2pns::twoStageResolution [private]

Use the two stage name resolution (KBR/DHt).


The documentation for this class was generated from the following files:
Generated on Thu Apr 17 13:19:29 2008 for ITM OverSim by  doxygen 1.5.3