sysio::trace_api_rpc_plugin_impl Struct Reference

Inheritance diagram for sysio::trace_api_rpc_plugin_impl:

Collaboration diagram for sysio::trace_api_rpc_plugin_impl:

Public Types
using	request_handler_t = request_handler<shared_store_provider<store_provider>, abi_data_handler::shared_provider>

Public Member Functions
	trace_api_rpc_plugin_impl (const std::shared_ptr< trace_api_common_impl > &common)
void	plugin_initialize (const appbase::variables_map &options)
fc::time_point	calc_deadline (const fc::microseconds &max_serialization_time)
void	plugin_startup ()
void	plugin_shutdown ()

Static Public Member Functions
static void	set_program_options (appbase::options_description &cli, appbase::options_description &cfg)

Public Attributes
std::shared_ptr< trace_api_common_impl >	common
std::shared_ptr< request_handler_t >	req_handler

Detailed Description

Interface with the RPC process

Definition at line 179 of file trace_api_plugin.cpp.

Member Typedef Documentation

request_handler_t

using sysio::trace_api_rpc_plugin_impl::request_handler_t = request_handler<shared_store_provider<store_provider>, abi_data_handler::shared_provider>

Definition at line 354 of file trace_api_plugin.cpp.

Constructor & Destructor Documentation

trace_api_rpc_plugin_impl()

sysio::trace_api_rpc_plugin_impl::trace_api_rpc_plugin_impl ( const std::shared_ptr< trace_api_common_impl > & common )

inline

Definition at line 181 of file trace_api_plugin.cpp.

   :common(common) {}

Member Function Documentation

calc_deadline()

fc::time_point sysio::trace_api_rpc_plugin_impl::calc_deadline ( const fc::microseconds & max_serialization_time )

inline

Definition at line 236 of file trace_api_plugin.cpp.

                                                                              {
      fc::time_point deadline = fc::time_point::now();
      if( max_serialization_time > fc::microseconds::maximum() - deadline.time_since_epoch() ) {
         deadline = fc::time_point::maximum();
      } else {
         deadline += max_serialization_time;
      }
      return deadline;
   }

Here is the call graph for this function:

plugin_initialize()

void sysio::trace_api_rpc_plugin_impl::plugin_initialize ( const appbase::variables_map & options )

inline

Definition at line 201 of file trace_api_plugin.cpp.

                                                               {
      ilog("initializing trace api rpc plugin");
      std::shared_ptr<abi_data_handler> data_handler = std::make_shared<abi_data_handler>([](const exception_with_context& e){
         log_exception(e, fc::log_level::debug);
      });
 
      if( options.count("trace-rpc-abi") ) {
         SYS_ASSERT(options.count("trace-no-abis") == 0, chain::plugin_config_exception,
                    "Trace API is configured with ABIs however trace-no-abis is set");
         const std::vector<std::string> key_value_pairs = options["trace-rpc-abi"].as<std::vector<std::string>>();
         for (const auto& entry : key_value_pairs) {
            try {
               auto kv = parse_kv_pairs(entry);
               auto account = chain::name(kv.first);
               auto abi = abi_def_from_file(kv.second, app().data_dir());
               data_handler->add_abi(account, abi);
            } catch (...) {
               elog("Malformed trace-rpc-abi provider: \"${val}\"", ("val", entry));
               throw;
            }
         }
      } else {
         SYS_ASSERT(options.count("trace-no-abis") != 0, chain::plugin_config_exception,
                    "Trace API is not configured with ABIs and trace-no-abis is not set");
      }
 
      req_handler = std::make_shared<request_handler_t>(
         shared_store_provider<store_provider>(common->store),
         abi_data_handler::shared_provider(data_handler),
         [](const std::string& msg ) {
            fc_dlog( _log, msg );
         }
      );
   }

Here is the call graph for this function:

plugin_shutdown()

void sysio::trace_api_rpc_plugin_impl::plugin_shutdown ( )

inline

Definition at line 349 of file trace_api_plugin.cpp.

                          {
   }

plugin_startup()

void sysio::trace_api_rpc_plugin_impl::plugin_startup ( )

inline

