db_with.hpp

Go to the documentation of this file.

#pragma once
 
#include <scorum/chain/database/database.hpp>
 
/*
 * This file provides with() functions which modify the database
 * temporarily, then restore it.  These functions are mostly internal
 * implementation detail of the database.
 *
 * Essentially, we want to be able to use "finally" to restore the
 * database regardless of whether an exception is thrown or not, but there
 * is no "finally" in C++.  Instead, C++ requires us to create a struct
 * and put the finally block in a destructor.  Aagh!
 */
 
namespace scorum {
namespace chain {
namespace detail {
struct skip_flags_restorer
{
    skip_flags_restorer(node_property_object& npo, uint32_t old_skip_flags)
        : _npo(npo)
        , _old_skip_flags(old_skip_flags)
    {
    }
 
    ~skip_flags_restorer()
    {
        _npo.skip_flags = _old_skip_flags;
    }
 
    node_property_object& _npo;
    uint32_t _old_skip_flags; // initialized in ctor
};
 
struct pending_transactions_restorer
{
    pending_transactions_restorer(database& db, std::vector<signed_transaction>&& pending_transactions)
        : _db(db)
        , _pending_transactions(std::move(pending_transactions))
    {
        _db.clear_pending();
    }
 
    ~pending_transactions_restorer()
    {
        for (const auto& tx : _db._popped_tx)
        {
            try
            {
                if (!_db.is_known_transaction(tx.id()))
                {
                    // since push_transaction() takes a signed_transaction,
                    // the operation_results field will be ignored.
                    _db._push_transaction(tx);
                }
            }
            catch (const fc::exception&)
            {
            }
        }
        _db._popped_tx.clear();
        for (const signed_transaction& tx : _pending_transactions)
        {
            try
            {
                if (!_db.is_known_transaction(tx.id()))
                {
                    // since push_transaction() takes a signed_transaction,
                    // the operation_results field will be ignored.
                    _db._push_transaction(tx);
                }
            }
            catch (const transaction_exception& e)
            {
                dlog("Pending transaction became invalid after switching to block ${b} ${n} ${t}",
                     ("b", _db.head_block_id())("n", _db.head_block_num())("t", _db.head_block_time()));
                dlog("The invalid transaction caused exception ${e}", ("e", e.to_detail_string()));
                dlog("${t}", ("t", tx));
            }
            catch (const fc::exception& e)
            {
 
                /*
                dlog( "Pending transaction became invalid after switching to block ${b} ${n} ${t}",
                   ("b", _db.head_block_id())("n", _db.head_block_num())("t", _db.head_block_time()) );
                dlog( "The invalid pending transaction caused exception ${e}", ("e", e.to_detail_string() ) );
                dlog( "${t}", ("t", tx) );
                */
            }
        }
    }
 
    database& _db;
    std::vector<signed_transaction> _pending_transactions;
};
 
template <typename Lambda> void with_skip_flags(database& db, uint32_t skip_flags, Lambda callback)
{
    node_property_object& npo = db.node_properties();
    skip_flags_restorer restorer(npo, npo.skip_flags);
    npo.skip_flags = skip_flags;
    callback();
    return;
}
 
template <typename Lambda>
void without_pending_transactions(database& db, std::vector<signed_transaction>&& pending_transactions, Lambda callback)
{
    pending_transactions_restorer restorer(db, std::move(pending_transactions));
    callback();
    return;
}
}
}
} // scorum::chain::detail