source: sample/pingpong/PingPong.cpp@ 12350

#include "PingPong.h"

#include <boost/property_tree/ptree.hpp>

#include <boost/property_tree/json_parser.hpp>



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_SERVICEID = ServiceID( 111 );



// construction

PingPong::PingPong( string config)  :

        node(),

        pingId( 0 ),

        config_file(config)

{

        Timer::setInterval( 5000 );

}



// destruction

PingPong::~PingPong() {

}



// implementation of the startup interface

void PingPong::startup()

{

    using boost::property_tree::ptree;

    using boost::property_tree::json_parser::read_json;

    

        // set up logging

        logging_rootlevel_debug();

        logging_classlevel_debug(PingPong);



        logging_info( "[PINGPONG]\t starting up PingPong service ... " );



    // read config

    ptree config;

    try

    {

        read_json(config_file, config);

    }

    catch ( exception& e )

    {

        logging_warn("ERROR: Failed to read config file »" << config_file << "«: ");

        logging_warn(e.what());

        logging_warn("---> Using fallback config.");

        

        config.put("ariba.spovnet_name", "pingpong");

    }

    

    // use node name also in the application

    name = config.get("ariba.node_name", "NO_NAME");

    

        // bind communication and node listener

        node.bind( this );                              /*NodeListener*/

        node.bind( this, PingPong::PINGPONG_SERVICEID); /*CommunicationListener*/



    // connecting

    logging_debug( "connecting ... " );



        node.connect(config.get_child("ariba"));



        // ping pong started up...

        logging_info( "[PINGPONG]\t pingpong starting up with"

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

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

}



// implementation of the startup interface

void PingPong::shutdown() {



        logging_info( "[PINGPONG]\t pingpong service starting shutdown sequence ..." );



        // stop timer

        Timer::stop();



        // leave spovnet

        node.leave();



        // unbind communication and node listener

        node.unbind( this );                               /*NodeListener*/

        node.unbind( this, PingPong::PINGPONG_SERVICEID ); /*CommunicationListener*/



        // now we are completely shut down

        logging_info( "pingpong service shut down" );

}



// 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

        // NOTE: Currently ariba only supports the Chord overlay.



        // In this sample we use auto-links: we just send out our message

        // to the node and the link is established automatically. for more

        // control we would use the node->establishLink function to create

        // a link and start using the link in the CommunicationListener::onLinkUp

        // function that is implemented further down in PingPong::onLinkUp

        

        // NOTE: This example still uses the old deprecated ariba::message messages 

        //   with the ariba built-in serialization. 

        // For future applications please use the new reboost::message_t messages. 

        //   Data is stored in high efficient zero-copy buffers of type 

        //   reboost::shared_buffer_t. These buffers hold plain data, so you have to 

        //   serialize the data "on your own".

        // We recommend third-party serialization libraries like:

        //   - Protocol Buffers (http://en.wikipedia.org/wiki/Protocol_Buffers)

        //   - MessagePack      (http://en.wikipedia.org/wiki/MessagePack)



        

        // don't do anything if we have no neighbors

        if ( node.getNeighborNodes().size() == 0)

    {

        logging_info( "[PINGPONG]\t +++ no neighbors +++" );

        return;

    }

    

    

        pingId++;

    logging_info( endl << "|||||||||| >>>>>>>>>>" << endl

                << "[PINGPONG]\t PINGING overlay neighbors with ping id " << pingId );

        PingPongMessage pingmsg( pingId, name );

        

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

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

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

        counter++;

        if (counter<0 || counter>4) {

                counter = 0;

                string s;

                for (int i=0; i<names.size();i++) {

                        if (i!=0) s+= ", ";

                        s = s+names[i];

                }

                logging_info("[PINGPONG]\t ----> I am " << name << " and I know " << s);

                names.clear();

        }



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

        BOOST_FOREACH( NodeID nid, nodes ){

                logging_info( "[PINGPONG]\t sending ping message to " << nid.toString() );

                node.sendMessage( pingmsg, nid, PingPong::PINGPONG_SERVICEID );

        }



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

        // 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_SERVICEID );

}



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

        logging_info( "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() );

}



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

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

        bool found=false;

        for (int i=0;i<names.size(); i++) if (names[i]==pingmsg->getName()) found=true;

        if (!found) names.push_back(pingmsg->getName());

        logging_info( endl << "<<<<<<<<<< ||||||||||" << endl

                << "[PINGPONG]\t RECEIVED ping message on link "

                << lnk.toString()

                << " " << (node.isLinkDirect(lnk) ? "[DIRECT-LINK]" : "[INDIRECT-LINK]")

                << " HopCount: " << node.getHopCount(lnk)

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

                        << " (" << pingmsg->getName() << ")"

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

        delete pingmsg;

}



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( "link-changed event for link " << lnk.toString()

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

}



bool PingPong::onLinkRequest(const NodeID& remote) {

        logging_info( "node " << remote.toString() << " wants to build up a link with us ... allowing" );

        return true;

}



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

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

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

}



}}} // namespace ariba, application, pingpong