feat: Implement flag manager. (#20)

Co-authored-by: Casey Waldren <[email protected]>
fix build on mac (#22)

Author: kinyoklion

CONTRIBUTING.md

@@ -34,6 +34,16 @@ class BarBaz;
 DoTheFoo();
 Bar();
 ```
+
+**Methods**
+```c++
+struct Thing {
+    uint64_t Size(); // Getter
+    void DoTheFoo();
+};
+
+```
+
 **Constants**
 ```c++
 const int kFooBarBaz = 1;
@@ -58,6 +68,19 @@ In C++:
 file_name.cpp
 file_name.hpp
 ```
+
+**Divergence: getters**
+
+```c++
+struct Thing {
+    // Good
+    uint64_t Size();
+
+    //Bad
+    uint64_t size();
+};
+```
+
 ### C++ Standard
 
 C++17.

libs/client-sdk/include/launchdarkly/client_side/data_source_update_sink.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
-#include <map>
+#include <optional>
+#include <ostream>
 #include <string>
+#include <unordered_map>
 
 #include "config/detail/service_endpoints.hpp"
 #include "context.hpp"
@@ -43,8 +45,8 @@ struct ItemDescriptor {
  */
 class IDataSourceUpdateSink {
    public:
-    virtual void init(std::map<std::string, ItemDescriptor> data) = 0;
-    virtual void upsert(std::string key, ItemDescriptor) = 0;
+    virtual void Init(std::unordered_map<std::string, ItemDescriptor> data) = 0;
+    virtual void Upsert(std::string key, ItemDescriptor item) = 0;
 
     // We could add this if we want to support data source status.
     // virtual void status(<something>)

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_change_event.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <boost/signals2.hpp>
+#include "value.hpp"
+
+namespace launchdarkly::client_side::flag_manager::detail {
+/**
+ * A notification, for the consumer of the SDK, that a flag value has
+ * changed.
+ */
+class FlagValueChangeEvent {
+   public:
+    /**
+     * The name of the flag that changed.
+     * @return The name of the flag.
+     */
+    [[nodiscard]] std::string const& FlagName() const;
+
+    /**
+     * Get the new value. If there was not an new value, because the flag was
+     * deleted, then the Value will be of a null type. Check the Deleted method
+     * to see if a flag was deleted.
+     *
+     * @return The new value.
+     */
+    [[nodiscard]] Value const& NewValue() const;
+
+    /**
+     * Get the old value. If there was not an old value, for instance a newly
+     * created flag, then the Value will be of a null type.
+     *
+     * @return The new value.
+     */
+    [[nodiscard]] Value const& OldValue() const;
+
+    /**
+     * Will be true if the flag was deleted. In which case the NewValue will
+     * be of a null type.
+     *
+     * @return True if the flag was deleted.
+     */
+    [[nodiscard]] bool Deleted() const;
+
+    /**
+     * Construct a flag changed event with a new and old value.
+     *
+     * This is a change event for a flag that has not been Deleted.
+     *
+     * @param new_value The new value.
+     * @param old_value The old value.
+     */
+    FlagValueChangeEvent(std::string name, Value new_value, Value old_value);
+    FlagValueChangeEvent(std::string name, Value old_value);
+
+   private:
+    Value new_value_;
+    Value old_value_;
+    bool deleted_;
+    std::string flag_name_;
+};
+
+}  // namespace launchdarkly::client_side::flag_manager::detail

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_manager.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "launchdarkly/client_side/data_source_update_sink.hpp"
+
+namespace launchdarkly::client_side::flag_manager::detail {
+
+class FlagManager {
+   public:
+    void Init(std::unordered_map<std::string, ItemDescriptor> const& data);
+    void Upsert(std::string const& key, ItemDescriptor item);
+
+    /**
+     * Attempts to get a flag by key from the current flags.
+     *
+     * @param flag_key The flag to get.
+     * @return A shared_ptr to the value if present. A null shared_ptr if the
+     * item is not present.
+     */
+    std::shared_ptr<ItemDescriptor> Get(std::string const& flag_key) const;
+
+    /**
+     * Gets all the current flags.
+     *
+     * @return All of the current flags.
+     */
+    std::unordered_map<std::string, std::shared_ptr<ItemDescriptor>> GetAll()
+        const;
+
+   private:
+    std::unordered_map<std::string, std::shared_ptr<ItemDescriptor>> data_;
+    mutable std::mutex data_mutex_;
+};
+
+}  // namespace launchdarkly::client_side::flag_manager::detail

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_notifier.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <boost/signals2.hpp>
+
+#include "launchdarkly/client_side/flag_manager/detail/flag_change_event.hpp"
+#include "value.hpp"
+
+namespace launchdarkly::client_side::flag_manager::detail {
+
+/**
+ * Represents the connection of a listener to a IFlagNotifier.
+ * Disconnecting the connection will cause the listener to stop receiving
+ * events.
+ */
+class IConnection {
+   public:
+    virtual void Disconnect() = 0;
+
+    virtual ~IConnection() = default;
+    IConnection(IConnection const& item) = delete;
+    IConnection(IConnection&& item) = delete;
+    IConnection& operator=(IConnection const&) = delete;
+    IConnection& operator=(IConnection&&) = delete;
+
+   protected:
+    IConnection() = default;
+};
+
+/**
+ * Interface to allow listening for flag changes. Notification events should
+ * be distributed after the store has been updated. Meaning that the "new"
+ * value will correspond to the current value in the store, and the "old" value
+ * will be what the value was before the update.
+ */
+class IFlagNotifier {
+   public:
+    // The FlagValueChangeEvent is in a shared pointer so that all handlers
+    // can use the same instance, and the lifetime is tied to how the consumer
+    // uses the event.
+    using ChangeHandler =
+        std::function<void(std::shared_ptr<FlagValueChangeEvent>)>;
+
+    /**
+     * Listen for changes for the specific flag.
+     * @param key The flag to listen to changes for.
+     * @param signal The handler for the changes.
+     * @return A connection which can be used to stop listening.
+     */
+    virtual std::unique_ptr<IConnection> OnFlagChange(
+        std::string const& key,
+        ChangeHandler handler) = 0;
+
+    virtual ~IFlagNotifier() = default;
+    IFlagNotifier(IFlagNotifier const& item) = delete;
+    IFlagNotifier(IFlagNotifier&& item) = delete;
+    IFlagNotifier& operator=(IFlagNotifier const&) = delete;
+    IFlagNotifier& operator=(IFlagNotifier&&) = delete;
+
+   protected:
+    IFlagNotifier() = default;
+};
+
+}  // namespace launchdarkly::client_side::flag_manager::detail

libs/client-sdk/include/launchdarkly/client_side/flag_manager/detail/flag_updater.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+#include "launchdarkly/client_side/data_source_update_sink.hpp"
+#include "launchdarkly/client_side/flag_manager/detail/flag_change_event.hpp"
+#include "launchdarkly/client_side/flag_manager/detail/flag_manager.hpp"
+#include "launchdarkly/client_side/flag_manager/detail/flag_notifier.hpp"
+
+namespace launchdarkly::client_side::flag_manager::detail {
+
+class FlagUpdater : public IDataSourceUpdateSink, public IFlagNotifier {
+   public:
+    FlagUpdater(FlagManager& flag_manager);
+    void Init(std::unordered_map<std::string, ItemDescriptor> data) override;
+    void Upsert(std::string key, ItemDescriptor item) override;
+
+    /**
+     * Listen for changes for the specific flag.
+     * @param key The flag to listen to.
+     * @param handler The handler to signal when the flag changes.
+     * @return A Connection which can be used to stop listening for changes
+     * to the flag using this handler.
+     */
+    std::unique_ptr<IConnection> OnFlagChange(
+        std::string const& key,
+        std::function<void(std::shared_ptr<FlagValueChangeEvent>)> handler)
+        override;
+
+   private:
+    class Connection : public IConnection {
+       public:
+        friend class FlagUpdater;
+        Connection(boost::signals2::connection connection);
+        void Disconnect() override;
+
+       private:
+        boost::signals2::connection connection_;
+    };
+
+    bool HasListeners() const;
+
+    FlagManager& flag_manager_;
+    std::unordered_map<
+        std::string,
+        boost::signals2::signal<void(std::shared_ptr<FlagValueChangeEvent>)>>
+        signals_;
+
+    // Recursive mutex so that has_listeners can non-conditionally lock
+    // the mutex. Otherwise a pre-condition for the call would be holding
+    // the mutex, which is more difficult to keep consistent over the code
+    // lifetime.
+    mutable std::recursive_mutex signal_mutex_;
+    void DispatchEvent(FlagValueChangeEvent event);
+};
+
+}  // namespace launchdarkly::client_side::flag_manager::detail

libs/client-sdk/src/CMakeLists.txt

@@ -2,7 +2,7 @@
 file(GLOB HEADER_LIST CONFIGURE_DEPENDS "${LaunchDarklyCPPClient_SOURCE_DIR}/include/launchdarkly/*.hpp")
 
 # Automatic library: static or dynamic based on user config.
-add_library(${LIBNAME} api.cpp ${HEADER_LIST} data_sources/streaming_data_source.cpp data_sources/base_64.cpp data_sources/streaming_data_handler.cpp data_source_update_sink.cpp)
+add_library(${LIBNAME} api.cpp ${HEADER_LIST} data_sources/streaming_data_source.cpp data_sources/base_64.cpp data_sources/streaming_data_handler.cpp data_source_update_sink.cpp flag_manager/flag_manager.cpp flag_manager/flag_updater.cpp flag_manager/flag_change_event.cpp)
 
 target_link_libraries(${LIBNAME} launchdarkly::common launchdarkly::sse)
 

libs/client-sdk/src/data_sources/streaming_data_handler.cpp

@@ -5,6 +5,7 @@
 #include "serialization/value_mapping.hpp"
 
 #include <boost/json.hpp>
+#include <unordered_map>
 #include <utility>
 
 #include "tl/expected.hpp"
@@ -14,10 +15,11 @@ namespace launchdarkly::client_side {
 // ItemDescriptor.
 
 static tl::expected<
-    std::map<std::string, launchdarkly::client_side::ItemDescriptor>,
+    std::unordered_map<std::string, launchdarkly::client_side::ItemDescriptor>,
     JsonError>
 tag_invoke(boost::json::value_to_tag<tl::expected<
-               std::map<std::string, launchdarkly::client_side::ItemDescriptor>,
+               std::unordered_map<std::string,
+                                  launchdarkly::client_side::ItemDescriptor>,
                JsonError>> const& unused,
            boost::json::value const& json_value) {
     boost::ignore_unused(unused);
@@ -26,7 +28,7 @@ tag_invoke(boost::json::value_to_tag<tl::expected<
         return tl::unexpected(JsonError::kSchemaFailure);
     }
     auto const& obj = json_value.as_object();
-    std::map<std::string, launchdarkly::client_side::ItemDescriptor>
+    std::unordered_map<std::string, launchdarkly::client_side::ItemDescriptor>
         descriptors;
     for (auto const& pair : obj) {
         auto eval_result =
@@ -102,12 +104,12 @@ StreamingDataHandler::MessageStatus StreamingDataHandler::handle_message(
             LD_LOG(logger_, LogLevel::kError) << "Could not parse PUT message";
             return StreamingDataHandler::MessageStatus::kInvalidMessage;
         }
-        auto res = boost::json::value_to<
-            tl::expected<std::map<std::string, ItemDescriptor>, JsonError>>(
+        auto res = boost::json::value_to<tl::expected<
+            std::unordered_map<std::string, ItemDescriptor>, JsonError>>(
             parsed);
 
         if (res.has_value()) {
-            handler_->init(res.value());
+            handler_->Init(res.value());
             return StreamingDataHandler::MessageStatus::kMessageHandled;
         }
         LD_LOG(logger_, LogLevel::kError)
@@ -125,7 +127,7 @@ StreamingDataHandler::MessageStatus StreamingDataHandler::handle_message(
         auto res = boost::json::value_to<
             tl::expected<StreamingDataHandler::PatchData, JsonError>>(parsed);
         if (res.has_value()) {
-            handler_->upsert(
+            handler_->Upsert(
                 res.value().key,
                 launchdarkly::client_side::ItemDescriptor(res.value().flag));
             return StreamingDataHandler::MessageStatus::kMessageHandled;
@@ -146,7 +148,7 @@ StreamingDataHandler::MessageStatus StreamingDataHandler::handle_message(
             tl::expected<StreamingDataHandler::DeleteData, JsonError>>(
             boost::json::parse(event.data()));
         if (res.has_value()) {
-            handler_->upsert(res.value().key,
+            handler_->Upsert(res.value().key,
                              ItemDescriptor(res.value().version));
             return StreamingDataHandler::MessageStatus::kMessageHandled;
         }

libs/client-sdk/src/flag_manager/flag_change_event.cpp

@@ -0,0 +1,34 @@
+#include "launchdarkly/client_side/flag_manager/detail/flag_change_event.hpp"
+
+namespace launchdarkly::client_side::flag_manager::detail {
+
+std::string const& FlagValueChangeEvent::FlagName() const {
+    return flag_name_;
+}
+
+Value const& FlagValueChangeEvent::NewValue() const {
+    return new_value_;
+}
+
+Value const& FlagValueChangeEvent::OldValue() const {
+    return old_value_;
+}
+
+bool FlagValueChangeEvent::Deleted() const {
+    return deleted_;
+}
+
+FlagValueChangeEvent::FlagValueChangeEvent(std::string name,
+                                           Value new_value,
+                                           Value old_value)
+    : flag_name_(std::move(name)),
+      new_value_(std::move(new_value)),
+      old_value_(std::move(old_value)),
+      deleted_(false) {}
+
+FlagValueChangeEvent::FlagValueChangeEvent(std::string name, Value old_value)
+    : flag_name_(std::move(name)),
+      old_value_(std::move(old_value)),
+      deleted_(true) {}
+
+}  // namespace launchdarkly::client_side::flag_manager::detail