source: trash/pingpong/PingPong.cpp@ 12769

#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