SQLiteBundleStorage.h

Go to the documentation of this file.

/*
 * SQLiteBundleStorage.h
 *
 * Copyright (C) 2011 IBR, TU Braunschweig
 *
 * Written-by: Johannes Morgenroth <morgenroth@ibr.cs.tu-bs.de>
 * Written-by: Matthias Myrtus
 *
 * 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 SQLITEBUNDLESTORAGE_H_
#define SQLITEBUNDLESTORAGE_H_

#include "storage/BundleStorage.h"
#include "storage/SQLiteDatabase.h"
#include "storage/SQLiteBundleSet.h"

#include "Component.h"
#include "core/EventReceiver.h"
#include "core/EventReceiver.h"
#include <ibrdtn/data/MetaBundle.h>

#include <ibrcommon/thread/Thread.h>
#include <ibrcommon/thread/RWMutex.h>
#include <ibrcommon/thread/Conditional.h>
#include <ibrcommon/data/File.h>
#include <ibrcommon/thread/Queue.h>

#include <string>
#include <list>
#include <set>

namespace dtn
{
        namespace storage
        {
                class SQLiteBundleStorage: public BundleStorage, public dtn::core::EventReceiver, public dtn::daemon::IndependentComponent, public ibrcommon::BLOB::Provider, public SQLiteDatabase::DatabaseListener
                {
                        static const std::string TAG;

                public:
                        ibrcommon::BLOB::Reference create();

                        SQLiteBundleStorage(const ibrcommon::File &path, const dtn::data::Length &maxsize, bool usePersistentBundleSets = false);

                        virtual ~SQLiteBundleStorage();

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

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

                        virtual dtn::data::MetaBundle info(const dtn::data::BundleID &id);

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

                        virtual void get(const BundleSelector &cb, BundleResult &result) throw (NoBundleFoundException, BundleSelectorException);

                        virtual const eid_set getDistinctDestinations();

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

                        void clear();

                        bool empty();

                        dtn::data::Size count();

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

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

                        void eventBundleExpired(const dtn::data::BundleID &id, const dtn::data::Length size) throw ();
                        void iterateDatabase(const dtn::data::MetaBundle &bundle, const dtn::data::Length size);


                        /*** BEGIN: methods for unit-testing ***/

                        virtual void wait();

                        virtual void setFaulty(bool mode);

                        /*** END: methods for unit-testing ***/


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

                private:
//                      enum Position
//                      {
//                              FIRST_FRAGMENT  = 0,
//                              LAST_FRAGMENT   = 1,
//                              BOTH_FRAGMENTS  = 2
//                      };

                        class Task
                        {
                        public:
                                virtual ~Task() {};
                                virtual void run(SQLiteBundleStorage &storage) = 0;
                        };

                        class BlockingTask : public Task
                        {
                        public:
                                BlockingTask() : _done(false), _abort(false) {};
                                virtual ~BlockingTask() {};
                                virtual void run(SQLiteBundleStorage &storage) = 0;

                                void wait()
                                {
                                        ibrcommon::MutexLock l(_cond);
                                        while (!_done && !_abort) _cond.wait();

                                        if (_abort) throw ibrcommon::Exception("Task aborted");
                                }

                                void abort()
                                {
                                        ibrcommon::MutexLock l(_cond);
                                        _abort = true;
                                        _cond.signal(true);
                                }

                                void done()
                                {
                                        ibrcommon::MutexLock l(_cond);
                                        _done = true;
                                        _cond.signal(true);
                                }

                        private:
                                ibrcommon::Conditional _cond;
                                bool _done;
                                bool _abort;
                        };

                        class TaskIdle : public Task
                        {
                        public:
                                TaskIdle() { };

                                virtual ~TaskIdle() {};
                                virtual void run(SQLiteBundleStorage &storage);

                                static ibrcommon::Mutex _mutex;
                                static bool _idle;
                        };

                        class TaskExpire : public Task
                        {
                        public:
                                TaskExpire(const dtn::data::Timestamp &timestamp)
                                : _timestamp(timestamp) { };

                                virtual ~TaskExpire() {};
                                virtual void run(SQLiteBundleStorage &storage);

                        private:
                                const dtn::data::Timestamp _timestamp;
                        };

                        class SQLiteBLOB : public ibrcommon::BLOB
                        {
                                friend class SQLiteBundleStorage;
                        public:
                                virtual ~SQLiteBLOB();

                                virtual void clear();

                                virtual void open();
                                virtual void close();

                        protected:
                                std::iostream &__get_stream()
                                {
                                        return _filestream;
                                }

                                std::streamsize __get_size();

                        private:
                                SQLiteBLOB(const ibrcommon::File &path);
                                std::fstream _filestream;
                                ibrcommon::TemporaryFile _file;
                        };


//                      /**
//                       *  This Funktion gets e list and a bundle. Every block of the bundle except the PrimaryBlock is saved in a File.
//                       *  The filenames of the blocks are stored in the List. The order of the filenames matches the order of the blocks.
//                       *  @param An empty Stringlist
//                       *  @param A Bundle which should be prepared to be Stored.
//                       *  @return A number bigges than zero is returned indicating an error. Zero is returned if no error occurred.
//                       */
//                      int prepareBundle(list<std::string> &filenames, dtn::data::Bundle &bundle);

                        virtual const std::string getName() const;

                        SQLiteDatabase _database;

                        ibrcommon::File _blobPath;
                        ibrcommon::File _blockPath;

                        // contains all jobs to do
                        ibrcommon::Queue<Task*> _tasks;

                        ibrcommon::RWMutex _global_lock;
                };
        }
}

#endif /* SQLITEBUNDLESTORAGE_H_ */