splitclient-rb 8.2.0 → 8.3.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb1d386fbacf462f6fb540e13b07037fef8bfeab4fcbbda8e1197f63cf64e101
-  data.tar.gz: 758c3e6e1cd5d8a6488d283d5eac29fce2942d0b14eb2757b3825a19bbae86f9
+  metadata.gz: 32f8f9ccb8bcbb2b703430a4db530ee1482e21bfbbb3102ed38d2bd4442894a1
+  data.tar.gz: 821b33d85d0555a8fd3db9e5c5d8faabd0c544bfc25b1e223f7fdbb24ce502b1
 SHA512:
-  metadata.gz: 9ad6c553a9af8afe5f2c91db3160d6043d7fd3e2f7c7c2e935c061dc0e49bfae59c5ddb47853c416d67ee692bd0c21c1e0d6c1b88dc51d713ead0a64f0c3c7c9
-  data.tar.gz: d4564ffdac1484039e244469b9c845a4def9d817a3a70ab05d1e9b5df78d274a864c2e2c98bb4cc952127b121656ad5522cfa6c6e583fca4422a26953593d157
+  metadata.gz: e7d8a70443e65336c2ac3ca09c115f0a7a9cf42f777da8ef4d77f814ea4958b21dc6dcfa1a673ae93952f4611c7a480c4eefdc111bf019de26622f39ae67241f
+  data.tar.gz: 15a35c6879e2e85def18e0e3bdf4a2df3d2e2b886497b514fc9f5db4051a881d4d90c79370f0edf9f21bc9a088b743bb86a1cbb2676a57f044a27c2e74d43e81

data/lib/splitclient-rb/cache/fetchers/split_fetcher.rb

@@ -17,7 +17,7 @@ module SplitIoClient
             fetch_splits
             return
           end
-          
+
           splits_thread
         end
 
@@ -25,13 +25,8 @@ module SplitIoClient
           @semaphore.synchronize do
             data = splits_since(@splits_repository.get_change_number, fetch_options)
 
-            data[:splits] && data[:splits].each do |split|
-              add_split_unless_archived(split)
-            end
-
+            SplitIoClient::Helpers::RepositoryHelper.update_feature_flag_repository(@splits_repository, data[:splits], data[:till], @config)
             @splits_repository.set_segment_names(data[:segment_names])
-            @splits_repository.set_change_number(data[:till])
-
             @config.logger.debug("segments seen(#{data[:segment_names].length}): #{data[:segment_names].to_a}") if @config.debug_enabled
 
             { segment_names: data[:segment_names], success: true }
@@ -64,28 +59,6 @@ module SplitIoClient
           splits_api.since(since, fetch_options)
         end
 
-        def add_split_unless_archived(split)
-          if Engine::Models::Split.archived?(split)
-            @config.logger.debug("Seeing archived feature flag #{split[:name]}") if @config.debug_enabled
-
-            remove_archived_split(split)
-          else
-            store_split(split)
-          end
-        end
-
-        def remove_archived_split(split)
-          @config.logger.debug("removing feature flag from store(#{split})") if @config.debug_enabled
-
-          @splits_repository.remove_split(split)
-        end
-
-        def store_split(split)
-          @config.logger.debug("storing feature flag (#{split[:name]})") if @config.debug_enabled
-
-          @splits_repository.add_split(split)
-        end
-
         def splits_api
           @splits_api ||= SplitIoClient::Api::Splits.new(@api_key, @config, @telemetry_runtime_producer)
         end

data/lib/splitclient-rb/cache/filter/flag_set_filter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module SplitIoClient
+  module Cache
+    module Filter
+      class FlagSetsFilter
+        def initialize(flag_sets = [])
+          @flag_sets = Set.new(flag_sets)
+          @should_filter = @flag_sets.any?
+        end
+
+        def should_filter?
+          @should_filter
+        end
+
+        def flag_set_exist?(flag_set)
+          return true unless @should_filter
+
+          if not flag_set.is_a?(String) or flag_set.empty?
+            return false
+          end
+
+          @flag_sets.intersection([flag_set]).any?
+        end
+
+        def intersect?(flag_sets)
+          return true unless @should_filter
+
+          if not flag_sets.is_a?(Array) or flag_sets.empty?
+            return false
+          end
+
+          @flag_sets.intersection(Set.new(flag_sets)).any?
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/flag_sets/memory_repository.rb

