source: source/ariba/communication/BaseCommunication.h@ 12766

// [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 ARIBA PROJECT 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]

#ifndef BASECOMMUNICATION_H_
#define BASECOMMUNICATION_H_

// boost & std includes
#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <map>
#include <set>
#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/foreach.hpp>

#ifdef ECLIPSE_PARSER
    #define foreach(a, b) for(a : b)
#else
    #define foreach(a, b) BOOST_FOREACH(a, b)
#endif

// utilities
#include "ariba/utility/types.h"
#include "ariba/utility/messages/MessageReceiver.h"
#include "ariba/utility/logging/Logging.h"
#include "ariba/utility/misc/Demultiplexer.hpp"
#include "ariba/utility/system/SystemEventListener.h"

// new transport and addressing
#include "ariba/utility/transport/transport_peer.hpp"
#include "ariba/utility/transport/interfaces/transport_connection.hpp"
#include "ariba/utility/transport/interfaces/transport_listener.hpp"
#include "ariba/utility/addressing2/endpoint.hpp"

// communication
#include "ariba/communication/CommunicationEvents.h"
#include "ariba/communication/EndpointDescriptor.h"
#include "ariba/communication/messages/AribaBaseMsg.h"

// network changes
#include "ariba/communication/networkinfo/NetworkChangeInterface.h"
#include "ariba/communication/networkinfo/NetworkChangeDetection.h"
#include "ariba/communication/networkinfo/NetworkInformation.h"

namespace ariba {
    class SideportListener;
}

namespace ariba {
namespace communication {


class communication_message_not_sent: public std::runtime_error
{
public:
    /** Takes a character string describing the error.  */
    explicit communication_message_not_sent(const string& __arg)  :
        std::runtime_error(__arg)
    {
    }
    
