4rkal/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-12-14 12:26:31 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

DB cleanup

Browse Source 
Hide LMDB-specific stuff behind blockchain_db.h. Nobody besides blockchain_db.cpp
should ever be including DB-specific headers any more.
This commit is contained in:
Howard Chu 2017-08-19 15:27:13 +01:00
parent 4466b6d1b0
commit 4c7f8ac04f
No known key found for this signature in database
GPG Key ID: FD2A70B44AB11BA7
8 changed files with 50 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/blockchain_db/blockchain_db.cpp
View File

@ -33,6 +33,11 @@
#include "profile_tools.h"
#include "ringct/rctOps.h"
#include "lmdb/db_lmdb.h"
#ifdef BERKELEY_DB
#include "berkeleydb/db_bdb.h"
#endif
#undef MONERO_DEFAULT_LOG_CATEGORY
#define MONERO_DEFAULT_LOG_CATEGORY "blockchain.db"
@ -41,6 +46,17 @@ using epee::string_tools::pod_to_hex;
namespace cryptonote
{
BlockchainDB *new_db(const std::string& db_type)
{
if (db_type == "lmdb")
return new BlockchainLMDB();
#if defined(BERKELEY_DB)
if (db_type == "berkeley")
return new BlockchainBDB();
#endif
return NULL;
}
void BlockchainDB::pop_block()
{
block blk;

7
src/blockchain_db/blockchain_db.h
View File

@ -145,6 +145,12 @@ struct txpool_tx_meta_t
uint8_t padding[77]; // till 192 bytes
};
#define DBF_SAFE 1
#define DBF_FAST 2
#define DBF_FASTEST 4
#define DBF_RDONLY 8
#define DBF_SALVAGE 0x10
/***********************************
* Exception Definitions
***********************************/
@ -1491,6 +1497,7 @@ public:
}; // class BlockchainDB
BlockchainDB *new_db(const std::string& db_type);
} // namespace cryptonote

12
src/blockchain_db/lmdb/db_lmdb.cpp
View File

