Move abi serialization of transaction trace off main thread

libraries/chain/include/eosio/chain/abi_serializer.hpp

@@ -485,14 +485,15 @@ namespace impl {
          };
 
          try {
-            auto abi = resolver(act.account);
-            if (abi) {
-               auto type = abi->get_action_type(act.name);
+            auto abi_optional = resolver(act.account);
+            if (abi_optional) {
+               auto& abi = (abi_serializer&)*abi_optional;
+               auto type = abi.get_action_type(act.name);
                if (!type.empty()) {
                   try {
-                     binary_to_variant_context _ctx(*abi, ctx, type);
+                     binary_to_variant_context _ctx(abi, ctx, type);
                      _ctx.short_path = true; // Just to be safe while avoiding the complexity of threading an override boolean all over the place
-                     mvo( "data", abi->_binary_to_variant( type, act.data, _ctx ));
+                     mvo( "data", abi._binary_to_variant( type, act.data, _ctx ));
                   } catch(...) {
                      // any failure to serialize data, then leave as not serailzed
                      set_hex_data(mvo, "data", act.data);
@@ -546,13 +547,14 @@ namespace impl {
          mvo("return_value_hex_data", act_trace.return_value);
          auto act = act_trace.act;
          try {
-            auto abi = resolver(act.account);
-            if (abi) {
-               auto type = abi->get_action_result_type(act.name);
+            auto abi_optional = resolver(act.account);
+            if (abi_optional) {
+               auto& abi = (abi_serializer&)*abi_optional;
+               auto type = abi.get_action_result_type(act.name);
                if (!type.empty()) {
-                  binary_to_variant_context _ctx(*abi, ctx, type);
+                  binary_to_variant_context _ctx(abi, ctx, type);
                   _ctx.short_path = true; // Just to be safe while avoiding the complexity of threading an override boolean all over the place
-                  mvo( "return_value_data", abi->_binary_to_variant( type, act_trace.return_value, _ctx ));
+                  mvo( "return_value_data", abi._binary_to_variant( type, act_trace.return_value, _ctx ));
                }
             }
          } catch(...) {}
@@ -678,13 +680,13 @@ namespace impl {
     * this will degrade to the common fc::to_variant as soon as the type no longer contains
     * ABI related info
     *
-    * @tparam Reslover - callable with the signature (const name& code_account) -> std::optional<abi_def>
+    * @tparam Resolver - callable with the signature (const name& code_account) -> std::optional<abi_def>
     */
    template<typename T, typename Resolver>
    class abi_to_variant_visitor
    {
       public:
-         abi_to_variant_visitor( mutable_variant_object& _mvo, const T& _val, Resolver _resolver, abi_traverse_context& _ctx )
+         abi_to_variant_visitor( mutable_variant_object& _mvo, const T& _val, Resolver& _resolver, abi_traverse_context& _ctx )
          :_vo(_mvo)
          ,_val(_val)
          ,_resolver(_resolver)
@@ -707,7 +709,7 @@ namespace impl {
       private:
          mutable_variant_object& _vo;
          const T& _val;
-         Resolver _resolver;
+         Resolver& _resolver;
          abi_traverse_context& _ctx;
    };
 
@@ -890,7 +892,7 @@ namespace impl {
    class abi_from_variant_visitor : public reflector_init_visitor<T>
    {
       public:
-         abi_from_variant_visitor( const variant_object& _vo, T& v, Resolver _resolver, abi_traverse_context& _ctx )
+         abi_from_variant_visitor( const variant_object& _vo, T& v, Resolver& _resolver, abi_traverse_context& _ctx )
          : reflector_init_visitor<T>(v)
          ,_vo(_vo)
          ,_resolver(_resolver)
@@ -914,7 +916,7 @@ namespace impl {
 
       private:
          const variant_object& _vo;
-         Resolver _resolver;
+         Resolver& _resolver;
          abi_traverse_context& _ctx;
    };
 

libraries/chain/include/eosio/chain/exceptions.hpp

@@ -87,6 +87,26 @@
       NEXT(e.dynamic_copy_exception());\
    }
 
+/**
+ * Capture all exceptions and return a fc::exception_ptr
+ */
+#define CATCH_AND_RETURN(return_type)\
+   catch ( const fc::exception& err ) {\
+      return return_type(err.dynamic_copy_exception());\
+   } catch ( const std::exception& e ) {\
+      fc::exception fce( \
+         FC_LOG_MESSAGE( warn, "rethrow ${what}: ", ("what",e.what())),\
+         fc::std_exception_code,\
+         BOOST_CORE_TYPEID(e).name(),\
+         e.what() ) ;\
+      return return_type(fce.dynamic_copy_exception());\
+   } catch( ... ) {\
+      fc::unhandled_exception e(\
+         FC_LOG_MESSAGE(warn, "rethrow"),\
+         std::current_exception());\
+      return return_type(e.dynamic_copy_exception());\
+   }
+
 #define EOS_RECODE_EXC( cause_type, effect_type ) \
    catch( const cause_type& e ) \
    { throw( effect_type( e.what(), e.get_log() ) ); }

libraries/chain/include/eosio/chain/types.hpp

@@ -405,7 +405,10 @@ namespace eosio::chain {
    // http_plugin thread pool) and which completes the API processing and returns the result T.
    // -------------------------------------------------------------------------------------------------------
    template<typename T>
-   using next_function_variant = std::variant<fc::exception_ptr, T, std::function<T()>>;
+   using t_or_exception = std::variant<fc::exception_ptr, T>;
+
+   template<typename T>
+   using next_function_variant = std::variant<fc::exception_ptr, T, std::function<t_or_exception<T>()>>;
 
    template<typename T>
    using next_function = std::function<void(const next_function_variant<T>&)>;

plugins/chain_api_plugin/chain_api_plugin.cpp

@@ -55,39 +55,46 @@ parse_params<chain_apis::read_only::get_transaction_status_params, http_params_t
           } \
        }}
 
+// call an API which returns either fc::exception_ptr, or a function to be posted on the http thread pool
+// for execution (typically doing the final serialization)
+// ------------------------------------------------------------------------------------------------------
+#define CALL_WITH_400_POST(api_name, api_handle, api_namespace, call_name, http_resp_code, params_type)         \
+{std::string("/v1/" #api_name "/" #call_name),                                                                  \
+      [api_handle, _http_plugin](string&&, string&& body, url_response_callback&& cb) mutable {                 \
+          auto deadline = api_handle.start();                                                                   \
+          try {                                                                                                 \
+             auto params = parse_params<api_namespace::call_name ## _params, params_type>(body);                \
+             FC_CHECK_DEADLINE(deadline);                                                                       \
+             using http_fwd_t = std::function<chain::t_or_exception<fc::variant>()>;                            \
+             http_fwd_t http_fwd( api_handle.call_name( std::move(params), deadline ) );                        \
+             FC_CHECK_DEADLINE(deadline);                                                                       \
+             _http_plugin.post_http_thread_pool([resp_code=http_resp_code, cb=std::move(cb),                    \
+                                                 body=std::move(body),                                          \
+                                                 http_fwd = std::move(http_fwd)]() {                            \
+                auto result = http_fwd(); /* this returns a t_or_exception variant */                           \
+                if (std::holds_alternative<fc::exception_ptr>(result)) {                                        \
+                   try {                                                                                        \
+                      std::get<fc::exception_ptr>(result)->dynamic_rethrow_exception();                         \
+                   } catch (...) {                                                                              \
+                      http_plugin::handle_exception(#api_name, #call_name, body, cb);                           \
+                   }                                                                                            \
+                } else {                                                                                        \
+                   cb(resp_code, fc::time_point::maximum(), std::get<fc::variant>(result)) ;                    \
+                }                                                                                               \
+             });                                                                                                \
+          } catch (...) {                                                                                       \
+             http_plugin::handle_exception(#api_name, #call_name, body, cb);                                    \
+          }                                                                                                     \
+       }}
+
 #define CHAIN_RO_CALL(call_name, http_response_code, params_type) CALL_WITH_400(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
 #define CHAIN_RW_CALL(call_name, http_response_code, params_type) CALL_WITH_400(chain, rw_api, chain_apis::read_write, call_name, http_response_code, params_type)
+#define CHAIN_RO_CALL_POST(call_name, http_response_code, params_type) CALL_WITH_400_POST(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
 #define CHAIN_RO_CALL_ASYNC(call_name, call_result, http_response_code, params_type) CALL_ASYNC_WITH_400(chain, ro_api, chain_apis::read_only, call_name, call_result, http_response_code, params_type)
 #define CHAIN_RW_CALL_ASYNC(call_name, call_result, http_response_code, params_type) CALL_ASYNC_WITH_400(chain, rw_api, chain_apis::read_write, call_name, call_result, http_response_code, params_type)
 
 #define CHAIN_RO_CALL_WITH_400(call_name, http_response_code, params_type) CALL_WITH_400(chain, ro_api, chain_apis::read_only, call_name, http_response_code, params_type)
 
-template<class API, class PARAMS_PARSER, class HANDLER>
-static api_entry make_api_entry(http_plugin& _http_plugin, API& api, const char* api_name,
-                                const char* call_name, PARAMS_PARSER params_parser, HANDLER handler) {
-   return api_entry(
-      std::string("/v1/") + api_name + "/" + call_name,
-      [&_http_plugin, api, api_name, call_name,
-       params_parser = std::move(params_parser), handler = std::move(handler)](string&&, string&& body, url_response_callback&& cb) {
-         auto deadline = api.start();
-         try {
-            auto start = fc::time_point::now();
-            auto params = params_parser(body);
-            FC_CHECK_DEADLINE(deadline);
-
-            // call first handler on main thread (likely because it accesses non thread-safe data)
-            // returns a thread-safe lambda that can be enqueued on the http thread pool to complete the request
-            auto completion_handler = handler(api, start, deadline, params, cb);
-            FC_CHECK_DEADLINE(deadline); // make sure remaining time is > 0
-
-            // execute thread-safe http_handler on _http_plugin's thread pool
-            _http_plugin.post_http_thread_pool(std::move(completion_handler));
-         } catch (...) {
-            http_plugin::handle_exception(api_name, call_name, body, cb);
-         }
-      });
-}
-
 void chain_api_plugin::plugin_startup() {
    ilog( "starting chain_api_plugin" );
    my.reset(new chain_api_plugin_impl(app().get_plugin<chain_plugin>().chain()));
@@ -104,6 +111,7 @@ void chain_api_plugin::plugin_startup() {
       CHAIN_RO_CALL(get_info, 200, http_params_types::no_params)}, appbase::exec_queue::read_only, appbase::priority::medium_high);
    _http_plugin.add_api({
       CHAIN_RO_CALL(get_activated_protocol_features, 200, http_params_types::possible_no_params),
+      CHAIN_RO_CALL_POST(get_block, 200, http_params_types::params_required), // _POST because get_block() returns a lambda to be executed on the http thread pool
       CHAIN_RO_CALL(get_block_info, 200, http_params_types::params_required),
       CHAIN_RO_CALL(get_block_header_state, 200, http_params_types::params_required),
       CHAIN_RO_CALL(get_account, 200, http_params_types::params_required),
@@ -153,31 +161,6 @@ void chain_api_plugin::plugin_startup() {
       }, appbase::exec_queue::read_only);
    }
 
-   _http_plugin.add_api({
-         make_api_entry(
-            _http_plugin, ro_api, "chain", "get_block",
-            [](const string& body) {
-               return parse_params<chain_apis::read_only::get_raw_block_params, http_params_types::params_required>(body);
-            },
-            [max_response_time, &chain](auto& api, fc::time_point start, fc::time_point deadline, auto &params, const url_response_callback &cb) {
-
-               chain::signed_block_ptr block = api.get_raw_block(params, deadline);
-               auto max_time = std::min(chain.get_abi_serializer_max_time(), max_response_time);
-               auto abi_cache = api.get_block_serializers(block, max_time);
-               auto post_time = fc::time_point::now();
-               auto remaining_time = max_time - (post_time - start);
-
-               return [api, cb, deadline, post_time, remaining_time, abi_cache=std::move(abi_cache), block=std::move(block)]() mutable {
-                  try {
-                     auto new_deadline = deadline + (fc::time_point::now() - post_time);
-                     fc::variant result = api.convert_block(block, std::move(abi_cache), remaining_time);
-                     cb(200, new_deadline, std::move(result));
-                  } catch( ... ) {
-                     http_plugin::handle_exception("chain", "get_block", "", cb);
-                  }
-               };
-            })},
-      appbase::exec_queue::read_only);
 }
 
 void chain_api_plugin::plugin_shutdown() {}