fix: hold FDv1 source via shared_ptr and forward init-time errors

Author: beekld

libs/server-sdk/src/data_systems/fdv2/fdv1_adapter_synchronizer.cpp

@@ -134,16 +134,18 @@ FDv1AdapterSynchronizer::FDv1AdapterSynchronizer(SourceBuilder source_builder)
               }
               switch (status.State()) {
                   case DataSourceState::kInterrupted:
+                  case DataSourceState::kInitializing:
+                      // Recoverable error.
                       state->Notify(FDv2SourceResult{
                           FDv2SourceResult::Interrupted{*error}});
                       break;
                   case DataSourceState::kOff:
+                      // Terminal error.
                       state->Notify(FDv2SourceResult{
                           FDv2SourceResult::TerminalError{*error}});
                       break;
-                  case DataSourceState::kInitializing:
                   case DataSourceState::kValid:
-                      // No FDv2 result for these states.
+                      // Recovery; no FDv2 result.
                       break;
               }
           })),

libs/server-sdk/src/data_systems/fdv2/fdv1_adapter_synchronizer.hpp

@@ -36,7 +36,7 @@ class FDv1AdapterSynchronizer final
     : public data_interfaces::IFDv2Synchronizer {
    public:
     using SourceBuilder =
-        std::function<std::unique_ptr<data_interfaces::IDataSynchronizer>(
+        std::function<std::shared_ptr<data_interfaces::IDataSynchronizer>(
             data_components::DataSourceStatusManager&)>;
 
     /**
@@ -116,7 +116,7 @@ class FDv1AdapterSynchronizer final
         status_manager_;
     std::unique_ptr<IConnection> const status_subscription_;
 
-    std::unique_ptr<data_interfaces::IDataSynchronizer> const fdv1_source_;
+    std::shared_ptr<data_interfaces::IDataSynchronizer> const fdv1_source_;
 
     // Serializes StartAsync and ShutdownAsync on fdv1_source_ across
     // concurrent Next() and Close() calls.

libs/server-sdk/tests/fdv1_adapter_synchronizer_test.cpp

@@ -57,7 +57,7 @@ FDv1AdapterSynchronizer::SourceBuilder MakeMockBuilder(
         if (out_sm) {
             *out_sm = &sm;
         }
-        auto source = std::make_unique<MockFDv1Source>(sm);
+        auto source = std::make_shared<MockFDv1Source>(sm);
         if (out_source) {
             *out_source = source.get();
         }
@@ -242,6 +242,25 @@ TEST(FDv1AdapterSynchronizerTest, InterruptedStatusProducesInterruptedResult) {
               interrupted->error.Kind());
 }
 
+TEST(FDv1AdapterSynchronizerTest,
+     InitializingWithErrorProducesInterruptedResult) {
+    DataSourceStatusManager* source_manager = nullptr;
+    FDv1AdapterSynchronizer adapter(MakeMockBuilder(nullptr, &source_manager));
+
+    auto future = adapter.Next(data_model::Selector{});
+    source_manager->SetState(
+        DataSourceStatus::DataSourceState::kInterrupted,
+        DataSourceStatus::ErrorInfo::ErrorKind::kNetworkError, "boom");
+
+    auto result = future.WaitForResult(1s);
+    ASSERT_TRUE(result.has_value());
+    auto* interrupted =
+        std::get_if<FDv2SourceResult::Interrupted>(&result->value);
+    ASSERT_NE(interrupted, nullptr);
+    EXPECT_EQ(DataSourceStatus::ErrorInfo::ErrorKind::kNetworkError,
+              interrupted->error.Kind());
+}
+
 TEST(FDv1AdapterSynchronizerTest, OffStatusProducesTerminalErrorResult) {
     DataSourceStatusManager* source_manager = nullptr;
     FDv1AdapterSynchronizer adapter(MakeMockBuilder(nullptr, &source_manager));