Fixed race condition on ProcessingServiceImpl's destructor

Author: EduMenges

src/processing/processing_service.cpp

@@ -145,8 +145,13 @@ namespace sgns::processing
         m_logger->debug( "List of processing channels requested" );
         m_timerChannelListRequestTimeout.expires_from_now( m_channelListRequestTimeout );
         m_timerChannelListRequestTimeout.async_wait(
-            [instance = shared_from_this()]( const boost::system::error_code & )
-            { instance->HandleRequestTimeout(); } );
+            [instance = weak_from_this()]( const boost::system::error_code & )
+            {
+                if ( auto strong = instance.lock() )
+                {
+                    strong->HandleRequestTimeout();
+                }
+            } );
     }
 
     void ProcessingServiceImpl::OnMessage( boost::optional<const ipfs_pubsub::GossipPubSub::Message &> message )
@@ -406,34 +411,39 @@ namespace sgns::processing
         m_channelListRequestTimeout = channelListRequestTimeout;
     }
 
-    ProcessingServiceImpl::ProcessingStatus ProcessingServiceImpl::GetProcessingStatus() const {
-        if (m_isStopped) {
-            return ProcessingStatus(Status::DISABLED, 0.0f);
+    ProcessingServiceImpl::ProcessingStatus ProcessingServiceImpl::GetProcessingStatus() const
+    {
+        if ( m_isStopped )
+        {
+            return ProcessingStatus( Status::DISABLED, 0.0f );
         }
-        
-        float totalProgress = 0.0f;
-        size_t nodeCount = 0;
-        
+
+        float  totalProgress = 0.0f;
+        size_t nodeCount     = 0;
+
         {
-            std::lock_guard lock(m_mutexNodes);
-            if (m_processingNodes.empty()) {
-                return ProcessingStatus(Status::IDLE, 0.0f);
+            std::lock_guard lock( m_mutexNodes );
+            if ( m_processingNodes.empty() )
+            {
+                return ProcessingStatus( Status::IDLE, 0.0f );
             }
-            
+
             // Calculate average progress across all processing nodes
-            for (const auto& [queueId, node] : m_processingNodes) {
-                if (node) {
+            for ( const auto &[queueId, node] : m_processingNodes )
+            {
+                if ( node )
+                {
                     totalProgress += node->GetProgress();
                     ++nodeCount;
                 }
             }
         }
-        
-        float averageProgress = (nodeCount > 0) ? (totalProgress / nodeCount) : 0.0f;
+
+        float averageProgress = ( nodeCount > 0 ) ? ( totalProgress / nodeCount ) : 0.0f;
         // Round to 2 decimal places
-        averageProgress = std::round(averageProgress * 100.0f) / 100.0f;
-        
-        return ProcessingStatus(Status::PROCESSING, averageProgress);
+        averageProgress = std::round( averageProgress * 100.0f ) / 100.0f;
+
+        return ProcessingStatus( Status::PROCESSING, averageProgress );
     }
 
     void ProcessingServiceImpl::HandleRequestTimeout()

test/src/multiaccount/multi_account_sync.cpp

@@ -75,7 +75,7 @@ class MultiAccountTest : public ::testing::Test
 
         if ( isGenesisAuthorized )
         {
-            auto response = sgns::GeniusAccount::GenerateGeniusAddress(  key.c_str(), outPath );
+            auto response = GeniusAccount::GenerateGeniusAddress( key.c_str(), outPath );
             if ( !response.has_value() )
             {
                 ADD_FAILURE() << "Failed to generate full-node address for authorization";
@@ -141,26 +141,26 @@ TEST_F( MultiAccountTest, SyncThroughEachOther )
     auto node_full = CreateNode( "node_multi_full",
                                  "0xcafe",
                                  "1.0",
-                                 sgns::TokenID::FromBytes( { 0x00 } ),
+                                 TokenID::FromBytes( { 0x00 } ),
                                  true, // is full node
                                  true, // is processor
                                  true );
     test::assertWaitForCondition(
         [&]() { return node_full->GetTransactionManagerState() == TransactionManager::State::READY; },
         std::chrono::milliseconds( 30000 ),
-        "node_full not synched" );
+        "node_full not synced" );
     auto node_main = CreateNode( "node_multi_1",
                                  "0xcafe",
                                  "1.0",
-                                 sgns::TokenID::FromBytes( { 0x00 } ),
+                                 TokenID::FromBytes( { 0x00 } ),
                                  false, // not full node
                                  false  // not processor
     );
 
     auto node_proc1 = CreateNode( "node_multi_1",
                                   "0xcafe",
                                   "1.0",
-                                  sgns::TokenID::FromBytes( { 0x00 } ),
+                                  TokenID::FromBytes( { 0x00 } ),
                                   false, // not full node
                                   true   // is processor
     );
@@ -173,11 +173,11 @@ TEST_F( MultiAccountTest, SyncThroughEachOther )
     test::assertWaitForCondition(
         [&]() { return node_proc1->GetTransactionManagerState() == TransactionManager::State::READY; },
         std::chrono::milliseconds( 30000 ),
-        "node_proc1 not synched" );
+        "node_proc1 not synced" );
     test::assertWaitForCondition(
         [&]() { return node_main->GetTransactionManagerState() == TransactionManager::State::READY; },
         std::chrono::milliseconds( 30000 ),
-        "node_main not synched" );
+        "node_main not synced" );
 
     // Get initial state
     auto transcount_main_start  = node_main->GetOutTransactions().size();
@@ -195,9 +195,9 @@ TEST_F( MultiAccountTest, SyncThroughEachOther )
 
     std::cout << "Mint transaction on main node completed, waiting for sync..." << std::endl;
 
-    test::assertWaitForCondition( [&]() { return node_proc1->GetBalance() == 50000000000; },
+    test::assertWaitForCondition( [&] { return node_proc1->GetBalance() == 50000000000; },
                                   std::chrono::milliseconds( 30000 ),
-                                  "node_proc1 balance not synched" );
+                                  "node_proc1 balance not synced" );
 
     //TODO - this is not working at the moment
     //auto mint_received = node_proc1->WaitForTransactionOutgoing(
@@ -211,9 +211,9 @@ TEST_F( MultiAccountTest, SyncThroughEachOther )
                                           std::chrono::milliseconds( OUTGOING_TIMEOUT_MILLISECONDS ) );
     ASSERT_TRUE( mint_result.has_value() ) << "Mint transaction failed or timed out on node_proc1";
 
-    test::assertWaitForCondition( [&]() { return node_main->GetBalance() == 100000000000; },
+    test::assertWaitForCondition( [&] { return node_main->GetBalance() == 100000000000; },
                                   std::chrono::milliseconds( 30000 ),
-                                  "node_main balance not synched" );
+                                  "node_main balance not synced" );
     //TODO - this is not working at the moment
     //auto mint_received2 = node_main->WaitForTransactionOutgoing(
     //    mint_result.value().first,