Context Navigation

PingPong

Timestamp:: Feb 4, 2010, 6:00:49 PM (15 years ago)
Author:: Christoph Mayer
Comment:: --

Legend:

: Unmodified
: Added
: Removed
: Modified

Documentation/Tutorial/PingPong

-              v33
+              v34
 {{{
+#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_SERVICEID = 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 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 );
+      // bind communication and node listener
+      node->bind( this );                              /*NodeListener*/
+      node->bind( this, PingPong::PINGPONG_SERVICEID); /*CommunicationListener*/
+      // start node module
+      node->start();
+      // initiate or join the spovnet
+      if (!isInitiator) node->join(spovnetName);
+      else node->initiate(spovnetName);
+      // ping pong started up...
+      logging_info( "pingpong starting up with"
+                      << " [spovnetid " << node->getSpoVNetId().toString() << "]"
+                      << " and [nodeid " << node->getNodeId().toString() << "]" );
+}
+  #include "PingPong.h"
+  #include "ariba/utility/configuration/Configuration.h"
+  #include "ariba/utility/visual/DddVis.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_SERVICEID = ServiceID( 111 );
+  // construction
+  PingPong::PingPong() : pingId( 0 ) {
+          Timer::setInterval( 1000 );
+  }
+  // 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();
+          Name spovnetName("pingpong");
+          Name nodeName = Name::UNSPECIFIED;
+          this->name = string("<ping>");
+          // get settings from configuration object
+          if( Configuration::haveConfig() ){
+                  Configuration& config = Configuration::instance();
+                  // get node name
+                  if (config.exists("node.name"))
+                          nodeName = config.read<string> ("node.name");
+                  // configure ariba module
+                  if (config.exists("ariba.endpoints"))
+                          ariba->setProperty("endpoints", config.read<string>("ariba.endpoints"));
+                  if (config.exists("ariba.bootstrap.hints"))
+                          ariba->setProperty("bootstrap.hints", config.read<string>("ariba.bootstrap.hints"));
+                  if (config.exists("pingpong.name"))
+                          name = config.read<string>("pingpong.name");
+                  // get visualization
+                  if( config.exists("ariba.visual3d.ip") && config.exists("ariba.visual3d.port")){
+                          string ip = config.read<string>("ariba.visual3d.ip");
+                          unsigned int port = config.read<unsigned int>("ariba.visual3d.port");
+                          unsigned int color = config.exists("node.color") ?
+                                          config.read<unsigned int>("node.color") : 0;
+                          ariba::utility::DddVis::instance().configure(ip, port, color);
+                  }
+          } // if( Configuration::haveConfig() )
+          // start ariba module
+          ariba->start();
+          // create node and join
+          node = new Node( *ariba, nodeName );
+          // bind communication and node listener
+          node->bind( this );                              /*NodeListener*/
+          node->bind( this, PingPong::PINGPONG_SERVICEID); /*CommunicationListener*/
+          // start node module
+          node->start();
+          // when initiating, you can define the overlay type, default is Chord [CHORD_OVERLAY]
+          SpoVNetProperties params;
+          //params.setBaseOverlayType( SpoVNetProperties::ONE_HOP_OVERLAY ); // alternative: OneHop
+          // initiate the spovnet
+          logging_info("initiating spovnet");
+          node->initiate(spovnetName, params);
+          // join the spovnet
+          logging_info("joining spovnet");
+          node->join(spovnetName);
+          // ping pong started up...
+          logging_info( "pingpong starting up with"
+                          << " [spovnetid " << node->getSpoVNetId().toString() << "]"
+                          << " and [nodeid " << node->getNodeId().toString() << "]" );
+  }
 }}}
 …
 {{{
 void PingPong::shutdown() {
       logging_info( "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*/
       // 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" );
 }
+  void PingPong::shutdown() {
+          logging_info( "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*/
+          // 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" );
+  }
 }}}
 …
 {{{
+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
+      // 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
+      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_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::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
+          // 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
+          logging_info( "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("----> I am " << name << " and I know " << s);
+                  names.clear();
+          }
+          vector<NodeID> nodes = node->getNeighborNodes();
+          BOOST_FOREACH( NodeID nid, nodes ){
+                  logging_info( "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 );
+  }
 }}}
 …
 {{{
 #include "PingPongMessage.h"
 namespace ariba {
 namespace application {
 namespace pingpong {
 vsznDefault(PingPongMessage);
 PingPongMessage::PingPongMessage() : id(0) {
 }
 PingPongMessage::PingPongMessage(uint8_t _id) : id(_id) {
 }
 PingPongMessage::~PingPongMessage(){
 }
 string PingPongMessage::info(){
       return "ping pong message id " + ariba::utility::Helper::ultos(id);
 }
 uint8_t PingPongMessage::getid(){
       return id;
 }
 }}} // namespace ariba, appplication, pingpong
+#include "PingPongMessage.h"
+namespace ariba {
+namespace application {
+namespace pingpong {
+vsznDefault(PingPongMessage);
+PingPongMessage::PingPongMessage() : id(0) {
+}
+PingPongMessage::PingPongMessage(uint8_t _id) : id(_id) {
+}
+PingPongMessage::~PingPongMessage(){
+}
+string PingPongMessage::info(){
+  return "ping pong message id " + ariba::utility::Helper::ultos(id);
+}
+uint8_t PingPongMessage::getid(){
+  return id;
+}
+}}} // namespace ariba, appplication, pingpong
 }}}
 …
 {{{
+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());
+}
+  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( "received ping message on link " << lnk.toString()
+                          << " from node " << remote.toString()
+                          << ": " << pingmsg->info() );
+  }
 }}}
 Getting back to ''!PingPong.cpp'': After the initiator has send a message to a joiner, it will arrive and has to be handled. This is accomplished in ''receiveMessage'' (the name says it). Every received message has to be decapsulated by a service, casting the data back to the service's message format (line 132).
-''Ariba'' provides several callback functions that may used by services to catch all kinds of events that could be of interest. In this exampe we limit ourselves to the event cases of node joins and node leaves. When a node successfull joines to the SpoVNet instance, ''onNodeJoin'' is triggered nn the initiator's service side. He may then react to this event, exemplary shown in line 80-93, implementing ''onNodeJoin''. In this case, the initiator starts establishing a link to the joined node (line 85), essentially for all kinds of communications via ''Ariba''. We then store the link for further usage (line 88) and prepare a timer which intention is to trigger periodic events. In our case we initialize the timer to be triggered every 2 seconds (line 90), before starting it (line 91).
-{{{
-void PingPong::onNodeLeave( const NodeID& id, const SpoVNetID& spovnetid ){
-     RemoteNodes::iterator i = remoteNodes.find( id );
-     if( i != remoteNodes.end() ) remoteNodes.erase( i );
-}
-}}}
-Node leaves in our case only lead to deletion of links we had stored before, for we don't need them anymore (line 102).
-{{{
-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();
-      }
-}
-}}}