Merge pull request #579

576effe blockchain: kill ioservice on scope end, rather than manually (moneromooo-monero) ed5d017 miner: minor fixes on stop (moneromooo-monero) b245215 core_tests: deinit core before destroying it (moneromooo-monero) bc8a52e wallet: add a rescan_bc command and rescan_blockchain RPC (moneromooo-monero) 92ef6b5 wallet: protect against exceptions in the block pull thread (moneromooo-monero) af21061 net_peerlist: move a couple functions from public to private (moneromooo-monero)
2024-11-23 18:47:36 -07:00 · 2015-12-31 08:18:06 +02:00 · 2015-12-31 08:18:06 +02:00 · 76a765c967
commit 76a765c967
parent 91001aa446 576effe11a
11 changed files with 131 additions and 38 deletions
--- a/src/cryptonote_core/blockchain.cpp
+++ b/src/cryptonote_core/blockchain.cpp
@ -2078,6 +2078,7 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc

  boost::asio::io_service ioservice;
  boost::thread_group threadpool;
+  bool ioservice_active = false;

  std::unique_ptr < boost::asio::io_service::work > work(new boost::asio::io_service::work(ioservice));
  if(threads > 1)
@ -2086,15 +2087,19 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
    {
      threadpool.create_thread(boost::bind(&boost::asio::io_service::run, &ioservice));
    }
+    ioservice_active = true;
  }

 #define KILL_IOSERVICE()  \
-        if(threads > 1) \
+        if(ioservice_active) \
        { \
            work.reset(); \
            threadpool.join_all(); \
            ioservice.stop(); \
-        } \
+            ioservice_active = false; \
+        }
+
+  epee::misc_utils::auto_scope_leave_caller ioservice_killer = epee::misc_utils::create_scope_leave_handler([&]() { KILL_IOSERVICE(); });

  for (const auto& txin : tx.vin)
  {
@ -2109,7 +2114,6 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
    if(have_tx_keyimg_as_spent(in_to_key.k_image))
    {
      LOG_PRINT_L1("Key image already spent in blockchain: " << epee::string_tools::pod_to_hex(in_to_key.k_image));
-      KILL_IOSERVICE();
      return false;
    }

@ -2123,7 +2127,6 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
      if(!itk->second)
      {
        LOG_PRINT_L1("Failed ring signature for tx " << get_transaction_hash(tx) << "  vin key with k_image: " << in_to_key.k_image << "  sig_index: " << sig_index);
-        KILL_IOSERVICE();
        return false;
      }

@ -2145,7 +2148,6 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
        LOG_PRINT_L1("  *pmax_used_block_height: " << *pmax_used_block_height);
      }

-      KILL_IOSERVICE();
      return false;
    }

@ -2168,7 +2170,6 @@ bool Blockchain::check_tx_inputs(const transaction& tx, uint64_t* pmax_used_bloc
          LOG_PRINT_L1("*pmax_used_block_height: " << *pmax_used_block_height);
        }

-        KILL_IOSERVICE();
        return false;
      }
      it->second[in_to_key.k_image] = true;
--- a/src/cryptonote_core/miner.cpp
+++ b/src/cryptonote_core/miner.cpp
@ -278,14 +278,17 @@ namespace cryptonote
  //-----------------------------------------------------------------------------------------------------
  bool miner::stop()
  {
+    if (!is_mining())
+      return true;
+
    send_stop_signal();
    CRITICAL_REGION_LOCAL(m_threads_lock);

    BOOST_FOREACH(boost::thread& th, m_threads)
      th.join();

-    m_threads.clear();
    LOG_PRINT_L0("Mining has been stopped, " << m_threads.size() << " finished" );
+    m_threads.clear();
    return true;
  }
  //-----------------------------------------------------------------------------------------------------
--- a/src/p2p/net_peerlist.h
+++ b/src/p2p/net_peerlist.h
@ -80,8 +80,6 @@ namespace nodetool
    bool set_peer_just_seen(peerid_type peer, const net_address& addr);
    bool set_peer_unreachable(const peerlist_entry& pr);
    bool is_ip_allowed(uint32_t ip);
-    void trim_white_peerlist();
-    void trim_gray_peerlist();

    
  private:
@ -166,6 +164,8 @@ namespace nodetool

  private: 
    bool peers_indexed_from_old(const peers_indexed_old& pio, peers_indexed& pi);
+    void trim_white_peerlist();
+    void trim_gray_peerlist();

    friend class boost::serialization::access;
    epee::critical_section m_peerlist_lock;
