source: source/ariba/Node.cpp@ 12063

// [License]

// The Ariba-Underlay Copyright

//

// Copyright (c) 2008-2009, Institute of Telematics, UniversitÀt Karlsruhe (TH)

//

// Institute of Telematics

// UniversitÀt Karlsruhe (TH)

// Zirkel 2, 76128 Karlsruhe

// Germany

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

// 1. Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

// 2. Redistributions in binary form must reproduce the above copyright

// notice, this list of conditions and the following disclaimer in the

// documentation and/or other materials provided with the distribution.

//

// THIS SOFTWARE IS PROVIDED BY THE INSTITUTE OF TELEMATICS ``AS IS'' AND

// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OF TELEMATICS OR

// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// The views and conclusions contained in the software and documentation

// are those of the authors and should not be interpreted as representing

// official policies, either expressed or implied, of the Institute of

// Telematics.

// [License]



#include "Node.h"



#include <boost/foreach.hpp>



#include "ariba/overlay/BaseOverlay.h"

#include "ariba/communication/BaseCommunication.h"



#include "ariba/utility/types/OverlayParameterSet.h"

#include "ariba/communication/EndpointDescriptor.h"



#include <boost/property_tree/exceptions.hpp>



using namespace std;

using ariba::communication::EndpointDescriptor;

using boost::property_tree::ptree;



namespace ariba {



//Node::Node(AribaModule& ariba_mod, const Name& node_name) :

//      name(node_name), ariba_mod(ariba_mod) {

//      base_overlay = new BaseOverlay();

//}



Node::Node()  :

        name(Name::UNSPECIFIED),

        base_communication(NULL),

