featurehub-sdk 1.0.0

data/lib/feature_hub/sdk/impl/rollout_holders.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# these are bulk copied in from OpenAPI and left in original case
+module FeatureHub
+  module Sdk
+    module Impl
+      # represents a condition for this attribute
+      class RolloutStrategyAttributeCondition
+        def initialize(attr)
+          @attr = attr
+        end
+
+        def equals?
+          @attr == "EQUALS"
+        end
+
+        def ends_with?
+          @attr == "ENDS_WITH"
+        end
+
+        def starts_with?
+          @attr == "STARTS_WITH"
+        end
+
+        def greater?
+          @attr == "GREATER"
+        end
+
+        def greater_equals?
+          @attr == "GREATER_EQUALS"
+        end
+
+        def less?
+          @attr == "LESS"
+        end
+
+        def less_equals?
+          @attr == "LESS_EQUALS"
+        end
+
+        def not_equals?
+          @attr == "NOT_EQUALS"
+        end
+
+        def includes?
+          @attr == "INCLUDES"
+        end
+
+        def excludes?
+          @attr == "EXCLUDES"
+        end
+
+        def regex?
+          @attr == "REGEX"
+        end
+
+        def to_s
+          @attr
+        end
+      end
+
+      # represents an individual attribute comparison
+      class RolloutStrategyAttribute
+        attr_reader :id, :conditional, :field_name, :values, :field_type
+
+        def initialize(attr)
+          @attr = attr
+          @id = @attr["id"]
+          @conditional = RolloutStrategyAttributeCondition.new(@attr["conditional"])
+          @field_name = @attr["fieldName"]
+          @values = @attr["values"]
+          @field_type = @attr["type"]
+        end
+
+        def float_values
+          @values.filter { |x| !x.nil? }.map(&:to_f)
+        end
+
+        def str_values
+          @values.filter { |x| !x.nil? }.map(&:to_s)
+        end
+
+        def to_s
+          "id: #{@id}, conditional: #{@conditional}, field_name: #{@field_name}, " \
+            "values: #{@values}, field_type: #{field_type}"
+        end
+      end
+
+      # represents a raw rollout strategy inside a feature
+      class RolloutStrategy
+        attr_reader :attributes, :id, :name, :percentage, :percentage_attributes, :value
+
+        def initialize(strategy)
+          @strategy = strategy
+          @attributes = (strategy["attributes"] || []).map { |attr| RolloutStrategyAttribute.new(attr) }
+          @id = strategy["id"]
+          @name = strategy["name"]
+          @percentage = (strategy["percentage"] || "0").to_i
+          @percentage_attributes = (strategy["percentageAttributes"] || [])
+          @value = strategy["value"]
+        end
+
+        def percentage_attributes?
+          !@percentage_attributes.empty?
+        end
+
+        def attributes?
+          !@attributes.empty?
+        end
+
+        def to_s
+          "id: #{@id}, name: #{@name}, percentage: #{@percentage}, percentage_attrs: #{@percentage_attributes}, " \
+            "value: #{@value}, attributes: [#{@attributes.map(&:to_s).join(",")}]"
+        end
+      end
+    end
+  end
+end

