sysio::chain_apis::account_query_db_impl Struct Reference

Collaboration diagram for sysio::chain_apis::account_query_db_impl:

Public Types
using	permission_set_t = std::set<chain::permission_level>
using	cached_trace_map_t = std::map<chain::transaction_id_type, chain::transaction_trace_ptr>
using	onblock_trace_t = std::optional<chain::transaction_trace_ptr>
using	time_map_t = std::map<fc::time_point, uint32_t>
using	name_bimap_t = bimap<multiset_of<weighted<chain::permission_level>>, multiset_of<permission_info::cref>>
using	key_bimap_t = bimap<multiset_of<weighted<chain::public_key_type>>, multiset_of<permission_info::cref>>

Public Member Functions
	account_query_db_impl (const chain::controller &controller)
void	build_account_query_map ()
void	add_to_bimaps (const permission_info &pi, const chain::permission_object &po)
void	remove_from_bimaps (const permission_info &pi)
bool	is_rollback_required (const chain::block_state_ptr &bsp) const
uint32_t	last_updated_time_to_height (const fc::time_point &last_updated)
void	rollback_to_before (const chain::block_state_ptr &bsp)
void	cache_transaction_trace (const chain::transaction_trace_ptr &trace)
auto	commit_block_prelock (const chain::block_state_ptr &bsp) const
void	commit_block (const chain::block_state_ptr &bsp)
account_query_db::get_accounts_by_authorizers_result	get_accounts_by_authorizers (const account_query_db::get_accounts_by_authorizers_params &args) const

Public Attributes
const chain::controller &	controller
	the controller to read data from
cached_trace_map_t	cached_trace_map
	temporary cache of uncommitted traces
onblock_trace_t	onblock_trace
	temporary cache of on_block trace
time_map_t	time_to_block_num
permission_info_index_t	permission_info_index
	multi-index that holds ephemeral indices
name_bimap_t	name_bimap
	many:many bimap of names:permission_infos
key_bimap_t	key_bimap
	many:many bimap of keys:permission_infos
std::shared_mutex	rw_mutex
	mutex for read/write locking on the Multi-index and bimaps

Detailed Description

Implementation details of the account query DB

Definition at line 131 of file account_query_db.cpp.

Member Typedef Documentation

cached_trace_map_t

using sysio::chain_apis::account_query_db_impl::cached_trace_map_t = std::map<chain::transaction_id_type, chain::transaction_trace_ptr>

Convenience aliases

Definition at line 482 of file account_query_db.cpp.

key_bimap_t

using sysio::chain_apis::account_query_db_impl::key_bimap_t = bimap<multiset_of<weighted<chain::public_key_type>>, multiset_of<permission_info::cref>>

Definition at line 495 of file account_query_db.cpp.

name_bimap_t

using sysio::chain_apis::account_query_db_impl::name_bimap_t = bimap<multiset_of<weighted<chain::permission_level>>, multiset_of<permission_info::cref>>

Definition at line 494 of file account_query_db.cpp.

onblock_trace_t

using sysio::chain_apis::account_query_db_impl::onblock_trace_t = std::optional<chain::transaction_trace_ptr>

Definition at line 483 of file account_query_db.cpp.

permission_set_t

using sysio::chain_apis::account_query_db_impl::permission_set_t = std::set<chain::permission_level>

Definition at line 302 of file account_query_db.cpp.

time_map_t

using sysio::chain_apis::account_query_db_impl::time_map_t = std::map<fc::time_point, uint32_t>

Definition at line 489 of file account_query_db.cpp.

Constructor & Destructor Documentation

account_query_db_impl()

sysio::chain_apis::account_query_db_impl::account_query_db_impl ( const chain::controller & controller )

inline

Definition at line 132 of file account_query_db.cpp.

      :controller(controller)
      {}

Member Function Documentation

add_to_bimaps()

void sysio::chain_apis::account_query_db_impl::add_to_bimaps ( const permission_info & pi, const chain::permission_object & po )

inline

Add a permission to the bimaps for keys and accounts

