daemon/src/core/SimpleBundleStorage.h

Go to the documentation of this file.

#ifndef SIMPLEBUNDLESTORAGE_H_
#define SIMPLEBUNDLESTORAGE_H_

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

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

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

#include <set>

using namespace dtn::data;

namespace dtn
{
        namespace core
        {
                class SimpleBundleStorage : public BundleStorage, public EventReceiver, public dtn::daemon::IndependentComponent
                {
                        class Task
                        {
                        public:
                                virtual ~Task() {};
                                virtual void run() = 0;
                        };

                public:
                        SimpleBundleStorage(size_t maxsize = 0);

                        SimpleBundleStorage(const ibrcommon::File &workdir, size_t maxsize = 0);

                        virtual ~SimpleBundleStorage();

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

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

                        virtual dtn::data::Bundle get(const ibrcommon::BloomFilter &filter);


                        const std::list<dtn::data::BundleID> getList();

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

                        void clear();

                        bool empty();

                        unsigned int count();

                        size_t size() const;

                        void releaseCustody(dtn::data::BundleID &bundle);

                        void raiseEvent(const Event *evt);

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

                private:
                        enum RunMode
                        {
                                MODE_NONPERSISTENT = 0,
                                MODE_PERSISTENT = 1
                        };

                        class BundleContainer : public dtn::data::MetaBundle
                        {
                        public:
                                BundleContainer(const dtn::data::Bundle &b);
                                BundleContainer(const ibrcommon::File &file);
                                BundleContainer(const dtn::data::Bundle &b, const ibrcommon::File &workdir, const size_t size);
                                ~BundleContainer();

                                bool operator!=(const BundleContainer& other) const;
                                bool operator==(const BundleContainer& other) const;
                                bool operator<(const BundleContainer& other) const;
                                bool operator>(const BundleContainer& other) const;

                                size_t size() const;

                                dtn::data::Bundle get() const;

                                BundleContainer& operator= (const BundleContainer &right);
                                BundleContainer& operator= (BundleContainer &right);
                                BundleContainer(const BundleContainer& right);

                                void invokeStore();

                                void remove();

                        protected:
                                class Holder
                                {
                                public:
                                        Holder( const dtn::data::Bundle &b );
                                        Holder( const ibrcommon::File &file );
                                        Holder( const dtn::data::Bundle &b, const ibrcommon::File &workdir, const size_t size );
                                        ~Holder();

                                        size_t size() const;

                                        void invokeStore();

                                        dtn::data::Bundle getBundle();

                                        void remove();

                                        unsigned _count;

                                        ibrcommon::Mutex lock;

                                private:
                                        enum STATE
                                        {
                                                HOLDER_MEMORY = 0,
                                                HOLDER_PENDING = 1,
                                                HOLDER_STORED = 2,
                                                HOLDER_DELETED = 3
                                        };

                                        ibrcommon::Mutex _state_lock;
                                        STATE _state;

                                        dtn::data::Bundle _bundle;
                                        ibrcommon::File _container;

                                        size_t _size;
                                };

                        private:
                                void down();
                                Holder *_holder;
                        };

                        class TaskStoreBundle : public Task
                        {
                        public:
                                TaskStoreBundle(const SimpleBundleStorage::BundleContainer&);
                                ~TaskStoreBundle();
                                virtual void run();

                        private:
                                SimpleBundleStorage::BundleContainer _container;
                        };

                        class BundleStore : private dtn::data::BundleList
                        {
                        public:
                                BundleStore(size_t maxsize = 0);
                                BundleStore(ibrcommon::File workdir, size_t maxsize = 0);
                                ~BundleStore();

                                void load(const ibrcommon::File &file);
                                void store(const dtn::data::Bundle &bundle, SimpleBundleStorage &storage);
                                void remove(const dtn::data::BundleID &id);
                                void clear();

                                unsigned int count();
                                size_t size() const;

                                dtn::data::Bundle get(const ibrcommon::BloomFilter &filter);
                                dtn::data::Bundle get(const dtn::data::EID &eid);
                                dtn::data::Bundle get(const dtn::data::BundleID &id);

                                const std::list<dtn::data::BundleID> getList();

                                void expire(const size_t timestamp);

                                std::set<BundleContainer> bundles;
                                ibrcommon::Mutex bundleslock;

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

                        private:
                                ibrcommon::File _workdir;
                                RunMode _mode;

                                size_t _maxsize;
                                size_t _currentsize;
                        };

                        BundleStore _store;
                        bool _running;

                        ibrcommon::ThreadSafeQueue<Task*> _tasks;
                };
        }
}

#endif /*SIMPLEBUNDLESTORAGE_H_*/

---