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

std::list<PubSubHelpCall*> PubSubLobby::waitingForHelp [protected]

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 Wed May 26 16:21:18 2010 for OverSim by  doxygen 1.6.3