NeighborDatabase.h

Go to the documentation of this file.

/*
 * NeighborDatabase.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 NEIGHBORDATABASE_H_
#define NEIGHBORDATABASE_H_

#include "routing/NeighborDataset.h"
#include <ibrdtn/data/BundleSet.h>
#include <ibrdtn/data/EID.h>
#include <ibrdtn/data/BundleID.h>
#include <ibrdtn/data/Number.h>
#include <ibrcommon/data/BloomFilter.h>
#include <ibrcommon/Exceptions.h>
#include <ibrcommon/thread/ThreadsafeState.h>
#include <algorithm>
#include <map>

namespace dtn
{
        namespace routing
        {
                class NeighborDatabase : public ibrcommon::Mutex
                {
                public:
                        class BloomfilterNotAvailableException : public ibrcommon::Exception
                        {
                        public:
                                BloomfilterNotAvailableException(const dtn::data::EID &host)
                                : ibrcommon::Exception("Bloom filter is not available for this node."), eid(host) { };

                                virtual ~BloomfilterNotAvailableException() throw () { };

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

                        class NoRouteKnownException : public ibrcommon::Exception
                        {
                        public:
                                NoRouteKnownException() : ibrcommon::Exception("No route known.") { };
                                virtual ~NoRouteKnownException() throw () { };
                        };

                        class NoMoreTransfersAvailable : public ibrcommon::Exception
                        {
                        public:
                                NoMoreTransfersAvailable() : ibrcommon::Exception("No more transfers allowed.") { };
                                virtual ~NoMoreTransfersAvailable() throw () { };
                        };

                        class AlreadyInTransitException : public ibrcommon::Exception
                        {
                        public:
                                AlreadyInTransitException() : ibrcommon::Exception("This bundle is already in transit.") { };
                                virtual ~AlreadyInTransitException() throw () { };
                        };

                        class NeighborNotAvailableException : public ibrcommon::Exception
                        {
                        public:
                                NeighborNotAvailableException() : ibrcommon::Exception("Entry for this neighbor not found.") { };
                                virtual ~NeighborNotAvailableException() throw () { };
                        };

                        class DatasetNotAvailableException : public ibrcommon::Exception
                        {
                        public:
                                DatasetNotAvailableException() : ibrcommon::Exception("Dataset not found.") { };
                                virtual ~DatasetNotAvailableException() throw () { };
                        };

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

                                void update(const ibrcommon::BloomFilter &bf, const dtn::data::Number &lifetime = 0);

                                void reset();

                                void add(const dtn::data::MetaBundle&);

                                bool has(const dtn::data::BundleID&, const bool require_bloomfilter = false) const;

                                void acquireTransfer(const dtn::data::BundleID &id) throw (NoMoreTransfersAvailable, AlreadyInTransitException);

                                dtn::data::Size getFreeTransferSlots() const;

                                bool isTransferThresholdReached() const;

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

                                // the EID of the corresponding node
                                const dtn::data::EID eid;

                                void expire(const dtn::data::Timestamp &timestamp);

                                bool isExpired(const dtn::data::Timestamp &timestamp) const;

                                const dtn::data::Timestamp& getLastUpdate() const;

                                void touch();

                                template <class T>
                                const T& getDataset() const throw (DatasetNotAvailableException)
                                {
                                        NeighborDataset item(T::identifier);
                                        data_set::const_iterator iter = _datasets.find(item);

                                        if (iter == _datasets.end()) throw DatasetNotAvailableException();

                                        try {
                                                return dynamic_cast<const T&>(**iter);
                                        } catch (const std::bad_cast&) {
                                                throw DatasetNotAvailableException();
                                        }
                                }

                                void putDataset(NeighborDataset &dset);

                                template <class T>
                                void removeDataset()
                                {
                                        NeighborDataset item(T::identifier);
                                        data_set::iterator it = _datasets.find(item);

                                        if (it == _datasets.end()) return;

                                        _datasets.erase(it);
                                }

                        private:
                                // stores bundle currently in transit
                                ibrcommon::Mutex _transit_lock;
                                std::set<dtn::data::BundleID> _transit_bundles;

                                // bloomfilter used as summary vector
                                ibrcommon::BloomFilter _filter;
                                dtn::data::BundleSet _summary;
                                dtn::data::Timestamp _filter_expire;

                                // extended neighbor data
                                typedef std::set<NeighborDataset> data_set;
                                data_set _datasets;

                                enum FILTER_REQUEST_STATE
                                {
                                        FILTER_AWAITING = 0,
                                        FILTER_AVAILABLE = 1,
                                        FILTER_EXPIRED = 2,
                                        FILTER_FINAL = 3
                                };

                                ibrcommon::ThreadsafeState<FILTER_REQUEST_STATE> _filter_state;

                                dtn::data::Timestamp _last_update;
                        };

                        NeighborDatabase();
                        virtual ~NeighborDatabase();

                        NeighborDatabase::NeighborEntry& get(const dtn::data::EID &eid) throw (NeighborNotAvailableException);

                        NeighborDatabase::NeighborEntry& create(const dtn::data::EID &eid) throw ();

                        void remove(const dtn::data::EID &eid);

                        void expire(const dtn::data::Timestamp &timestamp);

                private:
                        typedef std::map<dtn::data::EID, NeighborDatabase::NeighborEntry* > neighbor_map;
                        neighbor_map _entries;
                };
        }
}

#endif /* NEIGHBORDATABASE_H_ */