#include <P2pns.h>
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). | |
P2pnsCache * | p2pnsCache |
pointer to the name cache module | |
bool | twoStageResolution |
Use the two stage name resolution (KBR/DHt). |
P2pns::P2pns | ( | ) |
P2pns::~P2pns | ( | ) | [virtual] |
void P2pns::initializeApp | ( | int | stage | ) | [private, virtual] |
initializes derived class-attributes
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] |
void P2pns::handleTimerEvent | ( | cMessage * | msg | ) | [private, virtual] |
processes self-messages
method to handle self-messages should be overwritten in derived application if needed
msg | self-message |
Reimplemented from BaseApp.
bool P2pns::handleRpc | ( | BaseCallMessage * | msg | ) | [private, virtual] |
Processes Remote-Procedure-Call invokation messages.
This method should be overloaded when the overlay provides RPC functionality.
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.
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.
msg | The original RPC message. | |
dest | The destination node | |
rpcId | The RPC id. | |
destKey | the destination OverlayKey |
Reimplemented from RpcListener.
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 }
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).