#include <PubSubLobby.h>
Public Member Functions | |
virtual | ~PubSubLobby () |
virtual void | initializeOverlay (int stage) |
Initializes derived-class-attributes. | |
virtual void | finishOverlay () |
collects statistical data in derived class | |
virtual void | handleUDPMessage (BaseOverlayMessage *msg) |
Processes messages from underlay. | |
virtual void | handleTimerEvent (cMessage *msg) |
Processes "timer" self-messages. | |
virtual bool | handleRpc (BaseCallMessage *msg) |
Processes Remote-Procedure-Call invokation messages. | |
virtual void | handleRpcResponse (BaseResponseMessage *msg, cPolymorphic *context, int rpcId, simtime_t rtt) |
This method is called if an RPC response has been received. | |
virtual 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. | |
Protected Types | |
typedef std::map < TransportAddress, ChildEntry > | PlayerMap |
typedef std::multimap< int, ChildEntry *, std::greater < int > > | PlayerRessourceMap |
Protected Member Functions | |
virtual void | handleJoin (PubSubJoinCall *joinMsg) |
virtual void | handleHelpCall (PubSubHelpCall *helpMsg) |
virtual void | handleRespCall (PubSubResponsibleNodeCall *respCall) |
virtual void | handleTakeOverResponse (PubSubTakeOverSubspaceResponse *takeOverResp) |
virtual void | handleTakeOverTimeout (PubSubTakeOverSubspaceCall *takeOverCall, const TransportAddress &oldNode) |
void | handleHelpReleaseMessage (PubSubHelpReleaseMessage *helpRMsg) |
void | replaceResponsibleNode (int subspaceId, NodeHandle respNode) |
void | replaceResponsibleNode (PubSubSubspaceId subspaceId, NodeHandle respNode) |
void | failedNode (const TransportAddress &node) |
Protected Attributes | |
int | subspaceSize |
int | numSubspaces |
std::vector< std::vector < PubSubSubspaceLobby > > | subspaces |
std::list< PubSubHelpCall * > | waitingForHelp |
PlayerMap | playerMap |
PlayerRessourceMap | playerRessourceMap |
int | numPubSubSignalingMessages |
int | pubSubSignalingMessagesSize |
Friends | |
std::ostream & | operator<< (std::ostream &o, const ChildEntry &entry) |
Classes | |
class | ChildEntry |
typedef std::map<TransportAddress, ChildEntry> PubSubLobby::PlayerMap [protected] |
typedef std::multimap<int, ChildEntry*, std::greater<int> > PubSubLobby::PlayerRessourceMap [protected] |
void PubSubLobby::initializeOverlay | ( | int | stage | ) | [virtual] |
Initializes derived-class-attributes.
Initializes derived-class-attributes, called by BaseOverlay::initialize(). By default this method is called once. If more stages are needed one can overload numInitStages() and add more stages.
stage | the init stage |
Reimplemented from BaseOverlay.
00040 { 00041 // because of IPAddressResolver, we need to wait until interfaces are registered, 00042 // address auto-assignment takes place etc. 00043 if(stage != MIN_STAGE_OVERLAY) return; 00044 00045 numSubspaces = par("numSubspaces"); 00046 subspaceSize = (int) ( (unsigned int) par("areaDimension") / numSubspaces); 00047 00048 // FIXME: Inefficient, make subspace a single dimensioned array 00049 subspaces.resize( numSubspaces ); 00050 for ( int i = 0; i < numSubspaces; ++i ) { 00051 for( int ii = 0; ii < numSubspaces; ++ii ) { 00052 PubSubSubspaceId region( i, ii, numSubspaces ); 00053 subspaces[i].push_back( PubSubSubspaceLobby( region ) ); 00054 } 00055 WATCH_VECTOR( subspaces[i] ); 00056 } 00057 thisNode.setKey( OverlayKey::random() ); 00058 BootstrapOracleAccess().get()->registerPeer( thisNode ); 00059 00060 numPubSubSignalingMessages = 0; 00061 pubSubSignalingMessagesSize = 0; 00062 WATCH( numPubSubSignalingMessages ); 00063 WATCH( pubSubSignalingMessagesSize ); 00064 WATCH_MAP( playerMap ); 00065 }
void PubSubLobby::finishOverlay | ( | ) | [virtual] |
collects statistical data in derived class
Reimplemented from BaseOverlay.
00464 { 00465 simtime_t time = globalStatistics->calcMeasuredLifetime(creationTime); 00466 if(time == 0) return; 00467 00468 globalStatistics->addStdDev("PubSubLobby: Sent Signaling Messages/s", 00469 numPubSubSignalingMessages / time); 00470 globalStatistics->addStdDev("PubSubLobby: Sent Signaling bytes/s", 00471 pubSubSignalingMessagesSize / time); 00472 }
void PubSubLobby::handleUDPMessage | ( | BaseOverlayMessage * | msg | ) | [virtual] |
Processes messages from underlay.
msg | Message from UDP |
Reimplemented from BaseOverlay.
00082 { 00083 if( PubSubFailedNodeMessage* failMsg = dynamic_cast<PubSubFailedNodeMessage*>(msg) ){ 00084 failedNode( failMsg->getFailedNode() ); 00085 delete msg; 00086 00087 } else if( PubSubReplacementMessage* repMsg = dynamic_cast<PubSubReplacementMessage*>(msg) ){ 00088 replaceResponsibleNode( repMsg->getSubspaceId(), repMsg->getNewResponsibleNode() ); 00089 delete msg; 00090 } else if( PubSubHelpReleaseMessage* helpRMsg = dynamic_cast<PubSubHelpReleaseMessage*>(msg) ){ 00091 handleHelpReleaseMessage( helpRMsg ); 00092 delete msg; 00093 } 00094 }
void PubSubLobby::handleTimerEvent | ( | cMessage * | msg | ) | [virtual] |
Processes "timer" self-messages.
msg | A self-message |
Reimplemented from BaseOverlay.
00068 { 00069 if( PubSubTimer* timer = dynamic_cast<PubSubTimer*>(msg) ) { 00070 if( timer->getType() == PUBSUB_TAKEOVER_GRACE_TIME ){ 00071 // Grace period for subspace takeover timed out. 00072 // If noone claimed the subspace yet, the next respNode query will 00073 // trigger the selection of a new responsible node 00074 PubSubSubspaceId subspaceId(timer->getSubspaceId(), numSubspaces ); 00075 subspaces[subspaceId.getX()][subspaceId.getY()].waitingForRespNode = false; 00076 delete timer; 00077 } 00078 } 00079 }
bool PubSubLobby::handleRpc | ( | BaseCallMessage * | msg | ) | [virtual] |
Processes Remote-Procedure-Call invokation messages.
This method should be overloaded when the overlay provides RPC functionality.
Reimplemented from BaseRpc.
00097 { 00098 // delegate messages 00099 RPC_SWITCH_START( msg ) 00100 RPC_DELEGATE( PubSubJoin, handleJoin ); 00101 RPC_DELEGATE( PubSubHelp, handleHelpCall ); 00102 RPC_DELEGATE( PubSubResponsibleNode, handleRespCall ); 00103 RPC_SWITCH_END( ) 00104 00105 return RPC_HANDLED; 00106 }
void PubSubLobby::handleRpcResponse | ( | BaseResponseMessage * | msg, | |
cPolymorphic * | context, | |||
int | rpcId, | |||
simtime_t | rtt | |||
) | [virtual] |
This method is called if an RPC response has been received.
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.
00111 { 00112 RPC_SWITCH_START(msg); 00113 RPC_ON_RESPONSE( PubSubTakeOverSubspace ) { 00114 handleTakeOverResponse( _PubSubTakeOverSubspaceResponse ); 00115 break; 00116 } 00117 RPC_SWITCH_END( ); 00118 }
void PubSubLobby::handleRpcTimeout | ( | BaseCallMessage * | msg, | |
const TransportAddress & | dest, | |||
cPolymorphic * | context, | |||
int | rpcId, | |||
const OverlayKey & | destKey | |||
) | [virtual] |
This method is called if an RPC timeout has been reached.
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.
00124 { 00125 RPC_SWITCH_START(msg) 00126 RPC_ON_CALL( PubSubTakeOverSubspace ) { 00127 handleTakeOverTimeout( _PubSubTakeOverSubspaceCall, dest ); 00128 EV << "[PubSubMMOG::handleRpcTimeout() @ " << thisNode.ip 00129 << " (" << thisNode.key.toString(16) << ")]\n" 00130 << " TakeOverSubspace RPC Call timed out: id=" << rpcId << "\n" 00131 << " msg=" << *_PubSubTakeOverSubspaceCall 00132 << endl; 00133 break; 00134 } 00135 RPC_SWITCH_END( ) 00136 }
void PubSubLobby::handleJoin | ( | PubSubJoinCall * | joinMsg | ) | [protected, virtual] |
Referenced by handleRpc().
00139 { 00140 // Insert node in the queue of possible backup nodes 00141 ChildEntry e; 00142 e.handle = joinMsg->getSrcNode(); 00143 e.ressources = joinMsg->getRessources(); 00144 00145 pair<PlayerMap::iterator, bool> inserter; 00146 inserter = playerMap.insert( make_pair( e.handle, e )); 00147 ChildEntry* childEntry = &(inserter.first->second); 00148 //pair<PlayerRessourceMap::iterator, bool> rInserter; 00149 //rInserter = playerRessourceMap.insert( make_pair( e.ressources, childEntry )); 00150 PlayerRessourceMap::iterator rInserter; 00151 rInserter = playerRessourceMap.insert( make_pair( e.ressources, childEntry )); 00152 bool insertedAtBegin = rInserter == playerRessourceMap.begin(); 00153 00154 // send answer with responsible node 00155 PubSubJoinResponse* joinResp = new PubSubJoinResponse( "Join Response"); 00156 unsigned int x = (unsigned int) (joinMsg->getPosition().x / subspaceSize); 00157 unsigned int y = (unsigned int) (joinMsg->getPosition().y / subspaceSize); 00158 PubSubSubspaceLobby& subspace = subspaces[x][y]; 00159 NodeHandle respNode = subspace.getResponsibleNode(); 00160 joinResp->setResponsibleNode( respNode ); 00161 joinResp->setLength( PUBSUB_JOINRESPONSE_L( joinResp )); 00162 RECORD_STATS( 00163 ++numPubSubSignalingMessages; 00164 pubSubSignalingMessagesSize += joinResp->byteLength() 00165 ); 00166 sendRpcResponse( joinMsg, joinResp ); 00167 00168 if( respNode.isUnspecified() && !subspace.waitingForRespNode) { 00169 // respNode is unknown, create new... 00170 // TODO: refactor: make a funktion out of this... 00171 PubSubTakeOverSubspaceCall* toCall = new PubSubTakeOverSubspaceCall( "Take over subspace"); 00172 toCall->setSubspacePos( Vector2D(x, y) ); 00173 00174 ChildEntry* child = playerRessourceMap.begin()->second; 00175 toCall->setLength( PUBSUB_TAKEOVERSUBSPACECALL_L( toCall )); 00176 RECORD_STATS( 00177 ++numPubSubSignalingMessages; 00178 pubSubSignalingMessagesSize += toCall->byteLength() 00179 ); 00180 sendUdpRpcCall( child->handle, toCall ); 00181 00182 playerRessourceMap.erase( playerRessourceMap.begin() ); 00183 child->dutySet.insert( subspace.getId().getId() ); 00184 child->ressources-=2; // XXX FIXME: make it a parameter... 00185 if( insertedAtBegin ){ 00186 rInserter = playerRessourceMap.insert( make_pair(child->ressources, child) ); 00187 } else { 00188 playerRessourceMap.insert( make_pair(child->ressources, child) ); 00189 } 00190 00191 subspace.waitingForRespNode = true; 00192 } 00193 00194 // New node is out of luck: he gets to help all waiting nodes as long as he has ressources left 00195 if( waitingForHelp.size() > 0 ) { 00196 std::list<PubSubHelpCall*>::iterator it = waitingForHelp.begin(); 00197 while( it != waitingForHelp.end() ) { 00198 // Insert subspace into node's dutySet 00199 if( childEntry->dutySet.insert( (*it)->getSubspaceId() ).second ){ 00200 // If it was not already there (due to duplicate HelpCalls because of retransmissions), 00201 // decrease ressources 00202 childEntry->ressources -= ( (*it)->getHelpType() == PUBSUB_BACKUP ) ? 2 : 1; // FIXME: make it a parameter 00203 } 00204 00205 PubSubHelpResponse* helpResp = new PubSubHelpResponse("Ask him to help you"); 00206 helpResp->setSubspaceId( (*it)->getSubspaceId() ); 00207 helpResp->setType( (*it)->getType() ); 00208 helpResp->setNode( e.handle ); 00209 helpResp->setLength( PUBSUB_HELPRESPONSE_L( helpResp )); 00210 RECORD_STATS( 00211 ++numPubSubSignalingMessages; 00212 pubSubSignalingMessagesSize += helpResp->byteLength() 00213 ); 00214 sendRpcResponse( *it, helpResp ); 00215 00216 waitingForHelp.erase( it++ ); 00217 00218 if( childEntry->ressources <= 0 ) break; // FIXME: clean up duplicate calls! 00219 } 00220 // Fix ressource map entry 00221 playerRessourceMap.erase( rInserter ); 00222 playerRessourceMap.insert( make_pair(childEntry->ressources, childEntry) ); 00223 } 00224 }
void PubSubLobby::handleHelpCall | ( | PubSubHelpCall * | helpMsg | ) | [protected, virtual] |
Referenced by handleRpc().
00227 { 00228 // A node needs help! Give him the handle of the node with the most ressources... 00229 const NodeHandle& src = helpMsg->getSrcNode(); 00230 int subspaceId = helpMsg->getSubspaceId(); 00231 PlayerRessourceMap::iterator it; 00232 for( it = playerRessourceMap.begin(); it != playerRessourceMap.end(); ++it ){ 00233 if( it->second->handle != src && 00234 it->second->dutySet.find( subspaceId ) == it->second->dutySet.end() && 00235 it->second->ressources > 1 ){ 00236 break; 00237 } 00238 } 00239 00240 // No suitable node found! 00241 if( it == playerRessourceMap.end() ){ 00242 waitingForHelp.push_back( helpMsg ); 00243 return; 00244 } 00245 00246 // decrease ressources 00247 ChildEntry* child = it->second; 00248 child->ressources -= ( helpMsg->getHelpType() == PUBSUB_BACKUP ) ? 2 : 1; // FIXME: make it a parameter 00249 child->dutySet.insert( subspaceId ); 00250 playerRessourceMap.erase( it ); 00251 playerRessourceMap.insert( make_pair(child->ressources, child) ); 00252 00253 // Send handle to requesting node 00254 PubSubHelpResponse* helpResp = new PubSubHelpResponse("Ask him to help you"); 00255 helpResp->setSubspaceId( subspaceId ); 00256 helpResp->setHelpType( helpMsg->getHelpType() ); 00257 helpResp->setNode( child->handle ); 00258 helpResp->setLength( PUBSUB_HELPRESPONSE_L( helpResp )); 00259 RECORD_STATS( 00260 ++numPubSubSignalingMessages; 00261 pubSubSignalingMessagesSize += helpResp->byteLength() 00262 ); 00263 sendRpcResponse( helpMsg, helpResp ); 00264 }
void PubSubLobby::handleRespCall | ( | PubSubResponsibleNodeCall * | respCall | ) | [protected, virtual] |
Referenced by handleRpc().
00267 { 00268 unsigned int x = (unsigned int) respCall->getSubspacePos().x; 00269 unsigned int y = (unsigned int) respCall->getSubspacePos().y; 00270 NodeHandle respNode = subspaces[x][y].getResponsibleNode(); 00271 if( !respNode.isUnspecified() ) { 00272 PubSubSubspaceId region( x, y, numSubspaces); 00273 00274 PubSubResponsibleNodeResponse* msg = new PubSubResponsibleNodeResponse( "ResponsibleNode Response"); 00275 msg->setResponsibleNode( respNode ); 00276 msg->setSubspaceId( region.getId() ); 00277 msg->setLength( PUBSUB_RESPONSIBLENODERESPONSE_L( msg )); 00278 RECORD_STATS( 00279 ++numPubSubSignalingMessages; 00280 pubSubSignalingMessagesSize += msg->byteLength() 00281 ); 00282 sendRpcResponse( respCall, msg ); 00283 } else { 00284 // no responsible node for subspace known. 00285 // push call to list of waiting nodes ... 00286 PubSubSubspaceLobby& subspace = subspaces[x][y]; 00287 subspace.waitingNodes.push_back( respCall ); 00288 00289 if (!subspace.waitingForRespNode) { 00290 // ... and ask a node to take over the subspace 00291 PubSubTakeOverSubspaceCall* msg = new PubSubTakeOverSubspaceCall( "Take over subspace"); 00292 msg->setSubspacePos( Vector2D( x, y) ); 00293 00294 ChildEntry* child = playerRessourceMap.begin()->second; 00295 msg->setLength( PUBSUB_TAKEOVERSUBSPACECALL_L( msg )); 00296 RECORD_STATS( 00297 ++numPubSubSignalingMessages; 00298 pubSubSignalingMessagesSize += msg->byteLength() 00299 ); 00300 sendUdpRpcCall( child->handle, msg ); 00301 00302 playerRessourceMap.erase( playerRessourceMap.begin() ); 00303 child->dutySet.insert( subspace.getId().getId() ); 00304 // Decrease ressources. Note: the ressources are decreased by the cost of an "backup" node 00305 // The rest will be decreased when the new responsible answeres the takeover call 00306 child->ressources-=1; // FIXME: make it a parameter... 00307 playerRessourceMap.insert( make_pair(child->ressources, child) ); 00308 00309 subspace.waitingForRespNode = true; 00310 } 00311 } 00312 }
void PubSubLobby::handleTakeOverResponse | ( | PubSubTakeOverSubspaceResponse * | takeOverResp | ) | [protected, virtual] |
Referenced by handleRpcResponse().
00315 { 00316 NodeHandle respNode = takeOverResp->getSrcNode(); 00317 unsigned int x = (unsigned int) takeOverResp->getSubspacePos().x; 00318 unsigned int y = (unsigned int) takeOverResp->getSubspacePos().y; 00319 PubSubSubspaceId region( x, y, numSubspaces); 00320 00321 replaceResponsibleNode( region, takeOverResp->getSrcNode() ); 00322 }
void PubSubLobby::handleTakeOverTimeout | ( | PubSubTakeOverSubspaceCall * | takeOverCall, | |
const TransportAddress & | oldNode | |||
) | [protected, virtual] |
Referenced by handleRpcTimeout().
00325 { 00326 Vector2D pos = takeOverCall->getSubspacePos(); 00327 subspaces[(int) pos.x][(int) pos.y].waitingForRespNode = false; 00328 failedNode( oldNode ); 00329 }
void PubSubLobby::handleHelpReleaseMessage | ( | PubSubHelpReleaseMessage * | helpRMsg | ) | [protected] |
Referenced by handleUDPMessage().
00332 { 00333 PlayerMap::iterator playerIt = playerMap.find( helpRMsg->getNode() ); 00334 if( playerIt == playerMap.end() ){ 00335 // Player was already deleted 00336 return; 00337 } 00338 ChildEntry* nodeEntry = &(playerIt->second); 00339 00340 // remove subspace from node's duty set 00341 nodeEntry->dutySet.erase( helpRMsg->getSubspaceId() ); 00342 00343 // Increase node's ressources 00344 pair<PlayerRessourceMap::iterator, PlayerRessourceMap::iterator> resRange; 00345 PlayerRessourceMap::iterator resIt; 00346 resRange = playerRessourceMap.equal_range( nodeEntry->ressources ); 00347 for( resIt = resRange.first; resIt != resRange.second; ++resIt ){ 00348 if( resIt->second == nodeEntry ){ 00349 playerRessourceMap.erase( resIt ); 00350 break; 00351 } 00352 } 00353 nodeEntry->ressources += 1; // FIXME: make it a parameter 00354 playerRessourceMap.insert( make_pair(nodeEntry->ressources, nodeEntry) ); 00355 }
void PubSubLobby::replaceResponsibleNode | ( | int | subspaceId, | |
NodeHandle | respNode | |||
) | [protected] |
Referenced by handleTakeOverResponse(), and handleUDPMessage().
00358 { 00359 replaceResponsibleNode( PubSubSubspaceId( subspaceId, numSubspaces), respNode ); 00360 }
void PubSubLobby::replaceResponsibleNode | ( | PubSubSubspaceId | subspaceId, | |
NodeHandle | respNode | |||
) | [protected] |
00363 { 00364 // a new responsible node was found for a subspace 00365 PubSubSubspaceLobby& subspace = subspaces[subspaceId.getX()][subspaceId.getY()]; 00366 // NodeHandle oldNode = subspace.getResponsibleNode(); 00367 00368 // set new responsible node 00369 subspace.setResponsibleNode( respNode ); 00370 subspace.waitingForRespNode = false; 00371 00372 // decrease responsible node's ressources 00373 pair<PlayerRessourceMap::iterator, PlayerRessourceMap::iterator> resRange; 00374 PlayerRessourceMap::iterator resIt; 00375 PlayerMap::iterator plIt = playerMap.find( respNode ); 00376 00377 if( plIt == playerMap.end() ){ 00378 // FIXME: How to react? 00379 // Best would be: reinsert node. But most probable we have two nodes that want to be 00380 // responsible, so how to avoid the resulting inconsostency? 00381 opp_error("PlayerMap inconsistent: Allegedly failed node wants to become Responsible node"); 00382 } 00383 // ChildEntry* respNodeEntry = &(plIt->second); 00384 // resRange = playerRessourceMap.equal_range( respNodeEntry->ressources ); 00385 // for( resIt = resRange.first; resIt != resRange.second; ++resIt ){ 00386 // if( resIt->second == respNodeEntry ){ 00387 // playerRessourceMap.erase( resIt ); 00388 // break; 00389 // } 00390 // } 00391 // respNodeEntry->ressources -= 2; // FIXME: make it a parameter 00392 // playerRessourceMap.insert( make_pair(respNodeEntry->ressources, respNodeEntry) ); 00393 00394 // remove old node from backupList->he failed... 00395 // failedNode( oldNode ); 00396 00397 // inform all waiting nodes... 00398 std::list<PubSubResponsibleNodeCall*>::iterator it; 00399 for( it = subspace.waitingNodes.begin(); it != subspace.waitingNodes.end(); ++it ) { 00400 PubSubResponsibleNodeResponse* msg = new PubSubResponsibleNodeResponse( "ResponsibleNode Response"); 00401 msg->setResponsibleNode( respNode ); 00402 msg->setSubspaceId( subspaceId.getId() ); 00403 msg->setLength( PUBSUB_RESPONSIBLENODERESPONSE_L( msg )); 00404 RECORD_STATS( 00405 ++numPubSubSignalingMessages; 00406 pubSubSignalingMessagesSize += msg->byteLength() 00407 ); 00408 sendRpcResponse( *it, msg ); 00409 } 00410 subspace.waitingNodes.clear(); 00411 }
void PubSubLobby::failedNode | ( | const TransportAddress & | node | ) | [protected] |
Referenced by handleTakeOverTimeout(), and handleUDPMessage().
00415 { 00416 if( node.isUnspecified() ) return; 00417 00418 // Find node in playerMap 00419 PlayerMap::iterator playerIt = playerMap.find( node ); 00420 if( playerIt == playerMap.end() ){ 00421 // Player was already deleted 00422 return; 00423 } 00424 ChildEntry* respNodeEntry = &(playerIt->second); 00425 00426 // FIXME: only for debugging 00427 if( BootstrapOracleAccess().get()->getPeerInfo( node ) ){ 00428 opp_error("Trying to delete node that's still there..."); 00429 } 00430 00431 // check if node was responsible for a subspace 00432 set<int>::iterator dutyIt; 00433 for( dutyIt = respNodeEntry->dutySet.begin(); dutyIt != respNodeEntry->dutySet.end(); ++dutyIt ){ 00434 PubSubSubspaceId subspaceId( *dutyIt, numSubspaces ); 00435 PubSubSubspaceLobby& subspace = subspaces[subspaceId.getX()][subspaceId.getY()]; 00436 if( !subspace.getResponsibleNode().isUnspecified() && node == subspace.getResponsibleNode() ){ 00437 // remove old responsible node 00438 subspace.setResponsibleNode(NodeHandle()); 00439 00440 // wait for the backup node to claim subspace; if timer expires, waiting-flag will be reset 00441 subspace.waitingForRespNode = true; 00442 PubSubTimer* graceTimer = new PubSubTimer("Grace timer for claiming subspace"); 00443 graceTimer->setType( PUBSUB_TAKEOVER_GRACE_TIME ); 00444 graceTimer->setSubspaceId( subspace.getId().getId() ); 00445 scheduleAt( simulation.simTime() + 5, graceTimer ); //FIXME: make it a parameter 00446 } 00447 } 00448 00449 // delete node from backupList 00450 pair<PlayerRessourceMap::iterator, PlayerRessourceMap::iterator> resRange; 00451 PlayerRessourceMap::iterator resIt; 00452 00453 resRange = playerRessourceMap.equal_range( respNodeEntry->ressources ); 00454 for( resIt = resRange.first; resIt != resRange.second; ++resIt ){ 00455 if( resIt->second == respNodeEntry ){ 00456 playerRessourceMap.erase( resIt ); 00457 break; 00458 } 00459 } 00460 playerMap.erase( playerIt ); 00461 }
std::ostream& operator<< | ( | std::ostream & | o, | |
const ChildEntry & | entry | |||
) | [friend] |
int PubSubLobby::subspaceSize [protected] |
Referenced by handleJoin(), and initializeOverlay().
int PubSubLobby::numSubspaces [protected] |
Referenced by failedNode(), handleRespCall(), handleTakeOverResponse(), handleTimerEvent(), initializeOverlay(), and replaceResponsibleNode().
std::vector<std::vector<PubSubSubspaceLobby> > PubSubLobby::subspaces [protected] |
Referenced by failedNode(), handleJoin(), handleRespCall(), handleTakeOverTimeout(), handleTimerEvent(), initializeOverlay(), and replaceResponsibleNode().
std::list<PubSubHelpCall*> PubSubLobby::waitingForHelp [protected] |
Referenced by handleHelpCall(), and handleJoin().
PlayerMap PubSubLobby::playerMap [protected] |
Referenced by failedNode(), handleHelpReleaseMessage(), handleJoin(), initializeOverlay(), and replaceResponsibleNode().
PlayerRessourceMap PubSubLobby::playerRessourceMap [protected] |
Referenced by failedNode(), handleHelpCall(), handleHelpReleaseMessage(), handleJoin(), and handleRespCall().
int PubSubLobby::numPubSubSignalingMessages [protected] |
Referenced by finishOverlay(), handleHelpCall(), handleJoin(), handleRespCall(), initializeOverlay(), and replaceResponsibleNode().
int PubSubLobby::pubSubSignalingMessagesSize [protected] |
Referenced by finishOverlay(), handleHelpCall(), handleJoin(), handleRespCall(), initializeOverlay(), and replaceResponsibleNode().