--- a/src/simplewallet/simplewallet.cpp
+++ b/src/simplewallet/simplewallet.cpp
@ -551,6 +551,7 @@ simple_wallet::simple_wallet()
  m_cmd_binder.set_handler("get_tx_key", boost::bind(&simple_wallet::get_tx_key, this, _1), tr("Get transaction key (r) for a given <txid>"));
  m_cmd_binder.set_handler("check_tx_key", boost::bind(&simple_wallet::check_tx_key, this, _1), tr("Check amount going to <address> in <txid>"));
  m_cmd_binder.set_handler("show_transfers", boost::bind(&simple_wallet::show_transfers, this, _1), tr("show_transfers [in|out] [<min_height> [<max_height>]] - Show incoming/outgoing transfers within an optional height range"));
+  m_cmd_binder.set_handler("rescan_bc", boost::bind(&simple_wallet::rescan_blockchain, this, _1), tr("Rescan blockchain from scratch"));
  m_cmd_binder.set_handler("help", boost::bind(&simple_wallet::help, this, _1), tr("Show this help"));
 }
 //----------------------------------------------------------------------------------------------------
@ -1324,7 +1325,7 @@ void simple_wallet::on_skip_transaction(uint64_t height, const cryptonote::trans
    m_refresh_progress_reporter.update(height, true);
 }
 //----------------------------------------------------------------------------------------------------
-bool simple_wallet::refresh(const std::vector<std::string>& args)
+bool simple_wallet::refresh_main(uint64_t start_height, bool reset)
 {
  if (!try_connect_to_daemon())
    return true;
@ -1336,21 +1337,12 @@ bool simple_wallet::refresh(const std::vector<std::string>& args)
  std::unique_lock<std::mutex> lock(m_auto_refresh_mutex);
  m_auto_refresh_cond.notify_one();

+  if (reset)
+    m_wallet->rescan_blockchain(false);
+
  message_writer() << tr("Starting refresh...");

  uint64_t fetched_blocks = 0;
-  uint64_t start_height = 0;
-  if(!args.empty()){
-    try
-    {
-        start_height = boost::lexical_cast<uint64_t>( args[0] );
-    }
-    catch(const boost::bad_lexical_cast &)
-    {
-        start_height = 0;
-    }
-  }
-  
  bool ok = false;
  std::ostringstream ss;
  try
@ -1408,6 +1400,22 @@ bool simple_wallet::refresh(const std::vector<std::string>& args)
  return true;
 }
 //----------------------------------------------------------------------------------------------------
+bool simple_wallet::refresh(const std::vector<std::string>& args)
+{
+  uint64_t start_height = 0;
+  if(!args.empty()){
+    try
+    {
+        start_height = boost::lexical_cast<uint64_t>( args[0] );
+    }
+    catch(const boost::bad_lexical_cast &)
+    {
+        start_height = 0;
+    }
+  }
+  return refresh_main(start_height, false);
+}
+//----------------------------------------------------------------------------------------------------
 bool simple_wallet::show_balance(const std::vector<std::string>& args/* = std::vector<std::string>()*/)
 {
  success_msg_writer() << tr("Balance: ") << print_money(m_wallet->balance()) << ", "
@ -2276,6 +2284,11 @@ bool simple_wallet::show_transfers(const std::vector<std::string> &args_)
  return true;
 }
 //----------------------------------------------------------------------------------------------------
+bool simple_wallet::rescan_blockchain(const std::vector<std::string> &args_)
+{
+  return refresh_main(0, true);
+}
+//----------------------------------------------------------------------------------------------------
 void simple_wallet::wallet_refresh_thread()
 {
  while (true)
--- a/src/simplewallet/simplewallet.h
+++ b/src/simplewallet/simplewallet.h
@ -132,6 +132,8 @@ namespace cryptonote
    bool get_tx_key(const std::vector<std::string> &args);
    bool check_tx_key(const std::vector<std::string> &args);
    bool show_transfers(const std::vector<std::string> &args);
+    bool rescan_blockchain(const std::vector<std::string> &args);
+    bool refresh_main(uint64_t start_height, bool reset = false);

    uint64_t get_daemon_blockchain_height(std::string& err);
    bool try_connect_to_daemon();
--- a/src/wallet/wallet2.cpp
+++ b/src/wallet/wallet2.cpp
@ -648,21 +648,30 @@ void wallet2::refresh(uint64_t start_height, uint64_t & blocks_fetched)
  refresh(start_height, blocks_fetched, received_money);
 }
 //----------------------------------------------------------------------------------------------------
