Use command line --abi-serializer-max-time-ms of chain_plugin for abi serializer deadline.

Author: heifner

libraries/chain/include/eosio/chain/config.hpp

@@ -92,7 +92,7 @@ const static uint32_t   setcode_ram_bytes_multiplier       = 10;     ///< multip
 const static uint32_t   hashing_checktime_block_size       = 10*1024;  /// call checktime from hashing intrinsic once per this number of bytes
 
 const static eosio::chain::wasm_interface::vm_type default_wasm_runtime = eosio::chain::wasm_interface::vm_type::binaryen;
-const static fc::microseconds default_abi_serializer_max_time_ms = fc::microseconds(15*1000);
+const static uint32_t   default_abi_serializer_max_time_ms = 15*1000; ///< default deadline for abi serialization methods
 
 /**
  *  The number of sequential blocks produced by a single producer

plugins/chain_plugin/chain_plugin.cpp

@@ -128,6 +128,8 @@ class chain_plugin_impl {
    fc::optional<chain_id_type>      chain_id;
    //txn_msg_rate_limits              rate_limits;
    fc::optional<vm_type>            wasm_runtime;
+   fc::microseconds                 abi_serializer_max_time_ms;
+
 
    // retained references to channels for easy publication
    channels::pre_accepted_block::channel_type&     pre_accepted_block_channel;
@@ -174,7 +176,8 @@ void chain_plugin::set_program_options(options_description& cli, options_descrip
           "the location of the blocks directory (absolute path or relative to application data dir)")
          ("checkpoint", bpo::value<vector<string>>()->composing(), "Pairs of [BLOCK_NUM,BLOCK_ID] that should be enforced as checkpoints.")
          ("wasm-runtime", bpo::value<eosio::chain::wasm_interface::vm_type>()->value_name("wavm/binaryen"), "Override default WASM runtime")
-         ("abi-serializer-max-time-ms", bpo::value<uint32_t>(), "Override default maximum ABI serialization time allowed in ms")
+         ("abi-serializer-max-time-ms", bpo::value<uint32_t>()->default_value(config::default_abi_serializer_max_time_ms),
+          "Override default maximum ABI serialization time allowed in ms")
          ("chain-state-db-size-mb", bpo::value<uint64_t>()->default_value(config::default_state_size / (1024  * 1024)), "Maximum size (in MB) of the chain state database")
          ("reversible-blocks-db-size-mb", bpo::value<uint64_t>()->default_value(config::default_reversible_cache_size / (1024  * 1024)), "Maximum size (in MB) of the reversible blocks database")
          ("contracts-console", bpo::bool_switch()->default_value(false),
@@ -327,7 +330,7 @@ void chain_plugin::plugin_initialize(const variables_map& options) {
          my->wasm_runtime = options.at( "wasm-runtime" ).as<vm_type>();
 
       if(options.count("abi-serializer-max-time-ms"))
-         my->chain_config->abi_serializer_max_time_ms = fc::microseconds(options.at("abi-serializer-max-time-ms").as<uint32_t>() * 1000);
+         my->abi_serializer_max_time_ms = fc::microseconds(options.at("abi-serializer-max-time-ms").as<uint32_t>() * 1000);
 
       my->chain_config->blocks_dir = my->blocks_dir;
       my->chain_config->state_dir = app().data_dir() / config::default_state_dir_name;
@@ -573,7 +576,7 @@ void chain_plugin::plugin_shutdown() {
 }
 
 chain_apis::read_write chain_plugin::get_read_write_api() {
-   return chain_apis::read_write(chain());
+   return chain_apis::read_write(chain(), get_abi_serializer_max_time());
 }
 
 void chain_plugin::accept_block(const signed_block_ptr& block ) {
@@ -744,6 +747,11 @@ chain::chain_id_type chain_plugin::get_chain_id()const {
    return *my->chain_id;
 }
 
+fc::microseconds chain_plugin::get_abi_serializer_max_time() const {
+   return my->abi_serializer_max_time_ms;
+}
+
+
 namespace chain_apis {
 
 const string read_only::KEYi64 = "i64";
@@ -939,12 +947,12 @@ read_only::get_producers_result read_only::get_producers( const read_only::get_p
       }
       copy_inline_row(*kv_index.find(boost::make_tuple(table_id->id, it->primary_key)), data);
       if (p.json)
-         result.rows.emplace_back(abis.binary_to_variant(abis.get_table_type(N(producers)), data, db.get_abi_serializer_max_time_ms()));
+         result.rows.emplace_back(abis.binary_to_variant(abis.get_table_type(N(producers)), data, abi_serializer_max_time));
       else
          result.rows.emplace_back(fc::variant(data));
    }
 
-   result.total_producer_vote_weight = get_global_row(d, abi, abis, db.get_abi_serializer_max_time_ms())["total_producer_vote_weight"].as_double();
+   result.total_producer_vote_weight = get_global_row(d, abi, abis, abi_serializer_max_time)["total_producer_vote_weight"].as_double();
    return result;
 }
 
@@ -995,7 +1003,7 @@ fc::variant read_only::get_block(const read_only::get_block_params& params) cons
    EOS_ASSERT( block, unknown_block_exception, "Could not find block: ${block}", ("block", params.block_num_or_id));
 
    fc::variant pretty_output;
-   abi_serializer::to_variant(*block, pretty_output, make_resolver(this), db.get_abi_serializer_max_time_ms());
+   abi_serializer::to_variant(*block, pretty_output, make_resolver(this), abi_serializer_max_time);
 
    uint32_t ref_block_prefix = block->id()._hash[1];
 
@@ -1043,7 +1051,7 @@ void read_write::push_transaction(const read_write::push_transaction_params& par
       auto pretty_input = std::make_shared<packed_transaction>();
       auto resolver = make_resolver(this);
       try {
-         abi_serializer::from_variant(params, *pretty_input, resolver, db.get_abi_serializer_max_time_ms());
+         abi_serializer::from_variant(params, *pretty_input, resolver, abi_serializer_max_time);
       } EOS_RETHROW_EXCEPTIONS(chain::packed_transaction_type_exception, "Invalid packed transaction")
 
       app().get_method<incoming::methods::transaction_async>()(pretty_input, true, [this, next](const fc::static_variant<fc::exception_ptr, transaction_trace_ptr>& result) -> void{
@@ -1054,7 +1062,7 @@ void read_write::push_transaction(const read_write::push_transaction_params& par
 
             try {
                fc::variant pretty_output;
-               pretty_output = db.to_variant_with_abi(*trx_trace_ptr);
+               pretty_output = db.to_variant_with_abi(*trx_trace_ptr, abi_serializer_max_time);
                //abi_serializer::to_variant(*trx_trace_ptr, pretty_output, resolver);
 
                chain::transaction_id_type id = trx_trace_ptr->id;
@@ -1212,7 +1220,7 @@ read_only::get_account_results read_only::get_account( const get_account_params&
          if ( it != idx.end() ) {
             vector<char> data;
             copy_inline_row(*it, data);
-            result.total_resources = abis.binary_to_variant( "user_resources", data, db.get_abi_serializer_max_time_ms() );
+            result.total_resources = abis.binary_to_variant( "user_resources", data, abi_serializer_max_time );
          }
       }
 
@@ -1223,7 +1231,7 @@ read_only::get_account_results read_only::get_account( const get_account_params&
          if ( it != idx.end() ) {
             vector<char> data;
             copy_inline_row(*it, data);
-            result.self_delegated_bandwidth = abis.binary_to_variant( "delegated_bandwidth", data, db.get_abi_serializer_max_time_ms() );
+            result.self_delegated_bandwidth = abis.binary_to_variant( "delegated_bandwidth", data, abi_serializer_max_time );
          }
       }
 
@@ -1234,7 +1242,7 @@ read_only::get_account_results read_only::get_account( const get_account_params&
          if ( it != idx.end() ) {
             vector<char> data;
             copy_inline_row(*it, data);
-            result.refund_request = abis.binary_to_variant( "refund_request", data, db.get_abi_serializer_max_time_ms() );
+            result.refund_request = abis.binary_to_variant( "refund_request", data, abi_serializer_max_time );
          }
       }
 
@@ -1245,7 +1253,7 @@ read_only::get_account_results read_only::get_account( const get_account_params&
          if ( it != idx.end() ) {
             vector<char> data;
             copy_inline_row(*it, data);
-            result.voter_info = abis.binary_to_variant( "voter_info", data, db.get_abi_serializer_max_time_ms() );
+            result.voter_info = abis.binary_to_variant( "voter_info", data, abi_serializer_max_time );
          }
       }
    }
@@ -1271,7 +1279,7 @@ read_only::abi_json_to_bin_result read_only::abi_json_to_bin( const read_only::a
       auto action_type = abis.get_action_type(params.action);
       EOS_ASSERT(!action_type.empty(), action_validate_exception, "Unknown action ${action} in contract ${contract}", ("action", params.action)("contract", params.code));
       try {
-         result.binargs = abis.variant_to_binary(action_type, params.args, db.get_abi_serializer_max_time_ms());
+         result.binargs = abis.variant_to_binary(action_type, params.args, abi_serializer_max_time);
       } EOS_RETHROW_EXCEPTIONS(chain::invalid_action_args_exception,
                                 "'${args}' is invalid args for action '${action}' code '${code}'. expected '${proto}'",
                                 ("args", params.args)("action", params.action)("code", params.code)("proto", action_abi_to_variant(abi, action_type)))
@@ -1288,7 +1296,7 @@ read_only::abi_bin_to_json_result read_only::abi_bin_to_json( const read_only::a
    abi_def abi;
    if( abi_serializer::to_abi(code_account.abi, abi) ) {
       abi_serializer abis( abi );
-      result.args = abis.binary_to_variant( abis.get_action_type( params.action ), params.binargs, db.get_abi_serializer_max_time_ms() );
+      result.args = abis.binary_to_variant( abis.get_action_type( params.action ), params.binargs, abi_serializer_max_time );
    } else {
       EOS_ASSERT(false, abi_not_found_exception, "No ABI found for ${contract}", ("contract", params.code));
    }
@@ -1299,7 +1307,7 @@ read_only::get_required_keys_result read_only::get_required_keys( const get_requ
    transaction pretty_input;
    auto resolver = make_resolver(this);
    try {
-      abi_serializer::from_variant(params.transaction, pretty_input, resolver, db.get_abi_serializer_max_time_ms());
+      abi_serializer::from_variant(params.transaction, pretty_input, resolver, abi_serializer_max_time);
    } EOS_RETHROW_EXCEPTIONS(chain::transaction_type_exception, "Invalid transaction")
 
    auto required_keys_set = db.get_authorization_manager().get_required_keys(pretty_input, params.available_keys);

plugins/chain_plugin/include/eosio/chain_plugin/chain_plugin.hpp

@@ -60,12 +60,13 @@ uint64_t convert_to_type(const string& str, const string& desc);
 
 class read_only {
    const controller& db;
+   const fc::microseconds abi_serializer_max_time;
 
 public:
    static const string KEYi64;
 
-   read_only(const controller& db)
-      : db(db) {}
+   read_only(const controller& db, const fc::microseconds& abi_serializer_max_time)
+      : db(db), abi_serializer_max_time(abi_serializer_max_time) {}
 
    using get_info_params = empty;
 
@@ -328,7 +329,7 @@ class read_only {
             copy_inline_row(*itr, data);
 
             if (p.json) {
-               result.rows.emplace_back(abis.binary_to_variant(abis.get_table_type(p.table), data, db.get_abi_serializer_max_time_ms()));
+               result.rows.emplace_back(abis.binary_to_variant(abis.get_table_type(p.table), data, abi_serializer_max_time));
             } else {
                result.rows.emplace_back(fc::variant(data));
             }
@@ -349,8 +350,10 @@ class read_only {
 
 class read_write {
    controller& db;
+   const fc::microseconds abi_serializer_max_time;
 public:
-   read_write(controller& db) : db(db) {}
+   read_write(controller& db, const fc::microseconds& abi_serializer_max_time)
+         : db(db), abi_serializer_max_time(abi_serializer_max_time) {}
 
    using push_block_params = chain::signed_block;
    using push_block_results = empty;
@@ -385,7 +388,7 @@ class chain_plugin : public plugin<chain_plugin> {
    void plugin_startup();
    void plugin_shutdown();
 
-   chain_apis::read_only get_read_only_api() const { return chain_apis::read_only(chain()); }
+   chain_apis::read_only get_read_only_api() const { return chain_apis::read_only(chain(), get_abi_serializer_max_time()); }
    chain_apis::read_write get_read_write_api();
 
    void accept_block( const chain::signed_block_ptr& block );
@@ -412,6 +415,7 @@ class chain_plugin : public plugin<chain_plugin> {
    const controller& chain() const;
 
    chain::chain_id_type get_chain_id() const;
+   fc::microseconds get_abi_serializer_max_time() const;
 
 private:
    unique_ptr<class chain_plugin_impl> my;

plugins/history_plugin/history_plugin.cpp

@@ -315,6 +315,7 @@ namespace eosio {
          edump((params));
         auto& chain = history->chain_plug->chain();
         const auto& db = chain.db();
+        const auto abi_serializer_max_time = history->chain_plug->get_abi_serializer_max_time();
 
         const auto& idx = db.get_index<account_history_index, by_account_action_seq>();
 
@@ -366,7 +367,7 @@ namespace eosio {
                                  start_itr->action_sequence_num,
                                  start_itr->account_sequence_num,
                                  a.block_num, a.block_time,
-                                 chain.to_variant_with_abi(t)
+                                 chain.to_variant_with_abi(t, abi_serializer_max_time)
                                  });
 
            end_time = fc::time_point::now();
@@ -382,6 +383,7 @@ namespace eosio {
 
       read_only::get_transaction_result read_only::get_transaction( const read_only::get_transaction_params& p )const {
          auto& chain = history->chain_plug->chain();
+         const auto abi_serializer_max_time = history->chain_plug->get_abi_serializer_max_time();
          auto short_id = fc::variant(p.id).as_string().substr(0,8);
 
          const auto& db = chain.db();
@@ -410,7 +412,7 @@ namespace eosio {
               fc::datastream<const char*> ds( itr->packed_action_trace.data(), itr->packed_action_trace.size() );
               action_trace t;
               fc::raw::unpack( ds, t );
-              result.traces.emplace_back( chain.to_variant_with_abi(t) );
+              result.traces.emplace_back( chain.to_variant_with_abi(t, abi_serializer_max_time) );
 
               ++itr;
             }
@@ -429,7 +431,7 @@ namespace eosio {
                         auto mtrx = transaction_metadata(pt);
                         if (mtrx.id == result.id) {
                             fc::mutable_variant_object r("receipt", receipt);
-                            r("trx", chain.to_variant_with_abi(mtrx.trx));
+                            r("trx", chain.to_variant_with_abi(mtrx.trx, abi_serializer_max_time));
                             result.trx = move(r);
                             break;
                         }
@@ -457,7 +459,7 @@ namespace eosio {
                         result.block_num = *p.block_num_hint;
                         result.block_time = blk->timestamp;
                         fc::mutable_variant_object r("receipt", receipt);
-                        r("trx", chain.to_variant_with_abi(mtrx.trx));
+                        r("trx", chain.to_variant_with_abi(mtrx.trx, abi_serializer_max_time));
                         result.trx = move(r);
                         found = true;
                         break;

plugins/txn_test_gen_plugin/txn_test_gen_plugin.cpp

@@ -122,6 +122,7 @@ struct txn_test_gen_plugin_impl {
 
          controller& cc = app().get_plugin<chain_plugin>().chain();
          auto chainid = app().get_plugin<chain_plugin>().get_chain_id();
+         auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
 
          fc::crypto::private_key txn_test_receiver_A_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'a')));
          fc::crypto::private_key txn_test_receiver_B_priv_key = fc::crypto::private_key::regenerate(fc::sha256(std::string(64, 'b')));
@@ -187,31 +188,31 @@ struct txn_test_gen_plugin_impl {
                act.account = N(txn.test.t);
                act.name = N(create);
                act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
-               act.data = eosio_token_serializer.variant_to_binary("create", fc::json::from_string("{\"issuer\":\"txn.test.t\",\"maximum_supply\":\"1000000000.0000 CUR\"}}"), cc.get_abi_serializer_max_time_ms());
+               act.data = eosio_token_serializer.variant_to_binary("create", fc::json::from_string("{\"issuer\":\"txn.test.t\",\"maximum_supply\":\"1000000000.0000 CUR\"}}"), abi_serializer_max_time);
                trx.actions.push_back(act);
             }
             {
                action act;
                act.account = N(txn.test.t);
                act.name = N(issue);
                act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
-               act.data = eosio_token_serializer.variant_to_binary("issue", fc::json::from_string("{\"to\":\"txn.test.t\",\"quantity\":\"600.0000 CUR\",\"memo\":\"\"}"), cc.get_abi_serializer_max_time_ms());
+               act.data = eosio_token_serializer.variant_to_binary("issue", fc::json::from_string("{\"to\":\"txn.test.t\",\"quantity\":\"600.0000 CUR\",\"memo\":\"\"}"), abi_serializer_max_time);
                trx.actions.push_back(act);
             }
             {
                action act;
                act.account = N(txn.test.t);
                act.name = N(transfer);
                act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
-               act.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string("{\"from\":\"txn.test.t\",\"to\":\"txn.test.a\",\"quantity\":\"200.0000 CUR\",\"memo\":\"\"}"), cc.get_abi_serializer_max_time_ms());
+               act.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string("{\"from\":\"txn.test.t\",\"to\":\"txn.test.a\",\"quantity\":\"200.0000 CUR\",\"memo\":\"\"}"), abi_serializer_max_time);
                trx.actions.push_back(act);
             }
             {
                action act;
                act.account = N(txn.test.t);
                act.name = N(transfer);
                act.authorization = vector<permission_level>{{newaccountC,config::active_name}};
-               act.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string("{\"from\":\"txn.test.t\",\"to\":\"txn.test.b\",\"quantity\":\"200.0000 CUR\",\"memo\":\"\"}"), cc.get_abi_serializer_max_time_ms());
+               act.data = eosio_token_serializer.variant_to_binary("transfer", fc::json::from_string("{\"from\":\"txn.test.t\",\"to\":\"txn.test.b\",\"quantity\":\"200.0000 CUR\",\"memo\":\"\"}"), abi_serializer_max_time);
                trx.actions.push_back(act);
             }
 
@@ -242,22 +243,23 @@ struct txn_test_gen_plugin_impl {
       running = true;
 
       controller& cc = app().get_plugin<chain_plugin>().chain();
+      auto abi_serializer_max_time = app().get_plugin<chain_plugin>().get_abi_serializer_max_time();
       //create the actions here
       act_a_to_b.account = N(txn.test.t);
       act_a_to_b.name = N(transfer);
       act_a_to_b.authorization = vector<permission_level>{{name("txn.test.a"),config::active_name}};
       act_a_to_b.data = eosio_token_serializer.variant_to_binary("transfer", 
                                                                   fc::json::from_string(fc::format_string("{\"from\":\"txn.test.a\",\"to\":\"txn.test.b\",\"quantity\":\"1.0000 CUR\",\"memo\":\"${l}\"}", 
                                                                   fc::mutable_variant_object()("l", salt))),
-                                                                  cc.get_abi_serializer_max_time_ms());
+                                                                  abi_serializer_max_time);
 
       act_b_to_a.account = N(txn.test.t);
       act_b_to_a.name = N(transfer);
       act_b_to_a.authorization = vector<permission_level>{{name("txn.test.b"),config::active_name}};
       act_b_to_a.data = eosio_token_serializer.variant_to_binary("transfer", 
                                                                   fc::json::from_string(fc::format_string("{\"from\":\"txn.test.b\",\"to\":\"txn.test.a\",\"quantity\":\"1.0000 CUR\",\"memo\":\"${l}\"}", 
                                                                   fc::mutable_variant_object()("l", salt))),
-                                                                  cc.get_abi_serializer_max_time_ms());
+                                                                  abi_serializer_max_time);
 
       timer_timeout = period;
       batch = batch_size/2;