request_handler.hpp

Go to the documentation of this file.

#pragma once
 
#include <fc/variant.hpp>
#include <sysio/trace_api/metadata_log.hpp>
#include <sysio/trace_api/data_log.hpp>
#include <sysio/trace_api/common.hpp>
 
namespace sysio::trace_api {
   using data_handler_function = std::function<std::tuple<fc::variant, std::optional<fc::variant>>( const std::variant<action_trace_v0, action_trace_v1> & action_trace_t, const yield_function&)>;
 
   namespace detail {
      class response_formatter {
      public:
         static fc::variant process_block( const data_log_entry& trace, bool irreversible, const data_handler_function& data_handler, const yield_function& yield );
      };
   }
 
   template<typename LogfileProvider, typename DataHandlerProvider>
   class request_handler {
   public:
      request_handler(LogfileProvider&& logfile_provider, DataHandlerProvider&& data_handler_provider, log_handler log)
      :logfile_provider(std::move(logfile_provider))
      ,data_handler_provider(std::move(data_handler_provider))
      ,_log(log)
      {
         _log("Constructed request_handler");
      }
 
      fc::variant get_block_trace( uint32_t block_height, const yield_function& yield = {}) {
         auto data = logfile_provider.get_block(block_height, yield);
         if (!data) {
            _log("No block found at block height " + std::to_string(block_height) );
            return {};
         }
 
         yield();
 
         auto data_handler = [this](const auto& action, const yield_function& yield) -> std::tuple<fc::variant, std::optional<fc::variant>> {
            return std::visit([&](const auto& action_trace_t) {
               return data_handler_provider.serialize_to_variant(action_trace_t, yield);
            }, action);
         };
 
         return detail::response_formatter::process_block(std::get<0>(*data), std::get<1>(*data), data_handler, yield);
      }
 
      fc::variant get_transaction_trace(chain::transaction_id_type trxid, uint32_t block_height, const yield_function& yield = {}){
         _log("get_transaction_trace called" );
         fc::variant result = {};
         // extract the transaction trace from the block trace
         auto resp = get_block_trace(block_height, yield);
         if (!resp.is_null()) {
            auto& b_mvo = resp.get_object();
            if (b_mvo.contains("transactions")) {
               auto& transactions = b_mvo["transactions"];
               std::string input_id = trxid.str();
               for (uint32_t i = 0; i < transactions.size(); ++i) {
                  if (transactions[i].is_null()) continue;
                  auto& t_mvo = transactions[i].get_object();
                  if (t_mvo.contains("id")) {
                     const auto& t_id = t_mvo["id"].get_string();
                     if (t_id == input_id) {
                        result = transactions[i];
                        break;
                     }
                  }
               }
               if( result.is_null() )
                  _log("Exhausted all " + std::to_string(transactions.size()) + " transactions in block " + b_mvo["number"].as_string() + " without finding trxid " + trxid.str());
            }
         }
         return result;
      }
 
   private:
      LogfileProvider logfile_provider;
      DataHandlerProvider data_handler_provider;
      log_handler _log;
   };
 
 
}