-void wallet2::pull_next_blocks(uint64_t start_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, const std::list<cryptonote::block_complete_entry> &prev_blocks, std::list<cryptonote::block_complete_entry> &blocks)
+void wallet2::pull_next_blocks(uint64_t start_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, const std::list<cryptonote::block_complete_entry> &prev_blocks, std::list<cryptonote::block_complete_entry> &blocks, bool &error)
 {
-  // prepend the last 3 blocks, should be enough to guard against a block or two's reorg
-  cryptonote::block bl;
-  std::list<cryptonote::block_complete_entry>::const_reverse_iterator i = prev_blocks.rbegin();
-  for (size_t n = 0; n < std::min((size_t)3, prev_blocks.size()); ++n)
-  {
-    bool ok = cryptonote::parse_and_validate_block_from_blob(i->block, bl);
-    THROW_WALLET_EXCEPTION_IF(!ok, error::block_parse_error, i->block);
-    short_chain_history.push_front(cryptonote::get_block_hash(bl));
-    ++i;
-  }
+  error = false;

-  // pull the new blocks
-  pull_blocks(start_height, blocks_start_height, short_chain_history, blocks);
+  try
+  {
+    // prepend the last 3 blocks, should be enough to guard against a block or two's reorg
+    cryptonote::block bl;
+    std::list<cryptonote::block_complete_entry>::const_reverse_iterator i = prev_blocks.rbegin();
+    for (size_t n = 0; n < std::min((size_t)3, prev_blocks.size()); ++n)
+    {
+      bool ok = cryptonote::parse_and_validate_block_from_blob(i->block, bl);
+      THROW_WALLET_EXCEPTION_IF(!ok, error::block_parse_error, i->block);
+      short_chain_history.push_front(cryptonote::get_block_hash(bl));
+      ++i;
+    }
+
+    // pull the new blocks
+    pull_blocks(start_height, blocks_start_height, short_chain_history, blocks);
+  }
+  catch(...)
+  {
+    error = true;
+  }
 }
 //----------------------------------------------------------------------------------------------------
 void wallet2::refresh(uint64_t start_height, uint64_t & blocks_fetched, bool& received_money)
@ -689,7 +698,8 @@ void wallet2::refresh(uint64_t start_height, uint64_t & blocks_fetched, bool& re
      // pull the next set of blocks while we're processing the current one
      uint64_t next_blocks_start_height;
      std::list<cryptonote::block_complete_entry> next_blocks;
-      pull_thread = std::thread([&]{pull_next_blocks(start_height, next_blocks_start_height, short_chain_history, blocks, next_blocks);});
+      bool error = false;
+      pull_thread = std::thread([&]{pull_next_blocks(start_height, next_blocks_start_height, short_chain_history, blocks, next_blocks, error);});

      process_blocks(blocks_start_height, blocks, added_blocks);
      blocks_fetched += added_blocks;
@ -700,6 +710,12 @@ void wallet2::refresh(uint64_t start_height, uint64_t & blocks_fetched, bool& re
      // switch to the new blocks from the daemon
      blocks_start_height = next_blocks_start_height;
      blocks = next_blocks;
+
+      // handle error from async fetching thread
+      if (error)
+      {
+        throw std::runtime_error("proxy exception in refresh thread");
+      }
    }
    catch (const std::exception&)
    {
@ -785,6 +801,7 @@ bool wallet2::clear()
 {
  m_blockchain.clear();
  m_transfers.clear();
+  m_key_images.clear();
  m_local_bc_height = 1;
  return true;
 }
@ -1415,6 +1432,20 @@ void wallet2::rescan_spent()
  }
 }
 //----------------------------------------------------------------------------------------------------
+void wallet2::rescan_blockchain(bool refresh)
+{
+  clear();
+
+  cryptonote::block genesis;
+  generate_genesis(genesis);
+  crypto::hash genesis_hash = get_block_hash(genesis);
+  m_blockchain.push_back(genesis_hash);
+  m_local_bc_height = 1;
+
+  if (refresh)
+    this->refresh();
+}
+//----------------------------------------------------------------------------------------------------
 bool wallet2::is_transfer_unlocked(const transfer_details& td) const
 {
  if(!is_tx_spendtime_unlocked(td.m_tx.unlock_time))
--- a/src/wallet/wallet2.h
+++ b/src/wallet/wallet2.h
@ -280,6 +280,7 @@ namespace tools
    void get_unconfirmed_payments_out(std::list<std::pair<crypto::hash,wallet2::unconfirmed_transfer_details>>& unconfirmed_payments) const;
    uint64_t get_blockchain_current_height() const { return m_local_bc_height; }
    void rescan_spent();
+    void rescan_blockchain(bool refresh = true);
    template <class t_archive>
    inline void serialize(t_archive &a, const unsigned int ver)
    {
@ -359,7 +360,7 @@ namespace tools
    bool is_transfer_unlocked(const transfer_details& td) const;
    bool clear();
    void pull_blocks(uint64_t start_height, uint64_t& blocks_start_height, const std::list<crypto::hash> &short_chain_history, std::list<cryptonote::block_complete_entry> &blocks);
-    void pull_next_blocks(uint64_t start_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, const std::list<cryptonote::block_complete_entry> &prev_blocks, std::list<cryptonote::block_complete_entry> &blocks);
+    void pull_next_blocks(uint64_t start_height, uint64_t &blocks_start_height, std::list<crypto::hash> &short_chain_history, const std::list<cryptonote::block_complete_entry> &prev_blocks, std::list<cryptonote::block_complete_entry> &blocks, bool &error);
    void process_blocks(uint64_t start_height, const std::list<cryptonote::block_complete_entry> &blocks, uint64_t& blocks_added);
    uint64_t select_transfers(uint64_t needed_money, bool add_dust, uint64_t dust, std::list<transfer_container::iterator>& selected_transfers);
    bool prepare_file_names(const std::string& file_path);
--- a/src/wallet/wallet_rpc_server.cpp
+++ b/src/wallet/wallet_rpc_server.cpp
@ -646,6 +646,29 @@ namespace tools

      return true;
  }
+  //------------------------------------------------------------------------------------------------------------------------------
+  bool wallet_rpc_server::on_rescan_blockchain(const wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN::request& req, wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN::response& res, epee::json_rpc::error& er)
+  {
+    if (m_wallet.restricted())
+    {
+      er.code = WALLET_RPC_ERROR_CODE_DENIED;
+      er.message = "Command unavailable in restricted mode.";
+      return false;
+    }
+
+    try
+    {
+      m_wallet.rescan_blockchain();
+    }
+    catch (std::exception& e)
+    {
+      er.code = WALLET_RPC_ERROR_CODE_UNKNOWN_ERROR;
+      er.message = e.what();
+      return false;
+    }
+    return true;
+  }
+  //------------------------------------------------------------------------------------------------------------------------------
  bool wallet_rpc_server::on_stop_wallet(const wallet_rpc::COMMAND_RPC_STOP_WALLET::request& req, wallet_rpc::COMMAND_RPC_STOP_WALLET::response& res, epee::json_rpc::error& er)
  {
    if (m_wallet.restricted())
--- a/src/wallet/wallet_rpc_server.h
+++ b/src/wallet/wallet_rpc_server.h
@ -75,6 +75,7 @@ namespace tools
        MAP_JON_RPC_WE("make_integrated_address", on_make_integrated_address, wallet_rpc::COMMAND_RPC_MAKE_INTEGRATED_ADDRESS)
        MAP_JON_RPC_WE("split_integrated_address", on_split_integrated_address, wallet_rpc::COMMAND_RPC_SPLIT_INTEGRATED_ADDRESS)
        MAP_JON_RPC_WE("stop_wallet",        on_stop_wallet,        wallet_rpc::COMMAND_RPC_STOP_WALLET)
+        MAP_JON_RPC_WE("rescan_blockchain",  on_rescan_blockchain,  wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN)
      END_JSON_RPC_MAP()
    END_URI_MAP2()

@ -93,6 +94,7 @@ namespace tools
      bool on_get_bulk_payments(const wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS::request& req, wallet_rpc::COMMAND_RPC_GET_BULK_PAYMENTS::response& res, epee::json_rpc::error& er);
      bool on_incoming_transfers(const wallet_rpc::COMMAND_RPC_INCOMING_TRANSFERS::request& req, wallet_rpc::COMMAND_RPC_INCOMING_TRANSFERS::response& res, epee::json_rpc::error& er);
      bool on_stop_wallet(const wallet_rpc::COMMAND_RPC_STOP_WALLET::request& req, wallet_rpc::COMMAND_RPC_STOP_WALLET::response& res, epee::json_rpc::error& er);
+      bool on_rescan_blockchain(const wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN::request& req, wallet_rpc::COMMAND_RPC_RESCAN_BLOCKCHAIN::response& res, epee::json_rpc::error& er);

      bool handle_command_line(const boost::program_options::variables_map& vm);

--- a/src/wallet/wallet_rpc_server_commands_defs.h
+++ b/src/wallet/wallet_rpc_server_commands_defs.h
@ -391,6 +391,21 @@ namespace wallet_rpc
    };
  };

+  struct COMMAND_RPC_RESCAN_BLOCKCHAIN
+  {
+    struct request
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+
+    struct response
+    {
+      BEGIN_KV_SERIALIZE_MAP()
+      END_KV_SERIALIZE_MAP()
+    };
+  };
+
 }
 }

--- a/tests/core_tests/chaingen.h
+++ b/tests/core_tests/chaingen.h
@ -498,7 +498,9 @@ inline bool do_replay_events(std::vector<test_event_entry>& events)
    return false;
  }
  t_test_class validator;
-  return replay_events_through_core<t_test_class>(c, events, validator);
+  bool ret = replay_events_through_core<t_test_class>(c, events, validator);
+  c.deinit();
+  return ret;
 }
 //--------------------------------------------------------------------------
 template<class t_test_class>