Move private constants to datastore module

Author: jsonbailey

lib/ldclient-rb/impl/data_source.rb

@@ -52,7 +52,7 @@ def init(all_data)
           monitor_store_update do
             if @flag_change_broadcaster.has_listeners?
               old_data = {}
-              LaunchDarkly::ALL_KINDS.each do |kind|
+              Impl::DataStore::ALL_KINDS.each do |kind|
                 old_data[kind] = @data_store.all(kind)
               end
             end
@@ -153,7 +153,7 @@ def update_status(new_state, new_error)
         private def compute_changed_items_for_full_data_set(old_data, new_data)
           affected_items = Set.new
 
-          LaunchDarkly::ALL_KINDS.each do |kind|
+          Impl::DataStore::ALL_KINDS.each do |kind|
             old_items = old_data[kind] || {}
             new_items = new_data[kind] || {}
 
@@ -177,7 +177,7 @@ def update_status(new_state, new_error)
         #
         private def send_change_events(affected_items)
           affected_items.each do |item|
-            if item[:kind] == LaunchDarkly::FEATURES
+            if item[:kind] == Impl::DataStore::FEATURES
               @flag_change_broadcaster.broadcast(LaunchDarkly::Interfaces::FlagChange.new(item[:key]))
             end
           end

lib/ldclient-rb/impl/data_source/stream.rb

@@ -1,4 +1,6 @@
 require "ldclient-rb/impl/model/serialization"
+require "ldclient-rb/impl/util"
+require "ldclient-rb/in_memory_store"
 
 require "concurrent/atomics"
 require "json"
@@ -18,8 +20,8 @@ module DataSource
 
       # @api private
       KEY_PATHS = {
-        FEATURES => "/flags/",
-        SEGMENTS => "/segments/",
+        Impl::DataStore::FEATURES => "/flags/",
+        Impl::DataStore::SEGMENTS => "/segments/",
       }
 
       # @api private
@@ -55,7 +57,7 @@ def start
           }
           log_connection_started
 
-          uri = Util.add_payload_filter_key(@config.stream_uri + "/all", @config)
+          uri = Impl::Util.add_payload_filter_key(@config.stream_uri + "/all", @config)
           @es = SSE::Client.new(uri, **opts) do |conn|
             conn.on_event { |event| process_message(event) }
             conn.on_error { |err|
@@ -142,7 +144,7 @@ def process_message(message)
               @ready.set
             elsif method == PATCH
               data = JSON.parse(message.data, symbolize_names: true)
-              for kind in [FEATURES, SEGMENTS]
+              for kind in [Impl::DataStore::FEATURES, Impl::DataStore::SEGMENTS]
                 key = key_for_path(kind, data[:path])
                 if key
                   item = Impl::Model.deserialize(kind, data[:data], @config.logger)
@@ -152,7 +154,7 @@ def process_message(message)
               end
             elsif method == DELETE
               data = JSON.parse(message.data, symbolize_names: true)
-              for kind in [FEATURES, SEGMENTS]
+              for kind in [Impl::DataStore::FEATURES, Impl::DataStore::SEGMENTS]
                 key = key_for_path(kind, data[:path])
                 if key
                   update_sink_or_data_store.delete(kind, key, data[:version])

lib/ldclient-rb/impl/data_store.rb

@@ -1,108 +1,26 @@
 require 'concurrent'
 require "ldclient-rb/interfaces"
+require "ldclient-rb/impl/data_store/data_kind"
 
 module LaunchDarkly
   module Impl
     module DataStore
-      class DataKind
-        FEATURES = "features".freeze
-        SEGMENTS = "segments".freeze
-
-        FEATURE_PREREQ_FN = lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }.freeze
-
-        attr_reader :namespace
-        attr_reader :priority
-
-        #
-        # @param namespace [String]
-        # @param priority [Integer]
-        #
-        def initialize(namespace:, priority:)
-          @namespace = namespace
-          @priority = priority
-        end
-
+        # These constants denote the types of data that can be stored in the feature store.  If
+        # we add another storable data type in the future, as long as it follows the same pattern
+        # (having "key", "version", and "deleted" properties), we only need to add a corresponding
+        # constant here and the existing store should be able to handle it.
         #