@ -1083,9 +1083,10 @@ BlockchainLMDB::BlockchainLMDB(bool batch_transactions)
m_hardfork = nullptr;
}
void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
void BlockchainLMDB::open(const std::string& filename, const int db_flags)
{
int result;
int mdb_flags = MDB_NORDAHEAD;
LOG_PRINT_L3("BlockchainLMDB::" << __func__);
@ -1124,6 +1125,15 @@ void BlockchainLMDB::open(const std::string& filename, const int mdb_flags)
size_t mapsize = DEFAULT_MAPSIZE;
if (db_flags & DBF_FAST)
mdb_flags |= MDB_NOSYNC;
if (db_flags & DBF_FASTEST)
mdb_flags |= MDB_NOSYNC | MDB_WRITEMAP | MDB_MAPASYNC;
if (db_flags & DBF_RDONLY)
mdb_flags = MDB_RDONLY;
if (db_flags & DBF_SALVAGE)
mdb_flags |= MDB_PREVSNAPSHOT;
if (auto result = mdb_env_open(m_env, filename.c_str(), mdb_flags, 0644))
throw0(DB_ERROR(lmdb_error("Failed to open lmdb environment: ", result).c_str()));

28
src/blockchain_utilities/blockchain_export.cpp
View File

@ -31,10 +31,6 @@
#include "common/command_line.h"
#include "cryptonote_core/tx_pool.h"
#include "blockchain_db/blockchain_db.h"
#include "blockchain_db/lmdb/db_lmdb.h"
#if defined(BERKELEY_DB)
#include "blockchain_db/berkeleydb/db_bdb.h"
#endif
#include "blockchain_db/db_types.h"
#include "version.h"
@ -149,13 +145,6 @@ int main(int argc, char* argv[])
std::cerr << "Invalid database type: " << db_type << std::endl;
return 1;
}
#if !defined(BERKELEY_DB)
if (db_type == "berkeley")
{
LOG_ERROR("BerkeleyDB support disabled.");
return false;
}
#endif
if (command_line::has_arg(vm, arg_output_file))
output_file_path = boost::filesystem::path(command_line::get_arg(vm, arg_output_file));
@ -179,19 +168,8 @@ int main(int argc, char* argv[])
tx_memory_pool m_mempool(*core_storage);
core_storage = new Blockchain(m_mempool);
int db_flags = 0;
BlockchainDB* db = nullptr;
if (db_type == "lmdb")
{
db_flags |= MDB_RDONLY;
db = new BlockchainLMDB();
}
#if defined(BERKELEY_DB)
else if (db_type == "berkeley")
db = new BlockchainBDB();
#endif
else
BlockchainDB* db = new_db(db_type);
if (db == NULL)
{
LOG_ERROR("Attempted to use non-existent database type: " << db_type);
throw std::runtime_error("Attempting to use non-existent database type");
@ -205,7 +183,7 @@ int main(int argc, char* argv[])
LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");
try
{
db->open(filename, db_flags);
db->open(filename, DBF_RDONLY);
}
catch (const std::exception& e)
{

74
src/blockchain_utilities/blockchain_import.cpp
View File

@ -90,28 +90,16 @@ std::string join_set_strings(const std::unordered_set<std::string>& db_types_all
return result;
}
// db_type: lmdb, berkeley
// db_mode: safe, fast, fastest
int get_db_flags_from_mode(const std::string& db_type, const std::string& db_mode)
int get_db_flags_from_mode(const std::string& db_mode)
{
uint64_t BDB_FAST_MODE = 0;
uint64_t BDB_FASTEST_MODE = 0;
uint64_t BDB_SAFE_MODE = 0;
#if defined(BERKELEY_DB)
BDB_FAST_MODE = DB_TXN_WRITE_NOSYNC;
BDB_FASTEST_MODE = DB_TXN_NOSYNC;
BDB_SAFE_MODE = DB_TXN_SYNC;
#endif
int db_flags = 0;
bool islmdb = db_type == "lmdb";
if (db_mode == "safe")
db_flags = islmdb ? MDB_NORDAHEAD : BDB_SAFE_MODE;
db_flags = DBF_SAFE;
else if (db_mode == "fast")
db_flags = islmdb ? MDB_NOMETASYNC | MDB_NOSYNC | MDB_NORDAHEAD : BDB_FAST_MODE;
db_flags = DBF_FAST;
else if (db_mode == "fastest")
db_flags = islmdb ? MDB_WRITEMAP | MDB_MAPASYNC | MDB_NORDAHEAD | MDB_NOMETASYNC | MDB_NOSYNC : BDB_FASTEST_MODE;
db_flags = DBF_FASTEST;
return db_flags;
}
@ -132,14 +120,6 @@ int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int&
return 1;
}
#if !defined(BERKELEY_DB)
if (db_type == "berkeley")
{
MFATAL("BerkeleyDB support disabled.");
return false;
}
#endif
std::string db_arg_str2 = db_args[1];
boost::split(db_args, db_arg_str2, boost::is_any_of(","));
@ -155,51 +135,7 @@ int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int&
}
if (! db_mode.empty())
{
db_flags = get_db_flags_from_mode(db_type, db_mode);
}
else
{
for (auto& it : db_args)
{
boost::algorithm::trim(it);
if (it.empty())
continue;
if (db_type == "lmdb")
{
MINFO("LMDB flag: " << it);
if (it == "nosync")
db_flags |= MDB_NOSYNC;
else if (it == "nometasync")
db_flags |= MDB_NOMETASYNC;
else if (it == "writemap")
db_flags |= MDB_WRITEMAP;
else if (it == "mapasync")
db_flags |= MDB_MAPASYNC;
else if (it == "nordahead")
db_flags |= MDB_NORDAHEAD;
else
{
std::cerr << "unrecognized database flag: " << it << ENDL;
return 1;
}
}
#if defined(BERKELEY_DB)
else if (db_type == "berkeley")
{
if (it == "txn_write_nosync")
db_flags = DB_TXN_WRITE_NOSYNC;
else if (it == "txn_nosync")
db_flags = DB_TXN_NOSYNC;
else if (it == "txn_sync")
db_flags = DB_TXN_SYNC;
else
{
std::cerr << "unrecognized database flag: " << it << ENDL;
return 1;
}
}
#endif
}
db_flags = get_db_flags_from_mode(db_mode);
}
return 0;
}