@@ -0,0 +1,40 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      class MemoryFlagSetsRepository
+        def initialize(flag_sets = [])
+          @sets_feature_flag_map = {}
+          flag_sets.each{ |flag_set| @sets_feature_flag_map[flag_set] = Set[] }
+        end
+
+        def flag_set_exist?(flag_set)
+          @sets_feature_flag_map.key?(flag_set)
+        end
+
+        def get_flag_sets(flag_sets)
+          to_return = Array.new
+          flag_sets.each { |flag_set| to_return.concat(@sets_feature_flag_map[flag_set].to_a)}
+          to_return.uniq
+        end
+
+        def add_flag_set(flag_set)
+          @sets_feature_flag_map[flag_set] = Set[] if !flag_set_exist?(flag_set)
+        end
+
+        def remove_flag_set(flag_set)
+          @sets_feature_flag_map.delete(flag_set) if flag_set_exist?(flag_set)
+        end
+
+        def add_feature_flag_to_flag_set(flag_set, feature_flag)
+          @sets_feature_flag_map[flag_set].add(feature_flag) if flag_set_exist?(flag_set)
+        end
+
+        def remove_feature_flag_from_flag_set(flag_set, feature_flag)
+          @sets_feature_flag_map[flag_set].delete(feature_flag) if flag_set_exist?(flag_set)
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/flag_sets/redis_repository.rb

@@ -0,0 +1,49 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Repositories
+      class RedisFlagSetsRepository < Repository
+
+        def initialize(config)
+          super(config)
+          @adapter = SplitIoClient::Cache::Adapters::RedisAdapter.new(@config.redis_url)
+        end
+
+        def flag_set_exist?(flag_set)
+          @adapter.exists?(namespace_key(".flagSet.#{flag_set}"))
+        end
+
+        def get_flag_sets(flag_sets)
+          result = @adapter.redis.pipelined do |pipeline|
+            flag_sets.each do |flag_set|
+               pipeline.smembers(namespace_key(".flagSet.#{flag_set}"))
+            end
+          end
+          to_return = Array.new
+          result.each do |flag_set|
+            flag_set.each { |feature_flag_name| to_return.push(feature_flag_name.to_s)}
+          end
+          to_return.uniq
+        end
+
+        def add_flag_set(flag_set)
+          # not implemented
+        end
+
+        def remove_flag_set(flag_set)
+          # not implemented
+        end
+
+        def add_feature_flag_to_flag_set(flag_set, feature_flag)
+          # not implemented
+        end
+
+        def remove_feature_flag_from_flag_set(flag_set, feature_flag)
+          # not implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/repositories/splits_repository.rb

@@ -6,7 +6,7 @@ module SplitIoClient
       class SplitsRepository < Repository
         attr_reader :adapter
 
-        def initialize(config)
+        def initialize(config, flag_sets_repository, flag_set_filter)
           super(config)
           @tt_cache = {}
           @adapter = case @config.cache_adapter.class.to_s
@@ -15,48 +15,18 @@ module SplitIoClient
           else
             @config.cache_adapter
           end
+          @flag_sets = flag_sets_repository
+          @flag_set_filter = flag_set_filter
           unless @config.mode.equal?(:consumer)
             @adapter.set_string(namespace_key('.splits.till'), '-1')
             @adapter.initialize_map(namespace_key('.segments.registered'))
           end
         end
 
-        def add_split(split)
-          return unless split[:name]
-          existing_split = get_split(split[:name])
-
-          if(!existing_split)
-            increase_tt_name_count(split[:trafficTypeName])
-          elsif(existing_split[:trafficTypeName] != split[:trafficTypeName])
-            increase_tt_name_count(split[:trafficTypeName])
-            decrease_tt_name_count(existing_split[:trafficTypeName])
-          end
-
-          @adapter.set_string(namespace_key(".split.#{split[:name]}"), split.to_json)
-        end
-
-        def remove_split(split)
-          tt_name = split[:trafficTypeName]
-
-          decrease_tt_name_count(split[:trafficTypeName])
-
-          @adapter.delete(namespace_key(".split.#{split[:name]}"))
-        end
-
-        def get_splits(names, symbolize_names = true)
-          splits = {}
-          split_names = names.map { |name| namespace_key(".split.#{name}") }
-          splits.merge!(
-            @adapter
-              .multiple_strings(split_names)
-              .map { |name, data| [name.gsub(namespace_key('.split.'), ''), data] }.to_h
-          )
-
-          splits.map do |name, data|
-            parsed_data = data ? JSON.parse(data, symbolize_names: true) : nil
-            split_name = symbolize_names ? name.to_sym : name
-            [split_name, parsed_data]
-          end.to_h
+        def update(to_add, to_delete, new_change_number)
+          to_add.each{ |feature_flag| add_feature_flag(feature_flag) }
+          to_delete.each{ |feature_flag| remove_feature_flag(feature_flag) }
+          set_change_number(new_change_number)
         end
 
         def get_split(name)