    virtual ~communication_message_not_sent() throw() {}
};



using namespace std;
using namespace ariba::transport;
using namespace ariba::utility;

// use base ariba types (clarifies multiple definitions)
using ariba::utility::Message;
using ariba::utility::seqnum_t;

/**
 * This class implements the Ariba Base Communication<br />
 *
 * Its primary task is to provide an abstraction to existing
 * protocols and addressing schemes.
 *
 * @author Sebastian Mies, Christoph Mayer, Mario Hock
 */
class BaseCommunication:
        public NetworkChangeInterface,
        public transport_listener {

        use_logging_h(BaseCommunication);
        friend class ariba::SideportListener;

public:
        /// Default ctor that just creates an non-functional base communication
        BaseCommunication();

        /// Default dtor that does nothing
        virtual ~BaseCommunication();

        /// Startup the base communication, start modules etc.
        void start(addressing2::EndpointSetPtr listen_on);

        /// Stops the base communication, stop modules etc.
        void stop();

        /// Check whether the base communication has been started up
        bool isStarted();

        /// Establishes a link to another end-point.
        const LinkID establishLink(const EndpointDescriptor& descriptor,
                const LinkID& linkid = LinkID::UNSPECIFIED, const QoSParameterSet& qos =
                                QoSParameterSet::DEFAULT, const SecurityParameterSet& sec =
                                SecurityParameterSet::DEFAULT);

        /// Drops a link
        void dropLink(const LinkID link);

        /**
         * Sends a message though an existing link to an end-point.
         *
         * @param lid The link identifier
         * @param message The message to be sent
         * @return A sequence number for this message
         */
        seqnum_t sendMessage(const LinkID& lid,
                reboost::message_t message,
                uint8_t priority,
                bool bypass_overlay = false) throw(communication_message_not_sent);

        /**
         * Returns the end-point descriptor
         *
         * @param link the link id of the requested end-point
         * @return The end-point descriptor of the link's end-point
         */
        const EndpointDescriptor& getEndpointDescriptor(const LinkID link =
                        LinkID::UNSPECIFIED) const;

        /**
         * Get local links to the given endpoint of all local link
         * using the default parameter EndpointDescriptor::UNSPECIFIED
         * @param ep The remote endpoint to get all links to.
         * @return List of LinkID
         */
//      LinkIDs getLocalLinks(const address_v* addr) const;  // XXX aktuell

        /**
         * Registers a receiver.
         *
         * @param _receiver The receiving side
         */
        void registerMessageReceiver(MessageReceiver* receiver) {
                messageReceiver = receiver;
        }

        /**
         * Unregister a receiver.
         *
         * @param _receiver The receiving side
         */
        void unregisterMessageReceiver(MessageReceiver* receiver) {
                messageReceiver = NULL;
        }

        void registerEventListener(CommunicationEvents* _events);

        void unregisterEventListener(CommunicationEvents* _events);

        /**
         * called within the ASIO thread
         * when a message is received from underlay transport
         */ 
        virtual void receive_message(transport_connection::sptr connection,
                reboost::shared_buffer_t msg);

    /**
     * called within the ASIO thread
     * when a connection is terminated (e.g. TCP close)
     */ 
    virtual void connection_terminated(transport_connection::sptr connection);

    addressing2::EndpointPtr get_local_endpoint_of_link(const LinkID& linkid);
    addressing2::EndpointPtr get_remote_endpoint_of_link(const LinkID& linkid);

        
protected:

        /**
         * called within the ARIBA thread (System Queue)
         * when a message is received from underlay transport
         */ 
        void receiveMessage(transport_connection::sptr connection,
                reboost::shared_buffer_t message);
        
    /**
     * called within the ARIBA thread (System Queue)
     * when a connection is terminated (e.g. TCP close)
     */ 
    void connectionTerminated(transport_connection::sptr connection);
        

        /// called when a network interface change happens
        virtual void onNetworkChange(
                const NetworkChangeInterface::NetworkChangeInfo& info);

private:
        /**
         * A link descriptor consisting of the end-point descriptor and currently
         * used underlay address.
         */
        class LinkDescriptor {
        public:

                /// default constructor
                LinkDescriptor() :
                        localLink(LinkID::UNSPECIFIED),
                        remoteLink(LinkID::UNSPECIFIED),
                        up(false) {
                }

                ~LinkDescriptor()
                {
                        if ( connection )
                        {
                            connection->unregister_communication_link(&localLink);
                        }
                }

                bool isUnspecified() const {
                        return (this == &UNSPECIFIED());
                }

                static LinkDescriptor& UNSPECIFIED(){
                        static LinkDescriptor* unspec = NULL;
                        if(unspec == NULL) unspec = new LinkDescriptor();
                        return *unspec;
                }
                
                
                transport_connection::sptr get_connection() const
                {
                    return connection;
                }
                
                void set_connection(const transport_connection::sptr& conn)
                {
                    // unregister from old connection,
                    // if any (but normally there shouldn't..)
                    if ( connection )
                    {
                        connection->unregister_communication_link(&localLink);
                    }

                    // * set_connection *
                    connection = conn;
                    
                    // register this link with the connection
                    conn->register_communication_link(&localLink);
                }

                bool unspecified;

                /// link identifiers
                LinkID localLink;
                addressing2::EndpointPtr localLocator;

                /// used underlay addresses for the link
                LinkID remoteLink;
                addressing2::EndpointPtr remoteLocator;

                /// the remote end-point descriptor
                EndpointDescriptor remoteDescriptor;

                /// flag, whether this link is up
                bool up;
                
                
        private:
                /// connection if link is up
                transport_connection::sptr connection;
        };

        /// Link management: list of links
        typedef vector<LinkDescriptor*> LinkSet;

        /// Link management: the set of currently managed links
        LinkSet linkSet;

        /// Link management: add a link
        void addLink( LinkDescriptor* link );

        /// Link management: remove a link
        void removeLink(const LinkID& localLink);

        /// Link management: get link information using the local link
        LinkDescriptor& queryLocalLink(const LinkID& localLink) const;

        /// Link management: get link information using the remote link
        LinkDescriptor& queryRemoteLink(const LinkID& remoteLink) const;

        /// The local end-point descriptor
        EndpointDescriptor localDescriptor;
        
        /**
         * endpoint_set holding the addresses of the "server"-sockets,
         * ---> that should be opened
         * 
         * (e.g. 0.0.0.0:41322)
         */
        addressing2::EndpointSetPtr listenOn_endpoints;
        
    /**
     * endpoint_set holding the addresses of the "server"-sockets,
     * ---> that are actually open
     * 
     * (e.g. 0.0.0.0:41322)
     * 
     * XXX should only be in transport_peer
     */
        addressing2::EndpointSetPtr active_listenOn_endpoints;
        
    /**
     * endpoint_set holding the addresses of the "server"-sockets,
     * ---> here the discovered "addressable" addresses are stored
     * 
     * (e.g. 192.168.0.5:41322)
     * 
     * XXX should only be in localDescriptor
     */
        addressing2::EndpointSetPtr local_endpoints;

        /// network change detector
        NetworkChangeDetection networkMonitor;

        /// list of all remote addresses of links to end-points
        // XXX DEPRECATED
//      class endpoint_reference {
//      public:
//              int count; ///< the number of open links to this end-point
//              const address_v* endpoint; ///< the end-point itself
//      };
//      vector<endpoint_reference> remote_endpoints;

        // XXX DEPRECATED
//      /// adds an end-point to the list
//      void add_endpoint( const address_v* endpoint );
//
//      /// removes an end-point from the list
//      void remove_endpoint( const address_v* endpoint );

        /// event listener
        typedef set<CommunicationEvents*> EventListenerSet;
        EventListenerSet eventListener;

        /// sequence numbers
        seqnum_t currentSeqnum;

        /// transport peer
        transport_peer* transport;

        /// the base overlay message receiver
        MessageReceiver* messageReceiver;

        
        /* 
         * Sends a message over an existing link.
         *   ---> Adds »Link Message« Header
         */
        bool send_over_link(
                const uint8_t type,
                reboost::message_t message,
                const LinkDescriptor& desc,
                const uint8_t priority);

    /* 
     * Sends a message to a known peer. (To all known endpoints.)
     *   ---> Adds »Peer Message« Header
     */
        void send_to_peer(
                const uint8_t type,
                const PeerID& peer_id,
                reboost::message_t message,
                const EndpointDescriptor& endpoint,
                const uint8_t priority );
        

        /// state of the base communication
        bool started;

};

}} // namespace ariba, communication

#endif /* BASECOMMUNICATION_H_ */