Parameters

pi	- the ephemeral permission info structure being added
po	- the chain data associted with this permission

Definition at line 171 of file account_query_db.cpp.

                                                                                        {
         // For each account, add this permission info's non-owning reference to the bimap for accounts
         for (const auto& a : po.auth.accounts) {
            name_bimap.insert(name_bimap_t::value_type {{a.permission, a.weight}, pi});
         }
 
         // for each key, add this permission info's non-owning reference to the bimap for keys
         for (const auto& k: po.auth.keys) {
            chain::public_key_type key = k.key;
            key_bimap.insert(key_bimap_t::value_type {{std::move(key), k.weight}, pi});
         }
      }

Here is the caller graph for this function:

build_account_query_map()

void sysio::chain_apis::account_query_db_impl::build_account_query_map ( )

inline

Build the initial database from the chain controller by extracting the information contained in the blockchain state at the current HEAD

Definition at line 140 of file account_query_db.cpp.

                                     {
         std::unique_lock write_lock(rw_mutex);
 
         ilog("Building account query DB");
         auto start = fc::time_point::now();
         const auto& index = controller.db().get_index<chain::permission_index>().indices().get<by_id>();
 
         // build a initial time to block number map
         const auto lib_num = controller.last_irreversible_block_num();
         const auto head_num = controller.head_block_num();
 
         for (uint32_t block_num = lib_num + 1; block_num <= head_num; block_num++) {
            const auto block_p = controller.fetch_block_by_number(block_num);
            SYS_ASSERT(block_p, chain::plugin_exception, "cannot fetch reversible block ${block_num}, required for account_db initialization", ("block_num", block_num));
            time_to_block_num.emplace(block_p->timestamp.to_time_point(), block_num);
         }
 
         for (const auto& po : index ) {
            uint32_t last_updated_height = last_updated_time_to_height(po.last_updated);
            const auto& pi = permission_info_index.emplace( permission_info{ po.owner, po.name, last_updated_height, po.auth.threshold } ).first;
            add_to_bimaps(*pi, po);
         }
         auto duration = fc::time_point::now() - start;
         ilog("Finished building account query DB in ${sec}", ("sec", (duration.count() / 1'000'000.0 )));
      }

Here is the call graph for this function:

cache_transaction_trace()

void sysio::chain_apis::account_query_db_impl::cache_transaction_trace ( const chain::transaction_trace_ptr & trace )

inline

Store a potentially relevant transaction trace in a short lived cache so that it can be processed if its committed to by a block

Parameters

trace

Definition at line 286 of file account_query_db.cpp.

                                                                              {
         if( !trace->receipt ) return;
         // include only executed transactions; soft_fail included so that onerror (and any inlines via onerror) are included
         if((trace->receipt->status != chain::transaction_receipt_header::executed &&
             trace->receipt->status != chain::transaction_receipt_header::soft_fail)) {
            return;
         }
         if( is_onblock( trace )) {
            onblock_trace.emplace( trace );
         } else if( trace->failed_dtrx_trace ) {
            cached_trace_map[trace->failed_dtrx_trace->id] = trace;
         } else {
            cached_trace_map[trace->id] = trace;
         }
      }

Here is the call graph for this function:

commit_block()

void sysio::chain_apis::account_query_db_impl::commit_block ( const chain::block_state_ptr & bsp )

inline

Commit a block of transactions to the account query DB transaction traces need to be in the cache prior to this call

Parameters

bsp

Definition at line 363 of file account_query_db.cpp.

                                                          {
         permission_set_t updated;
         permission_set_t deleted;
         bool rollback_required = false;
 
         std::tie(updated, deleted, rollback_required) = commit_block_prelock(bsp);
 
         // optimistic skip of locking section if there is nothing to do
         if (!updated.empty() || !deleted.empty() || rollback_required) {
            std::unique_lock write_lock(rw_mutex);
 
            rollback_to_before(bsp);
 
            // insert this blocks time into the time map
            time_to_block_num.emplace(bsp->header.timestamp, bsp->block_num);
 
            const auto bnum = bsp->block_num;
            auto& index = permission_info_index.get<by_owner_name>();
            const auto& permission_by_owner = controller.db().get_index<chain::permission_index>().indices().get<chain::by_owner>();
 
            // for each updated permission, find the new values and update the account query db
            for (const auto& up: updated) {
               auto key = std::make_tuple(up.actor, up.permission);
               auto source_itr = permission_by_owner.find(key);
               SYS_ASSERT(source_itr != permission_by_owner.end(), chain::plugin_exception, "chain data is missing");
               auto itr = index.find(key);
               if (itr == index.end()) {
                  const auto& po = *source_itr;
                  itr = index.emplace(permission_info{ po.owner, po.name, bnum, po.auth.threshold }).first;
               } else {
                  remove_from_bimaps(*itr);
                  index.modify(itr, [&](auto& mutable_pi){
                     mutable_pi.last_updated_height = bnum;
                     mutable_pi.threshold = source_itr->auth.threshold;
                  });
               }
 
               add_to_bimaps(*itr, *source_itr);
            }
 
            // for all deleted permissions, process their removal from the account query DB
            for (const auto& dp: deleted) {
               auto key = std::make_tuple(dp.actor, dp.permission);
               auto itr = index.find(key);
               if (itr != index.end()) {
                  remove_from_bimaps(*itr);
                  index.erase(itr);
               }
            }
         }
 
         // drop any unprocessed cached traces
         cached_trace_map.clear();
         onblock_trace.reset();
      }

Here is the call graph for this function:

commit_block_prelock()

auto sysio::chain_apis::account_query_db_impl::commit_block_prelock ( const chain::block_state_ptr & bsp ) const

inline

Pre-Commit step with const qualifier to guarantee it does not mutate the thread-safe data set

Parameters

bsp

process traces to find updateauth and deleteauth calls maintaining a final set of permissions to either update or delete. Intra-block changes are discarded

Definition at line 308 of file account_query_db.cpp.

                                                                         {
         permission_set_t updated;
         permission_set_t deleted;
 
         auto process_trace = [&](const chain::transaction_trace_ptr& trace) {
            for( const auto& at : trace->action_traces ) {
               if (std::tie(at.receiver, at.act.account) != std::tie(chain::config::system_account_name,chain::config::system_account_name)) {
                  continue;
               }
 
               if (at.act.name == chain::updateauth::get_name()) {
                  auto data = at.act.data_as<chain::updateauth>();
                  auto itr = updated.emplace(chain::permission_level{data.account, data.permission}).first;
                  deleted.erase(*itr);
               } else if (at.act.name == chain::deleteauth::get_name()) {
                  auto data = at.act.data_as<chain::deleteauth>();
                  auto itr = deleted.emplace(chain::permission_level{data.account, data.permission}).first;
                  updated.erase(*itr);
               } else if (at.act.name == chain::newaccount::get_name()) {
                  auto data = at.act.data_as<chain::newaccount>();
                  updated.emplace(chain::permission_level{data.name, "owner"_n});
                  updated.emplace(chain::permission_level{data.name, "active"_n});
               }
            }
         };
 
         if( onblock_trace )
            process_trace(*onblock_trace);
 
         for( const auto& r : bsp->block->transactions ) {
            chain::transaction_id_type id;
            if( std::holds_alternative<chain::transaction_id_type>(r.trx)) {
               id = std::get<chain::transaction_id_type>(r.trx);
            } else {
               id = std::get<chain::packed_transaction>(r.trx).id();
            }
 
            const auto it = cached_trace_map.find( id );
            if( it != cached_trace_map.end() ) {
               process_trace( it->second );
            }
         }
 
         return std::make_tuple(std::move(updated), std::move(deleted), is_rollback_required(bsp));
      }

Here is the call graph for this function:

Here is the caller graph for this function:

get_accounts_by_authorizers()

account_query_db::get_accounts_by_authorizers_result sysio::chain_apis::account_query_db_impl::get_accounts_by_authorizers ( const account_query_db::get_accounts_by_authorizers_params & args ) const

inline

Add a range of results

Definition at line 420 of file account_query_db.cpp.

                                                                                                         {
         std::shared_lock read_lock(rw_mutex);
 
         using result_t = account_query_db::get_accounts_by_authorizers_result;
         result_t result;
 
         // deduplicate inputs
         auto account_set = std::set<chain::permission_level>(args.accounts.begin(), args.accounts.end());
         const auto key_set = std::set<chain::public_key_type>(args.keys.begin(), args.keys.end());
 
         auto push_results = [&result](const auto& begin, const auto& end) {
            for (auto itr = begin; itr != end; ++itr) {
               const auto& pi = itr->second.get();
               const auto& authorizer = itr->first.value;
               auto weight = itr->first.weight;
 
               result.accounts.emplace_back(result_t::account_result{
                     pi.owner,
                     pi.name,
                     make_optional_authorizer<chain::permission_level>(authorizer),
                     make_optional_authorizer<chain::public_key_type>(authorizer),
                     weight,
                     pi.threshold
               });
            }
         };
 
 
         for (const auto& a: account_set) {
            if (a.permission.empty()) {
               // empty permission is a wildcard
               // construct a range between the lower bound of the given account and the lower bound of the
               // next possible account name
               const auto begin = name_bimap.left.lower_bound(weighted<chain::permission_level>::lower_bound_for({a.actor, a.permission}));
               const auto next_account_name = chain::name(a.actor.to_uint64_t() + 1);
               const auto end = name_bimap.left.lower_bound(weighted<chain::permission_level>::lower_bound_for({next_account_name, a.permission}));
               push_results(begin, end);
            } else {
               // construct a range of all possible weights for an account/permission pair
               const auto p = chain::permission_level{a.actor, a.permission};
               const auto begin = name_bimap.left.lower_bound(weighted<chain::permission_level>::lower_bound_for(p));
               const auto end = name_bimap.left.upper_bound(weighted<chain::permission_level>::upper_bound_for(p));
               push_results(begin, end);
            }
         }
 
         for (const auto& k: key_set) {
            // construct a range of all possible weights for a key
            const auto begin = key_bimap.left.lower_bound(weighted<chain::public_key_type>::lower_bound_for(k));
            const auto end = key_bimap.left.upper_bound(weighted<chain::public_key_type>::upper_bound_for(k));
            push_results(begin, end);
         }
 
         return result;
      }

is_rollback_required()

bool sysio::chain_apis::account_query_db_impl::is_rollback_required ( const chain::block_state_ptr & bsp ) const

inline

Definition at line 198 of file account_query_db.cpp.

                                                                         {
         std::shared_lock read_lock(rw_mutex);
         const auto bnum = bsp->block->block_num();
         const auto& index = permission_info_index.get<by_last_updated_height>();
 
         if (index.empty()) {
            return false;
         } else {
            const auto& pi = (*index.rbegin());
            if (pi.last_updated_height < bnum) {
               return false;
            }
         }
 
         return true;
      }

Here is the caller graph for this function:

last_updated_time_to_height()

uint32_t sysio::chain_apis::account_query_db_impl::last_updated_time_to_height ( const fc::time_point & last_updated )

inline

Definition at line 215 of file account_query_db.cpp.

                                                                              {
         const auto lib_num = controller.last_irreversible_block_num();
         const auto lib_time = controller.last_irreversible_block_time();
 
         uint32_t last_updated_height = lib_num;
         if (last_updated > lib_time) {
            const auto iter = time_to_block_num.find(last_updated);
            SYS_ASSERT(iter != time_to_block_num.end(), chain::plugin_exception, "invalid block time encountered in on-chain accounts ${time}", ("time", last_updated));
            last_updated_height = iter->second;
         }
 
         return last_updated_height;
      }

Here is the call graph for this function:

Here is the caller graph for this function:

remove_from_bimaps()

void sysio::chain_apis::account_query_db_impl::remove_from_bimaps ( const permission_info & pi )

inline

Remove a permission from the bimaps for keys and accounts

Parameters

pi	- the ephemeral permission info structure being removed

Definition at line 188 of file account_query_db.cpp.

                                                           {
         // remove all entries from the name bimap that refer to this permission_info's reference
         const auto name_range = name_bimap.right.equal_range(pi);
         name_bimap.right.erase(name_range.first, name_range.second);
 
         // remove all entries from the key bimap that refer to this permission_info's reference
         const auto key_range = key_bimap.right.equal_range(pi);
         key_bimap.right.erase(key_range.first, key_range.second);
      }

Here is the caller graph for this function:

rollback_to_before()

void sysio::chain_apis::account_query_db_impl::rollback_to_before ( const chain::block_state_ptr & bsp )

inline

Given a block number, remove all permissions that were last updated at or after that block number this will effectively roll back the database to just before the incoming block

For each removed entry, this will create a new entry if there exists an equivalent {owner, name} permission at the HEAD state of the chain.

Parameters

bsp	- the block to rollback before

Definition at line 237 of file account_query_db.cpp.

                                                                 {
         const auto bnum = bsp->block->block_num();
         auto& index = permission_info_index.get<by_last_updated_height>();
         const auto& permission_by_owner = controller.db().get_index<chain::permission_index>().indices().get<chain::by_owner>();
 
         // roll back time-map
         auto time_iter = time_to_block_num.rbegin();
         while (time_iter != time_to_block_num.rend() && time_iter->second >= bnum) {
            time_iter = decltype(time_iter){time_to_block_num.erase( std::next(time_iter).base() )};
         }
 
         auto curr_iter = index.rbegin();
         while (!index.empty()) {
            if (curr_iter == index.rend()) {
               break;
            }
 
            const auto& pi = (*curr_iter);
            if (pi.last_updated_height < bnum) {
               break;
            }
 
            // remove this entry from the bimaps
            remove_from_bimaps(pi);
 
            auto itr = permission_by_owner.find(std::make_tuple(pi.owner, pi.name));
            if (itr == permission_by_owner.end()) {
               // this permission does not exist at this point in the chains history
               curr_iter = decltype(curr_iter)( index.erase(index.iterator_to(pi)) );
            } else {
               const auto& po = *itr;
 
               uint32_t last_updated_height = po.last_updated == bsp->header.timestamp ? bsp->block_num : last_updated_time_to_height(po.last_updated);
 
               index.modify(index.iterator_to(pi), [&po, last_updated_height](auto& mutable_pi) {
                  mutable_pi.last_updated_height = last_updated_height;
                  mutable_pi.threshold = po.auth.threshold;
               });
               add_to_bimaps(pi, po);
               ++curr_iter;
            }
         }
      }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

cached_trace_map

cached_trace_map_t sysio::chain_apis::account_query_db_impl::cached_trace_map

Definition at line 486 of file account_query_db.cpp.

controller

const chain::controller& sysio::chain_apis::account_query_db_impl::controller

Definition at line 485 of file account_query_db.cpp.

key_bimap

key_bimap_t sysio::chain_apis::account_query_db_impl::key_bimap

Definition at line 503 of file account_query_db.cpp.

name_bimap

name_bimap_t sysio::chain_apis::account_query_db_impl::name_bimap

Definition at line 502 of file account_query_db.cpp.

onblock_trace

onblock_trace_t sysio::chain_apis::account_query_db_impl::onblock_trace

Definition at line 487 of file account_query_db.cpp.

permission_info_index

permission_info_index_t sysio::chain_apis::account_query_db_impl::permission_info_index

Definition at line 501 of file account_query_db.cpp.

rw_mutex

std::shared_mutex sysio::chain_apis::account_query_db_impl::rw_mutex

mutable

Definition at line 505 of file account_query_db.cpp.

time_to_block_num

time_map_t sysio::chain_apis::account_query_db_impl::time_to_block_num

Definition at line 490 of file account_query_db.cpp.

---

The documentation for this struct was generated from the following file:

• plugins/chain_plugin/account_query_db.cpp