daemon/src/storage/SimpleBundleStorage.h

Go to the documentation of this file.

#ifndef SIMPLEBUNDLESTORAGE_H_
#define SIMPLEBUNDLESTORAGE_H_

#include "Component.h"
#include "core/BundleCore.h"
#include "storage/BundleStorage.h"
#include "core/Node.h"
#include "core/EventReceiver.h"

#include "storage/DataStorage.h"

#include <ibrcommon/thread/Conditional.h>
#include <ibrcommon/thread/AtomicCounter.h>
#include <ibrcommon/thread/RWMutex.h>

#include <ibrcommon/data/File.h>
#include <ibrdtn/data/Bundle.h>
#include <ibrdtn/data/BundleList.h>
#include <ibrcommon/thread/Queue.h>

#include <set>
#include <map>

using namespace dtn::data;

namespace dtn
{
        namespace storage
        {
                class SimpleBundleStorage : public DataStorage::Callback, public BundleStorage, public dtn::core::EventReceiver, public dtn::daemon::IntegratedComponent, private dtn::data::BundleList
                {
                public:
                        SimpleBundleStorage(const ibrcommon::File &workdir, size_t maxsize = 0, size_t buffer_limit = 0);

                        virtual ~SimpleBundleStorage();

                        virtual void store(const dtn::data::Bundle &bundle);

                        virtual dtn::data::Bundle get(const dtn::data::BundleID &id);

                        virtual const std::list<dtn::data::MetaBundle> get(BundleFilterCallback &cb);

                        virtual const std::set<dtn::data::EID> getDistinctDestinations();

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

                        dtn::data::MetaBundle remove(const ibrcommon::BloomFilter &filter);

                        void clear();

                        bool empty();

                        unsigned int count();

                        size_t size() const;

                        void releaseCustody(const dtn::data::EID &custodian, const dtn::data::BundleID &id);

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

                        virtual const std::string getName() const;

                        virtual void eventDataStorageStored(const dtn::storage::DataStorage::Hash &hash);
                        virtual void eventDataStorageStoreFailed(const dtn::storage::DataStorage::Hash &hash, const ibrcommon::Exception&);
                        virtual void eventDataStorageRemoved(const dtn::storage::DataStorage::Hash &hash);
                        virtual void eventDataStorageRemoveFailed(const dtn::storage::DataStorage::Hash &hash, const ibrcommon::Exception&);
                        virtual void iterateDataStorage(const dtn::storage::DataStorage::Hash &hash, dtn::storage::DataStorage::istream &stream);

                protected:
                        virtual void componentUp();
                        virtual void componentDown();
                        virtual void eventBundleExpired(const ExpiringBundle &b);

                private:
                        class BundleContainer : public DataStorage::Container
                        {
                        public:
                                BundleContainer(const dtn::data::Bundle &b);
                                virtual ~BundleContainer();

                                std::string getKey() const;
                                std::ostream& serialize(std::ostream &stream);

                        private:
                                const dtn::data::Bundle _bundle;
                        };

                        dtn::data::Bundle __get(const dtn::data::MetaBundle&);

                        // This object manage data stored on disk
                        DataStorage _datastore;

                        ibrcommon::RWMutex _bundleslock;
                        std::map<DataStorage::Hash, dtn::data::Bundle> _pending_bundles;
                        std::map<dtn::data::MetaBundle, DataStorage::Hash> _stored_bundles;

                        std::map<dtn::data::MetaBundle, size_t> _bundle_size;

                        struct CMP_BUNDLE_PRIORITY
                        {
                                bool operator() (const dtn::data::MetaBundle& lhs, const dtn::data::MetaBundle& rhs) const
                                {
                                        if (lhs.getPriority() == rhs.getPriority())
                                                return rhs > lhs;

                                        return (lhs.getPriority() > rhs.getPriority());
                                }
                        };

                        std::set<dtn::data::MetaBundle, CMP_BUNDLE_PRIORITY> _priority_index;

                        size_t _maxsize;
                        size_t _currentsize;
                };
        }
}

#endif /*SIMPLEBUNDLESTORAGE_H_*/