source: source/ariba/overlay/LinkDescriptor.h@ 6956

#ifndef __LINK_DESCRIPTOR_H

#define __LINK_DESCRIPTOR_H



#include <iostream>

#include <sstream>

#include <ctime>

#include <deque>

#include <boost/foreach.hpp>



#include "ariba/utility/messages.h"

#include "ariba/utility/types.h"

#include "ariba/CommunicationListener.h"



namespace ariba {

        class CommunicationListener;

}



using std::deque;

using ariba::utility::Message;

using ariba::utility::NodeID;

using ariba::utility::SpoVNetID;

using ariba::utility::ServiceID;

using ariba::utility::LinkID;

using ariba::CommunicationListener;



namespace ariba {

namespace overlay {



class LinkDescriptor;



std::ostream& operator<<(std::ostream& s, const LinkDescriptor* ld );

std::ostream& operator<<(std::ostream& s, const LinkDescriptor& ld );



/// LinkDescriptor

class LinkDescriptor {

public:

        // ctor

        LinkDescriptor() {

                // default values

                this->up = false;

                this->fromRemote = false;

                this->remoteNode = NodeID::UNSPECIFIED;

                this->overlayId  = LinkID::create();

                this->communicationUp = false;

                this->communicationId = LinkID::UNSPECIFIED;

                this->keepAliveTime = time(NULL);

                this->keepAliveMissed = 0;

                this->relaying     = false;

                this->timeRelaying = time(NULL);

                this->dropAfterRelaying = false;

                this->service  = ServiceID::UNSPECIFIED;

                this->listener = &CommunicationListener::DEFAULT;

                this->relayed = false;

                this->remoteLink = LinkID::UNSPECIFIED;

                this->autolink = false;

                this->lastuse = time(NULL);

        }



        // dtor

        ~LinkDescriptor() {

                flushQueue();

        }



        // general information about the link --------------------------------------

        bool up;           ///< flag whether this link is up and running

        bool fromRemote;   ///< flag, whether this link was requested from remote

        NodeID remoteNode; ///< remote end-point node

        bool isVital() {

                return up && keepAliveMissed == 0;

        }

        bool isDirectVital() {

                return isVital() && communicationUp && !relayed;

        }





        // link identifiers --------------------------------------------------------

        LinkID overlayId;       ///< the base overlay link id

        LinkID communicationId; ///< the communication id

        bool   communicationUp;   ///< flag, whether the communication is up



        // link alive information --------------------------------------------------

        time_t keepAliveTime; ///< the last time a keep-alive message was received

        int keepAliveMissed;  ///< the number of missed keep-alive messages

        void setAlive() {

                keepAliveMissed = 0;

                keepAliveTime = time(NULL);

        }



        // relay information -------------------------------------------------------

        bool   relayed;    ///< flag whether this link is a relayed link

        LinkID remoteLink; ///< the remote link id

        vector<NodeID> routeRecord;



        // relay state -------------------------------------------------------------

        bool   relaying;     ///< flag, wheter this link has been used as relay

        bool   dropAfterRelaying;

        time_t timeRelaying; ///< last time the link has been used as relay

        void setRelaying() {

                relaying = true;

                timeRelaying = time(NULL);

        }



        // owner -------------------------------------------------------------------

        ServiceID service; ///< service using this link

        CommunicationListener* listener; ///< the listener using this node



        // auto links --------------------------------------------------------------

        bool autolink;  ///< flag, whether this link is a auto-link

        time_t lastuse; ///< time, when the link was last used

        deque<Message*> messageQueue; ///< waiting messages to be delivered

        void setAutoUsed() {

                if (autolink) lastuse = time(NULL);

        }

        /// drops waiting auto-link messages

        void flushQueue() {

                BOOST_FOREACH( Message* msg, messageQueue )     delete msg;

                messageQueue.clear();

        }



        // string representation ---------------------------------------------------

        std::string to_string() const {

                std::ostringstream s;

                s << "up=" << up << " ";

                s << "init=" << !fromRemote << " ";

                s << "id=" << overlayId.toString().substr(0,4) << " ";

                s << "serv=" << service.toString() << " ";

                s << "node=" << remoteNode.toString().substr(0,4) << " ";

                s << "relaying=" << relaying << " ";

                s << "miss=" << keepAliveMissed << " ";

                s << "auto=" << autolink << " ";

                if ( relayed ) {

                        s << "| Relayed: ";

                        s << "remote link=" << remoteLink.toString().substr(0,4) << " ";

                        if (routeRecord.size()>0) {

                                s << "route record=";

                                for (size_t i=0; i<routeRecord.size(); i++)

                                        s << routeRecord[i].toString().substr(0,4) << " ";

                        }

                } else {

                        s << "| Direct: ";

                        s << "using id=" << communicationId.toString().substr(0,4) << " ";

                        s << "(up=" << communicationUp << ") ";

                }

                return s.str();

        }

};



}} // namespace ariba, overlay



#endif // __LINK_DESCRIPTOR_H