mirror of
https://codeberg.org/anoncontributorxmr/monero.git
synced 2024-11-26 09:24:47 +00:00
Removed Berkeley DB and db switching logic
This commit is contained in:
Jesus Ramirez
Lev Sizov
parent
98af2e954b
commit
f9b3f6ef3b
21 changed files with 37 additions and 3190 deletions
|
|
@ -356,54 +356,9 @@ endif()
|
|||
# memory was the default in Cryptonote before Monero implemented LMDB, it still works but is unnecessary.
|
||||
# set(DATABASE memory)
|
||||
set(DATABASE lmdb)
|
||||
|
||||
if (DEFINED ENV{DATABASE})
|
||||
set(DATABASE $ENV{DATABASE})
|
||||
message(STATUS "DATABASE set: ${DATABASE}")
|
||||
else()
|
||||
message(STATUS "Could not find DATABASE in env (not required unless you want to change database type from default: ${DATABASE})")
|
||||
endif()
|
||||
|
||||
set(BERKELEY_DB_OVERRIDE 0)
|
||||
if (DEFINED ENV{BERKELEY_DB})
|
||||
set(BERKELEY_DB_OVERRIDE 1)
|
||||
set(BERKELEY_DB $ENV{BERKELEY_DB})
|
||||
elseif()
|
||||
set(BERKELEY_DB 0)
|
||||
endif()
|
||||
|
||||
if (DATABASE STREQUAL "lmdb")
|
||||
message(STATUS "Using LMDB as default DB type")
|
||||
set(BLOCKCHAIN_DB DB_LMDB)
|
||||
add_definitions("-DDEFAULT_DB_TYPE=\"lmdb\"")
|
||||
elseif (DATABASE STREQUAL "berkeleydb")
|
||||
find_package(BerkeleyDB)
|
||||
if(NOT BERKELEY_DB)
|
||||
die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.")
|
||||
else()
|
||||
message(STATUS "Found BerkeleyDB include (db.h) in ${BERKELEY_DB_INCLUDE_DIR}")
|
||||
if(BERKELEY_DB_LIBRARIES)
|
||||
message(STATUS "Found BerkeleyDB shared library")
|
||||
set(BDB_STATIC false CACHE BOOL "BDB Static flag")
|
||||
set(BDB_INCLUDE ${BERKELEY_DB_INCLUDE_DIR} CACHE STRING "BDB include path")
|
||||
set(BDB_LIBRARY ${BERKELEY_DB_LIBRARIES} CACHE STRING "BDB library name")
|
||||
set(BDB_LIBRARY_DIRS "" CACHE STRING "BDB Library dirs")
|
||||
set(BERKELEY_DB 1)
|
||||
else()
|
||||
die("Found BerkeleyDB includes, but could not find BerkeleyDB library. Please make sure you have installed libdb and libdb-dev / libdb++-dev or the equivalent.")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
message(STATUS "Using Berkeley DB as default DB type")
|
||||
add_definitions("-DDEFAULT_DB_TYPE=\"berkeley\"")
|
||||
else()
|
||||
die("Invalid database type: ${DATABASE}")
|
||||
endif()
|
||||
|
||||
if(BERKELEY_DB)
|
||||
add_definitions("-DBERKELEY_DB")
|
||||
endif()
|
||||
|
||||
message(STATUS "Using LMDB as default DB type")
|
||||
set(BLOCKCHAIN_DB DB_LMDB)
|
||||
add_definitions("-DDEFAULT_DB_TYPE=\"lmdb\"")
|
||||
add_definitions("-DBLOCKCHAIN_DB=${BLOCKCHAIN_DB}")
|
||||
|
||||
# Can't install hook in static build on OSX, because OSX linker does not support --wrap
|
||||
|
|
@ -505,11 +460,6 @@ link_directories(${EASYLOGGING_LIBRARY_DIRS})
|
|||
# Final setup for liblmdb
|
||||
include_directories(${LMDB_INCLUDE})
|
||||
|
||||
# Final setup for Berkeley DB
|
||||
if (BERKELEY_DB)
|
||||
include_directories(${BDB_INCLUDE})
|
||||
endif()
|
||||
|
||||
# Final setup for libunwind
|
||||
include_directories(${LIBUNWIND_INCLUDE})
|
||||
link_directories(${LIBUNWIND_LIBRARY_DIRS})
|
||||
|
|
|
|||
|
|
@ -1,25 +0,0 @@
|
|||
# - Try to find Berkeley DB
|
||||
# Once done this will define
|
||||
#
|
||||
# BERKELEY_DB_FOUND - system has Berkeley DB
|
||||
# BERKELEY_DB_INCLUDE_DIR - the Berkeley DB include directory
|
||||
# BERKELEY_DB_LIBRARIES - Link these to use Berkeley DB
|
||||
# BERKELEY_DB_DEFINITIONS - Compiler switches required for using Berkeley DB
|
||||
|
||||
# Copyright (c) 2006, Alexander Dymo, <adymo@kdevelop.org>
|
||||
#
|
||||
# Redistribution and use is allowed according to the terms of the BSD license.
|
||||
# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
|
||||
|
||||
find_path(BERKELEY_DB_INCLUDE_DIR db_cxx.h
|
||||
/usr/include/db4
|
||||
/usr/local/include/db4
|
||||
)
|
||||
|
||||
find_library(BERKELEY_DB_LIBRARIES NAMES db_cxx )
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
find_package_handle_standard_args(Berkeley "Could not find Berkeley DB >= 4.1" BERKELEY_DB_INCLUDE_DIR BERKELEY_DB_LIBRARIES)
|
||||
# show the BERKELEY_DB_INCLUDE_DIR and BERKELEY_DB_LIBRARIES variables only in the advanced view
|
||||
mark_as_advanced(BERKELEY_DB_INCLUDE_DIR BERKELEY_DB_LIBRARIES )
|
||||
|
||||
|
|
@ -31,14 +31,6 @@ set(blockchain_db_sources
|
|||
lmdb/db_lmdb.cpp
|
||||
)
|
||||
|
||||
if (BERKELEY_DB)
|
||||
set(blockchain_db_sources
|
||||
${blockchain_db_sources}
|
||||
berkeleydb/db_bdb.cpp
|
||||
)
|
||||
endif()
|
||||
|
||||
|
||||
set(blockchain_db_headers)
|
||||
|
||||
set(blockchain_db_private_headers
|
||||
|
|
@ -46,13 +38,6 @@ set(blockchain_db_private_headers
|
|||
lmdb/db_lmdb.h
|
||||
)
|
||||
|
||||
if (BERKELEY_DB)
|
||||
set(blockchain_db_private_headers
|
||||
${blockchain_db_private_headers}
|
||||
berkeleydb/db_bdb.h
|
||||
)
|
||||
endif()
|
||||
|
||||
monero_private_headers(blockchain_db
|
||||
${crypto_private_headers})
|
||||
monero_add_library(blockchain_db
|
||||
|
|
@ -65,7 +50,6 @@ target_link_libraries(blockchain_db
|
|||
cncrypto
|
||||
ringct
|
||||
${LMDB_LIBRARY}
|
||||
${BDB_LIBRARY}
|
||||
${Boost_FILESYSTEM_LIBRARY}
|
||||
${Boost_THREAD_LIBRARY}
|
||||
PRIVATE
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,452 +0,0 @@
|
|||
// Copyright (c) 2014-2019, The Monero Project
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification, are
|
||||
// permitted provided that the following conditions are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
// conditions and the following disclaimer.
|
||||
//
|
||||
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
// of conditions and the following disclaimer in the documentation and/or other
|
||||
// materials provided with the distribution.
|
||||
//
|
||||
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without specific
|
||||
// prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
||||
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
||||
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
||||
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
#include <db_cxx.h>
|
||||
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "cryptonote_basic/blobdatatype.h" // for type blobdata
|
||||
|
||||
#include <unordered_map>
|
||||
#include <condition_variable>
|
||||
|
||||
// ND: Enables multi-threaded bulk reads for when getting indices.
|
||||
// TODO: Disabled for now, as it doesn't seem to provide noticeable improvements (??. Reason: TBD.
|
||||
// #define BDB_BULK_CAN_THREAD
|
||||
namespace cryptonote
|
||||
{
|
||||
|
||||
struct bdb_txn_safe
|
||||
{
|
||||
bdb_txn_safe() : m_txn(NULL) { }
|
||||
~bdb_txn_safe()
|
||||
{
|
||||
LOG_PRINT_L3("bdb_txn_safe: destructor");
|
||||
|
||||
if (m_txn != NULL)
|
||||
abort();
|
||||
}
|
||||
|
||||
void commit(std::string message = "")
|
||||
{
|
||||
if (message.size() == 0)
|
||||
{
|
||||
message = "Failed to commit a transaction to the db";
|
||||
}
|
||||
|
||||
if (m_txn->commit(0))
|
||||
{
|
||||
m_txn = NULL;
|
||||
LOG_PRINT_L0(message);
|
||||
throw DB_ERROR(message.c_str());
|
||||
}
|
||||
m_txn = NULL;
|
||||
}
|
||||
|
||||
void abort()
|
||||
{
|
||||
LOG_PRINT_L3("bdb_txn_safe: abort()");
|
||||
if(m_txn != NULL)
|
||||
{
|
||||
m_txn->abort();
|
||||
m_txn = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_PRINT_L0("WARNING: bdb_txn_safe: abort() called, but m_txn is NULL");
|
||||
}
|
||||
}
|
||||
|
||||
operator DbTxn*()
|
||||
{
|
||||
return m_txn;
|
||||
}
|
||||
|
||||
operator DbTxn**()
|
||||
{
|
||||
return &m_txn;
|
||||
}
|
||||
private:
|
||||
DbTxn* m_txn;
|
||||
};
|
||||
|
||||
// ND: Class to handle buffer management when doing bulk queries
|
||||
// (DB_MULTIPLE). Allocates buffers then handles thread queuing
|
||||
// so a fixed set of buffers can be used (instead of allocating
|
||||
// every time a bulk query is needed).
|
||||
template <typename T>
|
||||
class bdb_safe_buffer
|
||||
{
|
||||
// limit the number of buffers to 8
|
||||
const size_t MaxAllowedBuffers = 8;
|
||||
public:
|
||||
bdb_safe_buffer(size_t num_buffers, size_t count)
|
||||
{
|
||||
if(num_buffers > MaxAllowedBuffers)
|
||||
num_buffers = MaxAllowedBuffers;
|
||||
|
||||
set_count(num_buffers);
|
||||
for (size_t i = 0; i < num_buffers; i++)
|
||||
m_buffers.push_back((T) malloc(sizeof(T) * count));
|
||||
m_buffer_count = count;
|
||||
}
|
||||
|
||||
~bdb_safe_buffer()
|
||||
{
|
||||
for (size_t i = 0; i < m_buffers.size(); i++)
|
||||
{
|
||||
if (m_buffers[i])
|
||||
{
|
||||
free(m_buffers[i]);
|
||||
m_buffers[i] = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
m_buffers.resize(0);
|
||||
}
|
||||
|
||||
T acquire_buffer()
|
||||
{
|
||||
boost::unique_lock<boost::mutex> lock(m_lock);
|
||||
m_cv.wait(lock, [&]{ return m_count > 0; });
|
||||
|
||||
--m_count;
|
||||
size_t index = -1;
|
||||
for (size_t i = 0; i < m_open_slot.size(); i++)
|
||||
{
|
||||
if (m_open_slot[i])
|
||||
{
|
||||
m_open_slot[i] = false;
|
||||
index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
assert(index >= 0);
|
||||
|
||||
T buffer = m_buffers[index];
|
||||
m_buffer_map.emplace(buffer, index);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
void release_buffer(T buffer)
|
||||
{
|
||||
boost::unique_lock<boost::mutex> lock(m_lock);
|
||||
|
||||
assert(buffer != nullptr);
|
||||
auto it = m_buffer_map.find(buffer);
|
||||
if (it != m_buffer_map.end())
|
||||
{
|
||||
auto index = it->second;
|
||||
|
||||
assert(index < m_open_slot.size());
|
||||
assert(m_open_slot[index] == false);
|
||||
assert(m_count < m_open_slot.size());
|
||||
|
||||
++m_count;
|
||||
m_open_slot[index] = true;
|
||||
m_buffer_map.erase(it);
|
||||
m_cv.notify_one();
|
||||
}
|
||||
}
|
||||
|
||||
size_t get_buffer_size() const
|
||||
{
|
||||
return m_buffer_count * sizeof(T);
|
||||
}
|
||||
|
||||
size_t get_buffer_count() const
|
||||
{
|
||||
return m_buffer_count;
|
||||
}
|
||||
|
||||
typedef T type;
|
||||
|
||||
private:
|
||||
void set_count(size_t count)
|
||||
{
|
||||
assert(count > 0);
|
||||
m_open_slot.resize(count, true);
|
||||
m_count = count;
|
||||
}
|
||||
|
||||
std::vector<T> m_buffers;
|
||||
std::unordered_map<T, size_t> m_buffer_map;
|
||||
|
||||
boost::condition_variable m_cv;
|
||||
std::vector<bool> m_open_slot;
|
||||
size_t m_count;
|
||||
boost::mutex m_lock;
|
||||
|
||||
size_t m_buffer_count;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class bdb_safe_buffer_autolock
|
||||
{
|
||||
public:
|
||||
bdb_safe_buffer_autolock(T &safe_buffer, typename T::type &buffer) :
|
||||
m_safe_buffer(safe_buffer), m_buffer(nullptr)
|
||||
{
|
||||
m_buffer = m_safe_buffer.acquire_buffer();
|
||||
buffer = m_buffer;
|
||||
}
|
||||
|
||||
~bdb_safe_buffer_autolock()
|
||||
{
|
||||
if (m_buffer != nullptr)
|
||||
{
|
||||
m_safe_buffer.release_buffer(m_buffer);
|
||||
m_buffer = nullptr;
|
||||
}
|
||||
}
|
||||
private:
|
||||
T &m_safe_buffer;
|
||||
typename T::type m_buffer;
|
||||
};
|
||||
|
||||
class BlockchainBDB : public BlockchainDB
|
||||
{
|
||||
public:
|
||||
BlockchainBDB(bool batch_transactions=false);
|
||||
~BlockchainBDB();
|
||||
|
||||
virtual void open(const std::string& filename, const int db_flags);
|
||||
|
||||
virtual void close();
|
||||
|
||||
virtual void sync();
|
||||
|
||||
virtual void reset();
|
||||
|
||||
virtual std::vector<std::string> get_filenames() const;
|
||||
|
||||
virtual bool remove_data_file(const std::string& folder);
|
||||
|
||||
virtual std::string get_db_name() const;
|
||||
|
||||
virtual bool lock();
|
||||
|
||||
virtual void unlock();
|
||||
|
||||
virtual bool block_exists(const crypto::hash& h, uint64_t *height = NULL) const;
|
||||
|
||||
virtual block get_block(const crypto::hash& h) const;
|
||||
|
||||
virtual uint64_t get_block_height(const crypto::hash& h) const;
|
||||
|
||||
virtual block_header get_block_header(const crypto::hash& h) const;
|
||||
|
||||
virtual block get_block_from_height(const uint64_t& height) const;
|
||||
|
||||
virtual uint64_t get_block_timestamp(const uint64_t& height) const;
|
||||
|
||||
virtual uint64_t get_top_block_timestamp() const;
|
||||
|
||||
virtual size_t get_block_weight(const uint64_t& height) const;
|
||||
|
||||
virtual difficulty_type get_block_cumulative_difficulty(const uint64_t& height) const;
|
||||
|
||||
virtual difficulty_type get_block_difficulty(const uint64_t& height) const;
|
||||
|
||||
virtual uint64_t get_block_already_generated_coins(const uint64_t& height) const;
|
||||
|
||||
virtual crypto::hash get_block_hash_from_height(const uint64_t& height) const;
|
||||
|
||||
virtual std::vector<block> get_blocks_range(const uint64_t& h1, const uint64_t& h2) const;
|
||||
|
||||
virtual std::vector<crypto::hash> get_hashes_range(const uint64_t& h1, const uint64_t& h2) const;
|
||||
|
||||
virtual crypto::hash top_block_hash() const;
|
||||
|
||||
virtual block get_top_block() const;
|
||||
|
||||
virtual uint64_t height() const;
|
||||
|
||||
virtual bool tx_exists(const crypto::hash& h) const;
|
||||
|
||||
virtual uint64_t get_tx_unlock_time(const crypto::hash& h) const;
|
||||
|
||||
virtual transaction get_tx(const crypto::hash& h) const;
|
||||
|
||||
virtual uint64_t get_tx_count() const;
|
||||
|
||||
virtual std::vector<transaction> get_tx_list(const std::vector<crypto::hash>& hlist) const;
|
||||
|
||||
virtual uint64_t get_tx_block_height(const crypto::hash& h) const;
|
||||
|
||||
virtual uint64_t get_num_outputs(const uint64_t& amount) const;
|
||||
|
||||
virtual uint64_t get_indexing_base() const { return 1; }
|
||||
|
||||
virtual output_data_t get_output_key(const uint64_t& amount, const uint64_t& index);
|
||||
virtual void get_output_key(const uint64_t &amount, const std::vector<uint64_t> &offsets, std::vector<output_data_t> &outputs);
|
||||
|
||||
virtual tx_out_index get_output_tx_and_index_from_global(const uint64_t& index) const;
|
||||
virtual void get_output_tx_and_index_from_global(const std::vector<uint64_t> &global_indices,
|
||||
std::vector<tx_out_index> &tx_out_indices) const;
|
||||
|
||||
virtual tx_out_index get_output_tx_and_index(const uint64_t& amount, const uint64_t& index);
|
||||
virtual void get_output_tx_and_index(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<tx_out_index> &indices);
|
||||
|
||||
virtual std::vector<uint64_t> get_tx_amount_output_indices(const crypto::hash& h) const;
|
||||
|
||||
virtual bool has_key_image(const crypto::key_image& img) const;
|
||||
|
||||
virtual uint64_t add_block( const block& blk
|
||||
, size_t block_weight
|
||||
, const difficulty_type& cumulative_difficulty
|
||||
, const uint64_t& coins_generated
|
||||
, const std::vector<transaction>& txs
|
||||
);
|
||||
|
||||
virtual void set_batch_transactions(bool batch_transactions);
|
||||
virtual bool batch_start(uint64_t batch_num_blocks=0);
|
||||
virtual void batch_commit();
|
||||
virtual void batch_stop();
|
||||
virtual void batch_abort();
|
||||
|
||||
virtual void block_txn_start(bool readonly);
|
||||
virtual void block_txn_stop();
|
||||
virtual void block_txn_abort();
|
||||
|
||||
virtual void pop_block(block& blk, std::vector<transaction>& txs);
|
||||
|
||||
#if defined(BDB_BULK_CAN_THREAD)
|
||||
virtual bool can_thread_bulk_indices() const { return true; }
|
||||
#else
|
||||
virtual bool can_thread_bulk_indices() const { return false; }
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief return a histogram of outputs on the blockchain
|
||||
*
|
||||
* @param amounts optional set of amounts to lookup
|
||||
*
|
||||
* @return a set of amount/instances
|
||||
*/
|
||||
std::map<uint64_t, uint64_t> get_output_histogram(const std::vector<uint64_t> &amounts) const;
|
||||
|
||||
private:
|
||||
virtual void add_block( const block& blk
|
||||
, size_t block_weight
|
||||
, const difficulty_type& cumulative_difficulty
|
||||
, const uint64_t& coins_generated
|
||||
, const crypto::hash& block_hash
|
||||
);
|
||||
|
||||
virtual void remove_block();
|
||||
|
||||
virtual void add_transaction_data(const crypto::hash& blk_hash, const transaction& tx, const crypto::hash& tx_hash, const crypto::hash& tx_prunable_hash);
|
||||
|
||||
virtual void remove_transaction_data(const crypto::hash& tx_hash, const transaction& tx);
|
||||
|
||||
virtual void add_output(const crypto::hash& tx_hash, const tx_out& tx_output, const uint64_t& local_index, const uint64_t unlock_time, const rct::key *commitment);
|
||||
|
||||
virtual void remove_output(const tx_out& tx_output);
|
||||
|
||||
void remove_tx_outputs(const crypto::hash& tx_hash, const transaction& tx);
|
||||
|
||||
void remove_output(const uint64_t& out_index, const uint64_t amount);
|
||||
void remove_amount_output_index(const uint64_t amount, const uint64_t global_output_index);
|
||||
|
||||
virtual void add_spent_key(const crypto::key_image& k_image);
|
||||
|
||||
virtual void remove_spent_key(const crypto::key_image& k_image);
|
||||
|
||||
void get_output_global_indices(const uint64_t& amount, const std::vector<uint64_t> &offsets, std::vector<uint64_t> &global_indices);
|
||||
|
||||
virtual bool for_all_key_images(std::function<bool(const crypto::key_image&)>) const;
|
||||
virtual bool for_all_blocks(std::function<bool(uint64_t, const crypto::hash&, const cryptonote::block&)>) const;
|
||||
virtual bool for_all_transactions(std::function<bool(const crypto::hash&, const cryptonote::transaction&)>, bool pruned) const;
|
||||
virtual bool for_all_outputs(std::function<bool(uint64_t amount, const crypto::hash &tx_hash, size_t tx_idx)> f) const;
|
||||
|
||||
// Hard fork related storage
|
||||
virtual void set_hard_fork_version(uint64_t height, uint8_t version);
|
||||
virtual uint8_t get_hard_fork_version(uint64_t height) const;
|
||||
virtual void check_hard_fork_info();
|
||||
virtual void drop_hard_fork_info();
|
||||
|
||||
/**
|
||||
* @brief get the global index of the index-th output of the given amount
|
||||
*
|
||||
* @param amount the output amount
|
||||
* @param index the index into the set of outputs of that amount
|
||||
*
|
||||
* @return the global index of the desired output
|
||||
*/
|
||||
uint64_t get_output_global_index(const uint64_t& amount, const uint64_t& index);
|
||||
output_data_t get_output_key(const uint64_t& global_index) const;
|
||||
void checkpoint_worker() const;
|
||||
void check_open() const;
|
||||
|
||||
virtual bool is_read_only() const;
|
||||
|
||||
//
|
||||
// fix up anything that may be wrong due to past bugs
|
||||
virtual void fixup();
|
||||
|
||||
bool m_run_checkpoint;
|
||||
std::unique_ptr<boost::thread> m_checkpoint_thread;
|
||||
typedef bdb_safe_buffer<void *> bdb_safe_buffer_t;
|
||||
bdb_safe_buffer_t m_buffer;
|
||||
|
||||
DbEnv* m_env;
|
||||
|
||||
Db* m_blocks;
|
||||
Db* m_block_heights;
|
||||
Db* m_block_hashes;
|
||||
Db* m_block_timestamps;
|
||||
Db* m_block_sizes;
|
||||
Db* m_block_diffs;
|
||||
Db* m_block_coins;
|
||||
|
||||
Db* m_txs;
|
||||
Db* m_tx_unlocks;
|
||||
Db* m_tx_heights;
|
||||
Db* m_tx_outputs;
|
||||
|
||||
Db* m_output_txs;
|
||||
Db* m_output_indices;
|
||||
Db* m_output_amounts;
|
||||
Db* m_output_keys;
|
||||
|
||||
Db* m_spent_keys;
|
||||
|
||||
Db* m_hf_starting_heights;
|
||||
Db* m_hf_versions;
|
||||
|
||||
Db* m_properties;
|
||||
|
||||
uint64_t m_height;
|
||||
uint64_t m_num_outputs;
|
||||
std::string m_folder;
|
||||
bdb_txn_safe *m_write_txn;
|
||||
|
||||
bool m_batch_transactions; // support for batch transactions
|
||||
};
|
||||
|
||||
} // namespace cryptonote
|
||||
|
|
@ -35,17 +35,6 @@
|
|||
#include "ringct/rctOps.h"
|
||||
|
||||
#include "lmdb/db_lmdb.h"
|
||||
#ifdef BERKELEY_DB
|
||||
#include "berkeleydb/db_bdb.h"
|
||||
#endif
|
||||
|
||||
static const char *db_types[] = {
|
||||
"lmdb",
|
||||
#ifdef BERKELEY_DB
|
||||
"berkeley",
|
||||
#endif
|
||||
NULL
|
||||
};
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
#define MONERO_DEFAULT_LOG_CATEGORY "blockchain.db"
|
||||
|
|
@ -55,36 +44,6 @@ using epee::string_tools::pod_to_hex;
|
|||
namespace cryptonote
|
||||
{
|
||||
|
||||
bool blockchain_valid_db_type(const std::string& db_type)
|
||||
{
|
||||
int i;
|
||||
for (i=0; db_types[i]; i++)
|
||||
{
|
||||
if (db_types[i] == db_type)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string blockchain_db_types(const std::string& sep)
|
||||
{
|
||||
int i;
|
||||
std::string ret = "";
|
||||
for (i=0; db_types[i]; i++)
|
||||
{
|
||||
if (i)
|
||||
ret += sep;
|
||||
ret += db_types[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
std::string arg_db_type_description = "Specify database type, available: " + cryptonote::blockchain_db_types(", ");
|
||||
const command_line::arg_descriptor<std::string> arg_db_type = {
|
||||
"db-type"
|
||||
, arg_db_type_description.c_str()
|
||||
, DEFAULT_DB_TYPE
|
||||
};
|
||||
const command_line::arg_descriptor<std::string> arg_db_sync_mode = {
|
||||
"db-sync-mode"
|
||||
, "Specify sync option, using format [safe|fast|fastest]:[sync|async]:[<nblocks_per_sync>[blocks]|<nbytes_per_sync>[bytes]]."
|
||||
|
|
@ -96,20 +55,13 @@ const command_line::arg_descriptor<bool> arg_db_salvage = {
|
|||
, false
|
||||
};
|
||||
|
||||
BlockchainDB *new_db(const std::string& db_type)
|
||||
BlockchainDB *new_db()
|
||||
{
|
||||
if (db_type == "lmdb")
|
||||
return new BlockchainLMDB();
|
||||
#if defined(BERKELEY_DB)
|
||||
if (db_type == "berkeley")
|
||||
return new BlockchainBDB();
|
||||
#endif
|
||||
return NULL;
|
||||
return new BlockchainLMDB();
|
||||
}
|
||||
|
||||
void BlockchainDB::init_options(boost::program_options::options_description& desc)
|
||||
{
|
||||
command_line::add_arg(desc, arg_db_type);
|
||||
command_line::add_arg(desc, arg_db_sync_mode);
|
||||
command_line::add_arg(desc, arg_db_salvage);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -102,7 +102,6 @@ namespace cryptonote
|
|||
/** a pair of <transaction hash, output index>, typedef for convenience */
|
||||
typedef std::pair<crypto::hash, uint64_t> tx_out_index;
|
||||
|
||||
extern const command_line::arg_descriptor<std::string> arg_db_type;
|
||||
extern const command_line::arg_descriptor<std::string> arg_db_sync_mode;
|
||||
extern const command_line::arg_descriptor<bool, false> arg_db_salvage;
|
||||
|
||||
|
|
@ -1826,7 +1825,7 @@ private:
|
|||
class db_rtxn_guard: public db_txn_guard { public: db_rtxn_guard(BlockchainDB *db): db_txn_guard(db, true) {} };
|
||||
class db_wtxn_guard: public db_txn_guard { public: db_wtxn_guard(BlockchainDB *db): db_txn_guard(db, false) {} };
|
||||
|
||||
BlockchainDB *new_db(const std::string& db_type);
|
||||
BlockchainDB *new_db();
|
||||
|
||||
} // namespace cryptonote
|
||||
|
||||
|
|
|
|||
|
|
@ -1,36 +0,0 @@
|
|||
// Copyright (c) 2014-2019, The Monero Project
|
||||
//
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification, are
|
||||
// permitted provided that the following conditions are met:
|
||||
//
|
||||
// 1. Redistributions of source code must retain the above copyright notice, this list of
|
||||
// conditions and the following disclaimer.
|
||||
//
|
||||
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
|
||||
// of conditions and the following disclaimer in the documentation and/or other
|
||||
// materials provided with the distribution.
|
||||
//
|
||||
// 3. Neither the name of the copyright holder nor the names of its contributors may be
|
||||
// used to endorse or promote products derived from this software without specific
|
||||
// prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
|
||||
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
||||
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
|
||||
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
||||
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
||||
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
|
||||
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
|
||||
#pragma once
|
||||
|
||||
namespace cryptonote
|
||||
{
|
||||
bool blockchain_valid_db_type(const std::string& db_type);
|
||||
std::string blockchain_db_types(const std::string& sep);
|
||||
} // namespace cryptonote
|
||||
|
|
@ -40,7 +40,6 @@
|
|||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -336,11 +335,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
|
||||
tools::on_startup();
|
||||
|
|
@ -350,9 +344,6 @@ int main(int argc, char* argv[])
|
|||
po::options_description desc_cmd_only("Command line options");
|
||||
po::options_description desc_cmd_sett("Command line options and settings options");
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<std::string> arg_txid = {"txid", "Get ancestry for this txid", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_output = {"output", "Get ancestry for this output (amount/offset format)", ""};
|
||||
const command_line::arg_descriptor<uint64_t> arg_height = {"height", "Get ancestry for all txes at this height", 0};
|
||||
|
|
@ -367,7 +358,6 @@ int main(int argc, char* argv[])
|
|||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_txid);
|
||||
command_line::add_arg(desc_cmd_sett, arg_output);
|
||||
command_line::add_arg(desc_cmd_sett, arg_height);
|
||||
|
|
@ -446,13 +436,6 @@ int main(int argc, char* argv[])
|
|||
}
|
||||
}
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// If we wanted to use the memory pool, we would set up a fake_core.
|
||||
|
||||
// Use Blockchain instead of lower-level BlockchainDB for two reasons:
|
||||
|
|
@ -468,13 +451,13 @@ int main(int argc, char* argv[])
|
|||
std::unique_ptr<Blockchain> core_storage;
|
||||
tx_memory_pool m_mempool(*core_storage);
|
||||
core_storage.reset(new Blockchain(m_mempool));
|
||||
BlockchainDB *db = new_db(db_type);
|
||||
BlockchainDB *db = new_db();
|
||||
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");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
LOG_PRINT_L0("database: " << db_type);
|
||||
LOG_PRINT_L0("database: LMDB");
|
||||
|
||||
const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
|
||||
LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");
|
||||
|
|
|
|||
|
|
@ -39,7 +39,6 @@
|
|||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "wallet/ringdb.h"
|
||||
#include "version.h"
|
||||
|
||||
|
|
@ -1061,11 +1060,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
|
||||
tools::on_startup();
|
||||
|
|
@ -1079,9 +1073,6 @@ int main(int argc, char* argv[])
|
|||
get_default_db_path(),
|
||||
};
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<bool> arg_rct_only = {"rct-only", "Only work on ringCT outputs", false};
|
||||
const command_line::arg_descriptor<bool> arg_check_subsets = {"check-subsets", "Check ring subsets (very expensive)", false};
|
||||
const command_line::arg_descriptor<bool> arg_verbose = {"verbose", "Verbose output)", false};
|
||||
|
|
@ -1097,7 +1088,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
command_line::add_arg(desc_cmd_sett, arg_blackball_db_dir);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_rct_only);
|
||||
command_line::add_arg(desc_cmd_sett, arg_check_subsets);
|
||||
command_line::add_arg(desc_cmd_sett, arg_verbose);
|
||||
|
|
@ -1149,12 +1139,6 @@ int main(int argc, char* argv[])
|
|||
std::string extra_spent_list = command_line::get_arg(vm, arg_extra_spent_list);
|
||||
std::vector<std::pair<uint64_t, uint64_t>> extra_spent_outputs = extra_spent_list.empty() ? std::vector<std::pair<uint64_t, uint64_t>>() : load_outputs(extra_spent_list);
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::string db_sync_mode = command_line::get_arg(vm, arg_db_sync_mode);
|
||||
if (!parse_db_sync_mode(db_sync_mode))
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@
|
|||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -50,11 +49,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
|
||||
tools::on_startup();
|
||||
|
|
@ -64,9 +58,6 @@ int main(int argc, char* argv[])
|
|||
po::options_description desc_cmd_only("Command line options");
|
||||
po::options_description desc_cmd_sett("Command line options and settings options");
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<std::string> arg_txid = {"txid", "Get min depth for this txid", ""};
|
||||
const command_line::arg_descriptor<uint64_t> arg_height = {"height", "Get min depth for all txes at this height", 0};
|
||||
const command_line::arg_descriptor<bool> arg_include_coinbase = {"include-coinbase", "Include coinbase in the average", false};
|
||||
|
|
@ -75,7 +66,6 @@ int main(int argc, char* argv[])
|
|||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_txid);
|
||||
command_line::add_arg(desc_cmd_sett, arg_height);
|
||||
command_line::add_arg(desc_cmd_sett, arg_include_coinbase);
|
||||
|
|
@ -133,13 +123,6 @@ int main(int argc, char* argv[])
|
|||
}
|
||||
}
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// If we wanted to use the memory pool, we would set up a fake_core.
|
||||
|
||||
// Use Blockchain instead of lower-level BlockchainDB for two reasons:
|
||||
|
|
@ -155,13 +138,13 @@ int main(int argc, char* argv[])
|
|||
std::unique_ptr<Blockchain> core_storage;
|
||||
tx_memory_pool m_mempool(*core_storage);
|
||||
core_storage.reset(new Blockchain(m_mempool));
|
||||
BlockchainDB *db = new_db(db_type);
|
||||
BlockchainDB *db = new_db();
|
||||
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");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
LOG_PRINT_L0("database: " << db_type);
|
||||
LOG_PRINT_L0("database: LMDB");
|
||||
|
||||
const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
|
||||
LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");
|
||||
|
|
|
|||
|
|
@ -32,7 +32,6 @@
|
|||
#include "cryptonote_core/tx_pool.h"
|
||||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -47,11 +46,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
uint64_t block_stop = 0;
|
||||
bool blocks_dat = false;
|
||||
|
|
@ -65,9 +59,6 @@ int main(int argc, char* argv[])
|
|||
const command_line::arg_descriptor<std::string> arg_output_file = {"output-file", "Specify output file", "", true};
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<uint64_t> arg_block_stop = {"block-stop", "Stop at block number", block_stop};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<bool> arg_blocks_dat = {"blocksdat", "Output in blocks.dat format", blocks_dat};
|
||||
|
||||
|
||||
|
|
@ -76,7 +67,6 @@ int main(int argc, char* argv[])
|
|||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_block_stop);
|
||||
command_line::add_arg(desc_cmd_sett, arg_blocks_dat);
|
||||
|
||||
|
|
@ -124,13 +114,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
m_config_folder = command_line::get_arg(vm, cryptonote::arg_data_dir);
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (command_line::has_arg(vm, arg_output_file))
|
||||
output_file_path = boost::filesystem::path(command_line::get_arg(vm, arg_output_file));
|
||||
else
|
||||
|
|
@ -153,13 +136,13 @@ int main(int argc, char* argv[])
|
|||
tx_memory_pool m_mempool(*core_storage);
|
||||
core_storage = new Blockchain(m_mempool);
|
||||
|
||||
BlockchainDB* db = new_db(db_type);
|
||||
BlockchainDB* db = new_db();
|
||||
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");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
LOG_PRINT_L0("database: " << db_type);
|
||||
LOG_PRINT_L0("database: LMDB");
|
||||
|
||||
boost::filesystem::path folder(m_config_folder);
|
||||
folder /= db->get_db_name();
|
||||
|
|
|
|||
|
|
@ -42,7 +42,6 @@
|
|||
#include "serialization/binary_utils.h" // dump_binary(), parse_binary()
|
||||
#include "serialization/json_utils.h" // dump_json()
|
||||
#include "include_base_utils.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "cryptonote_core/cryptonote_core.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -93,44 +92,6 @@ int get_db_flags_from_mode(const std::string& db_mode)
|
|||
return db_flags;
|
||||
}
|
||||
|
||||
int parse_db_arguments(const std::string& db_arg_str, std::string& db_type, int& db_flags)
|
||||
{
|
||||
std::vector<std::string> db_args;
|
||||
boost::split(db_args, db_arg_str, boost::is_any_of("#"));
|
||||
db_type = db_args.front();
|
||||
boost::algorithm::trim(db_type);
|
||||
|
||||
if (db_args.size() == 1)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
else if (db_args.size() > 2)
|
||||
{
|
||||
std::cerr << "unrecognized database argument format: " << db_arg_str << ENDL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::string db_arg_str2 = db_args[1];
|
||||
boost::split(db_args, db_arg_str2, boost::is_any_of(","));
|
||||
|
||||
// optionally use a composite mode instead of individual flags
|
||||
const std::unordered_set<std::string> db_modes {"safe", "fast", "fastest"};
|
||||
std::string db_mode;
|
||||
if (db_args.size() == 1)
|
||||
{
|
||||
if (db_modes.count(db_args[0]) > 0)
|
||||
{
|
||||
db_mode = db_args[0];
|
||||
}
|
||||
}
|
||||
if (! db_mode.empty())
|
||||
{
|
||||
db_flags = get_db_flags_from_mode(db_mode);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int pop_blocks(cryptonote::core& core, int num_blocks)
|
||||
{
|
||||
bool use_batch = opt_batch;
|
||||
|
|
@ -594,11 +555,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
uint64_t num_blocks = 0;
|
||||
uint64_t block_stop = 0;
|
||||
|
|
@ -622,9 +578,6 @@ int main(int argc, char* argv[])
|
|||
, "Count blocks in bootstrap file and exit"
|
||||
, false
|
||||
};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<bool> arg_noverify = {"dangerous-unverified-import",
|
||||
"Blindly trust the import file and use potentially malicious blocks and transactions during import (only enable if you exported the file yourself)", false};
|
||||
const command_line::arg_descriptor<bool> arg_batch = {"batch",
|
||||
|
|
@ -634,7 +587,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
command_line::add_arg(desc_cmd_sett, arg_input_file);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_batch_size);
|
||||
command_line::add_arg(desc_cmd_sett, arg_block_stop);
|
||||
|
||||
|
|
@ -709,7 +661,6 @@ int main(int argc, char* argv[])
|
|||
return 1;
|
||||
}
|
||||
m_config_folder = command_line::get_arg(vm, cryptonote::arg_data_dir);
|
||||
db_arg_str = command_line::get_arg(vm, arg_database);
|
||||
|
||||
mlog_configure(mlog_get_default_log_path("monero-blockchain-import.log"), true);
|
||||
if (!command_line::is_arg_defaulted(vm, arg_log_level))
|
||||
|
|
@ -735,25 +686,7 @@ int main(int argc, char* argv[])
|
|||
return 0;
|
||||
}
|
||||
|
||||
|
||||
std::string db_type;
|
||||
int db_flags = 0;
|
||||
int res = 0;
|
||||
res = parse_db_arguments(db_arg_str, db_type, db_flags);
|
||||
if (res)
|
||||
{
|
||||
std::cerr << "Error parsing database argument(s)" << ENDL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
MINFO("database: " << db_type);
|
||||
MINFO("database flags: " << db_flags);
|
||||
MINFO("database: LMDB");
|
||||
MINFO("verify: " << std::boolalpha << opt_verify << std::noboolalpha);
|
||||
if (opt_batch)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -35,7 +35,6 @@
|
|||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/lmdb/db_lmdb.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -441,11 +440,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
|
||||
tools::on_startup();
|
||||
|
|
@ -455,9 +449,6 @@ int main(int argc, char* argv[])
|
|||
po::options_description desc_cmd_only("Command line options");
|
||||
po::options_description desc_cmd_sett("Command line options and settings options");
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<std::string> arg_db_sync_mode = {
|
||||
"db-sync-mode"
|
||||
, "Specify sync option, using format [safe|fast|fastest]:[nrecords_per_sync]."
|
||||
|
|
@ -469,7 +460,6 @@ int main(int argc, char* argv[])
|
|||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_db_sync_mode);
|
||||
command_line::add_arg(desc_cmd_sett, arg_copy_pruned_database);
|
||||
command_line::add_arg(desc_cmd_only, command_line::arg_help);
|
||||
|
|
@ -511,18 +501,6 @@ int main(int argc, char* argv[])
|
|||
while (boost::ends_with(data_dir, "/") || boost::ends_with(data_dir, "\\"))
|
||||
data_dir.pop_back();
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
MERROR("Invalid database type: " << db_type);
|
||||
return 1;
|
||||
}
|
||||
if (db_type != "lmdb")
|
||||
{
|
||||
MERROR("Unsupported database type: " << db_type << ". Only lmdb is supported");
|
||||
return 1;
|
||||
}
|
||||
|
||||
std::string db_sync_mode = command_line::get_arg(vm, arg_db_sync_mode);
|
||||
uint64_t db_flags = 0;
|
||||
if (!parse_db_sync_mode(db_sync_mode, db_flags))
|
||||
|
|
@ -552,13 +530,12 @@ int main(int argc, char* argv[])
|
|||
{
|
||||
core_storage[n].reset(new Blockchain(m_mempool));
|
||||
|
||||
BlockchainDB* db = new_db(db_type);
|
||||
BlockchainDB* db = new_db();
|
||||
if (db == NULL)
|
||||
{
|
||||
MERROR("Attempted to use non-existent database type: " << db_type);
|
||||
throw std::runtime_error("Attempting to use non-existent database type");
|
||||
MERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
MDEBUG("database: " << db_type);
|
||||
|
||||
if (n == 1)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -33,7 +33,6 @@
|
|||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -102,11 +101,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
|
||||
tools::on_startup();
|
||||
|
|
@ -114,9 +108,6 @@ int main(int argc, char* argv[])
|
|||
po::options_description desc_cmd_only("Command line options");
|
||||
po::options_description desc_cmd_sett("Command line options and settings options");
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<bool> arg_verbose = {"verbose", "Verbose output", false};
|
||||
const command_line::arg_descriptor<bool> arg_dry_run = {"dry-run", "Do not actually prune", false};
|
||||
const command_line::arg_descriptor<std::string> arg_input = {"input", "Path to the known spent outputs file"};
|
||||
|
|
@ -125,7 +116,6 @@ int main(int argc, char* argv[])
|
|||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_verbose);
|
||||
command_line::add_arg(desc_cmd_sett, arg_dry_run);
|
||||
command_line::add_arg(desc_cmd_sett, arg_input);
|
||||
|
|
@ -167,26 +157,18 @@ int main(int argc, char* argv[])
|
|||
bool opt_verbose = command_line::get_arg(vm, arg_verbose);
|
||||
bool opt_dry_run = command_line::get_arg(vm, arg_dry_run);
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
const std::string input = command_line::get_arg(vm, arg_input);
|
||||
|
||||
LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
|
||||
std::unique_ptr<Blockchain> core_storage;
|
||||
tx_memory_pool m_mempool(*core_storage);
|
||||
core_storage.reset(new Blockchain(m_mempool));
|
||||
BlockchainDB *db = new_db(db_type);
|
||||
BlockchainDB *db = new_db();
|
||||
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");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
LOG_PRINT_L0("database: " << db_type);
|
||||
|
||||
const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
|
||||
LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@
|
|||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -52,11 +51,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
uint64_t block_start = 0;
|
||||
uint64_t block_stop = 0;
|
||||
|
|
@ -68,9 +62,6 @@ int main(int argc, char* argv[])
|
|||
po::options_description desc_cmd_only("Command line options");
|
||||
po::options_description desc_cmd_sett("Command line options and settings options");
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<uint64_t> arg_block_start = {"block-start", "start at block number", block_start};
|
||||
const command_line::arg_descriptor<uint64_t> arg_block_stop = {"block-stop", "Stop at block number", block_stop};
|
||||
const command_line::arg_descriptor<bool> arg_inputs = {"with-inputs", "with input stats", false};
|
||||
|
|
@ -82,7 +73,6 @@ int main(int argc, char* argv[])
|
|||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_block_start);
|
||||
command_line::add_arg(desc_cmd_sett, arg_block_stop);
|
||||
command_line::add_arg(desc_cmd_sett, arg_inputs);
|
||||
|
|
@ -131,24 +121,16 @@ int main(int argc, char* argv[])
|
|||
bool do_ringsize = command_line::get_arg(vm, arg_ringsize);
|
||||
bool do_hours = command_line::get_arg(vm, arg_hours);
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
LOG_PRINT_L0("Initializing source blockchain (BlockchainDB)");
|
||||
std::unique_ptr<Blockchain> core_storage;
|
||||
tx_memory_pool m_mempool(*core_storage);
|
||||
core_storage.reset(new Blockchain(m_mempool));
|
||||
BlockchainDB *db = new_db(db_type);
|
||||
BlockchainDB *db = new_db();
|
||||
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");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
LOG_PRINT_L0("database: " << db_type);
|
||||
|
||||
const std::string filename = (boost::filesystem::path(opt_data_dir) / db->get_db_name()).string();
|
||||
LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");
|
||||
|
|
|
|||
|
|
@ -34,7 +34,6 @@
|
|||
#include "cryptonote_core/cryptonote_core.h"
|
||||
#include "cryptonote_core/blockchain.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#undef MONERO_DEFAULT_LOG_CATEGORY
|
||||
|
|
@ -82,11 +81,6 @@ int main(int argc, char* argv[])
|
|||
|
||||
epee::string_tools::set_module_name_and_folder(argv[0]);
|
||||
|
||||
std::string default_db_type = "lmdb";
|
||||
|
||||
std::string available_dbs = cryptonote::blockchain_db_types(", ");
|
||||
available_dbs = "available: " + available_dbs;
|
||||
|
||||
uint32_t log_level = 0;
|
||||
|
||||
tools::on_startup();
|
||||
|
|
@ -96,16 +90,12 @@ int main(int argc, char* argv[])
|
|||
po::options_description desc_cmd_only("Command line options");
|
||||
po::options_description desc_cmd_sett("Command line options and settings options");
|
||||
const command_line::arg_descriptor<std::string> arg_log_level = {"log-level", "0-4 or categories", ""};
|
||||
const command_line::arg_descriptor<std::string> arg_database = {
|
||||
"database", available_dbs.c_str(), default_db_type
|
||||
};
|
||||
const command_line::arg_descriptor<bool> arg_rct_only = {"rct-only", "Only work on ringCT outputs", false};
|
||||
const command_line::arg_descriptor<std::string> arg_input = {"input", ""};
|
||||
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_testnet_on);
|
||||
command_line::add_arg(desc_cmd_sett, cryptonote::arg_stagenet_on);
|
||||
command_line::add_arg(desc_cmd_sett, arg_log_level);
|
||||
command_line::add_arg(desc_cmd_sett, arg_database);
|
||||
command_line::add_arg(desc_cmd_sett, arg_rct_only);
|
||||
command_line::add_arg(desc_cmd_sett, arg_input);
|
||||
command_line::add_arg(desc_cmd_only, command_line::arg_help);
|
||||
|
|
@ -147,13 +137,6 @@ int main(int argc, char* argv[])
|
|||
network_type net_type = opt_testnet ? TESTNET : opt_stagenet ? STAGENET : MAINNET;
|
||||
bool opt_rct_only = command_line::get_arg(vm, arg_rct_only);
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, arg_database);
|
||||
if (!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cerr << "Invalid database type: " << db_type << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// If we wanted to use the memory pool, we would set up a fake_core.
|
||||
|
||||
// Use Blockchain instead of lower-level BlockchainDB for two reasons:
|
||||
|
|
@ -170,13 +153,13 @@ int main(int argc, char* argv[])
|
|||
std::unique_ptr<Blockchain> core_storage;
|
||||
tx_memory_pool m_mempool(*core_storage);
|
||||
core_storage.reset(new Blockchain(m_mempool));
|
||||
BlockchainDB* db = new_db(db_type);
|
||||
BlockchainDB* db = new_db();
|
||||
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");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
throw std::runtime_error("Failed to initialize a database");
|
||||
}
|
||||
LOG_PRINT_L0("database: " << db_type);
|
||||
LOG_PRINT_L0("database: LMDB");
|
||||
|
||||
const std::string filename = input;
|
||||
LOG_PRINT_L0("Loading blockchain from folder " << filename << " ...");
|
||||
|
|
|
|||
|
|
@ -1055,7 +1055,7 @@ bool Blockchain::switch_to_alternative_blockchain(std::list<block_extended_info>
|
|||
for(auto alt_ch_iter = alt_chain.begin(); alt_ch_iter != alt_chain.end(); alt_ch_iter++)
|
||||
{
|
||||
const auto &bei = *alt_ch_iter;
|
||||
block_verification_context bvc = boost::value_initialized<block_verification_context>();
|
||||
block_verification_context bvc = {};
|
||||
|
||||
// add block to main chain
|
||||
bool r = handle_block_to_main_chain(bei.bl, bvc);
|
||||
|
|
@ -1412,7 +1412,7 @@ bool Blockchain::create_block_template(block& b, const crypto::hash *from_block,
|
|||
|
||||
//we have new block in alternative chain
|
||||
std::list<block_extended_info> alt_chain;
|
||||
block_verification_context bvc = boost::value_initialized<block_verification_context>();
|
||||
block_verification_context bvc = {};
|
||||
std::vector<uint64_t> timestamps;
|
||||
if (!build_alt_chain(*from_block, alt_chain, timestamps, bvc))
|
||||
return false;
|
||||
|
|
|
|||
|
|
@ -454,7 +454,6 @@ namespace cryptonote
|
|||
bool r = handle_command_line(vm);
|
||||
CHECK_AND_ASSERT_MES(r, false, "Failed to handle command line");
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, cryptonote::arg_db_type);
|
||||
std::string db_sync_mode = command_line::get_arg(vm, cryptonote::arg_db_sync_mode);
|
||||
bool db_salvage = command_line::get_arg(vm, cryptonote::arg_db_salvage) != 0;
|
||||
bool fast_sync = command_line::get_arg(vm, arg_fast_block_sync) != 0;
|
||||
|
|
@ -488,10 +487,10 @@ namespace cryptonote
|
|||
// folder might not be a directory, etc, etc
|
||||
catch (...) { }
|
||||
|
||||
std::unique_ptr<BlockchainDB> db(new_db(db_type));
|
||||
std::unique_ptr<BlockchainDB> db(new_db());
|
||||
if (db == NULL)
|
||||
{
|
||||
LOG_ERROR("Attempted to use non-existent database type");
|
||||
LOG_ERROR("Failed to initialize a database");
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -44,7 +44,6 @@
|
|||
#include "rpc/core_rpc_server.h"
|
||||
#include "rpc/rpc_args.h"
|
||||
#include "daemon/command_line_args.h"
|
||||
#include "blockchain_db/db_types.h"
|
||||
#include "version.h"
|
||||
|
||||
#ifdef STACK_TRACE
|
||||
|
|
@ -224,16 +223,6 @@ int main(int argc, char const * argv[])
|
|||
return 1;
|
||||
}
|
||||
|
||||
std::string db_type = command_line::get_arg(vm, cryptonote::arg_db_type);
|
||||
|
||||
// verify that blockchaindb type is valid
|
||||
if(!cryptonote::blockchain_valid_db_type(db_type))
|
||||
{
|
||||
std::cout << "Invalid database type (" << db_type << "), available types are: " <<
|
||||
cryptonote::blockchain_db_types(", ") << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// data_dir
|
||||
// default: e.g. ~/.bitmonero/ or ~/.bitmonero/testnet
|
||||
// if data-dir argument given:
|
||||
|
|
|
|||
|
|
@ -38,9 +38,6 @@
|
|||
#include "string_tools.h"
|
||||
#include "blockchain_db/blockchain_db.h"
|
||||
#include "blockchain_db/lmdb/db_lmdb.h"
|
||||
#ifdef BERKELEY_DB
|
||||
#include "blockchain_db/berkeleydb/db_bdb.h"
|
||||
#endif
|
||||
#include "cryptonote_basic/cryptonote_format_utils.h"
|
||||
|
||||
using namespace cryptonote;
|
||||
|
|
@ -233,11 +230,7 @@ protected:
|
|||
|
||||
using testing::Types;
|
||||
|
||||
typedef Types<BlockchainLMDB
|
||||
#ifdef BERKELEY_DB
|
||||
, BlockchainBDB
|
||||
#endif
|
||||
> implementations;
|
||||
typedef Types<BlockchainLMDB> implementations;
|
||||
|
||||
TYPED_TEST_CASE(BlockchainDBTest, implementations);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue