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, cPolymorphic *context, int rpcId, simtime_t rtt)
 This method is called if an RPC response has been received.
void handleRpcTimeout (BaseCallMessage *msg, const TransportAddress &dest, cPolymorphic *context, 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, P2pnsRegisterCall *registerCall)
void handleDHTgetCAPIResponse (DHTgetCAPIResponse *gettResponse, P2pnsResolveCall *resolveCall)
void handleLookupResponse (LookupResponse *lookupResponse, P2pnsResolveCall *resolveCall)

Private Attributes

P2pnsCachep2pnsCache
 pointer to the name cache module
bool twoStageResolution
 Use the two stage name resolution (KBR/DHt).


Constructor & Destructor Documentation

P2pns::P2pns (  ) 

00033 {
00034     p2pnsCache = NULL;
00035 }

P2pns::~P2pns (  )  [virtual]

00038 {
00039 }


Member Function Documentation

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

initializes derived class-attributes

Parameters:
stage the init stage

Reimplemented from BaseApp.

00042 {
00043     if (stage != MIN_STAGE_APP)
00044         return;
00045 
00046     twoStageResolution = par("twoStageResolution");
00047 
00048     p2pnsCache = check_and_cast<P2pnsCache*> (parentModule()->
00049             submodule("p2pnsCache"));
00050 }

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

collects statistical data of derived app

Reimplemented from BaseApp.

00208 {
00209 }

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.

00053 {
00054 }

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.

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

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

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

Parameters:
msg The response message.
context Pointer to an optional state object. The object has to be handled/deleted by the handleRpcResponse() code
rpcId The RPC id.
rtt The Round-Trip-Time of this RPC

Reimplemented from RpcListener.

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

void P2pns::handleRpcTimeout ( BaseCallMessage *  msg,
const TransportAddress dest,
cPolymorphic *  context,
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
context Pointer to an optional state object. The object has to be handled/deleted by the handleRpcResponse() code
rpcId The RPC id.
destKey the destination OverlayKey

Reimplemented from RpcListener.

00101 {
00102     throw new cRuntimeError("P2PNS::handleRpcTimeout(): Not implemented!");
00103 }

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

Referenced by handleRpc().

00106 {
00107     p2pnsCache->addData(registerCall->getP2pName(),
00108                         registerCall->getAddress());
00109 
00110     DHTputCAPICall* dhtPutMsg = new DHTputCAPICall();
00111 
00112     EV << "RegisterRpc: name: " << registerCall->getP2pName()
00113        << " addr: " << registerCall->getAddress() << endl;
00114 
00115     dhtPutMsg->setKey(OverlayKey::sha1(registerCall->getP2pName()));
00116     if (twoStageResolution) {
00117         dhtPutMsg->setValue(overlay->getThisNode().key.toString());
00118     } else {
00119         dhtPutMsg->setValue(registerCall->getAddress());
00120     }
00121 
00122     dhtPutMsg->setTtl(registerCall->getTtl());
00123     dhtPutMsg->setIsModifiable(true);
00124 
00125     sendInternalRpcCall(TIER1_COMP, dhtPutMsg, registerCall);
00126 }

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

Referenced by handleRpc().

00129 {
00130     DHTgetCAPICall* dhtGetMsg = new DHTgetCAPICall();
00131 
00132     EV << "ResolveRpc: name: " << resolveCall->getP2pName()
00133            << endl;
00134 
00135     dhtGetMsg->setKey(OverlayKey::sha1(resolveCall->getP2pName()));
00136 
00137     sendInternalRpcCall(TIER1_COMP, dhtGetMsg, resolveCall);
00138 }

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

Referenced by handleRpcResponse().

00142 {
00143     P2pnsRegisterResponse* registerResponse = new P2pnsRegisterResponse();
00144     registerResponse->setP2pName(registerCall->getP2pName());
00145     registerResponse->setAddress(registerCall->getAddress());
00146     registerResponse->setIsSuccess(putResponse->getIsSuccess());
00147     sendRpcResponse(registerCall, registerResponse);
00148 }

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

Referenced by handleRpcResponse().

00152 {
00153     std::stringstream valueStream;
00154     valueStream << getResponse->getValue();
00155 
00156     if ((!getResponse->getIsSuccess())
00157             || (valueStream.str().size() == 0)) {
00158         P2pnsResolveResponse* resolveResponse = new P2pnsResolveResponse();
00159         resolveResponse->setP2pName(resolveCall->getP2pName());
00160         resolveResponse->setAddress(BinaryValue(""));
00161         resolveResponse->setIsSuccess(false);
00162         sendRpcResponse(resolveCall, resolveResponse);
00163         return;
00164     }
00165 
00166     p2pnsCache->addData(resolveCall->getP2pName(),
00167                         getResponse->getValue());
00168 
00169     if (twoStageResolution) {
00170         OverlayKey key(valueStream.str(), 16);
00171 
00172         LookupCall* lookupCall = new LookupCall();
00173 
00174         lookupCall->setKey(key);
00175         lookupCall->setNumSiblings(1);
00176 
00177         sendInternalRpcCall(OVERLAY_COMP, lookupCall, resolveCall);
00178 
00179         return;
00180     }
00181 
00182     EV << "ResolveRpcResponse: name: " << resolveCall->getP2pName()
00183        << " addr: " << getResponse->getValue() << endl;
00184 
00185 
00186     P2pnsResolveResponse* resolveResponse = new P2pnsResolveResponse();
00187     resolveResponse->setP2pName(resolveCall->getP2pName());
00188     resolveResponse->setAddress(getResponse->getValue());
00189     resolveResponse->setIsSuccess(getResponse->getIsSuccess());
00190     sendRpcResponse(resolveCall, resolveResponse);
00191 }

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

Referenced by handleRpcResponse().

00195 {
00196     stringstream sstream;
00197     sstream << lookupResponse->getSiblings(0);
00198 
00199     P2pnsResolveResponse* resolveResponse = new P2pnsResolveResponse();
00200     resolveResponse->setP2pName(resolveCall->getP2pName());
00201     resolveResponse->setAddress(sstream.str());
00202     resolveResponse->setIsSuccess(lookupResponse->getIsValid());
00203     sendRpcResponse(resolveCall, resolveResponse);
00204 }


Member Data Documentation

pointer to the name cache module

Referenced by handleDHTgetCAPIResponse(), initializeApp(), P2pns(), and p2pnsRegisterRpc().

bool P2pns::twoStageResolution [private]

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

Referenced by handleDHTgetCAPIResponse(), initializeApp(), and p2pnsRegisterRpc().


The documentation for this class was generated from the following files:

Generated on Fri Sep 19 13:05:07 2008 for ITM OverSim by  doxygen 1.5.5