An Overlay-based
Virtual Network Substrate
SpoVNet

Changeset 5316


Ignore:
Timestamp:
Jul 24, 2009, 8:53:41 PM (11 years ago)
Author:
Christoph Mayer
Message:

merge from bootstrap branch

Files:
28 edited

Legend:

Unmodified
Added
Removed
  • /

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • sample/pingpong/PingPong.cpp

    r5284 r5316  
    3333        ariba = new AribaModule();
    3434
    35         // get the configuration object
    36         Configuration& config = Configuration::instance();
    37 
    38         // generate spovnet name
    3935        Name spovnetName("pingpong");
    40 
    41         // get initiator flag
    42         this->isInitiator = Configuration::instance().read<bool>("node.initiator");
    43 
     36        Name nodeName = Name::UNSPECIFIED;
    4437        this->name = string("<ping>");
    4538
    46         // get node name
    47         Name nodeName = Name::UNSPECIFIED;
    48         if (config.exists("node.name")) nodeName = config.read<string> ("node.name");
    49 
    50         // configure ariba module
    51         if (config.exists("ariba.endpoints"))
    52                 ariba->setProperty("endpoints", config.read<string>("ariba.endpoints"));
    53         if (config.exists("ariba.bootstrap.hints"))
    54                 ariba->setProperty("bootstrap.hints", config.read<string>("ariba.bootstrap.hints"));
    55         if (config.exists("pingpong.name"))
    56                 name = config.read<string>("pingpong.name");
     39        // get settings from configuration object
     40        if( Configuration::haveConfig() ){
     41                Configuration& config = Configuration::instance();
     42
     43                // get node name
     44                if (config.exists("node.name"))
     45                        nodeName = config.read<string> ("node.name");
     46
     47                // configure ariba module
     48                if (config.exists("ariba.endpoints"))
     49                        ariba->setProperty("endpoints", config.read<string>("ariba.endpoints"));
     50                if (config.exists("ariba.bootstrap.hints"))
     51                        ariba->setProperty("bootstrap.hints", config.read<string>("ariba.bootstrap.hints"));
     52                if (config.exists("pingpong.name"))
     53                        name = config.read<string>("pingpong.name");
     54
     55        } // if( Configuration::haveConfig() )
    5756
    5857        // start ariba module
     
    7372        //params.setBaseOverlayType( SpoVNetProperties::ONE_HOP_OVERLAY ); // alternative: OneHop
    7473
    75         // initiate or join the spovnet
    76         if (!isInitiator) node->join(spovnetName);
    77         else node->initiate(spovnetName, params);
     74        // initiate the spovnet
     75        logging_info("initiating spovnet");
     76        node->initiate(spovnetName, params);
     77
     78        // join the spovnet
     79        logging_info("joining spovnet");
     80        node->join(spovnetName);
    7881
    7982        // ping pong started up...
     
    122125        // function that is implemented further down in PingPong::onLinkUp
    123126
    124 //      logging_info( "pinging overlay neighbors with ping id " << ++pingId );
    125 
     127        logging_info( "pinging overlay neighbors with ping id " << ++pingId );
    126128        PingPongMessage pingmsg( pingId, name );
    127129
     
    140142                names.clear();
    141143        }
     144
    142145        vector<NodeID> nodes = node->getNeighborNodes();
    143146        BOOST_FOREACH( NodeID nid, nodes ){
     147                logging_info( "sending ping message to " << nid.toString() );
    144148                node->sendMessage( pingmsg, nid, PingPong::PINGPONG_SERVICEID );
    145149        }
     
    176180        for (int i=0;i<names.size(); i++) if (names[i]==pingmsg->getName()) found=true;
    177181        if (!found) names.push_back(pingmsg->getName());
    178 //      logging_info( "received ping message on link " << lnk.toString()
    179 //                      << " from node " << remote.toString()
    180 //                      << ": " << pingmsg->info() );
     182        logging_info( "received ping message on link " << lnk.toString()
     183                        << " from node " << remote.toString()
     184                        << ": " << pingmsg->info() );
    181185}
    182186
  • sample/pingpong/PingPong.h

    r5151 r5316  
    6868        vector<string> names;
    6969
    70         // flag, whether this node initiates or just joins the spovnet
    71         bool isInitiator;
    72 
    7370        // the ping pong service id
    7471        static ServiceID PINGPONG_SERVICEID;
  • source/ariba/AribaModule.cpp

    r5284 r5316  
    6161AribaModule::AribaModule()
    6262        : base_comm(NULL), sideport_sniffer(NULL), started(false) {
     63
     64        endpoints = "tcp{41322}";
     65
     66        //srand( time(NULL) );
     67        //uint16_t tcpport = (rand() + 1024) % 50000;
     68        //uint16_t udpport = (rand() + 1024) % 50000;
    6369}
    6470
  • source/ariba/AribaModule.h

    r5284 r5316  
    4242#include <string>
    4343#include <vector>
     44#include <ctime>
     45#include <cstdlib>
    4446#include "ariba/utility/logging/Logging.h"
    45 
    4647
    4748using std::vector;
  • source/ariba/Node.cpp

    r5284 r5316  
    6363        const communication::EndpointDescriptor* ep =
    6464                        ariba_mod.getBootstrapNode(vnetname);
    65         if( ep == NULL ) {
    66                 std::cout << "no bootstrap node defined" << std::endl;
    67                 return;
    68         }
    69         ariba_mod.base_comm->start();
    70         base_overlay->start( *ariba_mod.base_comm, nodeId );
    71         base_overlay->joinSpoVNet( spovnetId, *ep);
     65
     66        // start base comm if not started
     67        if( !ariba_mod.base_comm->isStarted() )
     68                ariba_mod.base_comm->start();
     69
     70        // start base overlay if not started
     71        // join against ourselfs
     72        if( !base_overlay->isStarted() )
     73                base_overlay->start( *ariba_mod.base_comm, nodeId );
     74        base_overlay->joinSpoVNet( spovnetId );
     75
     76        // join against further nodes
     77        if( ep != NULL && *ep != EndpointDescriptor::UNSPECIFIED )
     78                base_overlay->joinSpoVNet( spovnetId, *ep);
    7279}
    7380
     
    8289        nodeId = generateNodeId(name);
    8390
    84         ariba_mod.base_comm->start();
    85 
    86         base_overlay->start( *ariba_mod.base_comm, nodeId );
     91        // start base comm if not started
     92        if( !ariba_mod.base_comm->isStarted() )
     93                ariba_mod.base_comm->start();
     94
     95        // start base overlay if not started
     96        if( !base_overlay->isStarted() )
     97                base_overlay->start( *ariba_mod.base_comm, nodeId );
     98
    8799        base_overlay->createSpoVNet( spovnetId, ovrpset );
    88 
    89         ariba_mod.addBootstrapNode(vnetname,
    90                 new EndpointDescriptor(ariba_mod.base_comm->getEndpointDescriptor()));
    91100}
    92101
  • source/ariba/SideportListener.cpp

    r5151 r5316  
    7474}
    7575
     76vector<NodeID> SideportListener::getOverlayNeighbors(bool deep){
     77        vector<NodeID> nodes;
     78        if( overlay == NULL ) return nodes;
     79
     80        overlay->getOverlayNeighbors(deep);
     81}
     82
    7683bool SideportListener::isRelayedNode(const NodeID& node){
    7784
  • source/ariba/SideportListener.h

    r5151 r5316  
    135135
    136136        /**
     137         * Get the neighbots in the overlay structure
     138         * @return A vector of NodeIDs of the neighbors
     139         */
     140        vector<NodeID> getOverlayNeighbors(bool deep = true);
     141
     142        /**
    137143         * Is this node acting as a relay for us
    138144         *
  • source/ariba/SpoVNetProperties.h

    r3718 r5316  
    7070                CHORD_OVERLAY = 1,
    7171        };
    72 
    7372
    7473        /**
  • source/ariba/overlay/BaseOverlay.cpp

    r5284 r5316  
    245245BaseOverlay::BaseOverlay() :
    246246        bc(NULL), overlayInterface(NULL), nodeId(NodeID::UNSPECIFIED),
    247         spovnetId(SpoVNetID::UNSPECIFIED), initiatorLink(LinkID::UNSPECIFIED),
    248         state(BaseOverlayStateInvalid), sideport(&SideportListener::DEFAULT) {
     247        spovnetId(SpoVNetID::UNSPECIFIED), state(BaseOverlayStateInvalid),
     248        sideport(&SideportListener::DEFAULT), started(false) {
    249249}
    250250
     
    268268        Timer::setInterval( 500 );
    269269        Timer::start();
     270
     271        started = true;
     272        state = BaseOverlayStateInvalid;
    270273}
    271274
     
    285288        bc->unregisterMessageReceiver( this );
    286289        bc->unregisterEventListener( this );
     290
     291        started = false;
     292        state = BaseOverlayStateInvalid;
     293}
     294
     295bool BaseOverlay::isStarted(){
     296        return started;
    287297}
    288298
     
    292302                const EndpointDescriptor& bootstrapEp) {
    293303
    294         ovl.visShowNodeBubble ( ovlId, nodeId, "joining..." );
     304        if(id != spovnetId){
     305                logging_error("attempt to join against invalid spovnet, call initiate first");
     306                return;
     307        }
     308
     309
     310        //ovl.visShowNodeBubble ( ovlId, nodeId, "joining..." );
    295311        logging_info( "Starting to join spovnet " << id.toString() <<
    296312                        " with nodeid " << nodeId.toString());
    297313
    298         // contact the spovnet initiator and request to join. if the join is granted we will
    299         // receive further information on the structure of the overlay that is used in the spovnet
    300         // but first, we have to establish a link to the initiator...
    301         spovnetId = id;
    302         state = BaseOverlayStateJoinInitiated;
    303 
    304         initiatorLink = bc->establishLink( bootstrapEp );
    305         logging_info("join process initiated for " << id.toString() << "...");
     314        if(bootstrapEp == EndpointDescriptor::UNSPECIFIED && state == BaseOverlayStateInvalid){
     315
     316                // bootstrap against ourselfs
     317                logging_debug("joining spovnet locally");
     318
     319                overlayInterface->joinOverlay();
     320                state = BaseOverlayStateCompleted;
     321                BOOST_FOREACH( NodeListener* i, nodeListeners )
     322                        i->onJoinCompleted( spovnetId );
     323
     324                //ovl.visChangeNodeIcon ( ovlId, nodeId, OvlVis::ICON_ID_CAMERA );
     325                //ovl.visChangeNodeColor( ovlId, nodeId, OvlVis::NODE_COLORS_GREEN );
     326
     327                logging_debug("starting overlay bootstrap module");
     328                overlayBootstrap.start(this, spovnetId, nodeId);
     329                overlayBootstrap.publish(bc->getEndpointDescriptor());
     330
     331        } else {
     332
     333                // bootstrap against another node
     334                logging_debug("joining spovnet remotely against " << bootstrapEp.toString());
     335
     336                const LinkID& lnk = bc->establishLink( bootstrapEp );
     337                bootstrapLinks.push_back(lnk);
     338                logging_info("join process initiated for " << id.toString() << "...");
     339        }
    306340}
    307341
     
    310344        logging_info( "Leaving spovnet " << spovnetId );
    311345        bool ret = ( state != this->BaseOverlayStateInvalid );
     346
     347        logging_debug("stopping overlay bootstrap module");
     348        overlayBootstrap.stop();
     349        overlayBootstrap.revoke();
    312350
    313351        logging_debug( "Dropping all auto-links" );
     
    329367                overlayInterface->leaveOverlay();
    330368
    331         // leave spovnet
    332         if( state != BaseOverlayStateInitiator ) {
    333                 // then, leave the spovnet baseoverlay
    334                 OverlayMsg overMsg( OverlayMsg::typeBye, nodeId );
    335                 bc->sendMessage( initiatorLink, &overMsg );
    336 
    337                 // drop the link and set to correct state
    338                 bc->dropLink( initiatorLink );
    339                 initiatorLink = LinkID::UNSPECIFIED;
    340         }
     369        // drop still open bootstrap links
     370        BOOST_FOREACH( LinkID lnk, bootstrapLinks )
     371                bc->dropLink( lnk );
    341372
    342373        // change to inalid state
    343374        state = BaseOverlayStateInvalid;
    344         ovl.visShutdown( ovlId, nodeId, string("") );
     375        //ovl.visShutdown( ovlId, nodeId, string("") );
    345376
    346377        // inform all registered services of the event
     
    362393
    363394        spovnetId = id;
    364         state = BaseOverlayStateInitiator;
    365395
    366396        overlayInterface = OverlayFactory::create( *this, param, nodeId, this );
     
    368398                logging_fatal( "overlay structure not supported" );
    369399                state = BaseOverlayStateInvalid;
     400
     401                BOOST_FOREACH( NodeListener* i, nodeListeners )
     402                        i->onJoinFailed( spovnetId );
     403
    370404                return;
    371405        }
    372 
    373         // bootstrap against ourselfs
    374         overlayInterface->joinOverlay();
    375         BOOST_FOREACH( NodeListener* i, nodeListeners )
    376                 i->onJoinCompleted( spovnetId );
    377 
    378         ovl.visChangeNodeIcon ( ovlId, nodeId, OvlVis::ICON_ID_CAMERA );
    379         ovl.visChangeNodeColor( ovlId, nodeId, OvlVis::NODE_COLORS_GREEN );
    380406}
    381407
     
    695721        LinkDescriptor* ld = getDescriptor(id, true);
    696722
    697         // handle initiator link
    698         if(state == BaseOverlayStateJoinInitiated && id == initiatorLink) {
     723        // handle bootstrap link we initiated
     724        if( std::find(bootstrapLinks.begin(), bootstrapLinks.end(), id) != bootstrapLinks.end() ){
    699725                logging_info(
    700726                        "Join has been initiated by me and the link is now up. " <<
     
    759785        const address_v* local, const address_v* remote) {
    760786
     787        // erase bootstrap links
     788        vector<LinkID>::iterator it = std::find( bootstrapLinks.begin(), bootstrapLinks.end(), id );
     789        if( it != bootstrapLinks.end() ) bootstrapLinks.erase( it );
     790
    761791        // get descriptor for link
    762792        LinkDescriptor* ld = getDescriptor(id, true);
     
    800830        const address_v* local, const address_v* remote) {
    801831        logging_debug( "Link fail with base communication link id=" << id );
     832
     833        // erase bootstrap links
     834        vector<LinkID>::iterator it = std::find( bootstrapLinks.begin(), bootstrapLinks.end(), id );
     835        if( it != bootstrapLinks.end() ) bootstrapLinks.erase( it );
    802836
    803837        // get descriptor for link
     
    927961                        logging_debug("received join reply message");
    928962                        JoinReply* replyMsg = overlayMsg->decapsulate<JoinReply>();
    929                         assert(state == BaseOverlayStateJoinInitiated);
    930963
    931964                        // correct spovnet?
     
    942975
    943976                                // drop initiator link
    944                                 bc->dropLink( initiatorLink );
    945                                 initiatorLink = LinkID::UNSPECIFIED;
    946                                 state = BaseOverlayStateInvalid;
     977
     978                                if(bcLink != LinkID::UNSPECIFIED){
     979                                        bc->dropLink( bcLink );
     980
     981                                        vector<LinkID>::iterator it = std::find(
     982                                                        bootstrapLinks.begin(), bootstrapLinks.end(), bcLink);
     983                                        if( it != bootstrapLinks.end() )
     984                                                bootstrapLinks.erase(it);
     985                                }
    947986
    948987                                // inform all registered services of the event
    949988                                BOOST_FOREACH( NodeListener* i, nodeListeners )
    950989                                        i->onJoinFailed( spovnetId );
     990
    951991                                return true;
    952992                        }
     
    956996                                        spovnetId.toString() );
    957997
     998                        logging_debug( "Using bootstrap end-point "
     999                                << replyMsg->getBootstrapEndpoint().toString() );
     1000
     1001                        //
    9581002                        // create overlay structure from spovnet parameter set
    959                         overlayInterface = OverlayFactory::create(
    960                                 *this, replyMsg->getParam(), nodeId, this );
    961 
    962                         // overlay structure supported? no-> fail!
    963                         if( overlayInterface == NULL ) {
    964                                 logging_error( "overlay structure not supported" );
    965 
    966                                 bc->dropLink( initiatorLink );
    967                                 initiatorLink = LinkID::UNSPECIFIED;
    968                                 state = BaseOverlayStateInvalid;
     1003                        // if we have not boostrapped yet against some other node
     1004                        //
     1005
     1006                        if( overlayInterface == NULL ){
     1007
     1008                                logging_debug("first-time bootstrapping");
     1009
     1010                                overlayInterface = OverlayFactory::create(
     1011                                        *this, replyMsg->getParam(), nodeId, this );
     1012
     1013                                // overlay structure supported? no-> fail!
     1014                                if( overlayInterface == NULL ) {
     1015                                        logging_error( "overlay structure not supported" );
     1016
     1017                                        if(bcLink != LinkID::UNSPECIFIED){
     1018                                                bc->dropLink( bcLink );
     1019
     1020                                                vector<LinkID>::iterator it = std::find(
     1021                                                                bootstrapLinks.begin(), bootstrapLinks.end(), bcLink);
     1022                                                if( it != bootstrapLinks.end() )
     1023                                                        bootstrapLinks.erase(it);
     1024                                        }
     1025
     1026                                        // inform all registered services of the event
     1027                                        BOOST_FOREACH( NodeListener* i, nodeListeners )
     1028                                        i->onJoinFailed( spovnetId );
     1029
     1030                                        return true;
     1031                                }
     1032
     1033                                // everything ok-> join the overlay!
     1034                                state = BaseOverlayStateCompleted;
     1035                                overlayInterface->createOverlay();
     1036
     1037                                overlayInterface->joinOverlay( replyMsg->getBootstrapEndpoint() );
     1038
     1039                                // update ovlvis
     1040                                //ovl.visChangeNodeColor( ovlId, nodeId, OvlVis::NODE_COLORS_GREEN);
    9691041
    9701042                                // inform all registered services of the event
    9711043                                BOOST_FOREACH( NodeListener* i, nodeListeners )
    972                                 i->onJoinFailed( spovnetId );
    973 
    974                                 return true;
    975                         }
    976 
    977                         // everything ok-> join the overlay!
    978                         state = BaseOverlayStateCompleted;
    979                         overlayInterface->createOverlay();
    980                         logging_debug( "Using bootstrap end-point "
    981                                 << replyMsg->getBootstrapEndpoint().toString() );
    982                         overlayInterface->joinOverlay( replyMsg->getBootstrapEndpoint() );
    983 
    984                         // update ovlvis
    985                         ovl.visChangeNodeColor( ovlId, nodeId, OvlVis::NODE_COLORS_GREEN);
    986 
    987                         // inform all registered services of the event
    988                         BOOST_FOREACH( NodeListener* i, nodeListeners )
    989                                 i->onJoinCompleted( spovnetId );
     1044                                        i->onJoinCompleted( spovnetId );
     1045
     1046                        } else {
     1047
     1048                                // this is not the first bootstrap, just join the additional node
     1049                                logging_debug("not first-time bootstrapping");
     1050                                overlayInterface->joinOverlay( replyMsg->getBootstrapEndpoint() );
     1051
     1052                        } // if( overlayInterface == NULL )
    9901053
    9911054                        return true;
     
    11031166
    11041167                // ---------------------------------------------------------------------
    1105                 // handle bye messages
    1106                 // ---------------------------------------------------------------------
    1107                 case OverlayMsg::typeBye: {
    1108                         logging_debug( "received bye message from " <<
    1109                                         overlayMsg->getSourceNode().toString() );
    1110 
    1111                         /* if we are the initiator and receive a bye from a node
    1112                          * the node just left. if we are a node and receive a bye
    1113                          * from the initiator, we have to close, too.
    1114                          */
    1115                         if( overlayMsg->getSourceNode() == spovnetInitiator ) {
    1116 
    1117                                 bc->dropLink( initiatorLink );
    1118                                 initiatorLink = LinkID::UNSPECIFIED;
    1119                                 state = BaseOverlayStateInvalid;
    1120 
    1121                                 logging_fatal( "initiator ended spovnet" );
    1122 
    1123                                 // inform all registered services of the event
    1124                                 BOOST_FOREACH( NodeListener* i, nodeListeners )
    1125                                         i->onLeaveFailed( spovnetId );
    1126 
    1127                         } else {
    1128                                 // a node that said goodbye and we are the initiator don't have to
    1129                                 // do much here, as the node also will go out of the overlay
    1130                                 // structure
    1131                                 logging_info( "node left " << overlayMsg->getSourceNode() );
    1132                         }
    1133 
    1134                         return true;
    1135 
    1136                 }
    1137 
    1138                 // ---------------------------------------------------------------------
    11391168                // handle link request forwarded through the overlay
    11401169                // ---------------------------------------------------------------------
    11411170                case OverlayMsg::typeLinkRequest: {
     1171
     1172                        logging_debug( "received link request on link" );
    11421173
    11431174                        // decapsulate message
     
    12611292                case OverlayMsg::typeRelay: {
    12621293
     1294                        logging_debug( "received relay request on link" );
     1295
    12631296                        // decapsulate message
    12641297                        RelayMessage* relayMsg = overlayMsg->decapsulate<RelayMessage>();
     
    13471380                // ---------------------------------------------------------------------
    13481381                case OverlayMsg::typeKeepAlive: {
     1382
     1383                        logging_debug( "received keep-alive on link" );
     1384
    13491385                        if ( ld != NULL ) {
    13501386                                //logging_force("Keep-Alive for "<< ld->overlayId);
     
    13581394                // ---------------------------------------------------------------------
    13591395                case OverlayMsg::typeDirectLink: {
     1396
     1397                        logging_debug( "received direct link replacement request" );
     1398
    13601399                        LinkDescriptor* rld = getDescriptor( overlayMsg->getRelayLink() );
    13611400                        logging_force( "Received direct link convert notification for " << rld );
     
    13801419
    13811420        } /* switch */
     1421
    13821422        return false;
    13831423}
     
    13981438}
    13991439
    1400 vector<NodeID> BaseOverlay::getOverlayNeighbors() const {
     1440vector<NodeID> BaseOverlay::getOverlayNeighbors(bool deep) const {
    14011441        // the known nodes _can_ also include our node, so we remove ourself
    1402         vector<NodeID> nodes = overlayInterface->getKnownNodes();
     1442        vector<NodeID> nodes = overlayInterface->getKnownNodes(deep);
    14031443        vector<NodeID>::iterator i = find( nodes.begin(), nodes.end(), this->nodeId );
    14041444        if( i != nodes.end() ) nodes.erase( i );
     
    14991539        // drop links
    15001540        BOOST_FOREACH( const LinkDescriptor* ld, oldlinks ) {
    1501                 if (!ld->communicationId.isUnspecified() && ld->communicationId == initiatorLink) {
     1541
     1542                vector<LinkID>::iterator it = std::find(
     1543                                bootstrapLinks.begin(), bootstrapLinks.end(), ld->communicationId);
     1544
     1545                if (!ld->communicationId.isUnspecified() && it != bootstrapLinks.end() ){
    15021546                        logging_force( "Not dropping initiator link: " << ld );
    15031547                        continue;
  • source/ariba/overlay/BaseOverlay.h

    r5284 r5316  
    112112using ariba::utility::OvlVis;
    113113
    114 #define ovl OvlVis::instance()
    115 #define ovlId OvlVis::NETWORK_ID_BASE_OVERLAY
     114//#define ovl OvlVis::instance()
     115//#define ovlId OvlVis::NETWORK_ID_BASE_OVERLAY
    116116
    117117namespace ariba {
     
    156156
    157157        /**
     158         * Is the BaseOverlay instance started up yet
     159         */
     160        bool isStarted();
     161
     162        /**
    158163         * Starts a link establishment procedure to the specfied node
    159164         * for the service with id service
     
    211216         * @return A list of overlay neighbors.
    212217         */
    213         vector<NodeID> getOverlayNeighbors() const;
     218        vector<NodeID> getOverlayNeighbors(bool deep = true) const;
    214219
    215220        /**
     
    264269         * @param boot A bootstrap node
    265270         */
    266         void joinSpoVNet(const SpoVNetID& id, const EndpointDescriptor& boot);
     271        void joinSpoVNet(const SpoVNetID& id, const EndpointDescriptor& boot = EndpointDescriptor::UNSPECIFIED);
    267272
    268273        /**
     
    365370        typedef enum _BaseOverlayState {
    366371                BaseOverlayStateInvalid = 0,
    367                 BaseOverlayStateInitiator = 1,
    368                 BaseOverlayStateJoinInitiated = 2,
    369                 BaseOverlayStateCompleted = 3,
     372                BaseOverlayStateCompleted = 1,
    370373        } BaseOverlayState;
    371374
    372         BaseOverlayState state; ///< Current Base-Overlay state
    373         BaseCommunication* bc;  ///< reference to the base communication
    374         NodeID nodeId;          ///< the node id of this node
    375         SpoVNetID spovnetId;    ///< the spovnet id of the currently joined overlay
    376         LinkID initiatorLink;   ///< the link id of the link to the initiator node
    377         NodeID spovnetInitiator;///< The initiator node
     375        BaseOverlayState state;          ///< Current Base-Overlay state
     376        BaseCommunication* bc;           ///< reference to the base communication
     377        NodeID nodeId;                   ///< the node id of this node
     378        SpoVNetID spovnetId;             ///< the spovnet id of the currently joined overlay
     379        vector<LinkID> bootstrapLinks;   ///< the link id of the link to the initiator node
     380        NodeID spovnetInitiator;         ///< The initiator node
    378381
    379382        /// the service id communication listeners
     
    440443         */
    441444        OverlayBootstrap overlayBootstrap;
     445
     446        /// is the base overlay started yet
     447        bool started;
    442448};
    443449
  • source/ariba/overlay/OverlayBootstrap.cpp

    r5002 r5316  
    6161        nodeid = _nodeid;
    6262
     63        logging_info("starting overlay bootstrap");
     64
    6365        manager.registerCallback( this );
    64         //manager.registerModule( BootstrapManager::BootstrapTypePeriodicBroadcast );
     66        manager.registerModule( BootstrapManager::BootstrapTypePeriodicBroadcast );
     67        //manager.registerModule( BootstrapManager::BootstrapTypeBluetoothSdp );
    6568}
    6669
     
    7073        nodeid = NodeID::UNSPECIFIED;
    7174
     75        logging_info("stopping overlay bootstrap");
     76
    7277        manager.unregisterCallback( this );
    73         //manager.unregisterModule( BootstrapManager::BootstrapTypePeriodicBroadcast );
     78        manager.unregisterModule( BootstrapManager::BootstrapTypePeriodicBroadcast );
     79        //manager.unregisterModule( BootstrapManager::BootstrapTypeBluetoothSdp );
    7480}
    7581
     
    8389        // tell the base overlay to join using this endpoint
    8490        assert( overlay != NULL );
    85         // TODO: overlay->joinSpoVNet( spovnetid, data->endpoint );
     91        overlay->joinSpoVNet( spovnetid, data->endpoint );
    8692
    8793        delete data;
  • source/ariba/overlay/messages/OverlayMsg.h

    r5151 r5316  
    7070                typeJoinReply = 3, ///< join reply
    7171                typeUpdate = 4, ///< update message for link association
    72                 typeBye = 5, ///< leave (no encapsulated messages)
    73                 typeLinkRequest = 6, ///< link request (sent over the overlay)
    74                 typeRelay = 7, ///< relay message
    75                 typeKeepAlive = 8, ///< a keep-alive message
    76                 typeDirectLink = 9,
     72                typeLinkRequest = 5, ///< link request (sent over the overlay)
     73                typeRelay = 6, ///< relay message
     74                typeKeepAlive = 7, ///< a keep-alive message
     75                typeDirectLink = 8,
    7776        ///< a direct connection has been established
    7877        };
  • source/ariba/overlay/modules/OverlayInterface.h

    r5151 r5316  
    149149         * @return The list of all known nodes
    150150         */
    151         virtual NodeList getKnownNodes() const = 0;
     151        virtual NodeList getKnownNodes(bool deep = true) const = 0;
    152152
    153153        /**
  • source/ariba/overlay/modules/chord/Chord.cpp

    r5151 r5316  
    6161        stabilize_counter = 0;
    6262        stabilize_finger = 0;
    63         bootstrapLink = LinkID::UNSPECIFIED;
    6463}
    6564
     
    112111void Chord::joinOverlay(const EndpointDescriptor& boot) {
    113112        logging_info( "joining Chord overlay structure through end-point " <<
    114                         (boot == EndpointDescriptor::UNSPECIFIED ?
    115                                         "local" : boot.toString()) );
     113                        (boot.isUnspecified() ? "local" : boot.toString()) );
    116114
    117115        // initiator? no->setup first link
    118         if (!(boot == EndpointDescriptor::UNSPECIFIED))
    119                 bootstrapLink = setup(boot);
     116        if (!boot.isUnspecified())
     117                bootstrapLinks.push_back( setup(boot) );
    120118
    121119        // timer for stabilization management
     
    176174}
    177175
    178 OverlayInterface::NodeList Chord::getKnownNodes() const {
     176OverlayInterface::NodeList Chord::getKnownNodes(bool deep) const {
    179177        OverlayInterface::NodeList nodelist;
    180         for (size_t i = 0; i < table->size(); i++)
    181                 if ((*table)[i]->ref_count != 0
    182                                 && !(*table)[i]->info.isUnspecified())
    183                         nodelist.push_back((*table)[i]->id);
     178
     179        if( deep ){
     180                // all nodes that I know, fingers, succ/pred
     181                for (size_t i = 0; i < table->size(); i++){
     182                        if ((*table)[i]->ref_count != 0
     183                                        && !(*table)[i]->info.isUnspecified())
     184                                nodelist.push_back((*table)[i]->id);
     185                }
     186        } else {
     187                // only succ and pred
     188                if( table->get_predesessor() != NULL )
     189                        nodelist.push_back( *(table->get_predesessor()) );
     190
     191                if( table->get_successor() != NULL )
     192                                        nodelist.push_back( *(table->get_successor()) );
     193        }
     194
    184195        return nodelist;
    185196}
     
    208219        }
    209220
    210         if (!bootstrapLink.isUnspecified() && lnk == bootstrapLink) {
     221        vector<LinkID>::iterator it = std::find(bootstrapLinks.begin(), bootstrapLinks.end(), lnk);
     222        if( it != bootstrapLinks.end() ) {
    211223                send_discovery_to(nodeid);
    212                 bootstrapLink = LinkID::UNSPECIFIED;
     224                bootstrapLinks.erase( it );
    213225        }
    214226}
  • source/ariba/overlay/modules/chord/Chord.h

    r5151 r5316  
    7676        int stabilize_counter;
    7777        int stabilize_finger;
    78         LinkID bootstrapLink;
     78        vector<LinkID> bootstrapLinks;
    7979        vector<NodeID> pending;
    8080
     
    120120
    121121        /// @see OverlayInterface.h
    122         virtual NodeList getKnownNodes() const;
     122        virtual NodeList getKnownNodes(bool deep = true) const;
    123123
    124124        /// @see CommunicationListener.h or @see OverlayInterface.h
  • source/ariba/overlay/modules/onehop/OneHop.cpp

    r5151 r5316  
    5252                OverlayStructureEvents* _eventsReceiver, const OverlayParameterSet& param)
    5353        :       OverlayInterface( _baseoverlay, _nodeid, _eventsReceiver, param ),
    54                 state           ( OneHopStateInvalid ),
    55                 bootstrapLink   ( LinkID::UNSPECIFIED ),
    56                 pendingLinks    ( 0 ) {
     54                state( OneHopStateInvalid ) {
    5755
    5856        //
     
    8886        logging_debug( "routing message to node " << destnode.toString() );
    8987
     88        // msg for ourselfs
     89        if(destnode == nodeid)
     90                baseoverlay.incomingRouteMessage( msg, LinkID::UNSPECIFIED, nodeid );
     91
     92        // msg for other node
    9093        OverlayNodeMapping::const_iterator i = overlayNodes.find( destnode );
    9194        if (i == overlayNodes.end()) {
     
    116119        // the create and join process is completed now.
    117120        logging_info( "creating onehop overlay structure" );
    118         state = OneHopStateCompleted;
    119121}
    120122
     
    123125        logging_info( "deleting onehop overlay structure" );
    124126        state = OneHopStateInvalid;
    125         pendingLinks = 0;
    126 }
    127 
    128 OverlayInterface::NodeList OneHop::getKnownNodes() const {
     127}
     128
     129OverlayInterface::NodeList OneHop::getKnownNodes(bool deep) const {
    129130
    130131        OverlayInterface::NodeList retlist;
     
    142143
    143144        logging_info( "joining onehop overlay structure through end-point " <<
    144                         (bootstrapEp == EndpointDescriptor::UNSPECIFIED ?
    145                                         "local" : bootstrapEp.toString()) );
    146 
    147         state = OneHopStateJoinInitiated;
    148         pendingLinks = 0;
    149 
    150         if( bootstrapEp == EndpointDescriptor::UNSPECIFIED ){
     145                        (bootstrapEp.isUnspecified() ? "local" : bootstrapEp.toString()) );
     146
     147        if( bootstrapEp.isUnspecified() ){
    151148
    152149                // we are the initiator and we are to bootstrap against
     
    156153                state = OneHopStateCompleted;
    157154        } else {
    158                 bootstrapLink = baseoverlay.establishLink( bootstrapEp,
    159                                         OverlayInterface::OVERLAY_SERVICE_ID );
     155                bootstrapLinks.push_back(
     156                                baseoverlay.establishLink( bootstrapEp,
     157                                        OverlayInterface::OVERLAY_SERVICE_ID )
     158                                        );
    160159        }
    161160}
     
    187186                }
    188187        }
    189 
    190         pendingLinks = 0;
    191188}
    192189
     
    210207                }
    211208        }
     209
     210        vector<LinkID>::iterator it = std::find( bootstrapLinks.begin(), bootstrapLinks.end(), lnk );
     211        if( it != bootstrapLinks.end() ) bootstrapLinks.erase( it );
    212212}
    213213
    214214void OneHop::onLinkUp(const LinkID& lnk, const NodeID& remote){
    215 
    216         //
    217         // as soon as a link goes up, we always request the node listing.
    218         // and try to get connections to as much nodes as possible in a greedy way.
    219         //
    220 
    221         if( lnk != bootstrapLink ){
    222                 if( pendingLinks > 0 )  pendingLinks--;
    223                 if( pendingLinks == 0 ) state = OneHopStateCompleted;
    224         }
    225215
    226216        logging_debug( "link is up, sending out node listing request" );
     
    230220        onemsg.encapsulate( &requestmsg );
    231221
    232         state = OneHopStateJoinListingRequested;
    233222        baseoverlay.sendMessage( &onemsg, lnk );
    234223}
     
    309298                const NodeListingReply::NodeEndpointList& endpoints = reply->getList();
    310299                logging_debug( "received " << endpoints.size() << " nodes in listing" );
    311                 pendingLinks = 0;
    312300
    313301                NodeListingReply::NodeEndpointList::const_iterator i = endpoints.begin();
     
    330318
    331319                        overlayNodes.insert( make_pair(node, link) );
    332                         pendingLinks++;
    333320
    334321                } // for( ; i != iend; i++ )
     
    356343        if( onemsg->isType( OneHopMessage::OneHopMessageTypeRoute) ){
    357344                logging_debug( "Route message arrived at destination node -> delegate to BaseOverlay" );
    358                 baseoverlay.incomingRouteMessage( onemsg );
     345                baseoverlay.incomingRouteMessage( onemsg, lnk, remote);
    359346        } // OneHopMessageTypeRoute
    360347
  • source/ariba/overlay/modules/onehop/OneHop.h

    r5151 r5316  
    9090
    9191        /// @see OverlayInterface.h
    92         virtual NodeList getKnownNodes() const;
     92        virtual NodeList getKnownNodes(bool deep = true) const;
    9393
    9494        /// @see CommunicationListener.h or @see OverlayInterface.h
     
    110110        typedef enum _OneHopState {
    111111                OneHopStateInvalid = 0,
    112                 OneHopStateJoinInitiated = 1,
    113                 OneHopStateJoinListingRequested = 2,
    114                 OneHopStateCompleted = 3,
     112                OneHopStateCompleted = 1,
    115113        } OneHopState;
    116114
    117115        OneHopState state;
    118         uint16_t pendingLinks;
    119         LinkID bootstrapLink;
     116        vector<LinkID> bootstrapLinks;
    120117};
    121118
  • source/ariba/utility/bootstrap/modules/bluetoothsdp

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • source/ariba/utility/bootstrap/modules/bluetoothsdp/BluetoothSdp.cpp

    r4970 r5316  
    4141#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
    4242
    43 // Attribute descriptors for SDP
    44 // base was chosen randomly
    45 #define SDP_SPOVNET_BASE                        0x4000
    46 #define SDP_ATTR_SPOVNET_NAME           0x0000 + SDP_SPOVNET_BASE
    47 #define SDP_ATTR_SPOVNET_INFO1          0x0001 + SDP_SPOVNET_BASE
    48 #define SDP_ATTR_SPOVNET_INFO2          0x0002 + SDP_SPOVNET_BASE
    49 #define SDP_ATTR_SPOVNET_INFO3          0x0003 + SDP_SPOVNET_BASE
    50 
    51 // The SpoVNet unique identifier, this should be the same for all SpoVNet implementations
    52 const uint8_t svc_uuid_int[] = {0x59, 0x29, 0x24, 0x34, 0x69, 0x42, 0x11, 0xde, 0x94,
    53         0x3e, 0x00, 0x21, 0x5d, 0xb4, 0xd8, 0x54};
    54 
    55 const char *service_name = "SpoVNet";
    56 const char *svc_dsc = "Spontaneous Virtual Network";
    57 const char *service_prov = "ITM Uni Karlsruhe";
     43        // Attribute descriptors for SDP
     44        // base was chosen randomly
     45        #define SDP_SPOVNET_BASE                        0x4000
     46        #define SDP_ATTR_SPOVNET_NAME           0x0000 + SDP_SPOVNET_BASE
     47        #define SDP_ATTR_SPOVNET_INFO1          0x0001 + SDP_SPOVNET_BASE
     48        #define SDP_ATTR_SPOVNET_INFO2          0x0002 + SDP_SPOVNET_BASE
     49        #define SDP_ATTR_SPOVNET_INFO3          0x0003 + SDP_SPOVNET_BASE
     50
     51        // The SpoVNet unique identifier, this should be the same for all SpoVNet implementations
     52        const uint8_t svc_uuid_int[] = {0x59, 0x29, 0x24, 0x34, 0x69, 0x42, 0x11, 0xde, 0x94,
     53                0x3e, 0x00, 0x21, 0x5d, 0xb4, 0xd8, 0x54};
     54
     55        const char *service_name = "SpoVNet";
     56        const char *svc_dsc = "www.ariba-underlay.org";
     57        const char *service_prov = "ITM Uni Karlsruhe";
    5858
    5959#endif // HAVE_BLUETOOTH_BLUETOOTH_H
     
    6666BluetoothSdp::BluetoothSdp(BootstrapInformationCallback* _callback) :
    6767        BootstrapModule(_callback), scan_timer_(io_service_) {
     68        srand( time(NULL) );
    6869#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
    6970
     
    8889bool BluetoothSdp::isFunctional() {
    8990#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
    90         return true; // Not tested yet :)
     91        return true;
    9192#else
    9293        return false;
     
    118119        t_.join();
    119120
     121        if(sdp_session_ != NULL)
     122                sdp_close(sdp_session_);
     123
    120124#endif // HAVE_BLUETOOTH_BLUETOOTH_H
    121125}
     
    130134         */
    131135
    132         logging_info("Registering SDP service");
     136        logging_debug("registering SDP service");
    133137
    134138        uint8_t rfcomm_channel = channel_;
     
    142146        sdp_session_ = 0;
    143147
    144         bdaddr_t bdaddr_any = (bdaddr_t) { {0, 0, 0, 0, 0, 0}};
    145         bdaddr_t bdaddr_local = (bdaddr_t) { {0, 0, 0, 0xff, 0xff, 0xff}};
    146 
    147148        // prepare the info attribute buffers
    148149        //string namebuf, info1buf, info2buf, info3buf;
     
    155156
    156157        if((namelen > 256) || (info1len > 256) || (info2len > 256) || (info3len > 256)) {
    157                 logging_error("String Argument too long, max size is 256!");
     158                logging_error("string argument too long, max size is 256!");
    158159                return;
    159160        }
    160 
    161         // we need to save the string len for sdp; do we?
    162         /*
    163         namebuf = (char)namelen;
    164         namebuf.append(name);
    165         info1buf = (char)info1len;
    166         info1buf.append(info1);
    167         info2buf = (char)info2len;
    168         info2buf.append(info2);
    169         info3buf = (char)info3len;
    170         info3buf.append(info3);
    171         */
    172161
    173162        // set the general service ID
     
    222211                        info3.data());
    223212
    224         // connect to the local SDP server, register the service record,
    225         // and disconnect
    226         sdp_session_ = sdp_connect(&bdaddr_any, &bdaddr_local, SDP_RETRY_IF_BUSY);
    227 
    228         if (sdp_session_ == 0) {
    229                 logging_error( "Something is wrong with your SDP server, nothing registered" );
     213        // connect to the local SDP server, register the service record
     214        if( sdp_session_ == NULL ){
     215                sdp_session_ = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
     216        }
     217
     218        if (sdp_session_ == NULL) {
     219                logging_error( "something is wrong with your SDP server, nothing registered" );
    230220        } else {
    231                 sdp_record_register(sdp_session_, &record, 0);
     221                int ret = sdp_record_register(sdp_session_, &record, 0);
     222
     223                if(ret < 0){
     224                        logging_error("failed registering sdp record");
     225                }else{
     226                        logging_debug("sdp record registered using session " << sdp_session_);
     227                }
    232228        }
    233229
     
    247243#ifdef HAVE_BLUETOOTH_BLUETOOTH_H
    248244
    249         logging_info("Unregistering SDP service");
     245        logging_debug("unregistering SDP service");
    250246        sdp_close(sdp_session_);
    251247
     
    256252
    257253void BluetoothSdp::bt_scan() {
    258 
    259 
    260254        /*
    261255         * Scans for other bluetooth devices and starts a SDP search on them.
    262          * Repeats 20 seconds after the end of the scan.
    263          */
    264 
    265         logging_info("Scanning for peers");
     256         */
     257
     258        logging_debug("scanning for peers");
    266259
    267260        inquiry_info *ii = NULL;
     
    276269        sock = hci_open_dev(dev_id);
    277270        if (dev_id < 0 || sock < 0) {
    278                 logging_error("opening socket");
    279                 exit(1);
     271                logging_error("opening socket for device " << dev_id << " failed. can not scan for peers");
     272                return;
    280273        }
    281274
     
    287280        num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags);
    288281        if (num_rsp < 0)
    289                 logging_error("hci_inquiry");
     282                logging_error("hci_inquiry failed with " << num_rsp);
    290283
    291284        for (i = 0; i < num_rsp; i++) {
    292                 /*
    293                  ba2str(&(ii + i)->bdaddr, addr);
    294                  memset(name, 0, sizeof(name));
    295                  if (hci_read_remote_name(sock, &(ii + i)->bdaddr, sizeof(name),
    296                  name, 0) < 0)
    297                  strcpy(name, "[unknown]");
    298                  printf("%s  %s\n", addr, name);
    299                  */
    300285
    301286                address = (ii + i)->bdaddr;
    302 
    303                 logging_info("Found peer " << ba2string(&address) << ", querying SDP.")
     287                logging_debug("found peer " << ba2string(&address) << ", querying SDP.")
    304288
    305289                // TODO: sdp_search can be very slow, fork it!
     
    310294        close(sock);
    311295
    312         logging_info("Next scan in 20 seconds");
    313 
    314         scan_timer_.expires_from_now(boost::posix_time::seconds(20));
     296        int nextscan = (rand() % 40) + 5;
     297        logging_debug("Next sdp scan in " << nextscan << " seconds");
     298
     299        scan_timer_.expires_from_now(boost::posix_time::seconds(nextscan));
    315300        scan_timer_.async_wait(boost::bind(&BluetoothSdp::bt_scan, this));
    316301}
     
    326311        uuid_t svc_uuid;
    327312        sdp_list_t *response_list, *search_list, *attrid_list;
    328         sdp_session_t *session = 0;
     313        sdp_session_t *session = NULL;
    329314        uint32_t range = 0x0000ffff;
    330315        uint8_t port = 0;
    331         bdaddr_t any_addr = (bdaddr_t) { {0, 0, 0, 0, 0, 0}};
    332316
    333317        // prepare the buffers for the attributes
     
    335319
    336320        // connect to the SDP server running on the remote machine
    337         session = sdp_connect(&any_addr, &target, 0);
    338 
    339         if (session == 0) {
    340                 logging_error("Failed to connect to SDP server at " << ba2string(&target) <<".");
     321        logging_debug("querying services from bt device " << ba2string(&target));
     322        session = sdp_connect(BDADDR_ANY, &target, 0);
     323
     324        if (session == NULL) {
     325                logging_error("failed to connect to SDP server at " << ba2string(&target) <<".");
    341326                return;
    342327        }
     
    356341
    357342                // go through each of the service records
    358                 for (; r; r = r->next) {
     343                for ( ; r != NULL; r = r->next) {
    359344                        sdp_record_t *rec = (sdp_record_t*) r->data;
    360345
     
    368353
    369354                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_NAME, (char*)&name, 256);
    370                                 sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO1, (char*)&name, 256);
    371                                 sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO2, (char*)&name, 256);
    372                                 sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO3, (char*)&name, 256);
     355                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO1, (char*)&info1, 256);
     356                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO2, (char*)&info2, 256);
     357                                sdp_get_string_attr(rec, SDP_ATTR_SPOVNET_INFO3, (char*)&info3, 256);
    373358
    374359                                logging_info("Remote peer name is: " << name);
     
    379364                                // Callback
    380365                                callback->onBootstrapServiceFound(name, info1, info2, info3);
    381 
    382366                        }
    383367                        sdp_record_free(rec);
    384368                }
    385         }
     369        } else {
     370                logging_error("sdp_service_search_attr_req failed with timeout");
     371        }
     372
    386373        sdp_list_free(response_list, 0);
    387374        sdp_list_free(search_list, 0);
    388375        sdp_list_free(attrid_list, 0);
    389376        sdp_close(session);
    390 
    391377}
    392378
     
    395381         * Returns a string holding the bt adress in human readable form.
    396382         */
    397         char *str;
     383        char addr[32] = { 0 };
     384        char str[32] = { 0 };
    398385        ba2str(ba, str);
    399386        string result = str;
  • source/ariba/utility/bootstrap/modules/bluetoothsdp/BluetoothSdp.h

    r4970 r5316  
    4444#include <iostream>
    4545#include <string>
     46#include <ctime>
    4647#include <boost/bind.hpp>
    4748#include <boost/asio.hpp>
     
    9495        boost::asio::deadline_timer scan_timer_;
    9596        boost::thread t_;
    96 
    9797};
    9898
  • source/ariba/utility/bootstrap/modules/periodicbroadcast

    • Property svn:mergeinfo changed (with no actual effect on merging)
  • source/ariba/utility/bootstrap/modules/periodicbroadcast/PeriodicBroadcast.cpp

    r4934 r5316  
    6666        : BootstrapModule(_callback),
    6767        server(io_service, &newRemoteServices, &newRemoteServicesMutex) {
    68 
    6968}
    7069
  • source/ariba/utility/configuration/Configuration.cpp

    r3690 r5316  
    5151void Configuration::setConfigFilename(string filename){
    5252        CONFIG_FILE = filename;
    53         instance().reload();
     53        if(haveConfig())
     54                instance().reload();
    5455}
    5556
    5657Configuration::~Configuration(){
    5758        delete config;
     59}
     60
     61bool Configuration::haveConfig(){
     62        std::ifstream in( CONFIG_FILE.c_str() );
     63        if( !in ) return false;
     64
     65        in.close();
     66        return true;
    5867}
    5968
     
    6473
    6574bool Configuration::exists(const string& name){
     75        if(config == NULL) return false;
    6676        return config->keyExists( name );
    6777}
  • source/ariba/utility/configuration/Configuration.h

    r3690 r5316  
    6363        static Configuration& instance();
    6464        static void setConfigFilename(string filename);
     65        static bool haveConfig();
    6566
    6667        /**
  • source/ariba/utility/misc/OvlVis.cpp

    r3690 r5316  
    5050OvlVis::OvlVis() : socket(io_service), socketOpened(false) {
    5151
     52        if( ! Configuration::haveConfig() ) return;
    5253        if( ! Configuration::instance().exists("DEMO_OvlVisIP") )   return;
    5354        if( ! Configuration::instance().exists("DEMO_OvlVisPort") ) return;
  • source/ariba/utility/system/StartupWrapper.cpp

    r5289 r5316  
    9898        {
    9999                log4cxx::LoggerPtr logger(log4cxx::Logger::getRootLogger());
    100                 logger->setLevel(log4cxx::Level::getError());
     100                logger->setLevel(log4cxx::Level::getWarn());
    101101        }
    102102
     
    107107        }
    108108        {
    109                 log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("BaseCommunication"));
    110                 logger->setLevel(log4cxx::Level::getError());
     109//              log4cxx::LoggerPtr logger(log4cxx::Logger::getLogger("BaseCommunication"));
     110//              logger->setLevel(log4cxx::Level::getError());
    111111        }
    112112
    113113        //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
    114         // DON'T SVN COMMIT YOUR CHANTED LOGGING! THE ABOVE CODE MUST REMAIN AS IS!
     114        // DON'T SVN COMMIT YOUR CHANGED LOGGING! THE ABOVE CODE MUST REMAIN AS IS!
    115115        //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
    116116}
  • source/ariba/utility/system/SystemQueue.cpp

    r4721 r5316  
    226226                        // call the queue and this will
    227227                        // call the actual event handler
     228                        obj->queueMutex.unlock();
    228229                        obj->onNextQueueItem( ev );
     230                        obj->queueMutex.lock();
    229231
    230232                } // !obj->eventsQueue.empty() )
Note: See TracChangeset for help on using the changeset viewer.