daemon/src/core/SQLiteBundleStorage.h

Go to the documentation of this file.

/*
 * SQLiteBundleStorage.h
 *
 *  Created on: 09.01.2010
 *      Author: Myrtus
 *
 *      Potentielle Erweiterungen:
 *              1) Zweite Tabelle für die Fragmente
 *              2)
 */

#ifndef SQLITEBUNDLESTORAGE_H_
#define SQLITEBUNDLESTORAGE_H_

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

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

#include <sqlite3.h>
#include <string>
#include <set>
#include <vector>


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

                public:
                        SQLiteBundleStorage(ibrcommon::File dbPath ,string dbFile , size_t size);

                        virtual ~SQLiteBundleStorage();

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

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

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

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

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

                        void clear();

                        bool empty();

                        unsigned int count();

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

                        //int availableSpace();

                        void raiseEvent(const Event *evt);

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

                private:
                //      /**
                //       * This Function stores Fragments.
                //       * @param bundle The bundle to store.
                //       */
                //      void storeFragment(const dtn::data::Bundle &bundle);

                        sqlite3_stmt* prepareStatement(string sqlquery);

                        void deleteexpired();

                        //Tablename
                        const std::string _BundleTable;
                        const std::string _FragmentTable;

                        ibrcommon::File dbPath;
                        string dbFile;
                        size_t dbSize;
                        sqlite3 *database;
                        ibrcommon::Conditional dbMutex;
                        ibrcommon::ThreadSafeQueue<Task*> _tasks;

                        sqlite3_stmt *getTTL;
                        sqlite3_stmt *getBundleByDestination;
                        sqlite3_stmt *getBundleByID;
                        sqlite3_stmt *getFragements;
                        sqlite3_stmt *store_Bundle;
                        sqlite3_stmt *store_Fragment;
                        sqlite3_stmt *clearStorage;
                        sqlite3_stmt *countEntries;
                        sqlite3_stmt *vacuum;
                        sqlite3_stmt *getROWID;
                        sqlite3_stmt *removeBundle;
                        sqlite3_stmt *removeFragments;

                };
        }
}

#endif /* SQLITEBUNDLESTORAGE_H_ */

---