Changeset 4866 for source


Ignore:
Timestamp:
Jul 13, 2009, 9:42:32 AM (15 years ago)
Author:
Christoph Mayer
Message:

periodic bootstrap vervollständigt

Location:
source/ariba
Files:
4 edited

Legend:

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

    r4850 r4866  
    4444
    4545use_logging_cpp(OverlayBootstrap);
     46SystemEventType OverlayBootstrapMethodType("OverlayBootstrapMethodType");
    4647
    4748OverlayBootstrap::OverlayBootstrap()
     
    6162
    6263        manager.registerCallback( this );
    63         manager.registerAllModules();
     64        manager.registerModule( BootstrapManager::BootstrapTypePeriodicBroadcast );
    6465}
    6566void OverlayBootstrap::stop(){
     
    6970
    7071        manager.unregisterCallback( this );
    71         manager.unregisterAllModules();
     72        manager.unregisterModule( BootstrapManager::BootstrapTypePeriodicBroadcast );
     73}
     74
     75void OverlayBootstrap::handleSystemEvent(const SystemEvent& event){
     76
     77
     78        EventData* data = event.getData<EventData>();
     79
     80        // announcement for our spovnet
     81        logging_info( "found bootstrap node for our SpoVNetID " << data->spovnetid.toString()
     82                        << " on NodeID " << data->nodeid.toString() << " with endpoint " << data->endpoint.toString() );
     83
     84
     85        // TODO: do stuff on overlay
     86
     87
     88        delete data;
    7289}
    7390
     
    95112        if( nid == this->nodeid ) return;
    96113
    97         // announcement for our spovnet
    98         logging_info( "found bootstrap node for our SpoVNetID " << sid.toString()
    99                         << " on NodeID " << nid << " with endpoint " << ep.toString() );
     114        //
     115        // send out the bootstrap information as
     116        // event to synchronize into the system queue
     117        //
     118
     119        EventData* data = new EventData();
     120        data->spovnetid = sid;
     121        data->nodeid = nid;
     122        data->endpoint = ep;
     123
     124        SystemQueue::instance().scheduleEvent(
     125                        SystemEvent( this, OverlayBootstrapMethodType, data), 0 );
    100126}
    101127
  • source/ariba/overlay/OverlayBootstrap.h

    r4836 r4866  
    4747#include "ariba/utility/bootstrap/BootstrapInformationCallback.h"
    4848#include "ariba/communication/EndpointDescriptor.h"
     49#include "ariba/utility/system/SystemEventListener.h"
     50#include "ariba/utility/system/SystemQueue.h"
     51#include "ariba/utility/system/SystemEvent.h"
     52#include "ariba/utility/system/SystemEventType.h"
    4953
    5054using std::string;
     
    5559using ariba::utility::BootstrapInformationCallback;
    5660using ariba::communication::EndpointDescriptor;
     61using ariba::utility::SystemEventType;
     62using ariba::utility::SystemEvent;
     63using ariba::utility::SystemQueue;
     64using ariba::utility::SystemEventListener;
    5765
    5866namespace ariba {
     
    6169class BaseOverlay;
    6270
    63 class OverlayBootstrap : public BootstrapInformationCallback {
     71class OverlayBootstrap : public BootstrapInformationCallback, public SystemEventListener {
    6472        use_logging_h(OverlayBootstrap);
    6573public:
     
    7482
    7583protected:
     84        virtual void handleSystemEvent(const SystemEvent& event);
    7685        virtual void onBootstrapServiceFound(string name, string info1, string info2, string info);
    7786
    7887private:
     88        typedef struct _EventData {
     89                SpoVNetID spovnetid;
     90                NodeID nodeid;
     91                EndpointDescriptor endpoint;
     92        } EventData;
     93
    7994        BootstrapManager& manager;
    8095        SpoVNetID spovnetid;
  • source/ariba/utility/bootstrap/modules/periodicbroadcast/PeriodicBroadcast.cpp

    r4853 r4866  
    5959use_logging_cpp(PeriodicBroadcast);
    6060const long PeriodicBroadcast::timerinterval = 1000;
     61const long PeriodicBroadcast::servicetimeout = 3000;
    6162const unsigned int PeriodicBroadcast::serverport_v4 = 5634;
    6263const unsigned int PeriodicBroadcast::serverport_v6 = 5636;
     
    130131void PeriodicBroadcast::updateRemoteServices(){
    131132
     133        // cleanup the services that timed out
     134        // so they are seen of as new after timeout
     135        {
     136                boost::mutex::scoped_lock lock( remoteServicesMutex );
     137                bool deleted;
     138
     139                do {
     140                        deleted = false;
     141
     142                        ServiceList::iterator i = remoteServices.begin();
     143                        ServiceList::iterator iend = remoteServices.end();
     144
     145                        for( ; i != iend; i++ ){
     146
     147                                if( time(NULL) > (i->second.lastseen + servicetimeout) ){
     148                                        remoteServices.erase( i );
     149                                        deleted = true;
     150                                        break;
     151                                }
     152                        }
     153
     154                }while(deleted);
     155        }
     156
     157        // check if we received new services:
     158        // check remoteServices against newRemoteServices
     159        {
     160                boost::mutex::scoped_lock lock( newRemoteServicesMutex );
     161                typedef std::pair<string,Service> mapitem;
     162
     163                BOOST_FOREACH( mapitem item, newRemoteServices ){
     164
     165                        string name = item.first;
     166                        Service service = item.second;
     167
     168                        ServiceList::iterator i = remoteServices.find( name );
     169                        if( i != remoteServices.end() ) {
     170                                // update the item lastseen time
     171                                i->second.lastseen = service.lastseen;
     172                                continue;
     173                        }
     174
     175                        {
     176                                // insert the new item as new, lastseen has been set in the
     177                                // receive function, as this timer only runs in intervals
     178                                boost::mutex::scoped_lock lock2( remoteServicesMutex );
     179                                remoteServices.insert( std::make_pair(name, service) );
     180                        }
     181
     182                        callback->onBootstrapServiceFound(name, service.info1, service.info2, service.info3);
     183                }
     184
     185                // we have checked and transfered all new items
     186                newRemoteServices.clear();
     187        }
    132188}
    133189
  • source/ariba/utility/bootstrap/modules/periodicbroadcast/PeriodicBroadcast.h

    r4853 r4866  
    4444#include <map>
    4545#include <string>
     46#include <ctime>
    4647#include <iostream>
    4748#include <boost/asio.hpp>
     
    5657using std::map;
    5758using std::string;
     59using std::cout;
    5860using boost::asio::ip::udp;
    5961
     
    8385        void updateRemoteServices();
    8486
    85         static const long timerinterval;
     87        static const long timerinterval; // used to send out updates on our services and check for new services
     88        static const long servicetimeout; // timeout after that a service is dead when we did not receive updates
    8689        static const unsigned int serverport_v4;
    8790        static const unsigned int serverport_v6;
     
    9295                string info2;
    9396                string info3;
     97                time_t lastseen;
     98
     99                _Service()
     100                        : name(""), info1(""), info2(""), info3(""), lastseen(0){
     101                }
    94102        } Service;
    95103
     
    133141                        Data data = data_serialize( msg, DEFAULT_V );
    134142                        uint8_t* pnt = data.getBuffer();
    135                         size_t len = data.getLength();
     143                        size_t len = data.getLength() / 8;
    136144                        boost::system::error_code ignored_error;
     145
     146                        cout << "-----------> sending out " << data << std::endl;
    137147
    138148                        {
     
    172182                                data_deserialize( msg, data );
    173183
     184                                cout << "-----------> received " << data << std::endl;
     185
    174186                                { // insert new found service
    175187                                        boost::mutex::scoped_lock( *servicesmutex );
     
    182194                                        s.info2 = msg.getInfo2();
    183195                                        s.info3 = msg.getInfo3();
     196                                        s.lastseen = time(NULL);
    184197                                        services->insert( std::make_pair(msg.getName(), s) );
    185198                                }
Note: See TracChangeset for help on using the changeset viewer.