1
src/blockchain_utilities/blocksdat_file.h
View File

@ -38,7 +38,6 @@
#include "cryptonote_basic/cryptonote_boost_serialization.h"
#include "cryptonote_core/blockchain.h"
#include "blockchain_db/blockchain_db.h"
#include "blockchain_db/lmdb/db_lmdb.h"
#include <algorithm>
#include <cstdio>

30
src/cryptonote_core/cryptonote_core.cpp
View File

@ -48,10 +48,6 @@ using namespace epee;
#include "cryptonote_basic/checkpoints.h"
#include "ringct/rctTypes.h"
#include "blockchain_db/blockchain_db.h"
#include "blockchain_db/lmdb/db_lmdb.h"
#if defined(BERKELEY_DB)
#include "blockchain_db/berkeleydb/db_bdb.h"
#endif
#include "ringct/rctSigs.h"
#undef MONERO_DEFAULT_LOG_CATEGORY
@ -308,20 +304,8 @@ namespace cryptonote
// folder might not be a directory, etc, etc
catch (...) { }
BlockchainDB* db = nullptr;
uint64_t DBS_FAST_MODE = 0;
uint64_t DBS_FASTEST_MODE = 0;
uint64_t DBS_SAFE_MODE = 0;
uint64_t DBS_SALVAGE = 0;
if (db_type == "lmdb")
{
db = new BlockchainLMDB();
DBS_SAFE_MODE = MDB_NORDAHEAD;
DBS_FAST_MODE = MDB_NORDAHEAD | MDB_NOSYNC;
DBS_FASTEST_MODE = MDB_NORDAHEAD | MDB_NOSYNC | MDB_WRITEMAP | MDB_MAPASYNC;
DBS_SALVAGE = MDB_PREVSNAPSHOT;
}
else
BlockchainDB* db = new_db(db_type);
if (db == NULL)
{
LOG_ERROR("Attempted to use non-existent database type");
return false;
@ -347,7 +331,7 @@ namespace cryptonote
MDEBUG("option: " << option);
// default to fast:async:1
uint64_t DEFAULT_FLAGS = DBS_FAST_MODE;
uint64_t DEFAULT_FLAGS = DBF_FAST;
if(options.size() == 0)
{
@ -361,14 +345,14 @@ namespace cryptonote
if(options[0] == "safe")
{
safemode = true;
db_flags = DBS_SAFE_MODE;
db_flags = DBF_SAFE;
sync_mode = db_nosync;
}
else if(options[0] == "fast")
db_flags = DBS_FAST_MODE;
db_flags = DBF_FAST;
else if(options[0] == "fastest")
{
db_flags = DBS_FASTEST_MODE;
db_flags = DBF_FASTEST;
blocks_per_sync = 1000; // default to fastest:async:1000
}
else
@ -392,7 +376,7 @@ namespace cryptonote
}
if (db_salvage)
db_flags |= DBS_SALVAGE;
db_flags |= DBF_SALVAGE;
db->open(filename, db_flags);
if(!db->m_open)

2
tests/unit_tests/hardfork.cpp
View File

@ -31,7 +31,7 @@
#include <algorithm>
#include "gtest/gtest.h"
#include "blockchain_db/lmdb/db_lmdb.h"
#include "blockchain_db/blockchain_db.h"
#include "cryptonote_basic/cryptonote_format_utils.h"
#include "cryptonote_basic/hardfork.h"