Change: applied transaction channel for statehistory plugin

Docker/Dockerfile

@@ -1,11 +1,11 @@
 FROM boscore/builder:v2.0.6 as builder
-ARG branch=master
+ARG branch=statehistoryplugin
 ARG symbol=EOS
 
 ENV OPENSSL_ROOT_DIR /usr/include/openssl
 
-RUN git clone -b $branch https://github.com/boscore/bos.git --recursive \
-    && cd bos && echo "$branch:$(git rev-parse HEAD)" > /etc/boscore-version \
+RUN git clone -b $branch https://github.com/eosiosg/eos.git --recursive \
+    && cd eos && echo "$branch:$(git rev-parse HEAD)" > /etc/eoscore-version \
     && cmake -H. -B"/tmp/build" -GNinja -DCMAKE_BUILD_TYPE=Release -DWASM_ROOT=/opt/wasm -DCMAKE_CXX_COMPILER=clang++ \
        -DCMAKE_C_COMPILER=clang -DCMAKE_INSTALL_PREFIX=/tmp/build -DBUILD_MONGO_DB_PLUGIN=true -DCORE_SYMBOL_NAME=$symbol \
        -DOPENSSL_ROOT_DIR="${OPENSSL_ROOT_DIR}" -DCMAKE_CXX_STANDARD_LIBRARIES="-lpthread" -DENABLE_TOOLS=OFF \
