daemon/src/core/SQLiteBundleStorage.h

Go to the documentation of this file.

/*
 * SQLiteBundleStorage.h
 *
 *  Created on: 09.01.2010
 *      Author: Myrtus
 */


#ifndef SQLITEBUNDLESTORAGE_H_
#define SQLITEBUNDLESTORAGE_H_

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

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

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


namespace dtn {
namespace testsuite{
        class SQLiteBundleStorageTestSuite;
}

namespace core {

class SQLiteBundleStorage: public BundleStorage, public EventReceiver, public ibrcommon::JoinableThread
{
        enum SQL_TABLES
        {
                SQL_TABLE_BUNDLE = 0,
                SQL_TABLE_FRAGMENT = 1,
                SQL_TABLE_BLOCK = 2,
                SQL_TABLE_ROUTING = 3,
                SQL_TABLE_BUNDLE_ROUTING_INFO = 4,
                SQL_TABLE_NODE_ROUTING_INFO = 5,
                SQL_TABLE_END = 6
        };

        static const std::string _tables[SQL_TABLE_END];

public:
        friend class testsuite::SQLiteBundleStorageTestSuite;

        class SQLiteQuerryException : public ibrcommon::Exception
        {
        public:
                SQLiteQuerryException(string what = "Unable to execute Querry.") throw(): Exception(what)
                {
                }
        };

        class NoBundleFoundException : public ibrcommon::Exception
        {
                public:
                        NoBundleFoundException(string what = "No bundle available.") throw() : Exception(what)
                        {
                        };
        };

        SQLiteBundleStorage(const ibrcommon::File &dbPath, const string &dbFile, const int &size);

        virtual ~SQLiteBundleStorage();

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

        void storeBundleRoutingInfo(const data::BundleID &BundleID, const int &key, const string &routingInfo);

        void storeNodeRoutingInfo(const data::EID &nodel, const int &key, const std::string &routingInfo);

        void storeRoutingInfo(const int &key, const std::string &routingInfo);

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

        const dtn::data::MetaBundle getByDestination(const dtn::data::EID &eid, bool exact = false);

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

        std::string getBundleRoutingInfo(const data::BundleID &bundleID, const int &key);

        std::string getNodeRoutingInfo(const data::EID &eid, const int &key);

        std::string getRoutingInfo(const int &key);

        void removeBundleRoutingInfo(const data::BundleID &bundleID, const int &key);

        void removeNodeRoutingInfo(const data::EID &eid, const int &key);

        void removeRoutingInfo(const int &key);

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

        void clear();

        void clearAll();

        bool empty();

        unsigned int count();

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

        void setPriority(const int priority,const dtn::data::BundleID &id);

        list<data::Bundle> getBundleBySize(const int &limit);

        list<data::Bundle> getBundleByTTL (const int &limit);

        list<data::Bundle> getBundlesBySource(const dtn::data::EID &sourceID);

        list<data::Bundle> getBundlesByDestination(const dtn::data::EID &sourceID);

        list<data::Block> getBlock(const data::BundleID &bundleID,const char &blocktype);

        int occupiedSpace();

        void raiseEvent(const Event *evt);

protected:
        void run(void);
        bool __cancellation();

private:
        void storeFragment(const dtn::data::Bundle &bundle);

        sqlite3_stmt* prepareStatement(string sqlquery);

        void deleteexpired();

        int prepareBundle(list<std::string> &filenames, dtn::data::Bundle &bundle);

        int storeBlocks(const data::Bundle &bundle);

        dtn::data::MetaBundle remove(const ibrcommon::BloomFilter&) { return dtn::data::MetaBundle(); };

        int readBlocks(data::Bundle &bundle, const string &bundleID);

        void idle_work();


        void consistenceCheck();

        void updateexpiredTime();

        virtual const std::string getName() const;

        bool global_shutdown;
        string dbPath, dbFile;
        int dbSize;
        sqlite3 *database;
        ibrcommon::Conditional dbMutex, timeeventConditional;

        ibrcommon::Mutex time_change;// idle_mutex;

        //local Variable which saves the timestamp from incoming Timeevents
        size_t actual_time;
        size_t nextExpiredTime;
        bool idle;

        //list containing filenames (inclusive path) which could be deleted
        list<string> deleteList;

        sqlite3_stmt *getBundleTTL;
        sqlite3_stmt *getFragmentTTL;
        sqlite3_stmt *deleteBundleTTL;
        sqlite3_stmt *deleteFragementTTL;
        sqlite3_stmt *getBundleByDestination;
        sqlite3_stmt *getBundleByID;
        sqlite3_stmt *getFragements;
        sqlite3_stmt *store_Bundle;
        sqlite3_stmt *store_Fragment;
        sqlite3_stmt *clearBundles;
        sqlite3_stmt *clearFragments;
        sqlite3_stmt *clearBlocks;
        sqlite3_stmt *clearRouting;
        sqlite3_stmt *clearNodeRouting;
        sqlite3_stmt *countEntries;
        sqlite3_stmt *vacuum;
        sqlite3_stmt *getROWID;
        sqlite3_stmt *removeBundle;
        sqlite3_stmt *removeFragments;
        sqlite3_stmt *getBlocksByID;
        sqlite3_stmt *storeBlock;
        sqlite3_stmt *getBundlesBySize;
        sqlite3_stmt *getBundleBySource;
        sqlite3_stmt *getBundlesByTTL;
        sqlite3_stmt *getBlocks;
        sqlite3_stmt *getProcFlags;
        sqlite3_stmt *updateProcFlags;
        sqlite3_stmt *storeBundleRouting;
        sqlite3_stmt *getBundleRouting;
        sqlite3_stmt *removeBundleRouting;
        sqlite3_stmt *storeRouting;
        sqlite3_stmt *getRouting;
        sqlite3_stmt *removeRouting;
        sqlite3_stmt *storeNodeRouting;
        sqlite3_stmt *getNodeRouting;
        sqlite3_stmt *removeNodeRouting;
        sqlite3_stmt *getnextExpiredBundle;
        sqlite3_stmt *getnextExpiredFragment;

};

}
}

#endif /* SQLITEBUNDLESTORAGE_H_ */