Ignore:
Timestamp:
Aug 11, 2009, 4:13:09 PM (15 years ago)
Author:
Christoph Mayer
Message:

merge noch nicht fertig

File:
1 edited

Legend:

Unmodified
Added
Removed
  • source/ariba/overlay/BaseOverlay.cpp

    r5870 r5871  
    137137        }
    138138
    139 <<<<<<< .working
    140         // get used next hop towards node
    141         LinkDescriptor* rld = NULL;
    142         NodeID relayNode = NodeID::UNSPECIFIED;
    143         LinkID rlid = overlayInterface->getNextLinkId(id);
    144         if ( relayNode.isUnspecified() && !rlid.isUnspecified() && rld == NULL ) {
    145                 // get descriptor of first hop
    146                 rld = getDescriptor(rlid);
    147 =======
    148139        // iterate over all links and check for time boundaries
    149140        vector<LinkDescriptor*> oldlinks;
     
    153144                if ( ld->relaying && difftime( now, ld->timeRelaying ) > 10)
    154145                        ld->relaying = false;
    155 >>>>>>> .merge-rechts.r5869
    156 
    157 <<<<<<< .working
    158                 // is first hop a relay path use local relay
    159                 if ( rld->relay ) relayNode = rld->localRelay;
    160 
    161                 // no-> a proper relay node has been found
    162                 else relayNode = rld->remoteNode;
    163         }
    164 =======
     146
    165147                // keep alives and not up? yes-> link connection request is stale!
    166148                if ( !ld->up && difftime( now, ld->keepAliveTime ) >= 2 ) {
    167 >>>>>>> .merge-rechts.r5869
    168149
    169150                        // increase counter
     
    181162                if (!ld->up) continue;
    182163
    183 <<<<<<< .working
    184         // get descriptor
    185         BOOST_FOREACH( LinkDescriptor* lp, links )
    186                 if (lp->remoteNode == relayNode &&
    187                     lp->service == OverlayInterface::OVERLAY_SERVICE_ID &&
    188                     lp->relay == false &&
    189                     lp->up)
    190                         return lp;
    191 =======
    192164                // drop links that are dropped and not used as relay
    193165                if (ld->dropAfterRelaying && !ld->relaying && !ld->autolink) {
     
    200172                        oldlinks.push_back( ld );
    201173                        continue;
    202 >>>>>>> .merge-rechts.r5869
     174                }
    203175
    204176                // keep alives missed? yes->
     
    536508        }
    537509
     510
    538511        //ovl.visShowNodeBubble ( ovlId, nodeId, "joining..." );
    539512        logging_info( "Starting to join spovnet " << id.toString() <<
     
    543516
    544517                // bootstrap against ourselfs
    545                 logging_info("joining spovnet locally");
     518                logging_debug("joining spovnet locally");
    546519
    547520                overlayInterface->joinOverlay();
     
    560533
    561534                // bootstrap against another node
    562                 logging_info("joining spovnet remotely against " << bootstrapEp.toString());
     535                logging_debug("joining spovnet remotely against " << bootstrapEp.toString());
    563536
    564537                const LinkID& lnk = bc->establishLink( bootstrapEp );
    565538                bootstrapLinks.push_back(lnk);
    566 
    567539                logging_info("join process initiated for " << id.toString() << "...");
    568 
    569540        }
    570541}
     
    12271198                delete replyMsg;
    12281199
    1229 <<<<<<< .working
    1230                                         // inform all registered services of the event
    1231                                         BOOST_FOREACH( NodeListener* i, nodeListeners )
    1232                                                 i->onJoinFailed( spovnetId );
    1233 =======
    12341200        } else {
    1235 >>>>>>> .merge-rechts.r5869
    12361201
    12371202                // this is not the first bootstrap, just join the additional node
     
    12411206
    12421207                delete replyMsg;
     1208
    12431209        } // if( overlayInterface == NULL )
    12441210
     
    12471213
    12481214
    1249 <<<<<<< .working
    1250 =======
    12511215bool BaseOverlay::handleData( OverlayMsg* overlayMsg, LinkDescriptor* ld ) {
    12521216        // get service
     
    12551219                << " on link " << overlayMsg->getDestinationLink().toString() );
    12561220
    1257 >>>>>>> .merge-rechts.r5869
    12581221        // delegate data message
    12591222        getListener(service)->onMessage(
     
    12661229}
    12671230
    1268 <<<<<<< .working
    1269 =======
    1270 
    1271 >>>>>>> .merge-rechts.r5869
     1231
    12721232bool BaseOverlay::handleLinkUpdate( OverlayMsg* overlayMsg, LinkDescriptor* ld ) {
    12731233
    1274 <<<<<<< .working
    1275                         //record bootstrap ep as good endpoint to join
    1276                         overlayBootstrap.recordJoin( replyMsg->getBootstrapEndpoint() );
    1277 
    1278                         delete replyMsg;
    1279                         ret = true;
    1280                         break;
    1281                 }
    1282 =======
    12831234        if( ld == NULL ) {
    12841235                logging_warn( "received overlay update message for link for "
     
    12871238        }
    12881239        logging_info("Received type update message on link " << ld );
    1289 >>>>>>> .merge-rechts.r5869
    12901240
    12911241        // update our link mapping information for this link
     
    13101260        }
    13111261
    1312 <<<<<<< .working
    1313                         // delegate data message
    1314                         listener->onMessage( overlayMsg,
    1315                                 overlayMsg->getSourceNode(), ld->overlayId );
    1316 =======
    13171262        // service registered? no-> error!
    13181263        if( !communicationListeners.contains( ld->service ) ) {
     
    13201265                return false;
    13211266        }
    1322 >>>>>>> .merge-rechts.r5869
    13231267
    13241268        // default or no service registered?
     
    14671411}
    14681412
    1469 <<<<<<< .working
    1470 =======
    14711413/// handle a keep-alive message for a link
    14721414bool BaseOverlay::handleLinkAlive( OverlayMsg* overlayMsg, LinkDescriptor* ld ) {
     
    14901432        logging_debug( "Received direct link replacement request" );
    14911433
    1492 >>>>>>> .merge-rechts.r5869
    14931434        /// get destination overlay link
    14941435        LinkDescriptor* rld = getDescriptor( overlayMsg->getDestinationLink() );
     
    15051446        rld->relayed = false;
    15061447
    1507 <<<<<<< .working
    1508                                         // mark incoming link as relay
    1509                                         if (ld!=NULL) ld->markAsRelay();
    1510 
    1511                                         // am I the destination of this message? yes->
    1512                                         if (relayMsg->getDestNode() == nodeId ) {
    1513                                                 // deliver relay message locally!
    1514                                                 logging_debug("Relay message reached destination. Handling the message.");
    1515                                                 handleMessage( relayMsg, relayMsg->getDestLink(), LinkID::UNSPECIFIED, remoteNode );
    1516                                                 ret = true;
    1517                                                 break;
    1518                                         }
    1519 
    1520                                         // create route message
    1521                                         OverlayMsg _overMsg( *overlayMsg );
    1522                                         RelayMessage _relayMsg( *relayMsg );
    1523                                         _relayMsg.setType( RelayMessage::typeRoute );
    1524                                         _overMsg.encapsulate( &_relayMsg );
    1525 =======
    15261448        // mark used and alive!
    15271449        rld->setAlive();
    15281450        rld->setAutoUsed();
    1529 >>>>>>> .merge-rechts.r5869
    15301451
    15311452        // erase the original descriptor
     
    15381459        logging_debug( "Handling message: " << message->toString());
    15391460
    1540 <<<<<<< .working
    1541                                         // mark incoming link as relay
    1542                                         if (ld!=NULL) ld->markAsRelay();
    1543 
    1544                                         // am I the destination of this message? yes->
    1545                                         if (relayMsg->getDestNode() == nodeId ) {
    1546                                                 // deliver relay message locally!
    1547                                                 logging_debug("Relay message reached destination. Handling the message.");
    1548                                                 handleMessage( relayMsg, relayMsg->getDestLink(), LinkID::UNSPECIFIED, remoteNode );
    1549                                                 ret = true;
    1550                                                 break;
    1551                                         }
    1552 
    1553                                         // am I the relay for this message? yes->
    1554                                         if (relayMsg->getRelayNode() == nodeId ) {
    1555                                                 logging_debug("I'm the relay for this message. Sending to destination.");
    1556                                                 OverlayMsg _overMsg( *overlayMsg );
    1557                                                 RelayMessage _relayMsg( *relayMsg );
    1558                                                 _overMsg.encapsulate(&_relayMsg);
    1559 =======
    15601461        // decapsulate overlay message
    15611462        OverlayMsg* overlayMsg =
    15621463                const_cast<Message*>(message)->decapsulate<OverlayMsg>();
    15631464        if( overlayMsg == NULL ) return false;
    1564 >>>>>>> .merge-rechts.r5869
    15651465
    15661466        // refresh relay information
     
    16511551/// return the overlay neighbors
    16521552vector<NodeID> BaseOverlay::getOverlayNeighbors(bool deep) const {
    1653 
     1553        // the known nodes _can_ also include our node, so we remove ourself
    16541554        vector<NodeID> nodes = overlayInterface->getKnownNodes(deep);
    1655         // the known nodes _can_ also include our node, so we remove ourself
    16561555        vector<NodeID>::iterator i = find( nodes.begin(), nodes.end(), this->nodeId );
    16571556        if( i != nodes.end() ) nodes.erase( i );
     
    16881587
    16891588void BaseOverlay::eventFunction() {
    1690 <<<<<<< .working
    1691 
    1692         // send keep-alive messages over established links
    1693         BOOST_FOREACH( LinkDescriptor* ld, links ) {
    1694                 if (!ld->up) continue;
    1695                 OverlayMsg overMsg( OverlayMsg::typeKeepAlive,
    1696                         OverlayInterface::OVERLAY_SERVICE_ID, nodeId );
    1697                 sendMessage( &overMsg, ld );
    1698         }
    1699 
    1700         // iterate over all links and check for time boundaries
    1701         vector<LinkDescriptor*> oldlinks;
    1702         time_t now = time(NULL);
    1703         BOOST_FOREACH( LinkDescriptor* ld, links ) {
    1704                 // remote used as relay flag
    1705                 if ( ld->usedAsRelay && difftime( now, ld->timeUsedAsRelay ) > 10)
    1706                         ld->usedAsRelay = false;
    1707 
    1708                 // keep alives and not up? yes-> link connection request is stale!
    1709                 if ( !ld->up && difftime( now, ld->keepAliveTime ) >= 2 ) {
    1710 
    1711                         // increase counter
    1712                         ld->keepAliveMissed++;
    1713 
    1714                         // missed more than four keep-alive messages (10 sec)? -> drop link
    1715                         if (ld->keepAliveMissed > 4) {
    1716                                 logging_info( "Link connection request is stale, closing: " << ld );
    1717                                 oldlinks.push_back( ld );
    1718                                 continue;
    1719                         }
    1720                 }
    1721 
    1722                 if (!ld->up) continue;
    1723 
    1724                 // drop links that are dropped and not used as relay
    1725                 if (ld->dropWhenRelaysLeft && !ld->usedAsRelay && !ld->autolink) {
    1726                         oldlinks.push_back( ld );
    1727                         continue;
    1728                 }
    1729 
    1730                 // auto-link time exceeded?
    1731                 if ( ld->autolink && difftime( now, ld->lastuse ) > 30 ) {
    1732                         oldlinks.push_back( ld );
    1733                         continue;
    1734                 }
    1735 
    1736                 // keep alives missed? yes->
    1737                 if ( difftime( now, ld->keepAliveTime ) > 2 ) {
    1738 
    1739                         // increase counter
    1740                         ld->keepAliveMissed++;
    1741 
    1742                         // missed more than four keep-alive messages (4 sec)? -> drop link
    1743                         if (ld->keepAliveMissed >= 8) {
    1744                                 logging_info( "Link is stale, closing: " << ld );
    1745                                 oldlinks.push_back( ld );
    1746                                 continue;
    1747                         }
    1748                 }
    1749         }
    1750 
    1751         // drop links
    1752         BOOST_FOREACH( const LinkDescriptor* ld, oldlinks ) {
    1753 /*
    1754                 vector<LinkID>::iterator it = std::find(
    1755                                 bootstrapLinks.begin(), bootstrapLinks.end(), ld->communicationId);
    1756 
    1757                 if (!ld->communicationId.isUnspecified() && it != bootstrapLinks.end() ){
    1758                         logging_info( "Not dropping initiator link: " << ld );
    1759                         continue;
    1760                 }
    1761 */
    1762                 logging_info( "Link timed out. Dropping " << ld );
    1763                 dropLink( ld->overlayId );
    1764         }
    1765 
    1766         // show link state
    1767         counter++;
    1768         if (counter>=4) showLinkState();
    1769         if (counter>=4 || counter<0) counter = 0;
    1770 =======
    17711589        stabilizeRelays();
    17721590        stabilizeLinks();
    1773 >>>>>>> .merge-rechts.r5869
    17741591}
    17751592
Note: See TracChangeset for help on using the changeset viewer.