@@ -16,9 +16,9 @@ FROM ubuntu:18.04
 RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get -y install openssl ca-certificates iproute2 && rm -rf /var/lib/apt/lists/*
 COPY --from=builder /usr/local/lib/* /usr/local/lib/
 COPY --from=builder /tmp/build/bin /opt/eosio/bin
-COPY --from=builder /bos/Docker/config.ini /
-COPY --from=builder /etc/boscore-version /etc
-COPY --from=builder /bos/Docker/nodeosd.sh /opt/eosio/bin/nodeosd.sh
+COPY --from=builder /eos/Docker/config.ini /
+COPY --from=builder /etc/eoscore-version /etc
+COPY --from=builder /eos/Docker/nodeosd.sh /opt/eosio/bin/nodeosd.sh
 ENV EOSIO_ROOT=/opt/eosio
 RUN chmod +x /opt/eosio/bin/nodeosd.sh
 ENV LD_LIBRARY_PATH /usr/local/lib

libraries/chain/controller.cpp

@@ -1201,7 +1201,7 @@ struct controller_impl {
          trace->scheduled = true;
          trace->receipt = push_receipt( gtrx.trx_id, transaction_receipt::expired, billed_cpu_time_us, 0 ); // expire the transaction
          emit( self.accepted_transaction, trx );
-         emit( self.applied_transaction, trace );
+         emit( self.applied_transaction, std::tie(trace, dtrx) );
          undo_session.squash();
          return trace;
       }
@@ -1241,7 +1241,7 @@ struct controller_impl {
          fc::move_append( pending->_actions, move(trx_context.executed) );
 
          emit( self.accepted_transaction, trx );
-         emit( self.applied_transaction, trace );
+         emit( self.applied_transaction, std::tie(trace, dtrx) );
 
          trx_context.squash();
          undo_session.squash();
@@ -1269,7 +1269,7 @@ struct controller_impl {
          trace = error_trace;
          if( !trace->except_ptr ) {
             emit( self.accepted_transaction, trx );
-            emit( self.applied_transaction, trace );
+            emit( self.applied_transaction, std::tie(trace, dtrx) );
             undo_session.squash();
             return trace;
          }
@@ -1306,12 +1306,12 @@ struct controller_impl {
          trace->receipt = push_receipt(gtrx.trx_id, transaction_receipt::hard_fail, cpu_time_to_bill_us, 0);
 
          emit( self.accepted_transaction, trx );
-         emit( self.applied_transaction, trace );
+         emit( self.applied_transaction, std::tie(trace, dtrx) );
 
          undo_session.squash();
       } else {
          emit( self.accepted_transaction, trx );
-         emit( self.applied_transaction, trace );
+         emit( self.applied_transaction, std::tie(trace, dtrx) );
       }
 
       return trace;
@@ -1421,7 +1421,7 @@ struct controller_impl {
                emit( self.accepted_transaction, trx);
             }
 
-            emit(self.applied_transaction, trace);
+            emit(self.applied_transaction, std::tie(trace, trn));
 
 
             if ( read_mode != db_read_mode::SPECULATIVE && pending->_block_status == controller::block_status::incomplete ) {
@@ -1446,7 +1446,7 @@ struct controller_impl {
          }
 
          emit( self.accepted_transaction, trx );
-         emit( self.applied_transaction, trace );
+         emit( self.applied_transaction, std::tie(trace, trn) );
 
          return trace;
       } FC_CAPTURE_AND_RETHROW((trace))

libraries/chain/include/eosio/chain/controller.hpp

@@ -311,7 +311,7 @@ namespace eosio { namespace chain {
          signal<void(const block_state_ptr&)>          irreversible_block;
          signal<void(const block_state_ptr&)>          new_irreversible_block;
          signal<void(const transaction_metadata_ptr&)> accepted_transaction;
-         signal<void(const transaction_trace_ptr&)>    applied_transaction;
+         signal<void(std::tuple<const transaction_trace_ptr&, const signed_transaction&>)> applied_transaction;
          signal<void(const header_confirmation&)>      accepted_confirmation;
          signal<void(const int&)>                      bad_alloc;
 

plugins/chain_plugin/chain_plugin.cpp

@@ -829,8 +829,8 @@ void chain_plugin::plugin_initialize(const variables_map& options) {
             } );
 
       my->applied_transaction_connection = my->chain->applied_transaction.connect(
-            [this]( const transaction_trace_ptr& trace ) {
-               my->applied_transaction_channel.publish( trace );
+            [this]( std::tuple<const transaction_trace_ptr&, const signed_transaction&> t ) {
+               my->applied_transaction_channel.publish( std::get<0>(t) );
             } );
 
       my->accepted_confirmation_connection = my->chain->accepted_confirmation.connect(

plugins/history_plugin/history_plugin.cpp

@@ -351,8 +351,8 @@ namespace eosio {
          db.add_index<public_key_history_multi_index>();
 
          my->applied_transaction_connection.emplace(
-               chain.applied_transaction.connect( [&]( const transaction_trace_ptr& p ) {
-                  my->on_applied_transaction( p );
+               chain.applied_transaction.connect( [&]( std::tuple<const transaction_trace_ptr&, const signed_transaction&> t ) {
+                  my->on_applied_transaction( std::get<0>(t) );
                } ));
       } FC_LOG_AND_RETHROW()
    }

plugins/kafka_plugin/kafka_plugin.cpp

@@ -133,9 +133,9 @@ void kafka_plugin::plugin_initialize(const variables_map& options) {
         }
         handle([=] { kafka_->push_block(b, true); }, "push irreversible block");
     });
-    transaction_conn_ = chain.applied_transaction.connect([=](const chain::transaction_trace_ptr& t) {
+    transaction_conn_ = chain.applied_transaction.connect([=]( std::tuple<const chain::transaction_trace_ptr&, const chain::signed_transaction&> t) {
         if (not start_sync_) return;
-        handle([=] { kafka_->push_transaction_trace(t); }, "push transaction");
+        handle([=] { kafka_->push_transaction_trace(std::get<0>(t)); }, "push transaction");
     });
 }
 

plugins/mongo_db_plugin/mongo_db_plugin.cpp

@@ -1616,8 +1616,8 @@ void mongo_db_plugin::plugin_initialize(const variables_map& options)
                   my->accepted_transaction( t );
                } ));
          my->applied_transaction_connection.emplace(
-               chain.applied_transaction.connect( [&]( const chain::transaction_trace_ptr& t ) {
-                  my->applied_transaction( t );
+               chain.applied_transaction.connect( [&]( std::tuple<const chain::transaction_trace_ptr&, const chain::signed_transaction&> t ) {
+                  my->applied_transaction( std::get<0>(t) );
                } ));
 
          if( my->wipe_database_on_startup ) {

plugins/notify_plugin/notify_plugin.cpp

@@ -329,8 +329,8 @@ void notify_plugin::plugin_initialize(const variables_map &options)
         }));
 
     my->applied_tx_conn.emplace(chain.applied_transaction.connect(
-        [&](const transaction_trace_ptr &tx) {
-          my->on_applied_tx(tx);
+        [&](std::tuple<const chain::transaction_trace_ptr&, const chain::signed_transaction&> t) {
+          my->on_applied_tx(std::get<0>(t));
         }));
   }
   FC_LOG_AND_RETHROW()

plugins/state_history_plugin/state_history_plugin.cpp

@@ -427,14 +427,14 @@ struct state_history_plugin_impl : std::enable_shared_from_this<state_history_pl
              auth.permission == eosio::chain::config::active_name;
    }
 
-   void on_applied_transaction(const transaction_trace_ptr& p) {
+   void on_applied_transaction(const transaction_trace_ptr& p, const signed_transaction& t) {
       if (p->receipt && trace_log) {
          if (is_onblock(p))
-            onblock_trace = p;
+            onblock_trace.emplace(p, t);
          else if (p->failed_dtrx_trace)
-            cached_traces[p->failed_dtrx_trace->id] = p;
+            cached_traces[p->failed_dtrx_trace->id] = augmented_transaction_trace{p, t};
          else
-            cached_traces[p->id] = p;
+            cached_traces[p->id] = augmented_transaction_trace{p, t};
       }
    }
 
@@ -614,7 +614,9 @@ void state_history_plugin::plugin_initialize(const variables_map& options) {
       EOS_ASSERT(my->chain_plug, chain::missing_chain_plugin_exception, "");
       auto& chain = my->chain_plug->chain();
       my->applied_transaction_connection.emplace(
-          chain.applied_transaction.connect([&](const transaction_trace_ptr& p) { my->on_applied_transaction(p); }));
+          chain.applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> t) {
+             my->on_applied_transaction(std::get<0>(t), std::get<1>(t));
+          }));
       my->accepted_block_connection.emplace(
           chain.accepted_block.connect([&](const block_state_ptr& p) { my->on_accepted_block(p); }));
 

unittests/api_tests.cpp

@@ -1076,8 +1076,10 @@ BOOST_FIXTURE_TEST_CASE(transaction_tests, TESTER) { try {
    {
       produce_blocks(10);
       transaction_trace_ptr trace;
-      auto c = control->applied_transaction.connect([&]( const transaction_trace_ptr& t) { if (t && t->receipt && t->receipt->status != transaction_receipt::executed) { trace = t; } } );
-
+      auto c = control->applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+         auto& t = std::get<0>(x);
+         if (t && t->receipt && t->receipt->status != transaction_receipt::executed) { trace = t; }
+      } );
       // test error handling on deferred transaction failure
       CALL_TEST_FUNCTION(*this, "test_transaction", "send_transaction_trigger_error_handler", {});
 
@@ -1120,7 +1122,10 @@ BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, TESTER) { try {
    //schedule
    {
       transaction_trace_ptr trace;
-      auto c = control->applied_transaction.connect([&]( const transaction_trace_ptr& t) { if (t->scheduled) { trace = t; } } );
+      auto c = control->applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+         auto& t = std::get<0>(x);
+         if (t->scheduled) { trace = t; }
+      } );
       CALL_TEST_FUNCTION(*this, "test_transaction", "send_deferred_transaction", {} );
       BOOST_CHECK(!trace);
       produce_block( fc::seconds(2) );
@@ -1140,7 +1145,10 @@ BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, TESTER) { try {
    {
       transaction_trace_ptr trace;
       uint32_t count = 0;
-      auto c = control->applied_transaction.connect([&]( const transaction_trace_ptr& t) { if (t && t->scheduled) { trace = t; ++count; } } );
+      auto c = control->applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+         auto& t = std::get<0>(x);
+         if (t && t->scheduled) { trace = t; ++count; }
+      } );
       CALL_TEST_FUNCTION(*this, "test_transaction", "send_deferred_transaction", {});
       BOOST_CHECK_THROW(CALL_TEST_FUNCTION(*this, "test_transaction", "send_deferred_transaction", {}), deferred_tx_duplicate);
       produce_blocks( 3 );
@@ -1165,7 +1173,10 @@ BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, TESTER) { try {
    {
       transaction_trace_ptr trace;
       uint32_t count = 0;
-      auto c = control->applied_transaction.connect([&]( const transaction_trace_ptr& t) { if (t && t->scheduled) { trace = t; ++count; } } );
+      auto c = control->applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+         auto& t = std::get<0>(x);
+         if (t && t->scheduled) { trace = t; ++count; }
+      } );
       CALL_TEST_FUNCTION(*this, "test_transaction", "send_deferred_transaction_replace", {});
       CALL_TEST_FUNCTION(*this, "test_transaction", "send_deferred_transaction_replace", {});
       produce_blocks( 3 );
@@ -1188,7 +1199,10 @@ BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, TESTER) { try {
    //schedule and cancel
    {
       transaction_trace_ptr trace;
-      auto c = control->applied_transaction.connect([&]( const transaction_trace_ptr& t) { if (t && t->scheduled) { trace = t; } } );
+      auto c = control->applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+         auto& t = std::get<0>(x);
+         if (t && t->scheduled) { trace = t; }
+      } );
       CALL_TEST_FUNCTION(*this, "test_transaction", "send_deferred_transaction", {});
       CALL_TEST_FUNCTION(*this, "test_transaction", "cancel_deferred_transaction_success", {});
       produce_block( fc::seconds(2) );
@@ -1208,7 +1222,8 @@ BOOST_FIXTURE_TEST_CASE(deferred_transaction_tests, TESTER) { try {
    //repeated deferred transactions
    {
       vector<transaction_trace_ptr> traces;
-      auto c = control->applied_transaction.connect([&]( const transaction_trace_ptr& t) {
+      auto c = control->applied_transaction.connect([&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+         auto& t = std::get<0>(x);
          if (t && t->scheduled) {
             traces.push_back( t );
          }

unittests/whitelist_blacklist_tests.cpp

@@ -499,7 +499,8 @@ BOOST_AUTO_TEST_CASE( actor_blacklist_inline_deferred ) { try {
       tester2.chain->push_block( b );
    }
 
-   auto log_trxs = [&]( const transaction_trace_ptr& t) {
+   auto log_trxs = [&](std::tuple<const transaction_trace_ptr&, const signed_transaction&> x) {
+      auto& t = std::get<0>(x);
       if( !t || t->action_traces.size() == 0 ) return;
 
       const auto& act = t->action_traces[0].act;