dbwrapper.h

Go to the documentation of this file.

// Copyright (c) 2012-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_DBWRAPPER_H
#define BITCOIN_DBWRAPPER_H
 
#include "clientversion.h"
#include "serialize.h"
#include "streams.h"
#include "util.h"
#include "utilstrencodings.h"
#include "version.h"
 
#include <boost/filesystem/path.hpp>
 
#include <leveldb/db.h>
#include <leveldb/write_batch.h>
 
static const size_t DBWRAPPER_PREALLOC_KEY_SIZE = 64;
static const size_t DBWRAPPER_PREALLOC_VALUE_SIZE = 1024;
 
class dbwrapper_error : public std::runtime_error
{
public:
    dbwrapper_error(const std::string& msg) : std::runtime_error(msg) {}
};
 
class CDBWrapper;
 
namespace dbwrapper_private {
 
void HandleError(const leveldb::Status& status);
 
const std::vector<unsigned char>& GetObfuscateKey(const CDBWrapper &w);
 
};
 
class CDBBatch
{
    friend class CDBWrapper;
 
private:
    const CDBWrapper &parent;
    leveldb::WriteBatch batch;
 
    CDataStream ssKey;
    CDataStream ssValue;
 
public:
    CDBBatch(const CDBWrapper &_parent) : parent(_parent), ssKey(SER_DISK, CLIENT_VERSION), ssValue(SER_DISK, CLIENT_VERSION) { };
 
    template <typename K, typename V>
    void Write(const K& key, const V& value)
    {
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        leveldb::Slice slKey(ssKey.data(), ssKey.size());
 
        ssValue.reserve(DBWRAPPER_PREALLOC_VALUE_SIZE);
        ssValue << value;
        ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
        leveldb::Slice slValue(ssValue.data(), ssValue.size());
 
        batch.Put(slKey, slValue);
        ssKey.clear();
        ssValue.clear();
    }
 
    template <typename K>
    void Erase(const K& key)
    {
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        leveldb::Slice slKey(ssKey.data(), ssKey.size());
 
        batch.Delete(slKey);
        ssKey.clear();
    }
};
 
class CDBIterator
{
private:
    const CDBWrapper &parent;
    leveldb::Iterator *piter;
 
public:
 
    CDBIterator(const CDBWrapper &_parent, leveldb::Iterator *_piter) :
        parent(_parent), piter(_piter) { };
    ~CDBIterator();
 
    bool Valid();
 
    void SeekToFirst();
 
    template<typename K> void Seek(const K& key) {
        CDataStream ssKey(SER_DISK, CLIENT_VERSION);
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        leveldb::Slice slKey(ssKey.data(), ssKey.size());
        piter->Seek(slKey);
    }
 
    void Next();
 
    template<typename K> bool GetKey(K& key) {
        leveldb::Slice slKey = piter->key();
        try {
            CDataStream ssKey(slKey.data(), slKey.data() + slKey.size(), SER_DISK, CLIENT_VERSION);
            ssKey >> key;
        } catch (const std::exception&) {
            return false;
        }
        return true;
    }
 
    unsigned int GetKeySize() {
        return piter->key().size();
    }
 
    template<typename V> bool GetValue(V& value) {
        leveldb::Slice slValue = piter->value();
        try {
            CDataStream ssValue(slValue.data(), slValue.data() + slValue.size(), SER_DISK, CLIENT_VERSION);
            ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
            ssValue >> value;
        } catch (const std::exception&) {
            return false;
        }
        return true;
    }
 
    unsigned int GetValueSize() {
        return piter->value().size();
    }
 
};
 
class CDBWrapper
{
    friend const std::vector<unsigned char>& dbwrapper_private::GetObfuscateKey(const CDBWrapper &w);
private:
    leveldb::Env* penv;
 
    leveldb::Options options;
 
    leveldb::ReadOptions readoptions;
 
    leveldb::ReadOptions iteroptions;
 
    leveldb::WriteOptions writeoptions;
 
    leveldb::WriteOptions syncoptions;
 
    leveldb::DB* pdb;
 
    std::vector<unsigned char> obfuscate_key;
 
    static const std::string OBFUSCATE_KEY_KEY;
 
    static const unsigned int OBFUSCATE_KEY_NUM_BYTES;
 
    std::vector<unsigned char> CreateObfuscateKey() const;
 
public:
    CDBWrapper(const boost::filesystem::path& path, size_t nCacheSize, bool fMemory = false, bool fWipe = false, bool obfuscate = false);
    ~CDBWrapper();
 
    template <typename K, typename V>
    bool Read(const K& key, V& value) const
    {
        CDataStream ssKey(SER_DISK, CLIENT_VERSION);
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        leveldb::Slice slKey(ssKey.data(), ssKey.size());
 
        std::string strValue;
        leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
        if (!status.ok()) {
            if (status.IsNotFound())
                return false;
            LogPrintf("LevelDB read failure: %s\n", status.ToString());
            dbwrapper_private::HandleError(status);
        }
        try {
            CDataStream ssValue(strValue.data(), strValue.data() + strValue.size(), SER_DISK, CLIENT_VERSION);
            ssValue.Xor(obfuscate_key);
            ssValue >> value;
        } catch (const std::exception&) {
            return false;
        }
        return true;
    }
 
    template <typename K, typename V>
    bool Write(const K& key, const V& value, bool fSync = false)
    {
        CDBBatch batch(*this);
        batch.Write(key, value);
        return WriteBatch(batch, fSync);
    }
 
    template <typename K>
    bool Exists(const K& key) const
    {
        CDataStream ssKey(SER_DISK, CLIENT_VERSION);
        ssKey.reserve(DBWRAPPER_PREALLOC_KEY_SIZE);
        ssKey << key;
        leveldb::Slice slKey(ssKey.data(), ssKey.size());
 
        std::string strValue;
        leveldb::Status status = pdb->Get(readoptions, slKey, &strValue);
        if (!status.ok()) {
            if (status.IsNotFound())
                return false;
            LogPrintf("LevelDB read failure: %s\n", status.ToString());
            dbwrapper_private::HandleError(status);
        }
        return true;
    }
 
    template <typename K>
    bool Erase(const K& key, bool fSync = false)
    {
        CDBBatch batch(*this);
        batch.Erase(key);
        return WriteBatch(batch, fSync);
    }
 
    bool WriteBatch(CDBBatch& batch, bool fSync = false);
 
    // not available for LevelDB; provide for compatibility with BDB
    bool Flush()
    {
        return true;
    }
 
    bool Sync()
    {
        CDBBatch batch(*this);
        return WriteBatch(batch, true);
    }
 
    CDBIterator *NewIterator()
    {
        return new CDBIterator(*this, pdb->NewIterator(iteroptions));
    }
 
    bool IsEmpty();
};
 
#endif // BITCOIN_DBWRAPPER_H