MyOverlay.cc
Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00023 #include <iostream>
00024
00025 #include <UnderlayConfigurator.h>
00026 #include <GlobalStatistics.h>
00027
00028 #include "MyOverlay_m.h"
00029
00030 #include "MyOverlay.h"
00031
00032
00033
00034 Define_Module(MyOverlay);
00035
00036
00037 #define BIGBIT (1 << 24)
00038
00039
00040
00041 void MyOverlay::initializeOverlay(int stage)
00042 {
00043
00044 if (stage != MIN_STAGE_OVERLAY) return;
00045
00046
00047 myKey = thisNode.getAddress().get4().getInt() & ~BIGBIT;
00048
00049
00050 numDropped = 0;
00051 if (!(par("enableDrops"))) {
00052 dropChance = 0;
00053 } else {
00054 dropChance = par("dropChance");
00055 }
00056
00057 rpcTimer = new cMessage("RPC timer");
00058 scheduleAt(simTime() + 5, rpcTimer);
00059 }
00060
00061
00062 void MyOverlay::setOwnNodeID()
00063 {
00064
00065 thisNode.setKey(OverlayKey(myKey));
00066 }
00067
00068
00069
00070 void MyOverlay::joinOverlay()
00071 {
00072
00073 prevNode.setAddress(IPAddress(BIGBIT | (myKey - 1)));
00074 prevNode.setPort(thisNode.getPort());
00075 prevNode.setKey(OverlayKey(myKey - 1));
00076
00077
00078 nextNode.setAddress(IPAddress(BIGBIT | (myKey + 1)));
00079 nextNode.setPort(thisNode.getPort());
00080 nextNode.setKey(OverlayKey(myKey + 1));
00081
00082
00083 setOverlayReady(true);
00084 }
00085
00086 void MyOverlay::handleTimerEvent(cMessage *msg)
00087 {
00088 if (msg == rpcTimer) {
00089
00090 scheduleAt(simTime() + 5, rpcTimer);
00091
00092
00093 if (underlayConfigurator->isInInitPhase()) return;
00094
00095
00096 OverlayKey key;
00097 int neighborToAsk = intuniform(0, 1);
00098
00099 if (neighborToAsk == 0) key = prevNode.getKey();
00100 else key = nextNode.getKey();
00101
00102 getNeighbors(key);
00103 }
00104 }
00105
00106
00107 bool MyOverlay::isSiblingFor(const NodeHandle& node,
00108 const OverlayKey& key,
00109 int numSiblings,
00110 bool* err)
00111 {
00112
00113 if (node == thisNode && key == thisNode.getKey()) {
00114 return true;
00115 }
00116
00117 return false;
00118 }
00119
00120
00121 NodeVector *MyOverlay::findNode(const OverlayKey& key,
00122 int numRedundantNodes,
00123 int numSiblings,
00124 BaseOverlayMessage* msg)
00125 {
00126 NodeVector* nextHops;
00127
00128
00129 if (uniform(0, 1) < dropChance) {
00130
00131 nextHops = new NodeVector(0);
00132 numDropped++;
00133 return nextHops;
00134 }
00135
00136
00137 nextHops = new NodeVector(1);
00138
00139
00140 if (key == thisNode.getKey()) {
00141 nextHops->add(thisNode);
00142 }
00143
00144 else if (key < thisNode.getKey()) {
00145 nextHops->add(prevNode);
00146 }
00147
00148 else {
00149 nextHops->add(nextNode);
00150 }
00151 return nextHops;
00152 }
00153
00154
00155 void MyOverlay::finishOverlay()
00156 {
00157
00158 setOverlayReady(false);
00159
00160
00161 globalStatistics->addStdDev("MyOverlay: Dropped packets", numDropped);
00162 }
00163
00164
00165 int MyOverlay::getMaxNumSiblings()
00166 {
00167 return 1;
00168 }
00169
00170
00171 int MyOverlay::getMaxNumRedundantNodes()
00172 {
00173 return 1;
00174 }
00175
00176
00177 void MyOverlay::getNeighbors(const OverlayKey &neighborKey)
00178 {
00179 MyNeighborCall *msg = new MyNeighborCall();
00180 msg->setDestinationKey(neighborKey);
00181
00182
00183
00184
00185
00186
00187
00188
00189 EV << thisNode << ": (RPC) Sending query to "
00190 << neighborKey << "!" << std::endl;
00191
00192 sendRouteRpcCall(OVERLAY_COMP, neighborKey, msg);
00193 }
00194
00195
00196
00197 bool MyOverlay::handleRpcCall(BaseCallMessage *msg)
00198 {
00199
00200
00201
00202 RPC_SWITCH_START(msg);
00203
00204
00205 RPC_ON_CALL(MyNeighbor) {
00206
00207 MyNeighborCall *mrpc = (MyNeighborCall*)msg;
00208
00209
00210 MyNeighborResponse *rrpc = new MyNeighborResponse();
00211 rrpc->setRespondingNode(thisNode);
00212 rrpc->setPrevNeighbor(prevNode);
00213 rrpc->setNextNeighbor(nextNode);
00214
00215
00216
00217 sendRpcResponse(mrpc, rrpc);
00218
00219 RPC_HANDLED = true;
00220 }
00221
00222
00223 RPC_SWITCH_END();
00224
00225
00226
00227 return RPC_HANDLED;
00228 }
00229
00230
00231
00232
00233 void MyOverlay::handleRpcTimeout(BaseCallMessage* msg,
00234 const TransportAddress& dest,
00235 cPolymorphic* context, int rpcId,
00236 const OverlayKey&)
00237 {
00238
00239
00240
00241 RPC_SWITCH_START(msg);
00242
00243
00244 RPC_ON_CALL(MyNeighbor) {
00245 MyNeighborCall *mrpc = (MyNeighborCall*)msg;
00246 callbackTimeout(mrpc->getDestinationKey());
00247 }
00248
00249 RPC_SWITCH_END();
00250 }
00251
00252
00253
00254
00255 void MyOverlay::handleRpcResponse(BaseResponseMessage* msg,
00256 cPolymorphic* context,
00257 int rpcId,
00258 simtime_t rtt)
00259 {
00260
00261
00262
00263 RPC_SWITCH_START(msg);
00264
00265
00266 RPC_ON_RESPONSE(MyNeighbor) {
00267
00268 MyNeighborResponse *mrpc = (MyNeighborResponse*)msg;
00269
00270 callbackNeighbors(mrpc->getRespondingNode(),
00271 mrpc->getPrevNeighbor(),
00272 mrpc->getNextNeighbor());
00273 }
00274
00275 RPC_SWITCH_END();
00276 }
00277
00278 void MyOverlay::callbackNeighbors(const NodeHandle& neighborKey,
00279 const NodeHandle& prevNeighbor,
00280 const NodeHandle& nextNeighbor)
00281 {
00282 EV << thisNode << ": (RPC) Got response from "
00283 << neighborKey << "\n"
00284 << thisNode << ": (RPC) Neighbors: "
00285 << prevNeighbor.getAddress() << ", "
00286 << nextNeighbor.getAddress() << std::endl;
00287 }
00288
00289 void MyOverlay::callbackTimeout(const OverlayKey &neighborKey)
00290 {
00291 EV << thisNode << ": (RPC) Query to " << neighborKey
00292 << " timed out!" << std::endl;
00293 }