-        # Maintain the same behavior when these data kinds were standard ruby hashes.
-        #
-        # @param key [Symbol]
-        # @return [Object]
-        #
-        def [](key)
-          return priority if key == :priority
-          return namespace if key == :namespace
-          return get_dependency_keys_fn() if key == :get_dependency_keys
-          nil
-        end
-
-        #
-        # Retrieve the dependency keys for a particular data kind. Right now, this is only defined for flags.
-        #
-        def get_dependency_keys_fn()
-          return nil unless @namespace == FEATURES
-
-          FEATURE_PREREQ_FN
-        end
-
-        def eql?(other)
-          other.is_a?(DataKind) && namespace == other.namespace && priority == other.priority
-        end
-
-        def hash
-          [namespace, priority].hash
-        end
-      end
-
-      class StatusProvider
-        include LaunchDarkly::Interfaces::DataStore::StatusProvider
-
-        def initialize(store, update_sink)
-          # @type [LaunchDarkly::Impl::FeatureStoreClientWrapper]
-          @store = store
-          # @type [UpdateSink]
-          @update_sink = update_sink
-        end
-
-        def status
-          @update_sink.last_status.get
-        end
-
-        def monitoring_enabled?
-          @store.monitoring_enabled?
-        end
-
-        def add_listener(listener)
-          @update_sink.broadcaster.add_listener(listener)
-        end
-
-        def remove_listener(listener)
-          @update_sink.broadcaster.remove_listener(listener)
-        end
-      end
-
-      class UpdateSink
-        include LaunchDarkly::Interfaces::DataStore::UpdateSink
-
-        # @return [LaunchDarkly::Impl::Broadcaster]
-        attr_reader :broadcaster
-
-        # @return [Concurrent::AtomicReference]
-        attr_reader :last_status
+        # The :priority and :get_dependency_keys properties are used by FeatureStoreDataSetSorter
+        # to ensure data consistency during non-atomic updates.
 
-        def initialize(broadcaster)
-          @broadcaster = broadcaster
-          @last_status = Concurrent::AtomicReference.new(
-            LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
-          )
-        end
+        # @api private
+        FEATURES = DataKind.new(namespace: "features", priority: 1).freeze
 
-        def update_status(status)
-          return if status.nil?
+        # @api private
+        SEGMENTS = DataKind.new(namespace: "segments", priority: 0).freeze
 
-          old_status = @last_status.get_and_set(status)
-          @broadcaster.broadcast(status) unless old_status == status
-        end
-      end
+        # @api private
+        ALL_KINDS = [FEATURES, SEGMENTS].freeze
     end
   end
-end
+end

lib/ldclient-rb/impl/data_store/data_kind.rb

@@ -0,0 +1,108 @@
+require 'concurrent'
+require "ldclient-rb/interfaces"
+
+module LaunchDarkly
+  module Impl
+    module DataStore
+      class DataKind
+        FEATURES = "features".freeze
+        SEGMENTS = "segments".freeze
+
+        FEATURE_PREREQ_FN = lambda { |flag| (flag[:prerequisites] || []).map { |p| p[:key] } }.freeze
+
+        attr_reader :namespace
+        attr_reader :priority
+
+        #
+        # @param namespace [String]
+        # @param priority [Integer]
+        #
+        def initialize(namespace:, priority:)
+          @namespace = namespace
+          @priority = priority
+        end
+
+        #
+        # Maintain the same behavior when these data kinds were standard ruby hashes.
+        #
+        # @param key [Symbol]
+        # @return [Object]
+        #
+        def [](key)
+          return priority if key == :priority
+          return namespace if key == :namespace
+          return get_dependency_keys_fn() if key == :get_dependency_keys
+          nil
+        end
+
+        #
+        # Retrieve the dependency keys for a particular data kind. Right now, this is only defined for flags.
+        #
+        def get_dependency_keys_fn()
+          return nil unless @namespace == FEATURES
+
+          FEATURE_PREREQ_FN
+        end
+
+        def eql?(other)
+          other.is_a?(DataKind) && namespace == other.namespace && priority == other.priority
+        end
+
+        def hash
+          [namespace, priority].hash
+        end
+      end
+
+      class StatusProvider
+        include LaunchDarkly::Interfaces::DataStore::StatusProvider
+
+        def initialize(store, update_sink)
+          # @type [LaunchDarkly::Impl::FeatureStoreClientWrapper]
+          @store = store
+          # @type [UpdateSink]
+          @update_sink = update_sink
+        end
+
+        def status
+          @update_sink.last_status.get
+        end
+
+        def monitoring_enabled?
+          @store.monitoring_enabled?
+        end
+
+        def add_listener(listener)
+          @update_sink.broadcaster.add_listener(listener)
+        end
+
+        def remove_listener(listener)
+          @update_sink.broadcaster.remove_listener(listener)
+        end
+      end
+
+      class UpdateSink
+        include LaunchDarkly::Interfaces::DataStore::UpdateSink
+
+        # @return [LaunchDarkly::Impl::Broadcaster]
+        attr_reader :broadcaster
+
+        # @return [Concurrent::AtomicReference]
+        attr_reader :last_status
+
+        def initialize(broadcaster)
+          @broadcaster = broadcaster
+          @last_status = Concurrent::AtomicReference.new(
+            LaunchDarkly::Interfaces::DataStore::Status.new(true, false)
+          )
+        end
+
+        def update_status(status)
+          return if status.nil?
+
+          old_status = @last_status.get_and_set(status)
+          @broadcaster.broadcast(status) unless old_status == status
+        end
+      end
+    end
+  end
+end

