refactor: remove obsolete server-related common lib components

libs/common/include/launchdarkly/config/shared/builders/data_source_builder.hpp

@@ -1,14 +1,16 @@
 #pragma once
 
-#include <chrono>
-#include <optional>
-#include <type_traits>
-#include <variant>
-
 #include <launchdarkly/config/shared/built/data_source_config.hpp>
 #include <launchdarkly/config/shared/defaults.hpp>
 #include <launchdarkly/config/shared/sdks.hpp>
 
+#include <launchdarkly/error.hpp>
+
+#include <tl/expected.hpp>
+
+#include <chrono>
+#include <variant>
+
 namespace launchdarkly::config::shared::builders {
 
 /**
@@ -76,23 +78,6 @@ class PollingBuilder {
     built::PollingConfig<SDK> config_;
 };
 
-/**
- * The method visitor is only needed inside this file
- */
-namespace {
-template <typename SDK>
-struct MethodVisitor {
-    std::variant<built::StreamingConfig<SDK>, built::PollingConfig<SDK>>
-    operator()(StreamingBuilder<SDK> streaming) {
-        return streaming.Build();
-    }
-    std::variant<built::StreamingConfig<SDK>, built::PollingConfig<SDK>>
-    operator()(PollingBuilder<SDK> polling) {
-        return polling.Build();
-    }
-};
-}  // namespace
-
 template <>
 class DataSourceBuilder<ClientSDK> {
    public:
@@ -166,49 +151,4 @@ class DataSourceBuilder<ClientSDK> {
     bool use_report_;
 };
 
-template <>
-class DataSourceBuilder<ServerSDK> {
-   public:
-    using Streaming = StreamingBuilder<ServerSDK>;
-    using Polling = PollingBuilder<ServerSDK>;
-
-    DataSourceBuilder();
-
-    /**
-     * Set the streaming configuration for the builder.
-     *
-     * A data source may either be streaming or polling. Setting a streaming
-     * builder indicates the data source will use streaming. Setting a polling
-     * builder will indicate the use of polling.
-     *
-     * @param stream_builder The streaming builder.
-     * @return Reference to this builder.
-     */
-    DataSourceBuilder& Method(Streaming stream_builder);
-
-    /**
-     * Set the polling configuration for the builder.
-     *
-     * A data source may either be streaming or polling. Setting a stream
-     * builder indicates the data source will use streaming. Setting a polling
-     * builder will indicate the use of polling.
-     *
-     * @param polling_builder The polling builder.
-     * @return Reference to this builder.
-     */
-    DataSourceBuilder& Method(Polling polling_builder);
-
-    /**
-     * Build a data source config. This is used internal to the SDK.
-     *
-     * @return The built config.
-     */
-    [[nodiscard]] built::DataSourceConfig<ServerSDK> Build() const;
-
-   private:
-    std::variant<Streaming, Polling> method_;
-    bool with_reasons_;
-    bool use_report_;
-};
-
 }  // namespace launchdarkly::config::shared::builders

libs/common/include/launchdarkly/config/shared/builders/persistence_builder.hpp

@@ -81,12 +81,4 @@ class PersistenceBuilder<ClientSDK> {
     std::size_t max_contexts_;
 };
 
-template <>
-class PersistenceBuilder<ServerSDK> {
-   public:
-    [[nodiscard]] built::Persistence<ServerSDK> Build() const {
-        return built::Persistence<ServerSDK>();
-    }
-};
-
 }  // namespace launchdarkly::config::shared::builders

libs/common/include/launchdarkly/config/shared/built/data_source_config.hpp

@@ -5,7 +5,6 @@
 #include <chrono>
 #include <optional>
 #include <string>
-#include <type_traits>
 #include <variant>
 
 namespace launchdarkly::config::shared::built {
@@ -61,8 +60,5 @@ struct DataSourceConfig<ClientSDK> {
 };
 
 template <>
-struct DataSourceConfig<ServerSDK> {
-    std::variant<StreamingConfig<ServerSDK>, PollingConfig<ServerSDK>> method;
-};
-
+struct DataSourceConfig<ServerSDK> {};
 }  // namespace launchdarkly::config::shared::built

libs/common/include/launchdarkly/config/shared/built/persistence.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <chrono>
 #include <cstddef>
+#include <memory>
 
 #include <launchdarkly/config/shared/sdks.hpp>
 #include <launchdarkly/persistence/persistence.hpp>

libs/common/include/launchdarkly/config/shared/defaults.hpp

@@ -3,6 +3,7 @@
 #include <launchdarkly/config/shared/built/data_source_config.hpp>
 #include <launchdarkly/config/shared/built/events.hpp>
 #include <launchdarkly/config/shared/built/http_properties.hpp>
