daemon/src/routing/BaseRouter.h

Go to the documentation of this file.

/*
 * BaseRouter.h
 *
 *  Created on: 15.02.2010
 *      Author: morgenro
 */

#ifndef BASEROUTER_H_
#define BASEROUTER_H_

#include "Component.h"
#include "routing/NeighborDatabase.h"
#include "routing/BundleSummary.h"
#include "core/EventReceiver.h"
#include "core/BundleStorage.h"

#include <ibrdtn/data/DTNTime.h>
#include <ibrdtn/data/BundleID.h>
#include <ibrdtn/data/MetaBundle.h>

#include <ibrcommon/thread/Thread.h>
#include <ibrcommon/thread/Conditional.h>


namespace dtn
{
        namespace routing
        {
                class BaseRouter : public dtn::core::EventReceiver, public dtn::daemon::IntegratedComponent
                {
                public:
                        class RoutingException : public ibrcommon::Exception
                        {
                                public:
                                        RoutingException(string what = "An error occured during routing.") throw() : Exception(what)
                                        {
                                        };
                        };

                        class NoNeighbourFoundException : public RoutingException
                        {
                                public:
                                        NoNeighbourFoundException(string what = "No neighbour was found.") throw() : RoutingException(what)
                                        {
                                        };
                        };

                        class NoRouteFoundException : public RoutingException
                        {
                                public:
                                        NoRouteFoundException(string what = "No route found.") throw() : RoutingException(what)
                                        {
                                        };
                        };

                        class Extension
                        {
                        public:
                                Extension();
                                virtual ~Extension() = 0;

                                virtual void notify(const dtn::core::Event *evt) = 0;

                                enum CALLBACK_ACTION
                                {
                                        ROUTE_CALLBACK_FORWARDED = 0,
                                        ROUTE_CALLBACK_ABORTED = 1,
                                        ROUTE_CALLBACK_REJECTED = 2,
                                        ROUTE_CALLBACK_DELETED = 3
                                };

                                void transferTo(const dtn::data::EID &destination, const dtn::data::BundleID &id);
                                void transferTo(NeighborDatabase::NeighborEntry &entry, const dtn::data::BundleID &id);

                        protected:
                                BaseRouter& operator*();

                        private:
                                friend class BaseRouter;
                                static BaseRouter *_router;
                        };

                        class ThreadedExtension : public Extension, public ibrcommon::JoinableThread
                        {
                        public:
                                ThreadedExtension();
                                virtual ~ThreadedExtension() = 0;

                                virtual void notify(const dtn::core::Event *evt) = 0;

                        protected:
                                virtual void stopExtension() = 0;
                        };

                        class Endpoint
                        {
                        public:
                                Endpoint();
                                virtual ~Endpoint() = 0;
                        };

                private:
                        class VirtualEndpoint
                        {
                        public:
                                VirtualEndpoint(dtn::data::EID name);
                                virtual ~VirtualEndpoint();

                                ibrcommon::Mutex _clientlock;
                                Endpoint *_client;

                                dtn::data::EID _name;
                                dtn::data::DTNTime _lastseen;
                                dtn::data::DTNTime _expire;
                        };

                public:
                        BaseRouter(dtn::core::BundleStorage &storage);
                        ~BaseRouter();

                        void addExtension(BaseRouter::Extension *extension);

                        void raiseEvent(const dtn::core::Event *evt);

                        dtn::data::Bundle getBundle(const dtn::data::BundleID &id);

                        dtn::core::BundleStorage &getStorage();

                        bool isKnown(const dtn::data::BundleID &id);

                        void setKnown(const dtn::data::MetaBundle &meta);

                        const SummaryVector getSummaryVector();

                        virtual const std::string getName() const;

                        NeighborDatabase& getNeighborDB();

                protected:
                        virtual void componentUp();
                        virtual void componentDown();

                private:
                        ibrcommon::Mutex _known_bundles_lock;
                        BundleSummary _known_bundles;

                        dtn::core::BundleStorage &_storage;
                        std::list<BaseRouter::Extension*> _extensions;

                        NeighborDatabase _neighbor_database;
                };
        }
}


#endif /* BASEROUTER_H_ */