PubSubLobby Class Reference

#include <PubSubLobby.h>

Inheritance diagram for PubSubLobby:

BaseOverlay BaseRpc TopologyVis RpcListener

List of all members.

Classes

class  ChildEntry

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)
virtual bool handleRpcCall (BaseCallMessage *msg)
 Processes Remote-Procedure-Call invocation 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)


Detailed Description

Definition at line 36 of file PubSubLobby.h.


Member Typedef Documentation

typedef std::map<TransportAddress, ChildEntry> PubSubLobby::PlayerMap [protected]

Definition at line 73 of file PubSubLobby.h.

typedef std::multimap<int, ChildEntry*, std::greater<int> > PubSubLobby::PlayerRessourceMap [protected]

Definition at line 75 of file PubSubLobby.h.


Constructor & Destructor Documentation

PubSubLobby::~PubSubLobby (  )  [virtual]

Definition at line 474 of file PubSubLobby.cc.

00475 {
00476 }


Member Function Documentation

void PubSubLobby::failedNode ( const TransportAddress node  )  [protected]

Definition at line 414 of file PubSubLobby.cc.

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( GlobalNodeListAccess().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( 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 }

void PubSubLobby::finishOverlay (  )  [virtual]

collects statistical data in derived class

Reimplemented from BaseOverlay.

Definition at line 463 of file PubSubLobby.cc.

00464 {
00465     simtime_t time = globalStatistics->calcMeasuredLifetime(creationTime);
00466     if (time < GlobalStatistics::MIN_MEASURED) 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::handleHelpCall ( PubSubHelpCall helpMsg  )  [protected, virtual]

Definition at line 226 of file PubSubLobby.cc.

Referenced by handleRpcCall().

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->setBitLength( PUBSUB_HELPRESPONSE_L( helpResp ));
00259     RECORD_STATS(
00260             ++numPubSubSignalingMessages;
00261             pubSubSignalingMessagesSize += helpResp->getByteLength()
00262             );
00263     sendRpcResponse( helpMsg, helpResp );
00264 }

void PubSubLobby::handleHelpReleaseMessage ( PubSubHelpReleaseMessage helpRMsg  )  [protected]

Definition at line 331 of file PubSubLobby.cc.

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::handleJoin ( PubSubJoinCall joinMsg  )  [protected, virtual]

Definition at line 138 of file PubSubLobby.cc.

Referenced by handleRpcCall().

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->setBitLength( PUBSUB_JOINRESPONSE_L( joinResp ));
00162     RECORD_STATS(
00163             ++numPubSubSignalingMessages;
00164             pubSubSignalingMessagesSize += joinResp->getByteLength()
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->setBitLength( PUBSUB_TAKEOVERSUBSPACECALL_L( toCall ));
00176         RECORD_STATS(
00177                 ++numPubSubSignalingMessages;
00178                 pubSubSignalingMessagesSize += toCall->getByteLength()
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->setBitLength( PUBSUB_HELPRESPONSE_L( helpResp ));
00210             RECORD_STATS(
00211                     ++numPubSubSignalingMessages;
00212                     pubSubSignalingMessagesSize += helpResp->getByteLength()
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::handleRespCall ( PubSubResponsibleNodeCall respCall  )  [protected, virtual]

Definition at line 266 of file PubSubLobby.cc.

Referenced by handleRpcCall().

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->setBitLength( PUBSUB_RESPONSIBLENODERESPONSE_L( msg ));
00278         RECORD_STATS(
00279                 ++numPubSubSignalingMessages;
00280                 pubSubSignalingMessagesSize += msg->getByteLength()
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->setBitLength( PUBSUB_TAKEOVERSUBSPACECALL_L( msg ));
00296             RECORD_STATS(
00297                     ++numPubSubSignalingMessages;
00298                     pubSubSignalingMessagesSize += msg->getByteLength()
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 }

bool PubSubLobby::handleRpcCall ( BaseCallMessage msg  )  [virtual]

Processes Remote-Procedure-Call invocation messages.


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

Returns:
true, if rpc has been handled

Reimplemented from BaseRpc.

Definition at line 96 of file PubSubLobby.cc.

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.

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.

Definition at line 108 of file PubSubLobby.cc.

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.

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.

Definition at line 120 of file PubSubLobby.cc.

00124 {
00125     RPC_SWITCH_START(msg)
00126     RPC_ON_CALL( PubSubTakeOverSubspace ) {
00127         handleTakeOverTimeout( _PubSubTakeOverSubspaceCall, dest );
00128         EV << "[PubSubMMOG::handleRpcTimeout() @ " << thisNode.getAddress()
00129            << " (" << thisNode.getKey().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::handleTakeOverResponse ( PubSubTakeOverSubspaceResponse takeOverResp  )  [protected, virtual]

Definition at line 314 of file PubSubLobby.cc.

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]

Definition at line 324 of file PubSubLobby.cc.

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::handleTimerEvent ( cMessage *  msg  )  [virtual]

Reimplemented from BaseRpc.

Definition at line 67 of file PubSubLobby.cc.

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 }

void PubSubLobby::handleUDPMessage ( BaseOverlayMessage msg  )  [virtual]

Processes messages from underlay.

Parameters:
msg Message from UDP

Reimplemented from BaseOverlay.

Definition at line 81 of file PubSubLobby.cc.

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::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.

Parameters:
stage the init stage

Reimplemented from BaseOverlay.

Definition at line 39 of file PubSubLobby.cc.

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     GlobalNodeListAccess().get()->registerPeer( thisNode );
00059 
00060     numPubSubSignalingMessages = 0;
00061     pubSubSignalingMessagesSize = 0;
00062     WATCH( numPubSubSignalingMessages );
00063     WATCH( pubSubSignalingMessagesSize );
00064     WATCH_MAP( playerMap );
00065 }

void PubSubLobby::replaceResponsibleNode ( PubSubSubspaceId  subspaceId,
NodeHandle  respNode 
) [protected]

Definition at line 362 of file PubSubLobby.cc.

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->setBitLength( PUBSUB_RESPONSIBLENODERESPONSE_L( msg ));
00404         RECORD_STATS(
00405                 ++numPubSubSignalingMessages;
00406                 pubSubSignalingMessagesSize += msg->getByteLength()
00407                 );
00408         sendRpcResponse( *it, msg );
00409     }
00410     subspace.waitingNodes.clear();
00411 }

void PubSubLobby::replaceResponsibleNode ( int  subspaceId,
NodeHandle  respNode 
) [protected]

Definition at line 357 of file PubSubLobby.cc.

Referenced by handleTakeOverResponse(), and handleUDPMessage().

00358 {
00359     replaceResponsibleNode( PubSubSubspaceId( subspaceId, numSubspaces), respNode );
00360 }


Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  o,
const ChildEntry entry 
) [friend]

Definition at line 31 of file PubSubLobby.cc.

00032 {
00033     o << "Node: " << entry.handle << " ressources: " << entry.ressources;
00034     return o;
00035 }


Member Data Documentation

int PubSubLobby::numSubspaces [protected]

std::vector<std::vector<PubSubSubspaceLobby> > PubSubLobby::subspaces [protected]

int PubSubLobby::subspaceSize [protected]

Definition at line 67 of file PubSubLobby.h.

Referenced by handleJoin(), and initializeOverlay().

Definition at line 70 of file PubSubLobby.h.

Referenced by handleHelpCall(), and handleJoin().


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

Generated on Tue Sep 8 17:27:01 2009 for OverSim by  doxygen 1.5.8