@@ -65,8 +35,13 @@ module SplitIoClient
           JSON.parse(split, symbolize_names: true) if split
         end
 
-        def splits
-          get_splits(split_names, false)
+        def splits(filtered_names=nil)
+          symbolize = true
+          if filtered_names.nil?
+            filtered_names = split_names
+            symbolize = false
+          end
+          get_splits(filtered_names, symbolize)
         end
 
         def traffic_type_exists(tt_name)
@@ -144,8 +119,94 @@ module SplitIoClient
           split_names.length
         end
 
+        def get_feature_flags_by_sets(flag_sets)
+          sets_to_fetch = Array.new
+          flag_sets.each do |flag_set|
+            unless @flag_sets.flag_set_exist?(flag_set)
+              @config.logger.warn("Flag set #{flag_set} is not part of the configured flag set list, ignoring it.")
+              next
+            end
+            sets_to_fetch.push(flag_set)
+          end
+          @flag_sets.get_flag_sets(flag_sets)
+        end
+
+        def is_flag_set_exist(flag_set)
+          @flag_sets.flag_set_exist?(flag_set)
+        end
+
+        def flag_set_filter
+          @flag_set_filter
+        end
+
         private
 
+        def add_feature_flag(split)
+          return unless split[:name]
+          existing_split = get_split(split[:name])
+
+          if(!existing_split)
+            increase_tt_name_count(split[:trafficTypeName])
+          elsif(existing_split[:trafficTypeName] != split[:trafficTypeName])
+            increase_tt_name_count(split[:trafficTypeName])
+            decrease_tt_name_count(existing_split[:trafficTypeName])
+            remove_from_flag_sets(existing_split)
+          elsif(existing_split[:sets] != split[:sets])
+            remove_from_flag_sets(existing_split)
+          end
+
+          if !split[:sets].nil?
+            for flag_set in split[:sets]
+              if !@flag_sets.flag_set_exist?(flag_set)
+                if @flag_set_filter.should_filter?
+                  next
+                end
+                @flag_sets.add_flag_set(flag_set)
+              end
+              @flag_sets.add_feature_flag_to_flag_set(flag_set, split[:name])
+            end
+          end
+
+          @adapter.set_string(namespace_key(".split.#{split[:name]}"), split.to_json)
+        end
+
+        def remove_feature_flag(split)
+          tt_name = split[:trafficTypeName]
+
+          decrease_tt_name_count(split[:trafficTypeName])
+          remove_from_flag_sets(split)
+          @adapter.delete(namespace_key(".split.#{split[:name]}"))
+        end
+
+        def get_splits(names, symbolize_names = true)
+          splits = {}
+          split_names = names.map { |name| namespace_key(".split.#{name}") }
+          splits.merge!(
+            @adapter
+              .multiple_strings(split_names)
+              .map { |name, data| [name.gsub(namespace_key('.split.'), ''), data] }.to_h
+          )
+
+          splits.map do |name, data|
+            parsed_data = data ? JSON.parse(data, symbolize_names: true) : nil
+            split_name = symbolize_names ? name.to_sym : name
+            [split_name, parsed_data]
+          end.to_h
+        end
+
+        def remove_from_flag_sets(feature_flag)
+          name = feature_flag[:name]
+          flag_sets = get_split(name)[:sets] if exists?(name)
+          if !flag_sets.nil?
+            for flag_set in flag_sets
+              @flag_sets.remove_feature_flag_from_flag_set(flag_set, feature_flag[:name])
+              if is_flag_set_exist(flag_set) && @flag_sets.get_flag_sets([flag_set]).length == 0 && !@flag_set_filter.should_filter?
+                  @flag_sets.remove_flag_set(flag_set)
+              end
+            end
+          end
+        end
+
         def increase_tt_name_count(tt_name)
           return unless tt_name
 

data/lib/splitclient-rb/cache/stores/localhost_split_store.rb

@@ -55,7 +55,7 @@ module SplitIoClient
         def store_split(split)
           @config.logger.debug("storing feature flag (#{split[:name]})") if @config.debug_enabled
 
-          @splits_repository.add_split(split)
+          @splits_repository.update([split], [], -1)
         end
 
         def load_features