source: trash/pingpong/PingPong.cpp@ 5521

#include "PingPong.h"



#include "ariba/interface/UnderlayAbstraction.h"



namespace ariba {

namespace appplication {

namespace pingpong {



use_logging_cpp(PingPong);

ServiceID PingPong::PINGPONG_ID = ServiceID(111);



PingPong::PingPong() : pingid( 0 ) {

}



PingPong::~PingPong(){

}



void PingPong::setMode(bool startingNode){

        startping = startingNode;

}



void PingPong::startup(){

        abstraction = new UnderlayAbstraction();



        logging_info( "starting up PingPong service ... " );



        SpoVNetID spovnetid (Identifier(5000));



        setMode( !Configuration::instance().read<bool>("GENERAL_Initiator") );



        NodeID nodeid = (Configuration::instance().exists("BASE_nodeid") ?

                        NodeID(Identifier(Configuration::instance().read<unsigned long>("BASE_nodeid"))) :

                        NodeID::UNSPECIFIED);



        IPv4Locator* locallocator = (Configuration::instance().exists("BASE_localLocator") ?

                                        &(IPv4Locator::fromString(Configuration::instance().read<string>("BASE_localLocator"))) :

                                        NULL);



        uint16_t localport = Configuration::instance().exists("BASE_port") ?

                                Configuration::instance().read<uint16_t>("BASE_port") :

                                ARIBA_DEFAULT_PORT;



        if( !startping ){



                context = abstraction->createSpoVNet(

                        spovnetid, nodeid, locallocator, localport );



        } else {



                if( !Configuration::instance().exists("BASE_bootstrapIP")){

                        logging_fatal( "no bootstrap address found" );

                        return;

                }



                logging_info( "using bootstrap point " <<

                        Configuration::instance().read<string>("BASE_bootstrapIP") );



                EndpointDescriptor bootstrap(

                new IPv4Locator(IPv4Locator::fromString(

                        Configuration::instance().read<string>("BASE_bootstrapIP"))));



                context = abstraction->joinSpoVNet(

                        spovnetid, bootstrap, nodeid, locallocator, localport );



        }



        overlay = &context->getOverlay();

        overlay->bind( this, PingPong::PINGPONG_ID );



        logging_info( "PingPong started up" );



        // trigger the creation of the pathload measurement module

        //PathloadMeasurement::instance( overlay );

}



void PingPong::shutdown(){

        logging_info( "shutting down PingPong service ..." );



        overlay->unbind( this, PingPong::PINGPONG_ID );

        Timer::stop();



        if( !startping ) abstraction->destroySpoVNet( context );

        else             abstraction->leaveSpoVNet( context );



        delete abstraction;



        logging_info( "PingPong service shut down" );

}



bool PingPong::receiveMessage(const Message* message, const LinkID& link, const NodeID& node){



        PingPongMessage* incoming = ((Message*)message)->decapsulate<PingPongMessage>();



        logging_info( "received ping message on link " << link.toString() <<

                                 " from node with id " << (int)incoming->getid());



//      if( ((int)incoming->getid() % 5) == 0 )

//              PathloadMeasurement::instance().measure( node, this );

}



void PingPong::eventFunction(){



        logging_info( "pinging our remote nodes" );



        RemoteNodes::iterator i = remoteNodes.begin();

        RemoteNodes::iterator iend = remoteNodes.end();



        pingid++;



        for( ; i != iend; i++ ){

                logging_info( "     -> pinging " << i->first );



                PingPongMessage pingmsg( pingid );

                overlay->sendMessage( &pingmsg, i->second );

        }

}



void PingPong::onMeasurement(NodeID node, double mbps){

        logging_info( "pingpong received measurement for node " << node.toString() << " with result " << mbps );

}



void PingPong::onJoinSuccess( const SpoVNetID& spovnetid ){

}



void PingPong::onOverlayCreate( const SpoVNetID& id ){

}



void PingPong::onOverlayDestroy( const SpoVNetID& id ){

}



bool PingPong::isJoinAllowed( const NodeID& nodeid, const SpoVNetID& spovnetid ){

        return true;

}



void PingPong::onNodeJoin( const NodeID& nodeid, const SpoVNetID& spovnetid ){



        if( !startping ){



                logging_info( "establishing link to node " << nodeid.toString() );

                const LinkID link = overlay->establishLink( nodeid, PingPong::PINGPONG_ID );



                logging_info( "adding node to registered nodes in pingpong: " << nodeid.toString() );

                remoteNodes.insert( make_pair(nodeid,link) );



                Timer::setInterval( 2000 );

                Timer::start();

        }

}



void PingPong::onNodeLeave( const NodeID& id, const SpoVNetID& spovnetid ){

        RemoteNodes::iterator i = remoteNodes.find( id );

        if( i != remoteNodes.end() ) remoteNodes.erase( i );

}



void PingPong::onJoinFail( const SpoVNetID& spovnetid ){

}



void PingPong::onLinkUp( const LinkID& link, const NodeID& local, const NodeID& remote ){

}



void PingPong::onLinkDown( const LinkID& link, const NodeID& local, const NodeID& remote ){

}



void PingPong::onLinkChanged( const LinkID& link, const NodeID& local, const NodeID& remote ){

}



void PingPong::onLinkFail(const LinkID& id, const NodeID& local, const NodeID& remote){

}



void PingPong::onLinkQoSChanged(const LinkID& id, const NodeID& local, const NodeID& remote , const QoSParameterSet& qos){

}



}}} // namespace ariba, appplication, pingpong