data/lib/feature_hub/sdk/impl/strategy_wrappers.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require "sem_version"
+
+module FeatureHub
+  module Sdk
+    module Impl
+      # generic strategy matcher (and fallthrough)
+      class StrategyMatcher
+        def match(_supplied_value, _attr)
+          false
+        end
+      end
+
+      # comparison for true/false
+      class BooleanMatcher < StrategyMatcher
+        def match(supplied_value, attr)
+          val = supplied_value.downcase == "true"
+
+          if attr.conditional.equals?
+            val == (attr.values[0].to_s.downcase == "true")
+          elsif attr.conditional.not_equals?
+            val != (attr.values[0].to_s.downcase == "true")
+          else
+            false
+          end
+        end
+      end
+
+      # matches for strings, dates and date-times
+      class StringMatcher < StrategyMatcher
+        def match(supplied_value, attr)
+          vals = attr.str_values
+
+          cond = attr.conditional
+          if cond.equals?
+            vals.any? { |v| supplied_value == v }
+          elsif cond.not_equals?
+            vals.none? { |v| supplied_value == v }
+          elsif cond.ends_with?
+            vals.any? { |v| supplied_value.end_with?(v) }
+          elsif cond.starts_with?
+            vals.any? { |v| supplied_value.start_with?(v) }
+          elsif cond.greater?
+            vals.any? { |v| supplied_value > v }
+          elsif cond.greater_equals?
+            vals.any? { |v| supplied_value >= v }
+          elsif cond.less?
+            vals.any? { |v| supplied_value < v }
+          elsif cond.less_equals?
+            vals.any? { |v| supplied_value <= v }
+          elsif cond.includes?
+            vals.any? { |v| supplied_value.include?(v) }
+          elsif cond.excludes?
+            vals.none? { |v| supplied_value.include?(v) }
+          elsif cond.regex?
+            vals.any? { |v| !Regexp.new(v).match(supplied_value).nil? }
+          else
+            false
+          end
+        end
+      end
+
+      # matches floating point numbers excep for end/start/regexp
+      class NumberMatcher < StrategyMatcher
+        def match(supplied_value, attr)
+          cond = attr.conditional
+
+          if cond.ends_with?
+            attr.str_values.any? { |v| supplied_value.end_with?(v) }
+          elsif cond.starts_with?
+            attr.str_values.any? { |v| supplied_value.start_with?(v) }
+          elsif cond.excludes?
+            attr.str_values.none? { |v| supplied_value.include?(v) }
+          elsif cond.includes?
+            attr.str_values.any? { |v| supplied_value.include?(v) }
+          elsif cond.regex?
+            attr.str_values.any? { |v| !Regexp.new(v).match(supplied_value).nil? }
+          else
+            parsed_val = supplied_value.to_f
+            vals = attr.float_values
+
+            if cond.equals?
+              vals.any? { |v| parsed_val == v }
+            elsif cond.not_equals?
+              vals.none? { |v| parsed_val == v }
+            elsif cond.greater?
+              vals.any? { |v| parsed_val > v }
+            elsif cond.greater_equals?
+              vals.any? { |v| parsed_val >= v }
+            elsif cond.less?
+              vals.any? { |v| parsed_val < v }
+            elsif cond.less_equals?
+              vals.any? { |v| parsed_val <= v }
+            elsif cond.includes?
+              vals.any? { |v| parsed_val.include?(v) }
+            elsif cond.excludes?
+              vals.none? { |v| parsed_val.include?(v) }
+            else
+              false
+            end
+          end
+        end
+      end
+
+      # NumberMatcher
+
+      # matches using semantic versions
+      class SemanticVersionMatcher < StrategyMatcher
+        def match(supplied_value, attr)
+          cond = attr.conditional
+
+          val = SemVersion.new(supplied_value)
+          vals = attr.str_values
+
+          if cond.includes? || cond.equals?
+            vals.any? { |v| val.satisfies?(v) }
+          elsif cond.excludes? || cond.not_equals?
+            vals.none? { |v| val.satisfies?(v) }
+          else
+            comparison_vals = vals.filter { |x| SemVersion.valid?(x) }
+            if cond.greater?
+              comparison_vals.any? { |v| supplied_value > v }
+            elsif cond.greater_equals?
+              comparison_vals.any? { |v| supplied_value >= v }
+            elsif cond.less?
+              comparison_vals.any? { |v| supplied_value < v }
+            elsif cond.less_equals?
+              comparison_vals.any? { |v| supplied_value <= v }
+            else
+              false
+            end
+          end
+        end
+      end
+
+      # matches based on ip addresses and CIDRs
+      class IpNetworkMatcher < StrategyMatcher
+        def match(supplied_value, attr)
+          cond = attr.conditional
+
+          val = IPAddr.new(supplied_value)
+          vals = attr.str_values
+
+          if cond.includes? || cond.equals?
+            vals.any? { |v| IPAddr.new(v).include?(val) }
+          elsif cond.excludes? || cond.not_equals?
+            vals.none? { |v| IPAddr.new(v).include?(val) }
+          else
+            false
+          end
+        end
+      end
+
+      # interface for the matcher repository finder
+      class MatcherRepository
+        def find_matcher(attr); end
+      end
+
+      # figures out what attribute type this is and passes back the right matcher
+      class MatcherRegistry < MatcherRepository
+        def find_matcher(attr)
+          case attr.field_type
+          when "BOOLEAN"
+            BooleanMatcher.new
+          when "STRING", "DATE", "DATE_TIME"
+            StringMatcher.new
+          when "SEMANTIC_VERSION"
+            SemanticVersionMatcher.new
+          when "NUMBER"
+            NumberMatcher.new
+          when "IP_ADDRESS"
+            IpNetworkMatcher.new
+          else
+            StrategyMatcher.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/feature_hub/sdk/interceptors.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module FeatureHub
+  module Sdk
+    # represents an intercepted value
+    class InterceptorValue
+      def initialize(val)
+        @val = val
+      end
+
+      def cast(expected_type)
+        return @val if expected_type.nil? || @val.nil?
+
+        case expected_type
+        when "BOOLEAN"
+          @val.to_s.downcase.strip == "true"
+        when "NUMBER"
+          @val.to_s.to_f
+        else
+          @val.to_s
+        end
+      end
+    end
+
+    # Holds the pattern for a value based interceptor, which could come from a file, or whatever
+    # they are not typed
+    class ValueInterceptor
+      def intercepted_value(feature_key); end
+    end
+
+    # An example of a value interceptor that uses environment variables
+    class EnvironmentInterceptor < ValueInterceptor
+      def initialize
+        super()
+        @enabled = ENV.fetch("FEATUREHUB_OVERRIDE_FEATURES", "false") == "true"
+      end
+
+      def intercepted_value(feature_key)
+        if @enabled
+          found = ENV.fetch("FEATUREHUB_#{sanitize_feature_name(feature_key.to_s)}", nil)
+          return InterceptorValue.new(found) unless found.nil?
+        end
+
+        nil
+      end
+
+      private
+
+      def sanitize_feature_name(key)
+        key.tr(" ", "_")
+      end
+    end
+  end
+end