+#include <launchdarkly/config/shared/built/persistence.hpp>
 #include <launchdarkly/config/shared/built/service_endpoints.hpp>
 #include <launchdarkly/config/shared/sdks.hpp>
 #include <launchdarkly/logging/log_level.hpp>
@@ -73,15 +74,13 @@ struct Defaults<ClientSDK> {
 
 template <>
 struct Defaults<ServerSDK> {
-    static bool Offline() { return Defaults<AnySDK>::Offline(); }
-
-    static auto ServiceEndpoints() -> shared::built::ServiceEndpoints {
+    static auto ServiceEndpoints() -> built::ServiceEndpoints {
         return {"https://sdk.launchdarkly.com",
                 "https://stream.launchdarkly.com",
                 "https://events.launchdarkly.com"};
     }
 
-    static auto Events() -> shared::built::Events {
+    static auto Events() -> built::Events {
         return {true,
                 10000,
                 std::chrono::seconds(5),
@@ -93,22 +92,17 @@ struct Defaults<ServerSDK> {
                 1000};
     }
 
-    static auto HttpProperties() -> shared::built::HttpProperties {
+    static auto HttpProperties() -> built::HttpProperties {
         return {std::chrono::seconds{10}, std::chrono::seconds{10},
                 std::chrono::seconds{10}, std::chrono::seconds{10},
                 std::map<std::string, std::string>()};
     }
 
-    static auto StreamingConfig() -> shared::built::StreamingConfig<ServerSDK> {
+    static auto StreamingConfig() -> built::StreamingConfig<ServerSDK> {
         return {std::chrono::seconds{1}, "/all"};
     }
 
-    static auto DataSourceConfig()
-        -> shared::built::DataSourceConfig<ServerSDK> {
-        return {Defaults<ServerSDK>::StreamingConfig()};
-    }
-
-    static auto PollingConfig() -> shared::built::PollingConfig<ServerSDK> {
+    static auto PollingConfig() -> built::PollingConfig<ServerSDK> {
         return {std::chrono::seconds{30}, "/sdk/latest-all",
                 std::chrono::seconds{30}};
     }

libs/common/src/CMakeLists.txt

@@ -9,6 +9,8 @@ file(GLOB HEADER_LIST CONFIGURE_DEPENDS
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/config/shared/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/config/shared/builders/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/config/shared/built/*.hpp"
+        "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/config/shared/builders/data_system/*.hpp"
+        "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/config/shared/built/data_system/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/data/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/logging/*.hpp"
         "${LaunchDarklyCommonSdk_SOURCE_DIR}/include/launchdarkly/data_sources/*.hpp"

libs/common/src/config/data_source_builder.cpp

@@ -2,6 +2,24 @@
 
 namespace launchdarkly::config::shared::builders {
 
+template <typename SDK>
+struct MethodVisitor {};
+
+template <>
+struct MethodVisitor<ClientSDK> {
+    using SDK = ClientSDK;
+    using Result =
+        std::variant<built::StreamingConfig<SDK>, built::PollingConfig<SDK>>;
+
+    Result operator()(StreamingBuilder<SDK> const& streaming) const {
+        return streaming.Build();
+    }
+
+    Result operator()(PollingBuilder<SDK> const& polling) const {
+        return polling.Build();
+    }
+};
+
 template <typename SDK>
 StreamingBuilder<SDK>::StreamingBuilder()
     : config_(Defaults<SDK>::StreamingConfig()) {}
@@ -51,45 +69,25 @@ DataSourceBuilder<ClientSDK>& DataSourceBuilder<ClientSDK>::UseReport(
 
 DataSourceBuilder<ClientSDK>& DataSourceBuilder<ClientSDK>::Method(
     StreamingBuilder<ClientSDK> builder) {
-    method_ = builder;
+    method_ = std::move(builder);
     return *this;
 }
 
 DataSourceBuilder<ClientSDK>& DataSourceBuilder<ClientSDK>::Method(
     PollingBuilder<ClientSDK> builder) {
-    method_ = builder;
+    method_ = std::move(builder);
     return *this;
 }
 
 built::DataSourceConfig<ClientSDK> DataSourceBuilder<ClientSDK>::Build() const {
-    auto method = std::visit(MethodVisitor<ClientSDK>(), method_);
-    return {method, with_reasons_, use_report_};
-}
-
-DataSourceBuilder<ServerSDK>::DataSourceBuilder()
-    : with_reasons_(false), use_report_(false), method_(Streaming()) {}
-
-DataSourceBuilder<ServerSDK>& DataSourceBuilder<ServerSDK>::Method(
-    StreamingBuilder<ServerSDK> builder) {
-    method_ = builder;
-    return *this;
-}
-
-DataSourceBuilder<ServerSDK>& DataSourceBuilder<ServerSDK>::Method(
-    PollingBuilder<ServerSDK> builder) {
-    method_ = builder;
-    return *this;
-}
-
-built::DataSourceConfig<ServerSDK> DataSourceBuilder<ServerSDK>::Build() const {
-    auto method = std::visit(MethodVisitor<ServerSDK>(), method_);
-    return {method};
+    return {std::visit(MethodVisitor<ClientSDK>(), method_), with_reasons_,
+            use_report_};
 }
 
-template class PollingBuilder<config::shared::ClientSDK>;
-template class PollingBuilder<config::shared::ServerSDK>;
+template class PollingBuilder<ClientSDK>;
+template class PollingBuilder<ServerSDK>;
 
-template class StreamingBuilder<config::shared::ClientSDK>;
-template class StreamingBuilder<config::shared::ServerSDK>;
+template class StreamingBuilder<ClientSDK>;
+template class StreamingBuilder<ServerSDK>;
 
 }  // namespace launchdarkly::config::shared::builders

libs/common/tests/data_source_builder_test.cpp

@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 #include <launchdarkly/config/client.hpp>
-#include <launchdarkly/config/server_builders.hpp>
 #include <launchdarkly/config/shared/sdks.hpp>
 #include <launchdarkly/value.hpp>
 
@@ -46,33 +45,3 @@ TEST(DataSourceBuilderTests, CanCreatePollingClientConfig) {
             client_config.method)
             .poll_interval);
 }
-
-TEST(DataSourceBuilderTests, CanCreateStreamingServerConfig) {
-    auto server_config =
-        server_side::DataSourceBuilder()
-            .Method(server_side::DataSourceBuilder::Streaming()
-                        .InitialReconnectDelay(std::chrono::milliseconds{1500}))
-            .Build();
-
-    EXPECT_EQ(
-        std::chrono::milliseconds{1500},
-        std::get<
-            config::shared::built::StreamingConfig<config::shared::ServerSDK>>(
-            server_config.method)
-            .initial_reconnect_delay);
-}
-
-TEST(DataSourceBuilderTests, CanCreatePollingServerConfig) {
-    auto server_config =
-        server_side::DataSourceBuilder()
-            .Method(server_side::DataSourceBuilder::Polling().PollInterval(
-                std::chrono::seconds{30000}))
-            .Build();
-
-    EXPECT_EQ(
-        std::chrono::seconds{30000},
-        std::get<
-            config::shared::built::PollingConfig<config::shared::ServerSDK>>(
-            server_config.method)
-            .poll_interval);
-}

libs/common/tests/service_endpoints_test.cpp

@@ -1,7 +1,6 @@
 #include <gtest/gtest.h>
 
 #include <launchdarkly/config/client.hpp>
-#include <launchdarkly/config/server_builders.hpp>
 #include <launchdarkly/error.hpp>
 
 class ServiceEndpointTest : public testing::Test {};
@@ -18,15 +17,6 @@ TEST(ServiceEndpointTest, DefaultClientBuilderURLs) {
     ASSERT_EQ(eps->EventsBaseUrl(), "https://mobile.launchdarkly.com");
 }
 
-TEST(ServiceEndpointTest, DefaultServerBuilderURLs) {
-    server_side::EndpointsBuilder builder;
-    auto eps = builder.Build();
-    ASSERT_TRUE(eps);
-    ASSERT_EQ(eps->PollingBaseUrl(), "https://sdk.launchdarkly.com");
-    ASSERT_EQ(eps->StreamingBaseUrl(), "https://stream.launchdarkly.com");
-    ASSERT_EQ(eps->EventsBaseUrl(), "https://events.launchdarkly.com");
-}
-
 TEST(ServiceEndpointTest, ModifySingleURLCausesError) {
     auto result = client_side::EndpointsBuilder().PollingBaseUrl("foo").Build();
     ASSERT_FALSE(result);

libs/server-sdk/src/data_systems/lazy_load/lazy_load_system.hpp

@@ -3,17 +3,16 @@
 #include "../../data_components/expiration_tracker/expiration_tracker.hpp"
 #include "../../data_components/kinds/kinds.hpp"
 #include "../../data_components/memory_store/memory_store.hpp"
-#include "../../data_components/serialization_adapters/json_deserializer.hpp"
+#include "../../data_interfaces/source/idata_reader.hpp"
 #include "../../data_interfaces/system/idata_system.hpp"
 
+#include <launchdarkly/server_side/data_interfaces/sources/iserialized_data_reader.hpp>
 #include <launchdarkly/server_side/integrations/serialized_item_descriptor.hpp>
 
 #include <launchdarkly/data_model/descriptors.hpp>
 #include <launchdarkly/detail/unreachable.hpp>
 #include <launchdarkly/logging/logger.hpp>
 
-#include <boost/asio/any_io_executor.hpp>
-
 namespace launchdarkly::server_side::data_systems {
 
 /**