Changeset 5871 for source/ariba


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

merge noch nicht fertig

Location:
source/ariba
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • source/ariba/SideportListener.cpp

    r5870 r5871  
    8888        bool relay = false;
    8989
    90         bool relay = false;
    91 
    9290        BOOST_FOREACH( LinkDescriptor* link, overlay->links ){
    9391
    … …  
    102100        }
    103101
    104 <<<<<<< .working
    105         return relay;
    106 =======
    107102        return relay;
    108103        */
    109104
    110105        return false;
    111 >>>>>>> .merge-rechts.r5869
    112106}
    113107

  • 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

  • source/ariba/overlay/modules/chord/Chord.cpp

    r5870 r5871  
    6262
    6363        // create routing table
    64 <<<<<<< .working
    65         this->table = new chord_routing_table(_nodeid, 2);
    66 =======
    6764        this->table = new chord_routing_table(_nodeid, 4);
    68 >>>>>>> .merge-rechts.r5869
    6965        orphan_removal_counter = 0;
    7066        discovery_count = 0;
    … …  
    10197
    10298        // establish link via base overlay
    103 <<<<<<< .working
    104         return baseoverlay.establishLink(endp, node, OverlayInterface::OVERLAY_SERVICE_ID, remoteRelay );
    105 =======
    10699        return baseoverlay.establishLink( endpoint, remote,
    107100                        OverlayInterface::OVERLAY_SERVICE_ID );
    108 >>>>>>> .merge-rechts.r5869
    109101}
    110102
    … …  
    127119        msg.encapsulate(&dmsg);
    128120
    129 <<<<<<< .working
    130         // get next hop
    131         const route_item* item = table->get_next_hop(destination);
    132         if (item!=NULL && !item->info.isUnspecified()) send(&cmsg, item->info);
    133 =======
    134121        // send to node
    135122        baseoverlay.send_node( &msg, remote );
    136 >>>>>>> .merge-rechts.r5869
    137123}
    138124
    … …  
    200186const LinkID& Chord::getNextLinkId( const NodeID& id ) const {
    201187        // get next hop
    202 <<<<<<< .working
    203         const route_item* item = table->get_next_hop(destnode);
    204 =======
    205188        const route_item* item = table->get_next_hop(id);
    206 >>>>>>> .merge-rechts.r5869
    207 
    208 <<<<<<< .working
    209         // message for this node? yes-> delegate to base overlay
    210         if (item->id == nodeid || destnode == nodeid)
    211                 baseoverlay.incomingRouteMessage( msg, LinkID::UNSPECIFIED, nodeid );
    212 =======
     189
    213190        // returns a unspecified id when this is itself
    214191        if (item == NULL || item->id == nodeid)
    215192                return LinkID::UNSPECIFIED;
    216 >>>>>>> .merge-rechts.r5869
    217 
    218 <<<<<<< .working
    219         else { // no-> send to next hop
    220                 ChordMessage cmsg(ChordMessage::route, nodeid, destnode);
    221                 cmsg.encapsulate(msg);
    222                 send(&cmsg, item->info);
    223         }
    224 =======
     193
    225194        /// return routing info
    226195        return item->info;
    227 >>>>>>> .merge-rechts.r5869
    228 }
    229 
    230 <<<<<<< .working
    231 /// @see OverlayInterface.h
    232 void Chord::routeMessage(const NodeID& node, const LinkID& link, Message* msg) {
    233         logging_debug("Redirect over Chord to node id=" << node.toString()
    234                         << " link id=" << link.toString() );
    235         ChordMessage cmsg(ChordMessage::route, nodeid, node);
    236         cmsg.encapsulate(msg);
    237         send(&cmsg, link);
    238 }
    239 
    240 /// @see OverlayInterface.h
    241 const LinkID& Chord::getNextLinkId( const NodeID& id ) const {
    242         // get next hop
    243         const route_item* item = table->get_next_hop(id);
    244 
    245         // returns a unspecified id when this is itself
    246         if (item == NULL || item->id == nodeid)
    247                 return LinkID::UNSPECIFIED;
    248 
    249         /// return routing info
    250         return item->info;
    251 }
    252 
    253 =======
    254 >>>>>>> .merge-rechts.r5869
     196}
     197
    255198OverlayInterface::NodeList Chord::getKnownNodes(bool deep) const {
    256199        OverlayInterface::NodeList nodelist;
    … …  
    351294        switch (m->getType()) {
    352295
    353 <<<<<<< .working
    354         // invalid message
    355         case M::invalid:
    356                 break;
    357 
    358         // route message with payload
    359         case M::route: {
    360                 // find next hop
    361                 const route_item* item = table->get_next_hop(m->getDestination());
    362 
    363                 // next hop == myself?
    364                 if (m->getDestination() == nodeid) { // yes-> route to base overlay
    365                         logging_debug("Send message to baseoverlay");
    366                         baseoverlay.incomingRouteMessage( m, item->info, remote );
    367                 }
    368                 // no-> route to next hop
    369                 else {
    370                         logging_debug("Route chord message to "
    371                                 << item->id.toString() << " (destination=" << m->getDestination() << ")");
    372                         send(m, item->info);
    373                 }
    374                 break;
    375         }
    376 
    377                 // discovery request
    378         case M::discovery: {
    379 =======
    380296        // discovery request
    381297        case typeDiscovery: {
    382 >>>>>>> .merge-rechts.r5869
    383298                // decapsulate message
    384299                Discovery* dmsg = m->decapsulate<Discovery> ();
    … …  
    410325                                        logging_debug("Discovery split: routing discovery message to successor "
    411326                                                        << succ_item->id.toString() );
    412 <<<<<<< .working
    413                                         send(&cmsg_s, succ_item->info);
    414 =======
    415327                                        send(&omsg, succ_item->info);
    416 >>>>>>> .merge-rechts.r5869
    417328                                }
    418329
    … …  
    426337                                        logging_debug("Discovery split: routing discovery message to predecessor "
    427338                                                        << pred_item->id.toString() );
    428 <<<<<<< .working
    429                                         send(&cmsg_p, pred_item->info);
    430 =======
    431339                                        send( &omsg, pred_item->info);
    432 >>>>>>> .merge-rechts.r5869
    433340                                }
    434341                        }
    435342                        // no-> route message
    436343                        else {
    437 <<<<<<< .working
    438                                 // find next hop
    439                                 const route_item* item = table->get_next_hop(m->getDestination());
    440                                 if (item == NULL || item->id == nodeid) break;
    441                                 logging_debug("routing discovery message to " <<
    442                                                 item->id.toString() );
    443                                 send(m, item->info);
    444 =======
    445344                                baseoverlay.send( m, m->getDestinationNode() );
    446 >>>>>>> .merge-rechts.r5869
    447345                        }
    448346                        break;
    … …  
    526424                // remove orphan links
    527425                orphan_removal_counter++;
    528 <<<<<<< .working
    529                 if (orphan_removal_counter <0 || orphan_removal_counter >= 4) {
    530 =======
    531426                if (orphan_removal_counter <0 || orphan_removal_counter >= 2) {
    532 >>>>>>> .merge-rechts.r5869
    533427                        logging_info("Running orphan removal");
    534428                        orphan_removal_counter = 0;
Note: See TracChangeset for help on using the changeset viewer.