Issue #765 - Beekeeper | Session timeout and lock_all API call locks wallets one by one so list_wallets can show different statuses during lock

Author: Mariusz-Trela

programs/beekeeper/beekeeper/beekeeper_app.cpp

@@ -171,7 +171,7 @@ init_data beekeeper_app::initialize( int argc, char** argv )
       return _initialization;
     }
 
-    api_ptr = std::make_unique<beekeeper::beekeeper_wallet_api>( wallet_manager_ptr, app, unlock_interval );
+    api_ptr = std::make_unique<beekeeper::beekeeper_wallet_api>( wallet_manager_ptr, mtx_handler, app, unlock_interval );
 
     app.notify_status( "beekeeper is starting" );
 
@@ -251,7 +251,8 @@ init_data beekeeper_app::save_keys( const boost::program_options::variables_map&
 std::shared_ptr<beekeeper::beekeeper_wallet_manager> beekeeper_app::create_wallet( const boost::filesystem::path& cmd_wallet_dir, uint64_t cmd_unlock_timeout, uint32_t cmd_session_limit )
 {
   instance = std::make_shared<beekeeper_instance>( app, cmd_wallet_dir, notifications_endpoint );
-  return std::make_shared<beekeeper::beekeeper_wallet_manager>( std::make_shared<session_manager>( notifications_endpoint ), instance,
+  mtx_handler = std::make_shared<mutex_handler>();
+  return std::make_shared<beekeeper::beekeeper_wallet_manager>( std::make_shared<session_manager>( notifications_endpoint, mtx_handler ), instance,
                                                                        cmd_wallet_dir, cmd_unlock_timeout, cmd_session_limit,
                                                                        [this]() { app.kill(); } );
 }

programs/beekeeper/beekeeper/beekeeper_wallet_api.cpp

@@ -8,8 +8,6 @@
 #include <fc/variant_object.hpp>
 #include <fc/reflect/variant.hpp>
 
-#include<shared_mutex>
-
 namespace beekeeper {
 
 #define HIVE_BEEKEEPER_API_NAME "beekeeper_api"
@@ -26,17 +24,19 @@ class beekeeper_api_impl
 
     extended_api ex_api;
 
-    std::shared_mutex mtx;
-
     public_key_type create( const std::string& source )
     {
       return utility::public_key::create( source, prefix );
     }
 
   public:
-    beekeeper_api_impl( std::shared_ptr<beekeeper::beekeeper_wallet_manager> wallet_mgr, uint64_t unlock_interval )
+    beekeeper_api_impl( std::shared_ptr<beekeeper::beekeeper_wallet_manager> wallet_mgr, std::shared_ptr<mutex_handler> mtx_handler, appbase::application& app, uint64_t unlock_interval )
                       : prefix( HIVE_ADDRESS_PREFIX/*At now this is only one allowed prefix, by maybe in the future custom prefixes could be used as well.*/ ),
-                        ex_api( unlock_interval ), _wallet_mgr( wallet_mgr ) {}
+                        ex_api( unlock_interval ), _wallet_mgr( wallet_mgr ), _mtx_handler( mtx_handler )
+                        {
+                          FC_ASSERT( _wallet_mgr );
+                          FC_ASSERT( _mtx_handler );
+                        }
 
     DECLARE_API_IMPL
     (
@@ -66,58 +66,59 @@ class beekeeper_api_impl
     )
 
     std::shared_ptr<beekeeper::beekeeper_wallet_manager> _wallet_mgr;
+    std::shared_ptr<mutex_handler> _mtx_handler;
 };
 
 DEFINE_API_IMPL( beekeeper_api_impl, create )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->create( args.token, args.wallet_name, args.password, args.is_temporary ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, open )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->open( args.token, args.wallet_name );
   return open_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, close )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->close( args.token, args.wallet_name );
   return close_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, set_timeout )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->set_timeout( args.token, args.seconds );
   return set_timeout_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, lock_all )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->lock_all( args.token );
   return lock_all_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, lock )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->lock( args.token, args.wallet_name );
   return lock_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, unlock )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   if( ex_api.unlock_allowed() )
   {
@@ -138,124 +139,125 @@ DEFINE_API_IMPL( beekeeper_api_impl, unlock )
 
 DEFINE_API_IMPL( beekeeper_api_impl, import_key )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->import_key( args.token, args.wallet_name, args.wif_key, prefix ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, import_keys )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->import_keys( args.token, args.wallet_name, args.wif_keys, prefix ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, remove_key )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->remove_key( args.token, args.wallet_name, create( args.public_key ) );
   return remove_key_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, list_wallets )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->list_wallets( args.token ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, list_created_wallets )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->list_created_wallets( args.token ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, get_public_keys )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   auto _keys = _wallet_mgr->get_public_keys( args.token, args.wallet_name );
   return { utility::get_public_keys( _keys ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, sign_digest )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   using namespace beekeeper;
   return { _wallet_mgr->sign_digest( args.token, args.wallet_name, args.sig_digest, create( args.public_key ), prefix ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, get_info )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return _wallet_mgr->get_info( args.token );
 } 
 
 DEFINE_API_IMPL( beekeeper_api_impl, create_session )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->create_session( args.salt, args.notifications_endpoint ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, close_session )
 {
-  std::unique_lock guard( mtx );
+  std::unique_lock guard( _mtx_handler->get_mutex() );
 
   _wallet_mgr->close_session( args.token );
   return close_session_return();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, has_matching_private_key )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->has_matching_private_key( args.token, args.wallet_name, create( args.public_key ) ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, encrypt_data )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->encrypt_data( args.token, create( args.from_public_key ), create( args.to_public_key ), args.wallet_name, args.content, args.nonce, prefix ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, decrypt_data )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->decrypt_data( args.token, create( args.from_public_key ), create( args.to_public_key ), args.wallet_name, args.encrypted_content ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, get_version )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return _wallet_mgr->get_version();
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, has_wallet )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return { _wallet_mgr->has_wallet( args.token, args.wallet_name ) };
 }
 
 DEFINE_API_IMPL( beekeeper_api_impl, is_wallet_unlocked )
 {
-  std::shared_lock guard( mtx );
+  std::shared_lock guard( _mtx_handler->get_mutex() );
 
   return _wallet_mgr->is_wallet_unlocked( args.token, args.wallet_name );
 }
 
 } // detail
 