lib/ldclient-rb/impl/dependency_tracker.rb

@@ -39,7 +39,7 @@ def update_dependencies_from(from_kind, from_key, from_item)
       def self.segment_keys_from_clauses(clauses)
         clauses.flat_map do |clause|
           if clause.op == :segmentMatch
-            clause.values.map { |value| {kind: LaunchDarkly::SEGMENTS, key: value }}
+            clause.values.map { |value| {kind: DataStore::SEGMENTS, key: value }}
           else
             []
           end
@@ -54,13 +54,13 @@ def self.segment_keys_from_clauses(clauses)
       def self.compute_dependencies_from(from_kind, from_item)
         return Set.new if from_item.nil?
 
-        if from_kind == LaunchDarkly::FEATURES
+        if from_kind == DataStore::FEATURES
           prereq_keys = from_item.prerequisites.map { |prereq| {kind: from_kind, key: prereq.key} }
           segment_keys = from_item.rules.flat_map { |rule| DependencyTracker.segment_keys_from_clauses(rule.clauses) }
 
           results = Set.new(prereq_keys)
           results.merge(segment_keys)
-        elsif from_kind == LaunchDarkly::SEGMENTS
+        elsif from_kind == DataStore::SEGMENTS
           kind_and_keys  = from_item.rules.flat_map do |rule|
             DependencyTracker.segment_keys_from_clauses(rule.clauses)
           end

lib/ldclient-rb/impl/integrations/file_data_source.rb

@@ -75,8 +75,8 @@ def stop
 
         def load_all
           all_data = {
-            FEATURES => {},
-            SEGMENTS => {},
+            Impl::DataStore::FEATURES => {},
+            Impl::DataStore::SEGMENTS => {},
           }
           @paths.each do |path|
             begin
@@ -105,14 +105,14 @@ def load_file(path, all_data)
           parsed = parse_content(IO.read(path))
           (parsed[:flags] || {}).each do |key, flag|
             flag[:version] = version
-            add_item(all_data, FEATURES, flag)
+            add_item(all_data, Impl::DataStore::FEATURES, flag)
           end
           (parsed[:flagValues] || {}).each do |key, value|
-            add_item(all_data, FEATURES, make_flag_with_value(key.to_s, value, version))
+            add_item(all_data, Impl::DataStore::FEATURES, make_flag_with_value(key.to_s, value, version))
           end
           (parsed[:segments] || {}).each do |key, segment|
             segment[:version] = version
-            add_item(all_data, SEGMENTS, segment)
+            add_item(all_data, Impl::DataStore::SEGMENTS, segment)
           end
         end
 

lib/ldclient-rb/impl/model/serialization.rb

@@ -34,7 +34,7 @@ module Model
       # SDK code outside of Impl::Model should use this method instead of calling the model class
       # constructors directly, so as not to rely on implementation details.
       #
-      # @param kind [Hash] normally either FEATURES or SEGMENTS
+      # @param kind [Hash] normally either Impl::DataStore::FEATURES or Impl::DataStore::SEGMENTS
       # @param input [object] a JSON string or a parsed hash (or a data model object, in which case
       #  we'll just return the original object)
       # @param logger [Logger|nil] logs errors if there are any data validation problems
@@ -44,9 +44,9 @@ def self.deserialize(kind, input, logger = nil)
         return input if !input.is_a?(String) && !input.is_a?(Hash)
         data = input.is_a?(Hash) ? input : JSON.parse(input, symbolize_names: true)
         case kind
-        when FEATURES
+        when Impl::DataStore::FEATURES
           FeatureFlag.new(data, logger)
-        when SEGMENTS
+        when Impl::DataStore::SEGMENTS
           Segment.new(data, logger)
         else
           data
@@ -63,8 +63,8 @@ def self.serialize(kind, item)
       # Translates a { flags: ..., segments: ... } object received from LaunchDarkly to the data store format.
       def self.make_all_store_data(received_data, logger = nil)
         {
-          FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
-          SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
+          Impl::DataStore::FEATURES => (received_data[:flags] || {}).transform_values { |data| FeatureFlag.new(data, logger) },
+          Impl::DataStore::SEGMENTS => (received_data[:segments] || {}).transform_values { |data| Segment.new(data, logger) },
         }
       end
     end