source: sample/pingpong/PingPong.cpp@ 3038

#include "PingPong.h"

#include "ariba/utility/configuration/Configuration.h"



using ariba::utility::Configuration;

using namespace ariba;



namespace ariba {

namespace application {

namespace pingpong {



// logging

use_logging_cpp( PingPong );



// the service that the pingpong wants to use

ServiceID PingPong::PINGPONG_ID = ServiceID( 111 );



// construction

PingPong::PingPong() : pingId( 0 ) {

        Timer::setInterval( 5000 );

}



// destruction

PingPong::~PingPong() {

}



// implementation of the startup interface

void PingPong::startup() {



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



        // create ariba module

        logging_debug( "creating ariba underlay module ... " );

        ariba = new AribaModule();



        // get the configuration object

        Configuration& config = Configuration::instance();



        // generate spovnet name

        Name spovnetName("pingpong");



        // get initiator flag

        this->isInitiator = Configuration::instance().read<bool>("node.initiator");



        // get node name

        Name nodeName = Name::UNSPECIFIED;

        if (config.exists("node.name")) nodeName = config.read<string> ("node.name");



        // configure ariba module

        if (config.exists("ariba.ip.addr")) ariba->setProperty("ip.addr",

                        config.read<string>("ariba.ip.addr"));

        if (config.exists("ariba.tcp.port")) ariba->setProperty("tcp.port",

                        config.read<string>("ariba.tcp.port"));

        if (config.exists("ariba.udp.port")) ariba->setProperty("udp.port",

                        config.read<string>("ariba.udp.port"));

        if (config.exists("ariba.bootstrap.hints")) ariba->setProperty("bootstrap.hints",

                        config.read<string>("ariba.bootstrap.hints"));



        // start ariba module

        ariba->start();



        // create node and join

        node = new Node( *ariba, nodeName );



        // start node module

        node->start();



        // initiate or join the spovnet

        if (!isInitiator) node->join(spovnetName);

        else node->initiate(spovnetName);



        // bind communication and node listener

        node->bind( this );                       /*NodeListener*/

        node->bind( this, PingPong::PINGPONG_ID); /*CommunicationListener*/



        // start the ping timer. if we are not

        // the initiator this will happen in onJoinCompleted

        if( isInitiator ) Timer::start();



        // ping pong started up...

        logging_info( "pingpong starting up with"

                        << " [spovnetid " << node->getSpoVNetId().toString() << "]"

                        << " and [nodeid " << node->getNodeId().toString() << "]" );

}



// implementation of the startup interface

void PingPong::shutdown() {



        logging_info( "pingpong service starting shutdown sequence ..." );



        // stop timer

        Timer::stop();



        // unbind communication and node listener

        node->unbind( this );                        /*NodeListener*/

        node->unbind( this, PingPong::PINGPONG_ID ); /*CommunicationListener*/



        // leave spovnet

        node->leave();



        // stop the ariba module

        ariba->stop();



        // delete node and ariba module

        delete node;

        delete ariba;



        // now we are completely shut down

        logging_info( "pingpong service shut down" );

}



// node listener interface

void PingPong::onJoinCompleted( const SpoVNetID& vid ) {

        logging_error( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX pingpong node join completed, spovnetid=" << vid.toString() );



        // start the timer to ping every second

        Timer::start();

}



void PingPong::onJoinFailed( const SpoVNetID& vid ) {

        logging_error("pingpong node join failed, spovnetid=" << vid.toString() );

}



void PingPong::onLeaveCompleted( const SpoVNetID& vid ){

        logging_info("pingpong node leave completed, spovnetid=" << vid.toString() );

}



void PingPong::onLeaveFailed( const SpoVNetID& vid ){

        logging_error("pingpong node leave failed, spovnetid=" << vid.toString() );

}



// timer event

void PingPong::eventFunction() {



        // we ping all nodes that are known in the overlay structure

        // this can be all nodes (OneHop) overlay or just some neighbors

        // in case of a Chord or Kademlia structure



        logging_info( "pinging overlay neighbors with ping id " << ++pingId );



        PingPongMessage pingmsg( pingId );



        //-----------------------------------------------------------------------

        // Option 1: get all neighboring nodes and send the message to each

        //-----------------------------------------------------------------------

        vector<NodeID> nodes = node->getNeighborNodes();

        BOOST_FOREACH( NodeID nid, nodes ){

                node->sendMessage( pingmsg, nid, PingPong::PINGPONG_ID );

        }



        //-----------------------------------------------------------------------

        // Option 2: send a "broadcast message" that actually does the same thing

        //           internally, gets all neighboring nodes and sends the message

        //-----------------------------------------------------------------------

        // node->sendBroadcastMessage( pingmsg, PingPong::PINGPONG_ID );

}



// communication listener

bool PingPong::onLinkRequest(const NodeID& remote, const DataMessage& msg) {

        return false;

}



void PingPong::onMessage(const DataMessage& msg, const NodeID& remote, const LinkID& lnk) {



        PingPongMessage* pingmsg = msg.getMessage()->convert<PingPongMessage> ();



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

                        << " from node " << remote.toString()

                        << ": " << pingmsg->info() );

}



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

        logging_info( "received link-up event for link " << lnk.toString()

                        << " and node " << remote.toString() );

}



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

        logging_info( "received link-down event for link " << lnk.toString()

                        << " and node " << remote.toString() );

}



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

        logging_info( "received link-changed event for link " << lnk.toString()

                        << " and node " << remote.toString() );

}



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

        logging_info( "received link-failed event for link " << lnk.toString()

                        << " and node " << remote.toString() );

}



void PingPong::onLinkQoSChanged(const LinkID& lnk, const NodeID& remote, const LinkProperties& prop){

        logging_info( "received link-qos-changed event for link " << lnk.toString()

                                << " and node " << remote.toString()

                                << " with link properties " << prop.toString() );

}



void PingPong::onMessageSent(seqnum_t seq_num, bool failed, const DataMessage& msg ){

        logging_info( "received message sent event for seqnum " << seq_num

                        << " with result " << failed );

}



}}} // namespace ariba, application, pingpong