-beekeeper_wallet_api::beekeeper_wallet_api( std::shared_ptr<beekeeper::beekeeper_wallet_manager> wallet_mgr, appbase::application& app, uint64_t unlock_interval )
-                    : my( new detail::beekeeper_api_impl( wallet_mgr, unlock_interval ) )
+beekeeper_wallet_api::beekeeper_wallet_api( std::shared_ptr<beekeeper::beekeeper_wallet_manager> wallet_mgr, std::shared_ptr<mutex_handler> mtx_handler,
+                                            appbase::application& app, uint64_t unlock_interval )
+                    : my( new detail::beekeeper_api_impl( wallet_mgr, mtx_handler, app, unlock_interval ) )
 {
   JSON_RPC_REGISTER_API( HIVE_BEEKEEPER_API_NAME );
 }

programs/beekeeper/beekeeper/include/beekeeper/beekeeper_app.hpp

@@ -4,6 +4,7 @@
 
 #include <beekeeper/beekeeper_instance.hpp>
 #include <beekeeper/beekeeper_wallet_api.hpp>
+#include <beekeeper/mutex_handler.hpp>
 
 #include <core/beekeeper_app_base.hpp>
 
@@ -27,6 +28,8 @@ class beekeeper_app: public beekeeper_app_base
 
     appbase::application app;
 
