ProphetRoutingExtension.h

Go to the documentation of this file.

/*
 * ProphetRoutingExtension.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#ifndef PROPHETROUTINGEXTENSION_H_
#define PROPHETROUTINGEXTENSION_H_

#include "routing/prophet/DeliveryPredictabilityMap.h"
#include "routing/prophet/ForwardingStrategy.h"
#include "routing/prophet/AcknowledgementSet.h"

#include "routing/RoutingExtension.h"
#include "core/EventReceiver.h"
#include "routing/NodeHandshakeEvent.h"
#include "core/TimeEvent.h"
#include "core/BundlePurgeEvent.h"

#include <ibrcommon/thread/Mutex.h>
#include <ibrcommon/thread/Queue.h>
#include <ibrcommon/thread/ThreadsafeReference.h>

#include <map>
#include <list>

namespace dtn
{
        namespace routing
        {
                class ProphetRoutingExtension : public RoutingExtension, public ibrcommon::JoinableThread,
                        public dtn::core::EventReceiver<dtn::routing::NodeHandshakeEvent>,
                        public dtn::core::EventReceiver<dtn::core::TimeEvent>,
                        public dtn::core::EventReceiver<dtn::core::BundlePurgeEvent>
                {
                        friend class ForwardingStrategy;
                        static const std::string TAG;

                public:
                        ProphetRoutingExtension(ForwardingStrategy *strategy, float p_encounter_max, float p_encounter_first,
                                                float p_first_threshold, float beta, float gamma, float delta,
                                                size_t time_unit, size_t i_typ,
                                                dtn::data::Timestamp next_exchange_timeout);
                        virtual ~ProphetRoutingExtension();

                        virtual const std::string getTag() const throw ();

                        /* virtual methods from BaseRouter::Extension */
                        virtual void requestHandshake(const dtn::data::EID&, NodeHandshake&) const; 
                        virtual void responseHandshake(const dtn::data::EID&, const NodeHandshake&, NodeHandshake&); 
                        virtual void processHandshake(const dtn::data::EID&, NodeHandshake&); 
                        virtual void componentUp() throw ();
                        virtual void componentDown() throw ();

                        virtual void raiseEvent(const dtn::routing::NodeHandshakeEvent &evt) throw ();
                        virtual void raiseEvent(const dtn::core::TimeEvent &evt) throw ();
                        virtual void raiseEvent(const dtn::core::BundlePurgeEvent &evt) throw ();

                        virtual void eventDataChanged(const dtn::data::EID &peer) throw ();

                        virtual void eventTransferCompleted(const dtn::data::EID &peer, const dtn::data::MetaBundle &meta) throw ();

                        virtual void eventBundleQueued(const dtn::data::EID &peer, const dtn::data::MetaBundle &meta) throw ();

                        ibrcommon::ThreadsafeReference<DeliveryPredictabilityMap> getDeliveryPredictabilityMap();
                        ibrcommon::ThreadsafeReference<const DeliveryPredictabilityMap> getDeliveryPredictabilityMap() const;

                        ibrcommon::ThreadsafeReference<const AcknowledgementSet> getAcknowledgementSet() const;
                protected:
                        virtual void run() throw ();
                        void __cancellation() throw ();
                private:
                        void updateNeighbor(const dtn::data::EID& neighbor, const DeliveryPredictabilityMap& neighbor_dp_map);

                        void age();

                        void store(const ibrcommon::File &target);

                        void restore(const ibrcommon::File &source);

                        DeliveryPredictabilityMap _deliveryPredictabilityMap;
                        ForwardingStrategy *_forwardingStrategy;
                        AcknowledgementSet _acknowledgementSet;

                        ibrcommon::Mutex _next_exchange_mutex; 
                        dtn::data::Timestamp _next_exchange_timeout; 
                        dtn::data::Timestamp _next_exchange_timestamp; 

                        float p_encounter(const dtn::data::EID &neighbor) const;

                        float _p_encounter_max; 
                        float _p_encounter_first; 
                        float _p_first_threshold; 
                        float _delta; 
                        size_t _i_typ; 

                        typedef std::map<dtn::data::EID, dtn::data::Timestamp> age_map;
                        age_map _ageMap; 

                        ibrcommon::File _persistent_file; 

                        class Task
                        {
                        public:
                                virtual ~Task() {};
                                virtual std::string toString() const = 0;
                        };

                        class SearchNextBundleTask : public Task
                        {
                        public:
                                SearchNextBundleTask(const dtn::data::EID &eid);
                                virtual ~SearchNextBundleTask();

                                virtual std::string toString() const;

                                const dtn::data::EID eid;
                        };

                        class NextExchangeTask : public Task
                        {
                        public:
                                NextExchangeTask();
                                virtual ~NextExchangeTask();

                                virtual std::string toString() const;
                        };

                        ibrcommon::Queue<Task* > _taskqueue;

                public:
                        class GRTR_Strategy : public ForwardingStrategy
                        {
                        public:
                                explicit GRTR_Strategy();
                                virtual ~GRTR_Strategy();
                                virtual bool shallForward(const DeliveryPredictabilityMap& neighbor_dpm, const dtn::data::MetaBundle& bundle) const;
                        };

                        class GTMX_Strategy : public ForwardingStrategy
                        {
                        public:
                                explicit GTMX_Strategy(unsigned int NF_max);
                                virtual ~GTMX_Strategy();
                                virtual bool shallForward(const DeliveryPredictabilityMap& neighbor_dpm, const dtn::data::MetaBundle& bundle) const;

                                void addForward(const dtn::data::BundleID &id);

                        private:
                                unsigned int _NF_max; 

                                typedef std::map<dtn::data::BundleID, unsigned int> nf_map;
                                nf_map _NF_map; 
                        };
                };
        } // namespace routing
} // namespace dtn

#endif // PROPHETROUTINGEXTENSION_H_