aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorNoodleDoodleNoodleDoodleNoodleDoodleNoo <NoodleDoodleNoodleDoodleNoodleDoodleNoo@users.noreply.github.com>2015-05-01 21:12:16 -0700
committerNoodleDoodleNoodleDoodleNoodleDoodleNoo <xeven77@outlook.com>2015-07-15 23:20:10 -0700
commit4b7ad2b0a7e16e53229af7644dbb6b834bfbb0e4 (patch)
treefa9f4342a45a781602b24dc2d3715abc1561a8e3 /src
parentExperimental BDB workaround optimizations (diff)
downloadmonero-4b7ad2b0a7e16e53229af7644dbb6b834bfbb0e4.tar.xz
Update db_bdb.cpp
Diffstat (limited to 'src')
-rw-r--r--src/blockchain_db/berkeleydb/db_bdb.cpp2320
1 files changed, 1166 insertions, 1154 deletions
diff --git a/src/blockchain_db/berkeleydb/db_bdb.cpp b/src/blockchain_db/berkeleydb/db_bdb.cpp
index 1f5839178..d104c2c34 100644
--- a/src/blockchain_db/berkeleydb/db_bdb.cpp
+++ b/src/blockchain_db/berkeleydb/db_bdb.cpp
@@ -1,20 +1,20 @@
// Copyright (c) 2014, 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
@@ -43,46 +43,58 @@ namespace
template <typename T>
inline void throw0(const T &e)
{
- LOG_PRINT_L0(e.what());
- throw e;
+ LOG_PRINT_L0(e.what());
+ throw e;
}
template <typename T>
inline void throw1(const T &e)
{
- LOG_PRINT_L1(e.what());
- throw e;
+ LOG_PRINT_L1(e.what());
+ throw e;
}
// cursor needs to be closed when it goes out of scope,
// this helps if the function using it throws
struct bdb_cur
{
- bdb_cur(DbTxn* txn, Db* dbi)
- {
- if (dbi->cursor(txn, &m_cur, 0))
- throw0(cryptonote::DB_ERROR("Error opening db cursor"));
- done = false;
- }
+ bdb_cur(DbTxn* txn, Db* dbi)
+ {
+ if (dbi->cursor(txn, &m_cur, 0))
+ throw0(cryptonote::DB_ERROR("Error opening db cursor"));
+ done = false;
+ }
- ~bdb_cur() { close(); }
+ ~bdb_cur()
+ {
+ close();
+ }
- operator Dbc*() { return m_cur; }
- operator Dbc**() { return &m_cur; }
- Dbc* operator->() { return m_cur; }
+ operator Dbc*()
+ {
+ return m_cur;
+ }
+ operator Dbc**()
+ {
+ return &m_cur;
+ }
+ Dbc* operator->()
+ {
+ return m_cur;
+ }
- void close()
- {
- if (!done)
+ void close()
{
- m_cur->close();
- done = true;
+ if (!done)
+ {
+ m_cur->close();
+ done = true;
+ }
}
- }
private:
- Dbc* m_cur;
- bool done;
+ Dbc* m_cur;
+ bool done;
};
const char* const BDB_BLOCKS = "blocks";
@@ -105,67 +117,67 @@ const char* const BDB_OUTPUT_KEYS = "output_keys";
const char* const BDB_SPENT_KEYS = "spent_keys";
-const int BUFFER_LENGTH = 32 * 1024 * 1024;
+const int BUFFER_LENGTH = 4 * 1024 * 1024;
template<typename T>
struct Dbt_copy: public Dbt
{
- Dbt_copy(const T &t): t_copy(t)
- {
- init();
- }
-
- Dbt_copy()
- {
- init();
- }
-
- void init()
- {
- set_data(&t_copy);
- set_size(sizeof(T));
- set_ulen(sizeof(T));
- set_flags(DB_DBT_USERMEM);
- }
-
- operator T()
- {
- return t_copy;
- }
+ Dbt_copy(const T &t): t_copy(t)
+ {
+ init();
+ }
+
+ Dbt_copy()
+ {
+ init();
+ }
+
+ void init()
+ {
+ set_data(&t_copy);
+ set_size(sizeof(T));
+ set_ulen(sizeof(T));
+ set_flags(DB_DBT_USERMEM);
+ }
+
+ operator T()
+ {
+ return t_copy;
+ }
private:
- T t_copy;
+ T t_copy;
};
template<>
struct Dbt_copy<cryptonote::blobdata>: public Dbt
{
- Dbt_copy(const cryptonote::blobdata &bd) : m_data(new char[bd.size()])
- {
- memcpy(m_data.get(), bd.data(), bd.size());
- set_data(m_data.get());
- set_size(bd.size());
- set_ulen(bd.size());
- set_flags(DB_DBT_USERMEM);
- }
+ Dbt_copy(const cryptonote::blobdata &bd) : m_data(new char[bd.size()])
+ {
+ memcpy(m_data.get(), bd.data(), bd.size());
+ set_data(m_data.get());
+ set_size(bd.size());
+ set_ulen(bd.size());
+ set_flags(DB_DBT_USERMEM);
+ }
private:
- std::unique_ptr<char[]> m_data;
+ std::unique_ptr<char[]> m_data;
};
struct Dbt_safe : public Dbt
{
- Dbt_safe()
- {
- set_data(NULL);
- set_flags(DB_DBT_MALLOC);
- }
- ~Dbt_safe()
- {
- void* buf = get_data();
- if (buf != NULL)
+ Dbt_safe()
+ {
+ set_data(NULL);
+ set_flags(DB_DBT_MALLOC);
+ }
+ ~Dbt_safe()
{
- free(buf);
+ void* buf = get_data();
+ if (buf != NULL)
+ {
+ free(buf);
+ }
}
- }
};
} // anonymous namespace
@@ -174,1236 +186,1236 @@ namespace cryptonote
{
void BlockchainBDB::add_block( const block& blk
- , const size_t& block_size
- , const difficulty_type& cumulative_difficulty
- , const uint64_t& coins_generated
- , const crypto::hash& blk_hash
- )
-{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
-
- Dbt_copy<crypto::hash> val_h(blk_hash);
- if (m_block_heights->exists(*m_write_txn, &val_h, 0) == 0)
- throw1(BLOCK_EXISTS("Attempting to add block that's already in the db"));
-
- if (m_height > 0)
- {
- Dbt_copy<crypto::hash> parent_key(blk.prev_id);
- Dbt_copy<uint32_t> parent_h;
- if (m_block_heights->get(*m_write_txn, &parent_key, &parent_h, 0))
+ , const size_t& block_size
+ , const difficulty_type& cumulative_difficulty
+ , const uint64_t& coins_generated
+ , const crypto::hash& blk_hash
+ )
+{
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+
+ Dbt_copy<crypto::hash> val_h(blk_hash);
+ if (m_block_heights->exists(*m_write_txn, &val_h, 0) == 0)
+ throw1(BLOCK_EXISTS("Attempting to add block that's already in the db"));
+
+ if (m_height > 0)
{
- LOG_PRINT_L3("m_height: " << m_height);
- LOG_PRINT_L3("parent_key: " << blk.prev_id);
- throw0(DB_ERROR("Failed to get top block hash to check for new block's parent"));
+ Dbt_copy<crypto::hash> parent_key(blk.prev_id);
+ Dbt_copy<uint32_t> parent_h;
+ if (m_block_heights->get(*m_write_txn, &parent_key, &parent_h, 0))
+ {
+ LOG_PRINT_L3("m_height: " << m_height);
+ LOG_PRINT_L3("parent_key: " << blk.prev_id);
+ throw0(DB_ERROR("Failed to get top block hash to check for new block's parent"));
+ }
+ uint32_t parent_height = parent_h;
+ if (parent_height != m_height)
+ throw0(BLOCK_PARENT_DNE("Top block is not new block's parent"));
}
- uint32_t parent_height = parent_h;
- if (parent_height != m_height)
- throw0(BLOCK_PARENT_DNE("Top block is not new block's parent"));
- }
- Dbt_copy<uint32_t> key(m_height + 1);
+ Dbt_copy<uint32_t> key(m_height + 1);
- Dbt_copy<blobdata> blob(block_to_blob(blk));
- auto res = m_blocks->put(*m_write_txn, &key, &blob, 0);
- if (res)
- throw0(DB_ERROR("Failed to add block blob to db transaction."));
+ Dbt_copy<blobdata> blob(block_to_blob(blk));
+ auto res = m_blocks->put(*m_write_txn, &key, &blob, 0);
+ if (res)
+ throw0(DB_ERROR("Failed to add block blob to db transaction."));
- Dbt_copy<size_t> sz(block_size);
- if (m_block_sizes->put(*m_write_txn, &key, &sz, 0))
- throw0(DB_ERROR("Failed to add block size to db transaction."));
+ Dbt_copy<size_t> sz(block_size);
+ if (m_block_sizes->put(*m_write_txn, &key, &sz, 0))
+ throw0(DB_ERROR("Failed to add block size to db transaction."));
- Dbt_copy<uint64_t> ts(blk.timestamp);
- if (m_block_timestamps->put(*m_write_txn, &key, &ts, 0))
- throw0(DB_ERROR("Failed to add block timestamp to db transaction."));
+ Dbt_copy<uint64_t> ts(blk.timestamp);
+ if (m_block_timestamps->put(*m_write_txn, &key, &ts, 0))
+ throw0(DB_ERROR("Failed to add block timestamp to db transaction."));
- Dbt_copy<difficulty_type> diff(cumulative_difficulty);
- if (m_block_diffs->put(*m_write_txn, &key, &diff, 0))
- throw0(DB_ERROR("Failed to add block cumulative difficulty to db transaction."));
+ Dbt_copy<difficulty_type> diff(cumulative_difficulty);
+ if (m_block_diffs->put(*m_write_txn, &key, &diff, 0))
+ throw0(DB_ERROR("Failed to add block cumulative difficulty to db transaction."));
- Dbt_copy<uint64_t> coinsgen(coins_generated);
- if (m_block_coins->put(*m_write_txn, &key, &coinsgen, 0))
- throw0(DB_ERROR("Failed to add block total generated coins to db transaction."));
+ Dbt_copy<uint64_t> coinsgen(coins_generated);
+ if (m_block_coins->put(*m_write_txn, &key, &coinsgen, 0))
+ throw0(DB_ERROR("Failed to add block total generated coins to db transaction."));
- if (m_block_heights->put(*m_write_txn, &val_h, &key, 0))
- throw0(DB_ERROR("Failed to add block height by hash to db transaction."));
+ if (m_block_heights->put(*m_write_txn, &val_h, &key, 0))
+ throw0(DB_ERROR("Failed to add block height by hash to db transaction."));
- if (m_block_hashes->put(*m_write_txn, &key, &val_h, 0))
- throw0(DB_ERROR("Failed to add block hash to db transaction."));
+ if (m_block_hashes->put(*m_write_txn, &key, &val_h, 0))
+ throw0(DB_ERROR("Failed to add block hash to db transaction."));
}
void BlockchainBDB::remove_block()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- if (m_height == 0)
- throw0(BLOCK_DNE ("Attempting to remove block from an empty blockchain"));
+ if (m_height == 0)
+ throw0(BLOCK_DNE ("Attempting to remove block from an empty blockchain"));
- Dbt_copy<uint32_t> k(m_height);
- Dbt_copy<crypto::hash> h;
- if (m_block_hashes->get(*m_write_txn, &k, &h, 0))
- throw1(BLOCK_DNE("Attempting to remove block that's not in the db"));
+ Dbt_copy<uint32_t> k(m_height);
+ Dbt_copy<crypto::hash> h;
+ if (m_block_hashes->get(*m_write_txn, &k, &h, 0))
+ throw1(BLOCK_DNE("Attempting to remove block that's not in the db"));
- if (m_blocks->del(*m_write_txn, &k, 0))
- throw1(DB_ERROR("Failed to add removal of block to db transaction"));
+ if (m_blocks->del(*m_write_txn, &k, 0))
+ throw1(DB_ERROR("Failed to add removal of block to db transaction"));
- if (m_block_sizes->del(*m_write_txn, &k, 0))
- throw1(DB_ERROR("Failed to add removal of block size to db transaction"));
+ if (m_block_sizes->del(*m_write_txn, &k, 0))
+ throw1(DB_ERROR("Failed to add removal of block size to db transaction"));
- if (m_block_diffs->del(*m_write_txn, &k, 0))
- throw1(DB_ERROR("Failed to add removal of block cumulative difficulty to db transaction"));
+ if (m_block_diffs->del(*m_write_txn, &k, 0))
+ throw1(DB_ERROR("Failed to add removal of block cumulative difficulty to db transaction"));
- if (m_block_coins->del(*m_write_txn, &k, 0))
- throw1(DB_ERROR("Failed to add removal of block total generated coins to db transaction"));
+ if (m_block_coins->del(*m_write_txn, &k, 0))
+ throw1(DB_ERROR("Failed to add removal of block total generated coins to db transaction"));
- if (m_block_timestamps->del(*m_write_txn, &k, 0))
- throw1(DB_ERROR("Failed to add removal of block timestamp to db transaction"));
+ if (m_block_timestamps->del(*m_write_txn, &k, 0))
+ throw1(DB_ERROR("Failed to add removal of block timestamp to db transaction"));
- if (m_block_heights->del(*m_write_txn, &h, 0))
- throw1(DB_ERROR("Failed to add removal of block height by hash to db transaction"));
+ if (m_block_heights->del(*m_write_txn, &h, 0))
+ throw1(DB_ERROR("Failed to add removal of block height by hash to db transaction"));
- if (m_block_hashes->del(*m_write_txn, &k, 0))
- throw1(DB_ERROR("Failed to add removal of block hash to db transaction"));
+ if (m_block_hashes->del(*m_write_txn, &k, 0))
+ throw1(DB_ERROR("Failed to add removal of block hash to db transaction"));
}
void BlockchainBDB::add_transaction_data(const crypto::hash& blk_hash, const transaction& tx, const crypto::hash& tx_hash)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- Dbt_copy<crypto::hash> val_h(tx_hash);
+ Dbt_copy<crypto::hash> val_h(tx_hash);
- if (m_txs->exists(*m_write_txn, &val_h, 0) == 0)
- throw1(TX_EXISTS("Attempting to add transaction that's already in the db"));
+ if (m_txs->exists(*m_write_txn, &val_h, 0) == 0)
+ throw1(TX_EXISTS("Attempting to add transaction that's already in the db"));
- Dbt_copy<blobdata> blob(tx_to_blob(tx));
- if (m_txs->put(*m_write_txn, &val_h, &blob, 0))
- throw0(DB_ERROR("Failed to add tx blob to db transaction"));
+ Dbt_copy<blobdata> blob(tx_to_blob(tx));
+ if (m_txs->put(*m_write_txn, &val_h, &blob, 0))
+ throw0(DB_ERROR("Failed to add tx blob to db transaction"));
- Dbt_copy<uint64_t> height(m_height + 1);
- if (m_tx_heights->put(*m_write_txn, &val_h, &height, 0))
- throw0(DB_ERROR("Failed to add tx block height to db transaction"));
+ Dbt_copy<uint64_t> height(m_height + 1);
+ if (m_tx_heights->put(*m_write_txn, &val_h, &height, 0))
+ throw0(DB_ERROR("Failed to add tx block height to db transaction"));
- Dbt_copy<uint64_t> unlock_time(tx.unlock_time);
- if (m_tx_unlocks->put(*m_write_txn, &val_h, &unlock_time, 0))
- throw0(DB_ERROR("Failed to add tx unlock time to db transaction"));
+ Dbt_copy<uint64_t> unlock_time(tx.unlock_time);
+ if (m_tx_unlocks->put(*m_write_txn, &val_h, &unlock_time, 0))
+ throw0(DB_ERROR("Failed to add tx unlock time to db transaction"));
}
void BlockchainBDB::remove_transaction_data(const crypto::hash& tx_hash, const transaction& tx)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- Dbt_copy<crypto::hash> val_h(tx_hash);
- if (m_txs->exists(*m_write_txn, &val_h, 0))
- throw1(TX_DNE("Attempting to remove transaction that isn't in the db"));
+ Dbt_copy<crypto::hash> val_h(tx_hash);
+ if (m_txs->exists(*m_write_txn, &val_h, 0))
+ throw1(TX_DNE("Attempting to remove transaction that isn't in the db"));
- if (m_txs->del(*m_write_txn, &val_h, 0))
- throw1(DB_ERROR("Failed to add removal of tx to db transaction"));
- if (m_tx_unlocks->del(*m_write_txn, &val_h, 0))
- throw1(DB_ERROR("Failed to add removal of tx unlock time to db transaction"));
- if (m_tx_heights->del(*m_write_txn, &val_h, 0))
- throw1(DB_ERROR("Failed to add removal of tx block height to db transaction"));
+ if (m_txs->del(*m_write_txn, &val_h, 0))
+ throw1(DB_ERROR("Failed to add removal of tx to db transaction"));
+ if (m_tx_unlocks->del(*m_write_txn, &val_h, 0))
+ throw1(DB_ERROR("Failed to add removal of tx unlock time to db transaction"));
+ if (m_tx_heights->del(*m_write_txn, &val_h, 0))
+ throw1(DB_ERROR("Failed to add removal of tx block height to db transaction"));
- remove_tx_outputs(tx_hash, tx);
+ remove_tx_outputs(tx_hash, tx);
- if (m_tx_outputs->del(*m_write_txn, &val_h, 0))
- throw1(DB_ERROR("Failed to add removal of tx outputs to db transaction"));
+ if (m_tx_outputs->del(*m_write_txn, &val_h, 0))
+ throw1(DB_ERROR("Failed to add removal of tx outputs to db transaction"));
}
void BlockchainBDB::add_output(const crypto::hash& tx_hash, const tx_out& tx_output, const uint64_t& local_index)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- Dbt_copy<uint32_t> k(m_num_outputs + 1);
- Dbt_copy<crypto::hash> v(tx_hash);
+ Dbt_copy<uint32_t> k(m_num_outputs + 1);
+ Dbt_copy<crypto::hash> v(tx_hash);
- if (m_output_txs->put(*m_write_txn, &k, &v, 0))
- throw0(DB_ERROR("Failed to add output tx hash to db transaction"));
- if (m_tx_outputs->put(*m_write_txn, &v, &k, 0))
- throw0(DB_ERROR("Failed to add tx output index to db transaction"));
+ if (m_output_txs->put(*m_write_txn, &k, &v, 0))
+ throw0(DB_ERROR("Failed to add output tx hash to db transaction"));
+ if (m_tx_outputs->put(*m_write_txn, &v, &k, 0))
+ throw0(DB_ERROR("Failed to add tx output index to db transaction"));
- Dbt_copy<uint64_t> val_local_index(local_index);
- if (m_output_indices->put(*m_write_txn, &k, &val_local_index, 0))
- throw0(DB_ERROR("Failed to add tx output index to db transaction"));
+ Dbt_copy<uint64_t> val_local_index(local_index);
+ if (m_output_indices->put(*m_write_txn, &k, &val_local_index, 0))
+ throw0(DB_ERROR("Failed to add tx output index to db transaction"));
- Dbt_copy<uint64_t> val_amount(tx_output.amount);
- if (m_output_amounts->put(*m_write_txn, &val_amount, &k, 0))
- throw0(DB_ERROR("Failed to add output amount to db transaction."));
+ Dbt_copy<uint64_t> val_amount(tx_output.amount);
+ if (m_output_amounts->put(*m_write_txn, &val_amount, &k, 0))
+ throw0(DB_ERROR("Failed to add output amount to db transaction."));
- if (tx_output.target.type() == typeid(txout_to_key))
- {
- Dbt_copy<crypto::public_key> val_pubkey(boost::get<txout_to_key>(tx_output.target).key);
- if (m_output_keys->put(*m_write_txn, &k, &val_pubkey, 0))
- throw0(DB_ERROR("Failed to add output pubkey to db transaction"));
- }
+ if (tx_output.target.type() == typeid(txout_to_key))
+ {
+ Dbt_copy<crypto::public_key> val_pubkey(boost::get<txout_to_key>(tx_output.target).key);
+ if (m_output_keys->put(*m_write_txn, &k, &val_pubkey, 0))
+ throw0(DB_ERROR("Failed to add output pubkey to db transaction"));
+ }
- m_num_outputs++;
+ m_num_outputs++;
}
void BlockchainBDB::remove_tx_outputs(const crypto::hash& tx_hash, const transaction& tx)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
-
- bdb_cur cur(*m_write_txn, m_tx_outputs);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
- Dbt_copy<crypto::hash> k(tx_hash);
- Dbt_copy<uint32_t> v;
+ bdb_cur cur(*m_write_txn, m_tx_outputs);
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- {
- throw0(DB_ERROR("Attempting to remove a tx's outputs, but none found."));
- }
- else if (result)
- {
- throw0(DB_ERROR("DB error attempting to get an output"));
- }
- else
- {
- db_recno_t num_elems = 0;
- cur->count(&num_elems, 0);
+ Dbt_copy<crypto::hash> k(tx_hash);
+ Dbt_copy<uint32_t> v;
- for (uint64_t i = 0; i < num_elems; ++i)
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
{
- const tx_out tx_output = tx.vout[i];
- remove_output(v, tx_output.amount);
- if (i < num_elems - 1)
- {
- cur->get(&k, &v, DB_NEXT_DUP);
- }
+ throw0(DB_ERROR("Attempting to remove a tx's outputs, but none found."));
+ }
+ else if (result)
+ {
+ throw0(DB_ERROR("DB error attempting to get an output"));
+ }
+ else
+ {
+ db_recno_t num_elems = 0;
+ cur->count(&num_elems, 0);
+
+ for (uint64_t i = 0; i < num_elems; ++i)
+ {
+ const tx_out tx_output = tx.vout[i];
+ remove_output(v, tx_output.amount);
+ if (i < num_elems - 1)
+ {
+ cur->get(&k, &v, DB_NEXT_DUP);
+ }
+ }
}
- }
- cur.close();
+ cur.close();
}
// TODO: probably remove this function
void BlockchainBDB::remove_output(const tx_out& tx_output)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__ << " (unused version - does nothing)");
- return;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__ << " (unused version - does nothing)");
+ return;
}
void BlockchainBDB::remove_output(const uint64_t& out_index, const uint64_t amount)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
-
- Dbt_copy<uint32_t> k(out_index);
-
- auto result = m_output_indices->del(*m_write_txn, &k, 0);
- if (result == DB_NOTFOUND)
- {
- LOG_PRINT_L0("Unexpected: global output index not found in m_output_indices");
- }
- else if (result)
- {
- throw1(DB_ERROR("Error adding removal of output tx index to db transaction"));
- }
-
- result = m_output_txs->del(*m_write_txn, &k, 0);
- // if (result != 0 && result != DB_NOTFOUND)
- // throw1(DB_ERROR("Error adding removal of output tx hash to db transaction"));
- if (result == DB_NOTFOUND)
- {
- LOG_PRINT_L0("Unexpected: global output index not found in m_output_txs");
- }
- else if (result)
- {
- throw1(DB_ERROR("Error adding removal of output tx hash to db transaction"));
- }
-
- result = m_output_keys->del(*m_write_txn, &k, 0);
- if (result == DB_NOTFOUND)
- {
- LOG_PRINT_L0("Unexpected: global output index not found in m_output_keys");
- }
- else if (result)
- throw1(DB_ERROR("Error adding removal of output pubkey to db transaction"));
-
- remove_amount_output_index(amount, out_index);
-
- m_num_outputs--;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+
+ Dbt_copy<uint32_t> k(out_index);
+
+ auto result = m_output_indices->del(*m_write_txn, &k, 0);
+ if (result == DB_NOTFOUND)
+ {
+ LOG_PRINT_L0("Unexpected: global output index not found in m_output_indices");
+ }
+ else if (result)
+ {
+ throw1(DB_ERROR("Error adding removal of output tx index to db transaction"));
+ }
+
+ result = m_output_txs->del(*m_write_txn, &k, 0);
+ // if (result != 0 && result != DB_NOTFOUND)
+ // throw1(DB_ERROR("Error adding removal of output tx hash to db transaction"));
+ if (result == DB_NOTFOUND)
+ {
+ LOG_PRINT_L0("Unexpected: global output index not found in m_output_txs");
+ }
+ else if (result)
+ {
+ throw1(DB_ERROR("Error adding removal of output tx hash to db transaction"));
+ }
+
+ result = m_output_keys->del(*m_write_txn, &k, 0);
+ if (result == DB_NOTFOUND)
+ {
+ LOG_PRINT_L0("Unexpected: global output index not found in m_output_keys");
+ }
+ else if (result)
+ throw1(DB_ERROR("Error adding removal of output pubkey to db transaction"));
+
+ remove_amount_output_index(amount, out_index);
+
+ m_num_outputs--;
}
void BlockchainBDB::remove_amount_output_index(const uint64_t amount, const uint64_t global_output_index)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_cur cur(*m_write_txn, m_output_amounts);
+ bdb_cur cur(*m_write_txn, m_output_amounts);
- Dbt_copy<uint64_t> k(amount);
- Dbt_copy<uint32_t> v;
-
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
- else if (result)
- throw0(DB_ERROR("DB error attempting to get an output"));
-
- db_recno_t num_elems = 0;
- cur->count(&num_elems, 0);
-
- uint64_t amount_output_index = 0;
- uint64_t goi = 0;
- bool found_index = false;
- for (uint64_t i = 0; i < num_elems; ++i)
- {
- goi = v;
- if (goi == global_output_index)
+ Dbt_copy<uint64_t> k(amount);
+ Dbt_copy<uint32_t> v;
+
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
+ throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
+ else if (result)
+ throw0(DB_ERROR("DB error attempting to get an output"));
+
+ db_recno_t num_elems = 0;
+ cur->count(&num_elems, 0);
+
+ uint64_t amount_output_index = 0;
+ uint64_t goi = 0;
+ bool found_index = false;
+ for (uint64_t i = 0; i < num_elems; ++i)
+ {
+ goi = v;
+ if (goi == global_output_index)
+ {
+ amount_output_index = i;
+ found_index = true;
+ break;
+ }
+ cur->get(&k, &v, DB_NEXT_DUP);
+ }
+ if (found_index)
+ {
+ // found the amount output index
+ // now delete it
+ result = cur->del(0);
+ if (result)
+ throw0(DB_ERROR(std::string("Error deleting amount output index ").append(boost::lexical_cast<std::string>(amount_output_index)).c_str()));
+ }
+ else
{
- amount_output_index = i;
- found_index = true;
- break;
+ // not found
+ throw1(OUTPUT_DNE("Failed to find amount output index"));
}
- cur->get(&k, &v, DB_NEXT_DUP);
- }
- if (found_index)
- {
- // found the amount output index
- // now delete it
- result = cur->del(0);
- if (result)
- throw0(DB_ERROR(std::string("Error deleting amount output index ").append(boost::lexical_cast<std::string>(amount_output_index)).c_str()));
- }
- else
- {
- // not found
- throw1(OUTPUT_DNE("Failed to find amount output index"));
- }
- cur.close();
+ cur.close();
}
void BlockchainBDB::add_spent_key(const crypto::key_image& k_image)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- Dbt_copy<crypto::key_image> val_key(k_image);
- if (m_spent_keys->exists(*m_write_txn, &val_key, 0) == 0)
- throw1(KEY_IMAGE_EXISTS("Attempting to add spent key image that's already in the db"));
+ Dbt_copy<crypto::key_image> val_key(k_image);
+ if (m_spent_keys->exists(*m_write_txn, &val_key, 0) == 0)
+ throw1(KEY_IMAGE_EXISTS("Attempting to add spent key image that's already in the db"));
- Dbt_copy<char> val('\0');
- if (m_spent_keys->put(*m_write_txn, &val_key, &val, 0))
- throw1(DB_ERROR("Error adding spent key image to db transaction."));
+ Dbt_copy<char> val('\0');
+ if (m_spent_keys->put(*m_write_txn, &val_key, &val, 0))
+ throw1(DB_ERROR("Error adding spent key image to db transaction."));
}
void BlockchainBDB::remove_spent_key(const crypto::key_image& k_image)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- Dbt_copy<crypto::key_image> k(k_image);
- auto result = m_spent_keys->del(*m_write_txn, &k, 0);
- if (result != 0 && result != DB_NOTFOUND)
- throw1(DB_ERROR("Error adding removal of key image to db transaction"));
+ Dbt_copy<crypto::key_image> k(k_image);
+ auto result = m_spent_keys->del(*m_write_txn, &k, 0);
+ if (result != 0 && result != DB_NOTFOUND)
+ throw1(DB_ERROR("Error adding removal of key image to db transaction"));
}
blobdata BlockchainBDB::output_to_blob(const tx_out& output) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- blobdata b;
- if (!t_serializable_object_to_blob(output, b))
- throw1(DB_ERROR("Error serializing output to blob"));
- return b;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ blobdata b;
+ if (!t_serializable_object_to_blob(output, b))
+ throw1(DB_ERROR("Error serializing output to blob"));
+ return b;
}
tx_out BlockchainBDB::output_from_blob(const blobdata& blob) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- std::stringstream ss;
- ss << blob;
- binary_archive<false> ba(ss);
- tx_out o;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ std::stringstream ss;
+ ss << blob;
+ binary_archive<false> ba(ss);
+ tx_out o;
- if (!(::serialization::serialize(ba, o)))
- throw1(DB_ERROR("Error deserializing tx output blob"));
+ if (!(::serialization::serialize(ba, o)))
+ throw1(DB_ERROR("Error deserializing tx output blob"));
- return o;
+ return o;
}
uint64_t BlockchainBDB::get_output_global_index(const uint64_t& amount, const uint64_t& index) const
{
- LOG_PRINT_L3("BlockchainLMDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- bdb_cur cur(txn, m_output_amounts);
+ bdb_cur cur(txn, m_output_amounts);
- Dbt_copy<uint64_t> k(amount);
- Dbt_copy<uint32_t> v;
+ Dbt_copy<uint64_t> k(amount);
+ Dbt_copy<uint32_t> v;
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
- else if (result)
- throw0(DB_ERROR("DB error attempting to get an output"));
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
+ throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
+ else if (result)
+ throw0(DB_ERROR("DB error attempting to get an output"));
- db_recno_t num_elems;
- cur->count(&num_elems, 0);
+ db_recno_t num_elems;
+ cur->count(&num_elems, 0);
- if (num_elems <= index)
- throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but output not found"));
+ if (num_elems <= index)
+ throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but output not found"));
- for (uint64_t i = 0; i < index; ++i)
- {
- cur->get(&k, &v, DB_NEXT_DUP);
- }
+ for (uint64_t i = 0; i < index; ++i)
+ {
+ cur->get(&k, &v, DB_NEXT_DUP);
+ }
- uint64_t glob_index = v;
+ uint64_t glob_index = v;
- cur.close();
+ cur.close();
- txn.commit();
+ txn.commit();
- return glob_index;
+ return glob_index;
}
void BlockchainBDB::check_open() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- if (!m_open)
- throw0(DB_ERROR("DB operation attempted on a not-open DB instance"));
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ if (!m_open)
+ throw0(DB_ERROR("DB operation attempted on a not-open DB instance"));
}
BlockchainBDB::~BlockchainBDB()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
if(m_buffer != NULL)
free(m_buffer);
m_buffer = NULL;
- if (m_open)
- {
- close();
- }
+ if (m_open)
+ {
+ close();
+ }
}
BlockchainBDB::BlockchainBDB(bool batch_transactions)
{
m_buffer = malloc(BUFFER_LENGTH);
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- // initialize folder to something "safe" just in case
- // someone accidentally misuses this class...
- m_folder = "thishsouldnotexistbecauseitisgibberish";
- m_open = false;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ // initialize folder to something "safe" just in case
+ // someone accidentally misuses this class...
+ m_folder = "thishsouldnotexistbecauseitisgibberish";
+ m_open = false;
- m_batch_transactions = batch_transactions;
- m_write_txn = nullptr;
- m_height = 0;
+ m_batch_transactions = batch_transactions;
+ m_write_txn = nullptr;
+ m_height = 0;
}
void BlockchainBDB::open(const std::string& filename, const int db_flags)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
-
- if (m_open)
- throw0(DB_OPEN_FAILURE("Attempted to open db, but it's already open"));
-
- boost::filesystem::path direc(filename);
- if (boost::filesystem::exists(direc))
- {
- if (!boost::filesystem::is_directory(direc))
- throw0(DB_OPEN_FAILURE("DB needs a directory path, but a file was passed"));
- }
- else
- {
- if (!boost::filesystem::create_directory(direc))
- throw0(DB_OPEN_FAILURE(std::string("Failed to create directory ").append(filename).c_str()));
- }
-
- m_folder = filename;
-
- try
- {
-
- //Create BerkeleyDB environment
- m_env = new DbEnv(0); // no flags needed for DbEnv
-
- uint32_t db_env_open_flags = DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK
- | DB_INIT_LOG | DB_INIT_TXN | DB_RECOVER
- | DB_THREAD;
-
- // last parameter left 0, files will be created with default rw access
- m_env->open(filename.c_str(), db_env_open_flags, 0);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
- // begin transaction to init dbs
- bdb_txn_safe txn;
- m_env->txn_begin(NULL, txn, 0);
-
- // create Dbs in the environment
- m_blocks = new Db(m_env, 0);
- m_block_heights = new Db(m_env, 0);
- m_block_hashes = new Db(m_env, 0);
- m_block_timestamps = new Db(m_env, 0);
- m_block_sizes = new Db(m_env, 0);
- m_block_diffs = new Db(m_env, 0);
- m_block_coins = new Db(m_env, 0);
-
- m_txs = new Db(m_env, 0);
- m_tx_unlocks = new Db(m_env, 0);
- m_tx_heights = new Db(m_env, 0);
- m_tx_outputs = new Db(m_env, 0);
-
- m_output_txs = new Db(m_env, 0);
- m_output_indices = new Db(m_env, 0);
- m_output_amounts = new Db(m_env, 0);
- m_output_keys = new Db(m_env, 0);
-
- m_spent_keys = new Db(m_env, 0);
-
- // Tell DB about Dbs that need duplicate support
- // Note: no need to tell about sorting,
- // as the default is insertion order, which we want
- m_tx_outputs->set_flags(DB_DUP);
- m_output_amounts->set_flags(DB_DUP);
-
- // Tell DB about fixed-size values.
- m_block_hashes->set_re_len(sizeof(crypto::hash));
- m_block_timestamps->set_re_len(sizeof(uint64_t));
- m_block_sizes->set_re_len(sizeof(size_t)); // should really store block size as uint64_t...
- m_block_diffs->set_re_len(sizeof(difficulty_type));
- m_block_coins->set_re_len(sizeof(uint64_t));
-
- m_output_txs->set_re_len(sizeof(crypto::hash));
- m_output_indices->set_re_len(sizeof(uint64_t));
- m_output_keys->set_re_len(sizeof(crypto::public_key));
-
- //TODO: Find out if we need to do Db::set_flags(DB_RENUMBER)
- // for the RECNO databases. We shouldn't as we're only
- // inserting/removing from the end, but we'll see.
-
- // open Dbs in the environment
- // m_tx_outputs and m_output_amounts must be DB_HASH or DB_BTREE
- // because they need duplicate entry support. The rest are DB_RECNO,
- // as it seems that will be the most performant choice.
- m_blocks->open(txn, BDB_BLOCKS, NULL, DB_RECNO, DB_CREATE, 0);
-
- m_block_timestamps->open(txn, BDB_BLOCK_TIMESTAMPS, NULL, DB_RECNO, DB_CREATE, 0);
- m_block_heights->open(txn, BDB_BLOCK_HEIGHTS, NULL, DB_HASH, DB_CREATE, 0);
- m_block_hashes->open(txn, BDB_BLOCK_HASHES, NULL, DB_RECNO, DB_CREATE, 0);
- m_block_sizes->open(txn, BDB_BLOCK_SIZES, NULL, DB_RECNO, DB_CREATE, 0);
- m_block_diffs->open(txn, BDB_BLOCK_DIFFS, NULL, DB_RECNO, DB_CREATE, 0);
- m_block_coins->open(txn, BDB_BLOCK_COINS, NULL, DB_RECNO, DB_CREATE, 0);
-
- m_txs->open(txn, BDB_TXS, NULL, DB_HASH, DB_CREATE, 0);
- m_tx_unlocks->open(txn, BDB_TX_UNLOCKS, NULL, DB_HASH, DB_CREATE, 0);
- m_tx_heights->open(txn, BDB_TX_HEIGHTS, NULL, DB_HASH, DB_CREATE, 0);
- m_tx_outputs->open(txn, BDB_TX_OUTPUTS, NULL, DB_HASH, DB_CREATE, 0);
-
- m_output_txs->open(txn, BDB_OUTPUT_TXS, NULL, DB_RECNO, DB_CREATE, 0);
- m_output_indices->open(txn, BDB_OUTPUT_INDICES, NULL, DB_RECNO, DB_CREATE, 0);
- m_output_amounts->open(txn, BDB_OUTPUT_AMOUNTS, NULL, DB_HASH, DB_CREATE, 0);
- m_output_keys->open(txn, BDB_OUTPUT_KEYS, NULL, DB_RECNO, DB_CREATE, 0);
-
- m_spent_keys->open(txn, BDB_SPENT_KEYS, NULL, DB_HASH, DB_CREATE, 0);
+ if (m_open)
+ throw0(DB_OPEN_FAILURE("Attempted to open db, but it's already open"));
- DB_BTREE_STAT* stats;
+ boost::filesystem::path direc(filename);
+ if (boost::filesystem::exists(direc))
+ {
+ if (!boost::filesystem::is_directory(direc))
+ throw0(DB_OPEN_FAILURE("DB needs a directory path, but a file was passed"));
+ }
+ else
+ {
+ if (!boost::filesystem::create_directory(direc))
+ throw0(DB_OPEN_FAILURE(std::string("Failed to create directory ").append(filename).c_str()));
+ }
- // DB_FAST_STAT can apparently cause an incorrect number of records
- // to be returned. The flag should be set to 0 instead if this proves
- // to be the case.
- m_blocks->stat(txn, &stats, DB_FAST_STAT);
- m_height = stats->bt_nkeys;
- delete stats;
+ m_folder = filename;
- // see above comment about DB_FAST_STAT
- m_output_indices->stat(txn, &stats, DB_FAST_STAT);
- m_num_outputs = stats->bt_nkeys;
- delete stats;
+ try
+ {
- txn.commit();
- }
- catch (const std::exception& e)
- {
- throw0(DB_OPEN_FAILURE(e.what()));
- }
+ //Create BerkeleyDB environment
+ m_env = new DbEnv(0); // no flags needed for DbEnv
+
+ uint32_t db_env_open_flags = DB_CREATE | DB_INIT_MPOOL | DB_INIT_LOCK
+ | DB_INIT_LOG | DB_INIT_TXN | DB_RECOVER
+ | DB_THREAD;
+
+ // last parameter left 0, files will be created with default rw access
+ m_env->open(filename.c_str(), db_env_open_flags, 0);
+
+ // begin transaction to init dbs
+ bdb_txn_safe txn;
+ m_env->txn_begin(NULL, txn, 0);
+
+ // create Dbs in the environment
+ m_blocks = new Db(m_env, 0);
+ m_block_heights = new Db(m_env, 0);
+ m_block_hashes = new Db(m_env, 0);
+ m_block_timestamps = new Db(m_env, 0);
+ m_block_sizes = new Db(m_env, 0);
+ m_block_diffs = new Db(m_env, 0);
+ m_block_coins = new Db(m_env, 0);
+
+ m_txs = new Db(m_env, 0);
+ m_tx_unlocks = new Db(m_env, 0);
+ m_tx_heights = new Db(m_env, 0);
+ m_tx_outputs = new Db(m_env, 0);
+
+ m_output_txs = new Db(m_env, 0);
+ m_output_indices = new Db(m_env, 0);
+ m_output_amounts = new Db(m_env, 0);
+ m_output_keys = new Db(m_env, 0);
+
+ m_spent_keys = new Db(m_env, 0);
+
+ // Tell DB about Dbs that need duplicate support
+ // Note: no need to tell about sorting,
+ // as the default is insertion order, which we want
+ m_tx_outputs->set_flags(DB_DUP);
+ m_output_amounts->set_flags(DB_DUP);
+
+ // Tell DB about fixed-size values.
+ m_block_hashes->set_re_len(sizeof(crypto::hash));
+ m_block_timestamps->set_re_len(sizeof(uint64_t));
+ m_block_sizes->set_re_len(sizeof(size_t)); // should really store block size as uint64_t...
+ m_block_diffs->set_re_len(sizeof(difficulty_type));
+ m_block_coins->set_re_len(sizeof(uint64_t));
+
+ m_output_txs->set_re_len(sizeof(crypto::hash));
+ m_output_indices->set_re_len(sizeof(uint64_t));
+ m_output_keys->set_re_len(sizeof(crypto::public_key));
+
+ //TODO: Find out if we need to do Db::set_flags(DB_RENUMBER)
+ // for the RECNO databases. We shouldn't as we're only
+ // inserting/removing from the end, but we'll see.
+
+ // open Dbs in the environment
+ // m_tx_outputs and m_output_amounts must be DB_HASH or DB_BTREE
+ // because they need duplicate entry support. The rest are DB_RECNO,
+ // as it seems that will be the most performant choice.
+ m_blocks->open(txn, BDB_BLOCKS, NULL, DB_RECNO, DB_CREATE, 0);
+
+ m_block_timestamps->open(txn, BDB_BLOCK_TIMESTAMPS, NULL, DB_RECNO, DB_CREATE, 0);
+ m_block_heights->open(txn, BDB_BLOCK_HEIGHTS, NULL, DB_HASH, DB_CREATE, 0);
+ m_block_hashes->open(txn, BDB_BLOCK_HASHES, NULL, DB_RECNO, DB_CREATE, 0);
+ m_block_sizes->open(txn, BDB_BLOCK_SIZES, NULL, DB_RECNO, DB_CREATE, 0);
+ m_block_diffs->open(txn, BDB_BLOCK_DIFFS, NULL, DB_RECNO, DB_CREATE, 0);
+ m_block_coins->open(txn, BDB_BLOCK_COINS, NULL, DB_RECNO, DB_CREATE, 0);
+
+ m_txs->open(txn, BDB_TXS, NULL, DB_HASH, DB_CREATE, 0);
+ m_tx_unlocks->open(txn, BDB_TX_UNLOCKS, NULL, DB_HASH, DB_CREATE, 0);
+ m_tx_heights->open(txn, BDB_TX_HEIGHTS, NULL, DB_HASH, DB_CREATE, 0);
+ m_tx_outputs->open(txn, BDB_TX_OUTPUTS, NULL, DB_HASH, DB_CREATE, 0);
+
+ m_output_txs->open(txn, BDB_OUTPUT_TXS, NULL, DB_RECNO, DB_CREATE, 0);
+ m_output_indices->open(txn, BDB_OUTPUT_INDICES, NULL, DB_RECNO, DB_CREATE, 0);
+ m_output_amounts->open(txn, BDB_OUTPUT_AMOUNTS, NULL, DB_HASH, DB_CREATE, 0);
+ m_output_keys->open(txn, BDB_OUTPUT_KEYS, NULL, DB_RECNO, DB_CREATE, 0);
+
+ m_spent_keys->open(txn, BDB_SPENT_KEYS, NULL, DB_HASH, DB_CREATE, 0);
+
+ DB_BTREE_STAT* stats;
+
+ // DB_FAST_STAT can apparently cause an incorrect number of records
+ // to be returned. The flag should be set to 0 instead if this proves
+ // to be the case.
+ m_blocks->stat(txn, &stats, DB_FAST_STAT);
+ m_height = stats->bt_nkeys;
+ delete stats;
+
+ // see above comment about DB_FAST_STAT
+ m_output_indices->stat(txn, &stats, DB_FAST_STAT);
+ m_num_outputs = stats->bt_nkeys;
+ delete stats;
+
+ txn.commit();
+ }
+ catch (const std::exception& e)
+ {
+ throw0(DB_OPEN_FAILURE(e.what()));
+ }
- m_open = true;
+ m_open = true;
}
void BlockchainBDB::close()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- this->sync();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ this->sync();
- // FIXME: not yet thread safe!!! Use with care.
- m_open = false;
- m_env->close(DB_FORCESYNC);
+ // FIXME: not yet thread safe!!! Use with care.
+ m_open = false;
+ m_env->close(DB_FORCESYNC);
}
void BlockchainBDB::sync()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
-
- try
- {
- m_blocks->sync(0);
- m_block_heights->sync(0);
- m_block_hashes->sync(0);
- m_block_timestamps->sync(0);
- m_block_sizes->sync(0);
- m_block_diffs->sync(0);
- m_block_coins->sync(0);
-
- m_txs->sync(0);
- m_tx_unlocks->sync(0);
- m_tx_heights->sync(0);
- m_tx_outputs->sync(0);
-
- m_output_txs->sync(0);
- m_output_indices->sync(0);
- m_output_amounts->sync(0);
- m_output_keys->sync(0);
-
- m_spent_keys->sync(0);
- }
- catch (const std::exception& e)
- {
- throw0(DB_ERROR(std::string("Failed to sync database: ").append(e.what()).c_str()));
- }
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+
+ try
+ {
+ m_blocks->sync(0);
+ m_block_heights->sync(0);
+ m_block_hashes->sync(0);
+ m_block_timestamps->sync(0);
+ m_block_sizes->sync(0);
+ m_block_diffs->sync(0);
+ m_block_coins->sync(0);
+
+ m_txs->sync(0);
+ m_tx_unlocks->sync(0);
+ m_tx_heights->sync(0);
+ m_tx_outputs->sync(0);
+
+ m_output_txs->sync(0);
+ m_output_indices->sync(0);
+ m_output_amounts->sync(0);
+ m_output_keys->sync(0);
+
+ m_spent_keys->sync(0);
+ }
+ catch (const std::exception& e)
+ {
+ throw0(DB_ERROR(std::string("Failed to sync database: ").append(e.what()).c_str()));
+ }
}
void BlockchainBDB::reset()
{
- LOG_PRINT_L3("BlockchainLMDB::" << __func__);
- // TODO: this
+ LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+ // TODO: this
}
std::vector<std::string> BlockchainBDB::get_filenames() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- std::vector<std::string> filenames;
+ std::vector<std::string> filenames;
- char *fname, *dbname;
- const char **pfname, **pdbname;
+ char *fname, *dbname;
+ const char **pfname, **pdbname;
- pfname = (const char **)&fname;
- pdbname = (const char **)&dbname;
+ pfname = (const char **)&fname;
+ pdbname = (const char **)&dbname;
- m_blocks->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_blocks->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_block_heights->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_block_heights->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_block_hashes->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_block_hashes->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_block_timestamps->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_block_timestamps->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_block_sizes->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_block_sizes->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_block_diffs->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_block_diffs->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_block_coins->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_block_coins->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_txs->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_txs->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_tx_unlocks->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_tx_unlocks->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_tx_heights->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_tx_heights->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_tx_outputs->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_tx_outputs->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_output_txs->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_output_txs->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_output_indices->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_output_indices->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_output_amounts->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_output_amounts->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_output_keys->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_output_keys->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- m_spent_keys->get_dbname(pfname, pdbname);
- filenames.push_back(fname);
+ m_spent_keys->get_dbname(pfname, pdbname);
+ filenames.push_back(fname);
- std::vector<std::string> full_paths;
+ std::vector<std::string> full_paths;
- for (auto& filename : filenames)
- {
- boost::filesystem::path p(m_folder);
- p /= filename;
- full_paths.push_back(p.string());
- }
+for (auto& filename : filenames)
+ {
+ boost::filesystem::path p(m_folder);
+ p /= filename;
+ full_paths.push_back(p.string());
+ }
- return full_paths;
+ return full_paths;
}
std::string BlockchainBDB::get_db_name() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
- return std::string("BerkeleyDB");
+ return std::string("BerkeleyDB");
}
// TODO: this?
bool BlockchainBDB::lock()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- return false;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ return false;
}
// TODO: this?
void BlockchainBDB::unlock()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
}
bool BlockchainBDB::block_exists(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::hash> key(h);
+ Dbt_copy<crypto::hash> key(h);
- auto get_result = m_block_heights->exists(txn, &key, 0);
- if (get_result == DB_NOTFOUND)
- {
- txn.commit();
- LOG_PRINT_L3("Block with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
- return false;
- }
- else if (get_result)
- throw0(DB_ERROR("DB error attempting to fetch block index from hash"));
+ auto get_result = m_block_heights->exists(txn, &key, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ txn.commit();
+ LOG_PRINT_L3("Block with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
+ return false;
+ }
+ else if (get_result)
+ throw0(DB_ERROR("DB error attempting to fetch block index from hash"));
- txn.commit();
- return true;
+ txn.commit();
+ return true;
}
block BlockchainBDB::get_block(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- return get_block_from_height(get_block_height(h));
+ return get_block_from_height(get_block_height(h));
}
uint64_t BlockchainBDB::get_block_height(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::hash> key(h);
- Dbt_copy<uint64_t> result;
+ Dbt_copy<crypto::hash> key(h);
+ Dbt_copy<uint64_t> result;
- auto get_result = m_block_heights->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- throw1(BLOCK_DNE("Attempted to retrieve non-existent block height"));
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a block height from the db"));
+ auto get_result = m_block_heights->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ throw1(BLOCK_DNE("Attempted to retrieve non-existent block height"));
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a block height from the db"));
- txn.commit();
+ txn.commit();
- return (uint64_t)result - 1;
+ return (uint64_t)result - 1;
}
block_header BlockchainBDB::get_block_header(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- // block_header object is automatically cast from block object
- return get_block(h);
+ // block_header object is automatically cast from block object
+ return get_block(h);
}
block BlockchainBDB::get_block_from_height(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> key(height + 1);
- Dbt_safe result;
- auto get_result = m_blocks->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw0(DB_ERROR(std::string("Attempt to get block from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block not in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a block from the db"));
+ Dbt_copy<uint32_t> key(height + 1);
+ Dbt_safe result;
+ auto get_result = m_blocks->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw0(DB_ERROR(std::string("Attempt to get block from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block not in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a block from the db"));
- txn.commit();
+ txn.commit();
- blobdata bd;
- bd.assign(reinterpret_cast<char*>(result.get_data()), result.get_size());
+ blobdata bd;
+ bd.assign(reinterpret_cast<char*>(result.get_data()), result.get_size());
- block b;
- if (!parse_and_validate_block_from_blob(bd, b))
- throw0(DB_ERROR("Failed to parse block from blob retrieved from the db"));
+ block b;
+ if (!parse_and_validate_block_from_blob(bd, b))
+ throw0(DB_ERROR("Failed to parse block from blob retrieved from the db"));
- return b;
+ return b;
}
uint64_t BlockchainBDB::get_block_timestamp(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> key(height + 1);
- Dbt_copy<uint64_t> result;
- auto get_result = m_block_timestamps->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw0(DB_ERROR(std::string("Attempt to get timestamp from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- timestamp not in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a timestamp from the db"));
+ Dbt_copy<uint32_t> key(height + 1);
+ Dbt_copy<uint64_t> result;
+ auto get_result = m_block_timestamps->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw0(DB_ERROR(std::string("Attempt to get timestamp from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- timestamp not in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a timestamp from the db"));
- txn.commit();
- return result;
+ txn.commit();
+ return result;
}
uint64_t BlockchainBDB::get_top_block_timestamp() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- // if no blocks, return 0
- if (m_height == 0)
- {
- return 0;
- }
+ // if no blocks, return 0
+ if (m_height == 0)
+ {
+ return 0;
+ }
- return get_block_timestamp(m_height - 1);
+ return get_block_timestamp(m_height - 1);
}
size_t BlockchainBDB::get_block_size(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> key(height + 1);
- Dbt_copy<size_t> result;
- auto get_result = m_block_sizes->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw0(DB_ERROR(std::string("Attempt to get block size from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block size not in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a block size from the db"));
+ Dbt_copy<uint32_t> key(height + 1);
+ Dbt_copy<size_t> result;
+ auto get_result = m_block_sizes->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw0(DB_ERROR(std::string("Attempt to get block size from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block size not in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a block size from the db"));
- txn.commit();
- return result;
+ txn.commit();
+ return result;
}
difficulty_type BlockchainBDB::get_block_cumulative_difficulty(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__ << " height: " << height);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__ << " height: " << height);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> key(height + 1);
- Dbt_copy<difficulty_type> result;
- auto get_result = m_block_diffs->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw0(DB_ERROR(std::string("Attempt to get cumulative difficulty from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- difficulty not in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a cumulative difficulty from the db"));
+ Dbt_copy<uint32_t> key(height + 1);
+ Dbt_copy<difficulty_type> result;
+ auto get_result = m_block_diffs->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw0(DB_ERROR(std::string("Attempt to get cumulative difficulty from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- difficulty not in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a cumulative difficulty from the db"));
- txn.commit();
- return result;
+ txn.commit();
+ return result;
}
difficulty_type BlockchainBDB::get_block_difficulty(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- difficulty_type diff1 = 0;
- difficulty_type diff2 = 0;
+ difficulty_type diff1 = 0;
+ difficulty_type diff2 = 0;
- diff1 = get_block_cumulative_difficulty(height);
- if (height != 0)
- {
- diff2 = get_block_cumulative_difficulty(height - 1);
- }
+ diff1 = get_block_cumulative_difficulty(height);
+ if (height != 0)
+ {
+ diff2 = get_block_cumulative_difficulty(height - 1);
+ }
- return diff1 - diff2;
+ return diff1 - diff2;
}
uint64_t BlockchainBDB::get_block_already_generated_coins(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> key(height + 1);
- Dbt_copy<uint64_t> result;
- auto get_result = m_block_coins->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw0(DB_ERROR(std::string("Attempt to get generated coins from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block size not in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a total generated coins from the db"));
+ Dbt_copy<uint32_t> key(height + 1);
+ Dbt_copy<uint64_t> result;
+ auto get_result = m_block_coins->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw0(DB_ERROR(std::string("Attempt to get generated coins from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- block size not in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a total generated coins from the db"));
- txn.commit();
- return result;
+ txn.commit();
+ return result;
}
crypto::hash BlockchainBDB::get_block_hash_from_height(const uint64_t& height) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> key(height + 1);
- Dbt_copy<crypto::hash> result;
- auto get_result = m_block_hashes->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw0(BLOCK_DNE(std::string("Attempt to get hash from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- hash not in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve a block hash from the db."));
+ Dbt_copy<uint32_t> key(height + 1);
+ Dbt_copy<crypto::hash> result;
+ auto get_result = m_block_hashes->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw0(BLOCK_DNE(std::string("Attempt to get hash from height ").append(boost::lexical_cast<std::string>(height)).append(" failed -- hash not in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve a block hash from the db."));
- txn.commit();
- return result;
+ txn.commit();
+ return result;
}
std::vector<block> BlockchainBDB::get_blocks_range(const uint64_t& h1, const uint64_t& h2) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- std::vector<block> v;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ std::vector<block> v;
- for (uint64_t height = h1; height <= h2; ++height)
- {
- v.push_back(get_block_from_height(height));
- }
+ for (uint64_t height = h1; height <= h2; ++height)
+ {
+ v.push_back(get_block_from_height(height));
+ }
- return v;
+ return v;
}
std::vector<crypto::hash> BlockchainBDB::get_hashes_range(const uint64_t& h1, const uint64_t& h2) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- std::vector<crypto::hash> v;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ std::vector<crypto::hash> v;
- for (uint64_t height = h1; height <= h2; ++height)
- {
- v.push_back(get_block_hash_from_height(height));
- }
+ for (uint64_t height = h1; height <= h2; ++height)
+ {
+ v.push_back(get_block_hash_from_height(height));
+ }
- return v;
+ return v;
}
crypto::hash BlockchainBDB::top_block_hash() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- if (m_height > 0)
- {
- return get_block_hash_from_height(m_height - 1);
- }
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ if (m_height > 0)
+ {
+ return get_block_hash_from_height(m_height - 1);
+ }
- return null_hash;
+ return null_hash;
}
block BlockchainBDB::get_top_block() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- if (m_height > 0)
- {
- return get_block_from_height(m_height - 1);
- }
+ if (m_height > 0)
+ {
+ return get_block_from_height(m_height - 1);
+ }
- block b;
- return b;
+ block b;
+ return b;
}
uint64_t BlockchainBDB::height() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- return m_height;
+ return m_height;
}
bool BlockchainBDB::tx_exists(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::hash> key(h);
+ Dbt_copy<crypto::hash> key(h);
- TIME_MEASURE_START(time1);
- auto get_result = m_txs->exists(txn, &key, 0);
- TIME_MEASURE_FINISH(time1);
- time_tx_exists += time1;
- if (get_result == DB_NOTFOUND)
- {
- txn.commit();
- LOG_PRINT_L1("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
- return false;
- }
- else if (get_result)
- throw0(DB_ERROR("DB error attempting to fetch transaction from hash"));
+ TIME_MEASURE_START(time1);
+ auto get_result = m_txs->exists(txn, &key, 0);
+ TIME_MEASURE_FINISH(time1);
+ time_tx_exists += time1;
+ if (get_result == DB_NOTFOUND)
+ {
+ txn.commit();
+ LOG_PRINT_L1("transaction with hash " << epee::string_tools::pod_to_hex(h) << " not found in db");
+ return false;
+ }
+ else if (get_result)
+ throw0(DB_ERROR("DB error attempting to fetch transaction from hash"));
- return true;
+ return true;
}
uint64_t BlockchainBDB::get_tx_unlock_time(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainLMDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::hash> key(h);
- Dbt_copy<uint64_t> result;
- auto get_result = m_tx_unlocks->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- throw1(TX_DNE(std::string("tx unlock time with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
- else if (get_result)
- throw0(DB_ERROR("DB error attempting to fetch tx unlock time from hash"));
+ Dbt_copy<crypto::hash> key(h);
+ Dbt_copy<uint64_t> result;
+ auto get_result = m_tx_unlocks->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ throw1(TX_DNE(std::string("tx unlock time with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
+ else if (get_result)
+ throw0(DB_ERROR("DB error attempting to fetch tx unlock time from hash"));
- return result;
+ return result;
}
transaction BlockchainBDB::get_tx(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::hash> key(h);
- Dbt_safe result;
- auto get_result = m_txs->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- throw1(TX_DNE(std::string("tx with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
- else if (get_result)
- throw0(DB_ERROR("DB error attempting to fetch tx from hash"));
+ Dbt_copy<crypto::hash> key(h);
+ Dbt_safe result;
+ auto get_result = m_txs->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ throw1(TX_DNE(std::string("tx with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
+ else if (get_result)
+ throw0(DB_ERROR("DB error attempting to fetch tx from hash"));
- blobdata bd;
- bd.assign(reinterpret_cast<char*>(result.get_data()), result.get_size());
+ blobdata bd;
+ bd.assign(reinterpret_cast<char*>(result.get_data()), result.get_size());
- transaction tx;
- if (!parse_and_validate_tx_from_blob(bd, tx))
- throw0(DB_ERROR("Failed to parse tx from blob retrieved from the db"));
+ transaction tx;
+ if (!parse_and_validate_tx_from_blob(bd, tx))
+ throw0(DB_ERROR("Failed to parse tx from blob retrieved from the db"));
- txn.commit();
+ txn.commit();
- return tx;
+ return tx;
}
uint64_t BlockchainBDB::get_tx_count() const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- DB_BTREE_STAT* stats;
+ DB_BTREE_STAT* stats;
- // DB_FAST_STAT can apparently cause an incorrect number of records
- // to be returned. The flag should be set to 0 instead if this proves
- // to be the case.
- m_txs->stat(txn, &stats, DB_FAST_STAT);
- auto num_txs = stats->bt_nkeys;
- delete stats;
+ // DB_FAST_STAT can apparently cause an incorrect number of records
+ // to be returned. The flag should be set to 0 instead if this proves
+ // to be the case.
+ m_txs->stat(txn, &stats, DB_FAST_STAT);
+ auto num_txs = stats->bt_nkeys;
+ delete stats;
- txn.commit();
+ txn.commit();
- return num_txs;
+ return num_txs;
}
std::vector<transaction> BlockchainBDB::get_tx_list(const std::vector<crypto::hash>& hlist) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- std::vector<transaction> v;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ std::vector<transaction> v;
- for (auto& h : hlist)
- {
- v.push_back(get_tx(h));
- }
+for (auto& h : hlist)
+ {
+ v.push_back(get_tx(h));
+ }
- return v;
+ return v;
}
uint64_t BlockchainBDB::get_tx_block_height(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::hash> key(h);
- Dbt_copy<uint64_t> result;
- auto get_result = m_tx_heights->get(txn, &key, &result, 0);
- if (get_result == DB_NOTFOUND)
- {
- throw1(TX_DNE(std::string("tx height with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
- }
- else if (get_result)
- throw0(DB_ERROR("DB error attempting to fetch tx height from hash"));
+ Dbt_copy<crypto::hash> key(h);
+ Dbt_copy<uint64_t> result;
+ auto get_result = m_tx_heights->get(txn, &key, &result, 0);
+ if (get_result == DB_NOTFOUND)
+ {
+ throw1(TX_DNE(std::string("tx height with hash ").append(epee::string_tools::pod_to_hex(h)).append(" not found in db").c_str()));
+ }
+ else if (get_result)
+ throw0(DB_ERROR("DB error attempting to fetch tx height from hash"));
- txn.commit();
+ txn.commit();
- return (uint64_t)result - 1;
+ return (uint64_t)result - 1;
}
//FIXME: make sure the random method used here is appropriate
uint64_t BlockchainBDB::get_random_output(const uint64_t& amount) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- uint64_t num_outputs = get_num_outputs(amount);
- if (num_outputs == 0)
- throw1(OUTPUT_DNE("Attempting to get a random output for an amount, but none exist"));
+ uint64_t num_outputs = get_num_outputs(amount);
+ if (num_outputs == 0)
+ throw1(OUTPUT_DNE("Attempting to get a random output for an amount, but none exist"));
- return crypto::rand<uint64_t>() % num_outputs;
+ return crypto::rand<uint64_t>() % num_outputs;
}
uint64_t BlockchainBDB::get_num_outputs(const uint64_t& amount) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- bdb_cur cur(txn, m_output_amounts);
+ bdb_cur cur(txn, m_output_amounts);
- Dbt_copy<uint64_t> k(amount);
- Dbt_copy<uint64_t> v;
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- {
- return 0;
- }
- else if (result)
- throw0(DB_ERROR("DB error attempting to get number of outputs of an amount"));
+ Dbt_copy<uint64_t> k(amount);
+ Dbt_copy<uint64_t> v;
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
+ {
+ return 0;
+ }
+ else if (result)
+ throw0(DB_ERROR("DB error attempting to get number of outputs of an amount"));
- db_recno_t num_elems = 0;
- cur->count(&num_elems, 0);
+ db_recno_t num_elems = 0;
+ cur->count(&num_elems, 0);
- txn.commit();
+ txn.commit();
- return num_elems;
+ return num_elems;
}
crypto::public_key BlockchainBDB::get_output_key(const uint64_t& amount, const uint64_t& index) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- uint64_t glob_index = get_output_global_index(amount, index);
+ uint64_t glob_index = get_output_global_index(amount, index);
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<uint32_t> k(glob_index);
- Dbt_copy<crypto::public_key> v;
- auto get_result = m_output_keys->get(txn, &k, &v, 0);
- if (get_result == DB_NOTFOUND)
- throw0(DB_ERROR("Attempting to get output pubkey by global index, but key does not exist"));
- else if (get_result)
- throw0(DB_ERROR("Error attempting to retrieve an output pubkey from the db"));
+ Dbt_copy<uint32_t> k(glob_index);
+ Dbt_copy<crypto::public_key> v;
+ auto get_result = m_output_keys->get(txn, &k, &v, 0);
+ if (get_result == DB_NOTFOUND)
+ throw0(DB_ERROR("Attempting to get output pubkey by global index, but key does not exist"));
+ else if (get_result)
+ throw0(DB_ERROR("Error attempting to retrieve an output pubkey from the db"));
- return v;
+ return v;
}
// As this is not used, its return is now a blank output.
// This will save on space in the db.
tx_out BlockchainBDB::get_output(const crypto::hash& h, const uint64_t& index) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- return tx_out();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ return tx_out();
}
// As this is not used, its return is now a blank output.
// This will save on space in the db.
tx_out BlockchainBDB::get_output(const uint64_t& index) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- return tx_out();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ return tx_out();
}
void BlockchainBDB::get_output_tx_and_index(const uint64_t& amount,
std::vector<uint64_t> &offsets,
std::vector<tx_out_index> &indices) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
bdb_cur cur(txn, m_output_amounts);
uint64_t max = 0;
@@ -1413,31 +1425,31 @@ void BlockchainBDB::get_output_tx_and_index(const uint64_t& amount,
max = index;
}
- // ??? might be a bug, don't always treat as uint64_t
- #define DBT_VALUE(dbt) v.get_size() == sizeof(uint64_t) ? \
- *((uint64_t *)v.get_data()) : *((uint32_t *)v.get_data()) \
-
- // get returned keypairs count
- #define DB_COUNT_RECORDS(dbt, cnt) \
- do { \
- uint32_t *_p = (uint32_t *) ((uint8_t *)(dbt)->data + \
- (dbt)->ulen - sizeof(uint32_t)); \
- cnt = 0; \
- while(*_p != (uint32_t) -1) { \
- _p -= 2; \
- ++cnt; \
- } \
- } while(0); \
-
- Dbt_copy<uint64_t> k(amount);
+ // ??? might be a bug, don't always treat as uint64_t
+ #define DBT_VALUE(dbt) v.get_size() == sizeof(uint64_t) ? \
+ *((uint64_t *)v.get_data()) : *((uint32_t *)v.get_data()) \
+
+ // get returned keypairs count
+ #define DB_COUNT_RECORDS(dbt, cnt) \
+ do { \
+ uint32_t *_p = (uint32_t *) ((uint8_t *)(dbt)->data + \
+ (dbt)->ulen - sizeof(uint32_t)); \
+ cnt = 0; \
+ while(*_p != (uint32_t) -1) { \
+ _p -= 2; \
+ ++cnt; \
+ } \
+ } while(0); \
+
+ Dbt_copy<uint64_t> k(amount);
Dbt_copy<uint64_t> v;
uint64_t buflen = 0;
- uint64_t t_dbmul = 0;
- uint64_t t_dbscan = 0;
+ uint64_t t_dbmul = 0;
+ uint64_t t_dbscan = 0;
TIME_MEASURE_START(db2);
if(max <= 1)
{
- for (const uint64_t& index : offsets)
+ for (const uint64_t& index : offsets)
{
TIME_MEASURE_START(t_seek);
@@ -1469,28 +1481,28 @@ void BlockchainBDB::get_output_tx_and_index(const uint64_t& amount,
}
else
{
- // setup a 256KB minimum buffer size
- uint32_t pagesize = 256 * 1024;
-
- // Retrieve only a suitable portion of the kvp data, up to somewhere near
- // the maximum offset value being retrieved
- buflen = (max + 1) * 4 * sizeof(uint64_t);
- buflen = ((buflen / pagesize) + ((buflen % pagesize) > 0 ? 1 : 0)) * pagesize;
- bool singlebuff = buflen <= BUFFER_LENGTH;
- buflen = buflen < BUFFER_LENGTH ? buflen : BUFFER_LENGTH;
-
- Dbt data;
- data.set_data(m_buffer);
- data.set_ulen(buflen);
- data.set_size(buflen);
- data.set_flags(DB_DBT_USERMEM);
-
- uint32_t curcount = 0;
- uint32_t blockstart = 0;
+ // setup a 256KB minimum buffer size
+ uint32_t pagesize = 256 * 1024;
+
+ // Retrieve only a suitable portion of the kvp data, up to somewhere near
+ // the maximum offset value being retrieved
+ buflen = (max + 1) * 4 * sizeof(uint64_t);
+ buflen = ((buflen / pagesize) + ((buflen % pagesize) > 0 ? 1 : 0)) * pagesize;
+ bool singlebuff = buflen <= BUFFER_LENGTH;
+ buflen = buflen < BUFFER_LENGTH ? buflen : BUFFER_LENGTH;
+
+ Dbt data;
+ data.set_data(m_buffer);
+ data.set_ulen(buflen);
+ data.set_size(buflen);
+ data.set_flags(DB_DBT_USERMEM);
+
+ uint32_t curcount = 0;
+ uint32_t blockstart = 0;
for (const uint64_t& index : offsets)
{
- // fixme! for whatever reason, the first call to DB_MULTIPLE | DB_SET does not
- // retrieve the first value.
+ // fixme! for whatever reason, the first call to DB_MULTIPLE | DB_SET does not
+ // retrieve the first value.
if(index <= 1)
{
auto result = cur->get(&k, &v, DB_SET);
@@ -1509,40 +1521,40 @@ void BlockchainBDB::get_output_tx_and_index(const uint64_t& amount,
}
else
{
- while(index >= curcount)
- {
- TIME_MEASURE_START(t_db1);
- try
- {
- cur->get(&k, &data, DB_MULTIPLE | (curcount == 0 ? DB_SET : DB_NEXT_DUP));
- blockstart = curcount;
- // skip counting if using single buffer, it actually adds some overhead on some systems.
- if(!singlebuff)
- {
- int count = 0;
- DB_COUNT_RECORDS((DBT *) &data, count);
- curcount += count;
- }
- }
- catch (const std::exception &e)
- {
- LOG_PRINT_L0("DB_EXCEPTION: " << e.what());
- }
-
- TIME_MEASURE_FINISH(t_db1);
- t_dbmul += t_db1;
- if(singlebuff)
- break;
- }
-
- LOG_PRINT_L1("Records returned: " << curcount << " Index: " << index);
- TIME_MEASURE_START(t_db2);
- DBT *pdata = (DBT *) &data;
+ while(index >= curcount)
+ {
+ TIME_MEASURE_START(t_db1);
+ try
+ {
+ cur->get(&k, &data, DB_MULTIPLE | (curcount == 0 ? DB_SET : DB_NEXT_DUP));
+ blockstart = curcount;
+ // skip counting if using single buffer, it actually adds some overhead on some systems.
+ if(!singlebuff)
+ {
+ int count = 0;
+ DB_COUNT_RECORDS((DBT *) &data, count);
+ curcount += count;
+ }
+ }
+ catch (const std::exception &e)
+ {
+ LOG_PRINT_L0("DB_EXCEPTION: " << e.what());
+ }
+
+ TIME_MEASURE_FINISH(t_db1);
+ t_dbmul += t_db1;
+ if(singlebuff)
+ break;
+ }
+
+ LOG_PRINT_L1("Records returned: " << curcount << " Index: " << index);
+ TIME_MEASURE_START(t_db2);
+ DBT *pdata = (DBT *) &data;
uint8_t *value;
uint64_t dlen = 0;
- void *pbase = ((uint8_t *)(pdata->data)) + pdata->ulen - sizeof(uint32_t);
+ void *pbase = ((uint8_t *)(pdata->data)) + pdata->ulen - sizeof(uint32_t);
uint32_t *p = (uint32_t *) pbase;
if (*p == (uint32_t) -1)
{
@@ -1560,11 +1572,11 @@ void BlockchainBDB::get_output_tx_and_index(const uint64_t& amount,
if (value != NULL)
{
v = dlen == sizeof(uint64_t) ? *((uint64_t *) value)
- : *((uint32_t *) value);
+ : *((uint32_t *) value);
}
- TIME_MEASURE_FINISH(t_db2);
- t_dbscan += t_db2;
- }
+ TIME_MEASURE_FINISH(t_db2);
+ t_dbscan += t_db2;
+ }
uint64_t glob_index = DBT_VALUE(v);
@@ -1579,156 +1591,156 @@ void BlockchainBDB::get_output_tx_and_index(const uint64_t& amount,
LOG_PRINT_L1("blen: " << buflen << " db1: " << t_dbmul << " db2: " << t_dbscan);
cur.close();
- txn.commit();
+ txn.commit();
}
tx_out_index BlockchainBDB::get_output_tx_and_index(const uint64_t& amount, const uint64_t& index) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- bdb_cur cur(txn, m_output_amounts);
+ bdb_cur cur(txn, m_output_amounts);
- Dbt_copy<uint64_t> k(amount);
- Dbt_copy<uint64_t> v;
+ Dbt_copy<uint64_t> k(amount);
+ Dbt_copy<uint64_t> v;
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
- else if (result)
- throw0(DB_ERROR("DB error attempting to get an output"));
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
+ throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
+ else if (result)
+ throw0(DB_ERROR("DB error attempting to get an output"));
- db_recno_t num_elems = 0;
- cur->count(&num_elems, 0);
+ db_recno_t num_elems = 0;
+ cur->count(&num_elems, 0);
- if (num_elems <= index)
- throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but output not found"));
+ if (num_elems <= index)
+ throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but output not found"));
- for (uint64_t i = 0; i < index; ++i)
- {
- cur->get(&k, &v, DB_NEXT_DUP);
- }
+ for (uint64_t i = 0; i < index; ++i)
+ {
+ cur->get(&k, &v, DB_NEXT_DUP);
+ }
- uint64_t glob_index = v;
+ uint64_t glob_index = v;
- cur.close();
+ cur.close();
- txn.commit();
+ txn.commit();
- return get_output_tx_and_index_from_global(glob_index);
+ return get_output_tx_and_index_from_global(glob_index);
}
std::vector<uint64_t> BlockchainBDB::get_tx_output_indices(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- std::vector<uint64_t> index_vec;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ std::vector<uint64_t> index_vec;
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- bdb_cur cur(txn, m_tx_outputs);
+ bdb_cur cur(txn, m_tx_outputs);
- Dbt_copy<crypto::hash> k(h);
- Dbt_copy<uint64_t> v;
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- throw1(OUTPUT_DNE("Attempting to get an output by tx hash and tx index, but output not found"));
- else if (result)
- throw0(DB_ERROR("DB error attempting to get an output"));
+ Dbt_copy<crypto::hash> k(h);
+ Dbt_copy<uint64_t> v;
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
+ throw1(OUTPUT_DNE("Attempting to get an output by tx hash and tx index, but output not found"));
+ else if (result)
+ throw0(DB_ERROR("DB error attempting to get an output"));
- db_recno_t num_elems = 0;
- cur->count(&num_elems, 0);
+ db_recno_t num_elems = 0;
+ cur->count(&num_elems, 0);
- for (uint64_t i = 0; i < num_elems; ++i)
- {
- index_vec.push_back(v);
- cur->get(&k, &v, DB_NEXT_DUP);
- }
+ for (uint64_t i = 0; i < num_elems; ++i)
+ {
+ index_vec.push_back(v);
+ cur->get(&k, &v, DB_NEXT_DUP);
+ }
- cur.close();
- txn.commit();
+ cur.close();
+ txn.commit();
- return index_vec;
+ return index_vec;
}
std::vector<uint64_t> BlockchainBDB::get_tx_amount_output_indices(const crypto::hash& h) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
- std::vector<uint64_t> index_vec;
- std::vector<uint64_t> index_vec2;
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
+ std::vector<uint64_t> index_vec;
+ std::vector<uint64_t> index_vec2;
- // get the transaction's global output indices first
- index_vec = get_tx_output_indices(h);
- // these are next used to obtain the amount output indices
+ // get the transaction's global output indices first
+ index_vec = get_tx_output_indices(h);
+ // these are next used to obtain the amount output indices
- transaction tx = get_tx(h);
+ transaction tx = get_tx(h);
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- uint64_t i = 0;
- uint64_t global_index;
- for (const auto& vout : tx.vout)
- {
- uint64_t amount = vout.amount;
+ uint64_t i = 0;
+ uint64_t global_index;
+ for (const auto& vout : tx.vout)
+ {
+ uint64_t amount = vout.amount;
- global_index = index_vec[i];
+ global_index = index_vec[i];
- bdb_cur cur(txn, m_output_amounts);
+ bdb_cur cur(txn, m_output_amounts);
- Dbt_copy<uint64_t> k(amount);
- Dbt_copy<uint64_t> v;
+ Dbt_copy<uint64_t> k(amount);
+ Dbt_copy<uint64_t> v;
- auto result = cur->get(&k, &v, DB_SET);
- if (result == DB_NOTFOUND)
- throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
- else if (result)
- throw0(DB_ERROR("DB error attempting to get an output"));
+ auto result = cur->get(&k, &v, DB_SET);
+ if (result == DB_NOTFOUND)
+ throw1(OUTPUT_DNE("Attempting to get an output index by amount and amount index, but amount not found"));
+ else if (result)
+ throw0(DB_ERROR("DB error attempting to get an output"));
- db_recno_t num_elems = 0;
- cur->count(&num_elems, 0);
+ db_recno_t num_elems = 0;
+ cur->count(&num_elems, 0);
- uint64_t amount_output_index = 0;
- uint64_t output_index = 0;
- bool found_index = false;
- for (uint64_t j = 0; j < num_elems; ++j)
- {
- output_index = v;
- if (output_index == global_index)
- {
- amount_output_index = j;
- found_index = true;
- break;
- }
- cur->get(&k, &v, DB_NEXT_DUP);
- }
- if (found_index)
- {
- index_vec2.push_back(amount_output_index);
- }
- else
- {
- // not found
- cur.close();
- txn.commit();
- throw1(OUTPUT_DNE("specified output not found in db"));
- }
+ uint64_t amount_output_index = 0;
+ uint64_t output_index = 0;
+ bool found_index = false;
+ for (uint64_t j = 0; j < num_elems; ++j)
+ {
+ output_index = v;
+ if (output_index == global_index)
+ {
+ amount_output_index = j;
+ found_index = true;
+ break;
+ }
+ cur->get(&k, &v, DB_NEXT_DUP);
+ }
+ if (found_index)
+ {
+ index_vec2.push_back(amount_output_index);
+ }
+ else
+ {
+ // not found
+ cur.close();
+ txn.commit();
+ throw1(OUTPUT_DNE("specified output not found in db"));
+ }
- cur.close();
- ++i;
- }
+ cur.close();
+ ++i;
+ }
- txn.commit();
+ txn.commit();
- return index_vec2;
+ return index_vec2;
}
@@ -1766,22 +1778,22 @@ tx_out_index BlockchainBDB::get_output_tx_and_index_from_global(const uint64_t&
bool BlockchainBDB::has_key_image(const crypto::key_image& img) const
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
- Dbt_copy<crypto::key_image> val_key(img);
- if (m_spent_keys->exists(txn, &val_key, 0) == 0)
- {
- txn.commit();
- return true;
- }
+ Dbt_copy<crypto::key_image> val_key(img);
+ if (m_spent_keys->exists(txn, &val_key, 0) == 0)
+ {
+ txn.commit();
+ return true;
+ }
- txn.commit();
- return false;
+ txn.commit();
+ return false;
}
// Ostensibly BerkeleyDB has batch transaction support built-in,
@@ -1789,93 +1801,93 @@ bool BlockchainBDB::has_key_image(const crypto::key_image& img) const
void BlockchainBDB::batch_start(uint64_t batch_num_blocks)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
}
void BlockchainBDB::batch_commit()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
}
void BlockchainBDB::batch_stop()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
}
void BlockchainBDB::batch_abort()
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
}
void BlockchainBDB::set_batch_transactions(bool batch_transactions)
{
- LOG_PRINT_L3("BlockchainLMDB::" << __func__);
- m_batch_transactions = batch_transactions;
- LOG_PRINT_L3("batch transactions " << (m_batch_transactions ? "enabled" : "disabled"));
+ LOG_PRINT_L3("BlockchainLMDB::" << __func__);
+ m_batch_transactions = batch_transactions;
+ LOG_PRINT_L3("batch transactions " << (m_batch_transactions ? "enabled" : "disabled"));
}
uint64_t BlockchainBDB::add_block( const block& blk
- , const size_t& block_size
- , const difficulty_type& cumulative_difficulty
- , const uint64_t& coins_generated
- , const std::vector<transaction>& txs
- )
-{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
-
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
- m_write_txn = &txn;
-
- uint64_t num_outputs = m_num_outputs;
- try
- {
- BlockchainDB::add_block(blk, block_size, cumulative_difficulty, coins_generated, txs);
- m_write_txn = NULL;
+ , const size_t& block_size
+ , const difficulty_type& cumulative_difficulty
+ , const uint64_t& coins_generated
+ , const std::vector<transaction>& txs
+ )
+{
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- TIME_MEASURE_START(time1);
- txn.commit();
- TIME_MEASURE_FINISH(time1);
- time_commit1 += time1;
- }
- catch (const std::exception& e)
- {
- m_num_outputs = num_outputs;
- m_write_txn = NULL;
- throw;
- }
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
+ m_write_txn = &txn;
+
+ uint64_t num_outputs = m_num_outputs;
+ try
+ {
+ BlockchainDB::add_block(blk, block_size, cumulative_difficulty, coins_generated, txs);
+ m_write_txn = NULL;
- return ++m_height;
+ TIME_MEASURE_START(time1);
+ txn.commit();
+ TIME_MEASURE_FINISH(time1);
+ time_commit1 += time1;
+ }
+ catch (const std::exception& e)
+ {
+ m_num_outputs = num_outputs;
+ m_write_txn = NULL;
+ throw;
+ }
+
+ return ++m_height;
}
void BlockchainBDB::pop_block(block& blk, std::vector<transaction>& txs)
{
- LOG_PRINT_L3("BlockchainBDB::" << __func__);
- check_open();
+ LOG_PRINT_L3("BlockchainBDB::" << __func__);
+ check_open();
- bdb_txn_safe txn;
- if (m_env->txn_begin(NULL, txn, 0))
- throw0(DB_ERROR("Failed to create a transaction for the db"));
- m_write_txn = &txn;
+ bdb_txn_safe txn;
+ if (m_env->txn_begin(NULL, txn, 0))
+ throw0(DB_ERROR("Failed to create a transaction for the db"));
+ m_write_txn = &txn;
- uint64_t num_outputs = m_num_outputs;
- try
- {
- BlockchainDB::pop_block(blk, txs);
+ uint64_t num_outputs = m_num_outputs;
+ try
+ {
+ BlockchainDB::pop_block(blk, txs);
- m_write_txn = NULL;
- txn.commit();
- }
- catch (...)
- {
- m_num_outputs = num_outputs;
- m_write_txn = NULL;
- throw;
- }
-
- --m_height;
+ m_write_txn = NULL;
+ txn.commit();
+ }
+ catch (...)
+ {
+ m_num_outputs = num_outputs;
+ m_write_txn = NULL;
+ throw;
+ }
+
+ --m_height;
}
} // namespace cryptonote