+    std::shared_ptr<mutex_handler> mtx_handler;
+
     std::string check_version();
     bool save_keys( const std::optional<std::string>& notification, const std::string& wallet_name, const std::string& wallet_password );
 

programs/beekeeper/beekeeper/include/beekeeper/beekeeper_wallet_api.hpp

@@ -3,6 +3,8 @@
 #include <core/beekeeper_wallet_manager.hpp>
 #include <core/utilities.hpp>
 
+#include <beekeeper/mutex_handler.hpp>
+
 #include <hive/plugins/json_rpc/utility.hpp>
 
 #include <fc/optional.hpp>
@@ -24,7 +26,8 @@ namespace detail
 class beekeeper_wallet_api
 {
   public:
-    beekeeper_wallet_api( std::shared_ptr<beekeeper::beekeeper_wallet_manager> wallet_mgr, appbase::application& app, uint64_t unlock_interval );
+    beekeeper_wallet_api( std::shared_ptr<beekeeper::beekeeper_wallet_manager> wallet_mgr, std::shared_ptr<mutex_handler> mtx_handler,
+                          appbase::application& app, uint64_t unlock_interval );
     ~beekeeper_wallet_api();
 
     DECLARE_API(

programs/beekeeper/beekeeper/include/beekeeper/mutex_handler.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include<shared_mutex>
+
+namespace beekeeper {
+
+class mutex_handler
+{
+  private:
+
+    std::shared_mutex mtx;
+
+  public:
+
+    inline std::shared_mutex& get_mutex(){ return mtx; }
+};
+
+} //beekeeper

programs/beekeeper/beekeeper/include/beekeeper/session_manager.hpp

@@ -2,19 +2,27 @@
 
 #include <core/session_manager_base.hpp>
 
+#include <beekeeper/mutex_handler.hpp>
+
 #include <string>
 
 namespace beekeeper {
 
 class session_manager: public session_manager_base
 {
+  private:
+
+    std::shared_ptr<mutex_handler> mtx_handler;
+
   protected:
 
     std::shared_ptr<session_base> create_session( const std::optional<std::string>& notifications_endpoint, const std::string& token, std::shared_ptr<time_manager_base> not_used_time, const boost::filesystem::path& wallet_directory ) override;
 
+    void lock( const std::string& token ) override;
+
   public:
 
-    session_manager( const std::optional<std::string>& notifications_endpoint );
+    session_manager( const std::optional<std::string>& notifications_endpoint, std::shared_ptr<mutex_handler> mtx_handler );
     ~session_manager() override {}
 };
 

programs/beekeeper/beekeeper/session_manager.cpp

@@ -4,7 +4,8 @@
 
 namespace beekeeper {
 
-session_manager::session_manager( const std::optional<std::string>& notifications_endpoint )
+session_manager::session_manager( const std::optional<std::string>& notifications_endpoint, std::shared_ptr<mutex_handler> mtx_handler )
+              : mtx_handler( mtx_handler )
 {
   time = std::make_shared<time_manager>( notifications_endpoint );
 }
@@ -14,4 +15,12 @@ std::shared_ptr<session_base> session_manager::create_session( const std::option
   return std::make_shared<session>( content_deliverer, notifications_endpoint, token, time, wallet_directory );
 }
 
+void session_manager::lock( const std::string& token )
+{
+  FC_ASSERT( mtx_handler );
+
+  std::unique_lock guard( mtx_handler->get_mutex() );
+  session_manager_base::lock( token );
+}
+
 } //beekeeper

programs/beekeeper/core/include/core/session_manager_base.hpp

@@ -28,6 +28,8 @@ class session_manager_base
 
     virtual std::shared_ptr<session_base> create_session( const std::optional<std::string>& notifications_endpoint, const std::string& token, std::shared_ptr<time_manager_base> time, const boost::filesystem::path& wallet_directory );
 
+    virtual void lock( const std::string& token );
+
   public:
 
     session_manager_base();