        base_overlay(NULL)

{

    base_communication = new BaseCommunication();

    base_overlay = new BaseOverlay();

}



Node::~Node() {

        delete base_overlay;

        base_overlay = NULL;

        

        delete base_communication;

        base_communication = NULL;

}



void Node::connect(const ptree& config)

{

    using namespace boost::property_tree;

    using namespace addressing2;

    

    assert( ! base_communication->isStarted() );

    assert( ! base_overlay->isStarted() );



    // XXX needed since »empty_ptree<ptree>()« is not working

    //   ---> see: http://stackoverflow.com/questions/5003549/where-is-boost-property-treeempty-ptree

    static const ptree empty_pt;

    

    // SpovNet ID

    Name spovnet_name(config.get<string>("spovnet_name"));

    spovnetId = spovnet_name.toSpoVNetId();

    

    // Node ID

    try

    {

        name = config.get<string>("node_name");

    }

    catch ( ptree_bad_path& e )

    {

        name = Name::UNSPECIFIED;

    }

    nodeId = generateNodeId(name);



    

    

    /* Base Communication */

    EndpointSetPtr listen_on;

    try

    {

        listen_on = endpoint_set::create_EndpointSet(

            config.get_child("listen_on"));

    }

    catch ( ptree_bad_path& e )

    {

        /* no endpoints specified, using default: »[::]:41322+« */

        

        ptree default_listen_on;

        default_listen_on.put("endp.category", "TCPIP");

        default_listen_on.put("endp.addr", "::");

        default_listen_on.put("endp.port", 0);  // defaults to 41322 (or higher)

        

        listen_on = endpoint_set::create_EndpointSet(default_listen_on);

//        logging_warn("No endpoints specified in config. ---> Using default.");

        cout << "No endpoints specified in config. ---> Using default." << endl;

    }

    base_communication->start(listen_on);

    

    // TODO maybe notify the upper layer whether we have any active endpoints

    



    /* Base Overlay */

    base_overlay->start( base_communication, nodeId );



    base_overlay->createSpoVNet( spovnetId );

    base_overlay->joinSpoVNet( spovnetId );

    

    

    

    /* Bootstrap */

    const ptree& bootstrap_pt = config.get_child("bootstrap", empty_pt);

    

    // Static Bootstrap

    try

    {

        // read endpoint_set from config

        EndpointSetPtr ep_set = endpoint_set::create_EndpointSet(

                bootstrap_pt.get_child("direct"));

        

        EndpointDescriptor ep = EndpointDescriptor::UNSPECIFIED();

        ep.replace_endpoint_set(ep_set);

        

        // try to connect

        base_overlay->joinSpoVNet( spovnetId, ep);

    }

    catch ( ptree_bad_path& e )

    {

//        logging_info("No direct bootstrap info in config.");

        cout << "No direct bootstrap info in config." << endl;

    }



    

    /* Bootstrap modules */

    vector<pair<BootstrapManager::BootstrapType,string> > internalmodules;

    

    // Bootstrap: Broadcast

    if ( bootstrap_pt.get("broadcast", false) )

    {

        internalmodules.push_back(make_pair(

                BootstrapManager::BootstrapTypePeriodicBroadcast,""));

    }

    

    // Bootstrap: MDNS

    if ( bootstrap_pt.get("mdns", false) )

    {

        internalmodules.push_back(make_pair(

                BootstrapManager::BootstrapTypeMulticastDns,""));

    }



    // Bootstrap: SDP

    if ( bootstrap_pt.get("sdp", false) )

    {

        internalmodules.push_back(make_pair(

                BootstrapManager::BootstrapTypeBluetoothSdp,""));

    }



    // start automatic overlay bootstrapping modules

    base_overlay->startBootstrapModules(internalmodules);

}



//void Node::join(const Name& vnetname) {

//      spovnetId = vnetname.toSpoVNetId();

//      nodeId = generateNodeId(name);

//

//      // start base comm if not started

//      if( !ariba_mod.base_comm->isStarted() )

//              ariba_mod.base_comm->start();

//

//      // start base overlay if not started

//      // join against ourselfs

//      if( !base_overlay->isStarted() )

//              base_overlay->start( *ariba_mod.base_comm, nodeId );

//      base_overlay->joinSpoVNet( spovnetId );

//

//      // join against static bootstrap points and

//      // start automatic bootstrapping modules

//      vector<AribaModule::BootstrapMechanism> mechanisms

//              = ariba_mod.getBootstrapMechanisms(vnetname);

//

//      vector<pair<BootstrapManager::BootstrapType,string> > internalmodules;

//

//      BOOST_FOREACH(AribaModule::BootstrapMechanism m, mechanisms){

//              switch(m){

//                      case AribaModule::BootstrapMechanismStatic:

//                      {

//                              const communication::EndpointDescriptor* ep =

//                                                      ariba_mod.getBootstrapNode(vnetname, m);

//                                      if( ep != NULL && ep->isUnspecified() == false )

//                                              base_overlay->joinSpoVNet( spovnetId, *ep);

//                              break;

//                      }

//                      case AribaModule::BootstrapMechanismBroadcast:

//                              internalmodules.push_back(make_pair(

//                                              BootstrapManager::BootstrapTypePeriodicBroadcast,

//                                              ariba_mod.getBootstrapInfo(vnetname, m)));

//                              break;

//                      case AribaModule::BootstrapMechanismMulticastDNS:

//                              internalmodules.push_back(make_pair(

//                                              BootstrapManager::BootstrapTypeMulticastDns,

//                                              ariba_mod.getBootstrapInfo(vnetname, m)));

//                              break;

//                      case AribaModule::BootstrapMechanismSDP:

//                              internalmodules.push_back(make_pair(

//                                              BootstrapManager::BootstrapTypeBluetoothSdp,

//                                              ariba_mod.getBootstrapInfo(vnetname, m)));

//                              break;

//                      default:

//                              break;

//              }

//      }

//

//      // start automatic overlay bootstrapping modules

//      base_overlay->startBootstrapModules(internalmodules);

//

//      // done

//}

//

//void Node::initiate(const Name& vnetname, const SpoVNetProperties& parm) {

//      utility::OverlayParameterSet ovrpset;

//      ovrpset.setOverlayStructure(

//                      (utility::OverlayParameterSet::_OverlayStructure)

//                      parm.getBaseOverlayType()

//                      );

//

//      spovnetId = vnetname.toSpoVNetId();

//      nodeId = generateNodeId(name);

//

//      // start base comm if not started

//      if( !ariba_mod.base_comm->isStarted() )

//              ariba_mod.base_comm->start();

//

//      // start base overlay if not started

//      if( !base_overlay->isStarted() )

//              base_overlay->start( *ariba_mod.base_comm, nodeId );

//

//      base_overlay->createSpoVNet( spovnetId, ovrpset );

//}



void Node::leave() {

        base_overlay->stopBootstrapModules();

        base_overlay->leaveSpoVNet();

        base_communication->stop();  // XXX before »base_overlay->stop()« ??

        base_overlay->stop();

}



const SpoVNetProperties& Node::getSpoVNetProperties() const {

        return SpoVNetProperties::DEFAULT;

}



const SpoVNetID& Node::getSpoVNetId() const {

        return spovnetId;

}



const NodeID& Node::getNodeId(const LinkID& lid) const {

        if( lid == LinkID::UNSPECIFIED ) return nodeId;

        else return base_overlay->getNodeID( lid );

}



NodeID Node::generateNodeId(const Name& name) const {

        if (name == Name::UNSPECIFIED) return Name::random().toNodeId();

        else return name.toNodeId();

}



vector<NodeID> Node::getNeighborNodes() const {

        return base_overlay->getOverlayNeighbors();

}



LinkID Node::establishLink(const NodeID& nid, const ServiceID& sid) {

        return base_overlay->establishLink(nid, sid);

}



void Node::dropLink(const LinkID& lnk) {

        base_overlay->dropLink(lnk);

}



bool Node::isLinkDirect(const ariba::LinkID& lnk) const

{

    return base_overlay->isLinkDirect(lnk);

}



int Node::getHopCount(const ariba::LinkID& lnk) const

{

    return base_overlay->getHopCount(lnk);

}









/* +++++ Message sending +++++ */

void Node::check_send_priority(uint8_t priority)

{

    if ( priority < send_priority::HIGHEST || priority > send_priority::LOWEST )

        throw std::invalid_argument("Illegal priority");     

}





// +++ new interface +++

const SequenceNumber& Node::sendMessage(reboost::message_t msg, const LinkID& lnk, uint8_t priority)

{

    // check priority

    check_send_priority(priority);

        

    // * call base overlay *

    return base_overlay->sendMessage(msg, lnk, priority);

}



// +++ legacy interface +++

seqnum_t Node::sendMessage(const DataMessage& msg, const LinkID& lnk)

{

    reboost::message_t message = ((Message*) msg)->wrap_up_for_sending();

    

    try

    {

        base_overlay->sendMessage(message, lnk, send_priority::NORMAL);

        return 0;

    }

    catch ( ariba::overlay::message_not_sent& e )

    {

        logging_warn("Message could not be sent. Dropped.");

        return -1;

    }

}





// +++ new interface +++

const SequenceNumber& Node::sendMessage(reboost::message_t msg, const NodeID& nid,

        const ServiceID& sid, uint8_t priority, const LinkProperties& req) {



    // check priority

    check_send_priority(priority);

        

    // * call base overlay *

    return base_overlay->sendMessage(msg, nid, priority, sid);

}



// +++ legacy interface +++

seqnum_t Node::sendMessage(const DataMessage& msg, const NodeID& nid,

                const ServiceID& sid, const LinkProperties& req) {

    

//    reboost::message_t message = ((Message*) msg)->wrap_up_for_sending();

    reboost::message_t message;

    message.push_back( ((Message*) msg)->serialize_into_shared_buffer() );

    

    try

    {

        sendMessage(message, nid, sid, send_priority::NORMAL, req);

        return 0;

    }

    catch ( ariba::overlay::message_not_sent& e )

    {

        logging_warn("Message could not be sent. Dropped.");

        return -1;

    }

}





// +++ new interface +++

NodeID Node::sendMessageCloserToNodeID(reboost::message_t msg, const NodeID& nid, const ServiceID& sid,

        uint8_t priority, const LinkProperties& req) {



    // check priority

    check_send_priority(priority);

        

    // * call base overlay *

    return base_overlay->sendMessageCloserToNodeID(msg, nid, priority, sid);

}



// +++ legacy interface +++

NodeID Node::sendMessageCloserToNodeID(const DataMessage& msg, const NodeID& nid, const ServiceID& sid,

        const LinkProperties& req) {

    

    reboost::message_t message = ((Message*) msg)->wrap_up_for_sending();

    

    return sendMessageCloserToNodeID(message, nid, sid, send_priority::NORMAL, req);

}





// +++ new interface +++

void Node::sendBroadcastMessage(reboost::message_t msg, const ServiceID& sid, uint8_t priority) {



    // check priority

    check_send_priority(priority);

        

    // * call base overlay *

    return base_overlay->broadcastMessage(msg, sid, priority);

}



// +++ legacy interface +++

void Node::sendBroadcastMessage(const DataMessage& msg, const ServiceID& sid) {

    reboost::message_t message = ((Message*) msg)->wrap_up_for_sending();



        return sendBroadcastMessage(message, sid);

}





/* +++++ [Message sending] +++++ */









bool Node::bind(NodeListener* listener) {

        return base_overlay->bind(listener);

}



bool Node::unbind(NodeListener* listener) {

        return base_overlay->unbind(listener);

}



bool Node::bind(CommunicationListener* listener, const ServiceID& sid) {

        // bind the listener

        bool ret = base_overlay->bind(listener, sid);



//      // now that we have a listener, we can ask if sniffing is ok

//      if( ariba_mod.sideport_sniffer != NULL ){

//              base_overlay->registerSidePort(ariba_mod.sideport_sniffer);

//      }



        return ret;

}



bool Node::unbind(CommunicationListener* listener, const ServiceID& sid) {

        return base_overlay->unbind(listener, sid);

}



// @see Module.h

string Node::getName() const {

        return name.toString();

}



} // namespace ariba