data/lib/feature_hub/sdk/internal_feature_repository.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module FeatureHub
+  module Sdk
+    # surface features of a repository that must be implemented for any repository wrapper
+    class InternalFeatureRepository
+      def feature(_key)
+        nil
+      end
+
+      def find_interceptor(_feature_value)
+        nil
+      end
+
+      def ready?
+        false
+      end
+
+      def not_ready!; end
+
+      def apply(_strategies, _key, _feature_id, _context)
+        Applied.new(false, nil)
+      end
+
+      def notify(status, data); end
+    end
+  end
+end

data/lib/feature_hub/sdk/percentage_calc.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FeatureHub
+  module Sdk
+    # generic percentage calculator
+    class PercentageCalculator
+      def determine_client_percentage(_percentage_text, _feature_id)
+        0
+      end
+    end
+  end
+end

data/lib/feature_hub/sdk/poll_edge_service.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/net_http"
+require "json"
+require "concurrent-ruby"
+
+module FeatureHub
+  module Sdk
+    # uses a periodic polling mechanism to get updates
+    class PollingEdgeService < EdgeService
+      attr_reader :repository, :api_keys, :edge_url, :interval
+
+      def initialize(repository, api_keys, edge_url, interval, logger = nil)
+        super(repository, api_keys, edge_url)
+
+        @repository = repository
+        @api_keys = api_keys
+        @edge_url = edge_url
+        @interval = interval
+
+        @logger = logger || FeatureHub::Sdk.default_logger
+
+        @task = nil
+        @cancel = false
+        @context = nil
+        @etag = nil
+
+        generate_url
+      end
+
+      # abstract
+      def poll
+        @cancel = false
+        poll_with_interval
+      end
+
+      def update_interval(interval)
+        @interval = interval
+        if @task.nil?
+          poll
+        else
+          @task.execution_interval = interval
+        end
+      end
+
+      def context_change(new_header)
+        return if new_header == @context
+
+        @context = new_header
+
+        get_updates
+      end
+
+      def close
+        cancel_task
+      end
+
+      private
+
+      def poll_with_interval
+        return if @cancel || !@task.nil?
+
+        get_updates
+
+        @logger.info("starting polling for #{determine_request_url}")
+        @task = Concurrent::TimerTask.new(execution_interval: @interval) do
+          get_updates
+        end
+        @task.execute
+      end
+
+      def cancel_task
+        return if @task.nil?
+
+        @task.shutdown
+        @task = nil
+        @cancel = true
+      end
+
+      # rubocop:disable Naming/AccessorMethodName
+      def get_updates
+        url = determine_request_url
+        headers = {
+          accept: "application/json",
+          "X-SDK": "Ruby",
+          "X-SDK-Version": FeatureHub::Sdk::VERSION
+        }
+        headers["if-none-match"] = @etag unless @etag.nil?
+        @logger.debug("polling for #{url}")
+        resp = @conn.get(url, request: { timeout: @timeout }, headers: headers)
+        case resp.status
+        when 200
+          @etag = resp.headers["etag"]
+          process_results(JSON.parse(resp.body))
+        when 404 # no such key
+          @repository.notify("failed", nil)
+          @cancel = true
+          @logger.error("featurehub: key does not exist, stopping polling")
+        when 503 # dacha busy
+          @logger.debug("featurehub: dacha is busy, trying tgaina")
+        else
+          @logger.debug("featurehub: unknown error #{resp.status}")
+        end
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      def process_results(data)
+        data.each do |environment|
+          @repository.notify("features", environment["features"]) if environment
+        end
+      end
+
+      def determine_request_url
+        if @context.nil?
+          @url
+        else
+          "#{@url}&#{@context}"
+        end
+      end
+
+      def generate_url
+        api_key_cat = (@api_keys.map { |key| "apiKey=#{key}" } * "&")
+        @url = "features?#{api_key_cat}"
+        @timeout = ENV.fetch("FEATUREHUB_POLL_HTTP_TIMEOUT", "12").to_i
+        @conn = Faraday.new(url: @edge_url) do |f|
+          f.adapter :net_http
+        end
+      end
+    end
+  end
+end