Definition at line 246 of file trace_api_plugin.cpp.

                         {
      auto& http = app().get_plugin<http_plugin>();
      fc::microseconds max_response_time = http.get_max_response_time();
 
      http.add_async_handler("/v1/trace_api/get_block",
            [wthis=weak_from_this(), max_response_time](std::string, std::string body, url_response_callback cb)
      {
         auto that = wthis.lock();
         if (!that) {
            return;
         }
 
         auto block_number = ([&body]() -> std::optional<uint32_t> {
            if (body.empty()) {
               return {};
            }
 
            try {
               auto input = fc::json::from_string(body);
               auto block_num = input.get_object()["block_num"].as_uint64();
               if (block_num > std::numeric_limits<uint32_t>::max()) {
                  return {};
               }
               return block_num;
            } catch (...) {
               return {};
            }
         })();
 
         if (!block_number) {
            error_results results{400, "Bad or missing block_num"};
            cb( 400, fc::variant( results ));
            return;
         }
 
         try {
 
            const auto deadline = that->calc_deadline( max_response_time );
            auto resp = that->req_handler->get_block_trace(*block_number, [deadline]() { FC_CHECK_DEADLINE(deadline); });
            if (resp.is_null()) {
               error_results results{404, "Trace API: block trace missing"};
               cb( 404, fc::variant( results ));
            } else {
               cb( 200, std::move(resp) );
            }
         } catch (...) {
            http_plugin::handle_exception("trace_api", "get_block", body, cb);
         }
      });
 
 
      http.add_async_handler("/v1/trace_api/get_transaction_trace",
            [wthis=weak_from_this(), max_response_time, this](std::string, std::string body, url_response_callback cb)
      {
         auto that = wthis.lock();
         if (!that) {
            return;
         }
 
         auto trx_id = ([&body]() -> std::optional<transaction_id_type> {
            if (body.empty()) {
               return {};
            }
            try {
               auto input = fc::json::from_string(body);
               auto trxid = input.get_object()["id"].as_string();
               if (trxid.size() < 8 || trxid.size() > 64) {
                  return {};
               }
               return transaction_id_type(trxid);
            } catch (...) {
               return {};
            }
         })();
 
         if (!trx_id) {
            error_results results{400, "Bad or missing transaction ID"};
            cb( 400, fc::variant( results ));
            return;
         }
 
         try {
            const auto deadline = that->calc_deadline( max_response_time );
            // search for the block that contains the transaction
            get_block_n blk_num = common->store->get_trx_block_number(*trx_id, common->minimum_irreversible_history_blocks, [deadline]() { FC_CHECK_DEADLINE(deadline); });
            if (!blk_num.has_value()){
               error_results results{404, "Trace API: transaction id missing in the transaction id log files"};
               cb( 404, fc::variant( results ));
            } else {
               auto resp = that->req_handler->get_transaction_trace(*trx_id, *blk_num, [deadline]() { FC_CHECK_DEADLINE(deadline); });
               if (resp.is_null()) {
                  error_results results{404, "Trace API: transaction trace missing"};
                  cb( 404, fc::variant( results ));
               } else {
                  cb( 200, std::move(resp) );
               }
            }
          } catch (...) {
             http_plugin::handle_exception("trace_api", "get_transaction", body, cb);
          }
      });
   }

Here is the call graph for this function:

set_program_options()

static void sysio::trace_api_rpc_plugin_impl::set_program_options ( appbase::options_description & cli, appbase::options_description & cfg )

inlinestatic

Definition at line 184 of file trace_api_plugin.cpp.

                                                                                                     {
      auto cfg_options = cfg.add_options();
      cfg_options("trace-rpc-abi", bpo::value<vector<string>>()->composing(),
                  "ABIs used when decoding trace RPC responses.\n"
                  "There must be at least one ABI specified OR the flag trace-no-abis must be used.\n"
                  "ABIs are specified as \"Key=Value\" pairs in the form <account-name>=<abi-def>\n"
                  "Where <abi-def> can be:\n"
                  "   an absolute path to a file containing a valid JSON-encoded ABI\n"
                  "   a relative path from `data-dir` to a file containing a valid JSON-encoded ABI\n"
                  );
      cfg_options("trace-no-abis",
            "Use to indicate that the RPC responses will not use ABIs.\n"
            "Failure to specify this option when there are no trace-rpc-abi configuations will result in an Error.\n"
            "This option is mutually exclusive with trace-rpc-api"
      );
   }

Here is the caller graph for this function:

Member Data Documentation

common

std::shared_ptr<trace_api_common_impl> sysio::trace_api_rpc_plugin_impl::common

Definition at line 352 of file trace_api_plugin.cpp.

req_handler

std::shared_ptr<request_handler_t> sysio::trace_api_rpc_plugin_impl::req_handler

Definition at line 355 of file trace_api_plugin.cpp.

---

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

• plugins/trace_api_plugin/trace_api_plugin.cpp