configcat 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f09ffb7f9d1bba3ecd5da0f306df08dead784a95f2a87e4998d7842ebfdf20b8
+  data.tar.gz: fbe49ce6b2cd1e643829c6092aa8d3f8b17393d2f273e5f1d23fee5ebf889b64
+SHA512:
+  metadata.gz: ddeb7ec223e24bdd30d2f436fd9c23817b2e77424f1c15ea99e5d7b9c548fe26d2c568307230a42ad8d29541d3b9b09fb09a8440deae4f3014d58bd09298b674
+  data.tar.gz: e826984124b63d61b54ecc862caeabf870161fdb712424916d6cc2e7d793dd2770305ab714af97e9a2644048d8b8e520bfb03e2fe4f379b2ec2e3f1999dbeaf5

data/lib/configcat/autopollingcachepolicy.rb

@@ -0,0 +1,83 @@
+require 'configcat/interfaces'
+require 'concurrent'
+
+module ConfigCat
+  class AutoPollingCachePolicy < CachePolicy
+    def initialize(config_fetcher, config_cache, poll_interval_seconds=60, max_init_wait_time_seconds=5, on_configuration_changed_callback=nil)
+      if poll_interval_seconds < 1
+        poll_interval_seconds = 1
+      end
+      if max_init_wait_time_seconds < 0
+        max_init_wait_time_seconds = 0
+      end
+      @_config_fetcher = config_fetcher
+      @_config_cache = config_cache
+      @_poll_interval_seconds = poll_interval_seconds
+      @_max_init_wait_time_seconds = max_init_wait_time_seconds
+      @_on_configuration_changed_callback = on_configuration_changed_callback
+      @_initialized = false
+      @_is_running = false
+      @_start_time = Time.now.utc
+      @_lock = Concurrent::ReadWriteLock.new()
+      @_is_started = Concurrent::Event.new()
+      @thread = Thread.new{_run()}
+      @_is_started.wait()
+    end
+
+    def _run()
+      @_is_running = true
+      @_is_started.set()
+      loop do
+        force_refresh()
+        sleep(@_poll_interval_seconds)
+        break if !@_is_running
+      end
+    end
+
+    def get()
+      while !@_initialized && (Time.now.utc < @_start_time + @_max_init_wait_time_seconds)
+        sleep(0.5)
+      end
+      begin
+        @_lock.acquire_read_lock()
+        return @_config_cache.get()
+      ensure
+        @_lock.release_read_lock()
+      end
+    end
+
+    def force_refresh()
+      begin
+        @_lock.acquire_read_lock()
+        old_configuration = @_config_cache.get()
+      ensure
+        @_lock.release_read_lock()
+      end
+      begin
+        configuration = @_config_fetcher.get_configuration_json()
+        begin
+          @_lock.acquire_write_lock()
+          @_config_cache.set(configuration)
+          @_initialized = true
+        ensure
+          @_lock.release_write_lock()
+        end
+        begin
+          if !@_on_configuration_changed_callback.equal?(nil) && configuration != old_configuration
+            @_on_configuration_changed_callback.call()
+          end
+        rescue Exception => e
+          ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
+          ConfigCat.logger.error "stacktrace: #{e.backtrace}"
+        end
+      rescue StandardError => e
+        ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
+        ConfigCat.logger.error "stacktrace: #{e.backtrace}"
+      end
+    end
+
+    def stop()
+      @_is_running = false
+    end
+  end
+end

data/lib/configcat/configcache.rb

@@ -0,0 +1,17 @@
+require 'configcat/interfaces'
+
+module ConfigCat
+  class InMemoryConfigCache < ConfigCache
+    def initialize()
+      @_value = nil
+    end
+
+    def get()
+      return @_value
+    end
+
+    def set(value)
+      @_value = value
+    end
+  end
+end

data/lib/configcat/configcatclient.rb

@@ -0,0 +1,69 @@
+require 'configcat/interfaces'
+require 'configcat/configcache'
+require 'configcat/configfetcher'
+require 'configcat/autopollingcachepolicy'
+require 'configcat/manualpollingcachepolicy'
+require 'configcat/lazyloadingcachepolicy'
+require 'configcat/rolloutevaluator'
+
+module ConfigCat
+  class ConfigCatClient
+    def initialize(api_key,
+                   poll_interval_seconds=60,
+                   max_init_wait_time_seconds=5,
+                   on_configuration_changed_callback=nil,
+                   cache_time_to_live_seconds=60,
+                   config_cache_class=nil,
+                   base_url=nil)
+      if api_key === nil
+        raise ConfigCatClientException, "API Key is required."
+      end
+      @_api_key = api_key
+
+      if config_cache_class
+        @_config_cache = config_cache_class.new()
+      else
+        @_config_cache = InMemoryConfigCache.new()
+      end
+
+      if poll_interval_seconds > 0
+        @_config_fetcher = CacheControlConfigFetcher.new(api_key, "p", base_url)
+        @_cache_policy = AutoPollingCachePolicy.new(@_config_fetcher, @_config_cache, poll_interval_seconds, max_init_wait_time_seconds, on_configuration_changed_callback)
+      else
+        if cache_time_to_live_seconds > 0
+          @_config_fetcher = CacheControlConfigFetcher.new(api_key, "l", base_url)
+          @_cache_policy = LazyLoadingCachePolicy.new(@_config_fetcher, @_config_cache, cache_time_to_live_seconds)
+        else
+          @_config_fetcher = CacheControlConfigFetcher.new(api_key, "m", base_url)
+          @_cache_policy = ManualPollingCachePolicy.new(@_config_fetcher, @_config_cache)
+        end
+      end
+    end
+
+    def get_value(key, default_value, user=nil)
+      config = @_cache_policy.get()
+      if config === nil
+        return default_value
+      end
+      return RolloutEvaluator.evaluate(key, user, default_value, config)
+    end
+
+    def get_all_keys()
+      config = @_cache_policy.get()
+      if config === nil
+        return []
+      end
+      return config.keys
+    end
+
+    def force_refresh()
+      @_cache_policy.force_refresh()
+    end
+
+    def stop()
+      @_cache_policy.stop()
+      @_config_fetcher.close()
+    end
+
+  end
+end

data/lib/configcat/configfetcher.rb

@@ -0,0 +1,45 @@
+require 'configcat/interfaces'
+require 'configcat/version'
+require 'net/http'
+require 'uri'
+require 'json'
+
+module ConfigCat
+  BASE_URL = "https://cdn.configcat.com"
+  BASE_PATH = "configuration-files/"
+  BASE_EXTENSION = "/config_v2.json"
+
+  class CacheControlConfigFetcher < ConfigFetcher
+    def initialize(api_key, mode, base_url=nil)
+      @_api_key = api_key
+      @_headers = {"User-Agent" => ((("ConfigCat-Ruby/") + mode) + ("-")) + VERSION, "X-ConfigCat-UserAgent" => ((("ConfigCat-Ruby/") + mode) + ("-")) + VERSION, "Content-Type" => "application/json"}
+      if !base_url.equal?(nil)
+        @_base_url = base_url.chomp("/")
+      else
+        @_base_url = BASE_URL
+      end
+      uri = URI.parse(@_base_url)
+      @_http = Net::HTTP.new(uri.host, uri.port)
+      @_http.use_ssl = true if uri.scheme == 'https'
+      @_http.open_timeout = 10 # in seconds
+      @_http.read_timeout = 30 # in seconds
+    end
+
+    def get_configuration_json()
+      ConfigCat.logger.debug "Fetching configuration from ConfigCat"
+      uri = URI.parse((((@_base_url + ("/")) + BASE_PATH) + @_api_key) + BASE_EXTENSION)
+      request = Net::HTTP::Get.new(uri.request_uri, @_headers)
+      response = @_http.request(request)
+      json = JSON.parse(response.body)
+      # TODO: check cached entry
+      ConfigCat.logger.debug "ConfigCat configuration json fetch response code:#{response.code} Cached:#{response['ETag']}"
+      return json
+    end
+
+    def close()
+      if @_http
+        @_http = nil
+      end
+    end
+  end
+end

data/lib/configcat/interfaces.rb

@@ -0,0 +1,71 @@
+module ConfigCat
+
+  class ConfigFetcher
+    #
+    #       Config fetcher interface
+    #
+
+    def get_configuration_json()
+      #
+      #     :return: Returns the configuration json Dictionary
+      #
+    end
+
+    def close()
+      #
+      #         Closes the ConfigFetcher's resources
+      #
+    end
+  end
+
+  class ConfigCache
+    #
+    #       Config cache interface
+    #
+
+    def get()
+      #
+      #     :returns the config json object from the cache
+      #
+    end
+
+    def set(value)
+      #
+      #     Sets the config json cache.
+      #
+    end
+  end
+
+  class CachePolicy
+    #
+    #       Config cache interface
+    #
+
+    def get()
+      #
+      #     :returns the config json object from the cache
+      #
+    end
+
+    def force_refresh()
+      #
+      #
+      #     :return:
+      #
+    end
+
+    def stop()
+      #
+      #
+      #     :return:
+      #
+    end
+  end
+
+  class ConfigCatClientException < Exception
+    #
+    #   Generic ConfigCatClientException
+    #
+  end
+
+end

data/lib/configcat/lazyloadingcachepolicy.rb

@@ -0,0 +1,62 @@
+require 'configcat/interfaces'
+require 'concurrent'
+
+module ConfigCat
+  class LazyLoadingCachePolicy < CachePolicy
+
+    def initialize(config_fetcher, config_cache, cache_time_to_live_seconds=60)
+      if cache_time_to_live_seconds < 1
+        cache_time_to_live_seconds = 1
+      end
+      @_config_fetcher = config_fetcher
+      @_config_cache = config_cache
+      @_cache_time_to_live = cache_time_to_live_seconds
+      @_lock = Concurrent::ReadWriteLock.new()
+      @_last_updated = nil
+    end
+
+    def get()
+      begin
+        @_lock.acquire_read_lock()
+        utc_now = Time.now.utc
+        if !@_last_updated.equal?(nil) && (@_last_updated + @_cache_time_to_live > utc_now)
+          config = @_config_cache.get()
+          if !config.equal?(nil)
+            return config
+          end
+        end
+      ensure
+        @_lock.release_read_lock()
+      end
+      force_refresh()
+      begin
+        @_lock.acquire_read_lock()
+        config = @_config_cache.get()
+        return config
+      ensure
+        @_lock.release_read_lock()
+      end
+    end
+
+    def force_refresh()
+      begin
+        configuration = @_config_fetcher.get_configuration_json()
+        begin
+          @_lock.acquire_write_lock()
+          @_config_cache.set(configuration)
+          @_last_updated = Time.now.utc
+        ensure
+          @_lock.release_write_lock()
+        end
+      rescue StandardError => e
+        ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
+        ConfigCat.logger.error "stacktrace: #{e.backtrace}"
+      end
+    end
+
+    def stop()
+    end
+  end
+
+end
+

data/lib/configcat/manualpollingcachepolicy.rb

@@ -0,0 +1,41 @@
+require 'configcat/interfaces'
+require 'concurrent'
+
+module ConfigCat
+  class ManualPollingCachePolicy < CachePolicy
+    def initialize(config_fetcher, config_cache)
+      @_config_fetcher = config_fetcher
+      @_config_cache = config_cache
+      @_lock = Concurrent::ReadWriteLock.new()
+    end
+
+    def get()
+      begin
+        @_lock.acquire_read_lock()
+        config = @_config_cache.get()
+        return config
+      ensure
+        @_lock.release_read_lock()
+      end
+    end
+
+    def force_refresh()
+      begin
+        configuration = @_config_fetcher.get_configuration_json()
+        begin
+          @_lock.acquire_write_lock()
+          @_config_cache.set(configuration)
+        ensure
+          @_lock.release_write_lock()
+        end
+      rescue StandardError => e
+        ConfigCat.logger.error "threw exception #{e.class}:'#{e}'"
+        ConfigCat.logger.error "stacktrace: #{e.backtrace}"
+      end
+    end
+
+    def stop()
+      # pass
+    end
+  end
+end

data/lib/configcat/rolloutevaluator.rb

@@ -0,0 +1,72 @@
+require 'configcat/user'
+require 'digest'
+
+module ConfigCat
+  class RolloutEvaluator
+
+    def self.evaluate(key, user, default_value, config)
+      if !user.equal?(nil) && !user.class.equal?(User)
+        ConfigCat.logger.warn "User parameter is not an instance of User type."
+        user = nil
+      end
+      setting_descriptor = config.fetch(key, nil)
+      if setting_descriptor === nil
+        ConfigCat.logger.warn "Could not find setting by key, returning default value. Key: #{key}"
+        return default_value
+      end
+      if user === nil
+        return setting_descriptor.fetch("Value", default_value)
+      end
+      rollout_rules = setting_descriptor.fetch("RolloutRules", [])
+      for rollout_rule in rollout_rules
+        comparison_attribute = rollout_rule.fetch("ComparisonAttribute")
+        user_value = user.get_attribute(comparison_attribute)
+        if user_value === nil || !user_value
+          next
+        end
+        comparison_value = rollout_rule.fetch("ComparisonValue", nil)
+        comparator = rollout_rule.fetch("Comparator", nil)
+        value = rollout_rule.fetch("Value", nil)
+        if comparator == 0
+          if comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
+            return value
+          end
+        else
+          if comparator == 1
+            if !comparison_value.to_s.split(",").map { |x| x.strip() }.include?(user_value.to_s)
+              return value
+            end
+          else
+            if comparator == 2
+              if user_value.to_s.include?(comparison_value.to_s)
+                return value
+              end
+            else
+              if comparator == 3
+                if !user_value.to_s.include?(comparison_value.to_s)
+                  return value
+                end
+              end
+            end
+          end
+        end
+      end
+      rollout_percentage_items = setting_descriptor.fetch("RolloutPercentageItems", [])
+      if rollout_percentage_items.size > 0
+        user_key = user.get_identifier()
+        hash_candidate = ("%s%s" % [key, user_key]).encode("utf-8")
+        hash_val = Digest::SHA1.hexdigest(hash_candidate)[0...7].to_i(base=16) % 100
+        bucket = 0
+        for rollout_percentage_item in rollout_percentage_items || []
+          bucket += rollout_percentage_item.fetch("Percentage", 0)
+          if hash_val < bucket
+            return rollout_percentage_item.fetch("Value", nil)
+          end
+        end
+      end
+      return setting_descriptor.fetch("Value", default_value)
+    end
+  end
+
+end
+

data/lib/configcat/user.rb

@@ -0,0 +1,37 @@
+module ConfigCat
+
+  class User
+    #
+    #    The user object for variation evaluation
+    #
+
+    PREDEFINED = ["identifier", "email", "country"]
+
+    def initialize(identifier, email: nil, country: nil, custom: nil)
+      @__identifier = identifier
+      @__data = {"identifier" => identifier, "email" => email, "country" => country}
+      @__custom = custom
+    end
+
+    def get_identifier()
+      return @__identifier
+    end
+
+    def get_attribute(attribute)
+      attribute = attribute.to_s.downcase()
+      if PREDEFINED.include?(attribute)
+        return @__data[attribute]
+      end
+
+      if !@__custom.equal?(nil)
+        @__custom.each do |customField, customValue|
+          if customField.to_s.downcase() == attribute
+            return customValue
+          end
+        end
+      end
+      return nil
+    end
+  end
+
+end

data/lib/configcat/version.rb

@@ -0,0 +1,3 @@
+module ConfigCat
+  VERSION = "0.0.1"
+end

data/lib/configcat.rb

@@ -0,0 +1,80 @@
+require 'configcat/interfaces'
+require 'configcat/configcatclient'
+require 'configcat/user'
+require 'logger'
+
+module ConfigCat
+
+  @logger = Logger.new(STDOUT, level: Logger::INFO)
+  class << self
+    attr_accessor :logger
+  end
+
+  def ConfigCat.create_client(api_key)
+    #
+    #   Create an instance of ConfigCatClient and setup Auto Poll mode with default options
+    #
+    #   :param api_key: ConfigCat ApiKey to access your configuration.
+    #
+    return create_client_with_auto_poll(api_key)
+  end
+
+  def ConfigCat.create_client_with_auto_poll(api_key, poll_interval_seconds: 60, max_init_wait_time_seconds: 5, on_configuration_changed_callback: nil, config_cache_class: nil, base_url: nil)
+    #
+    #   Create an instance of ConfigCatClient and setup Auto Poll mode with custom options
+    #
+    #   :param api_key: ConfigCat ApiKey to access your configuration.
+    #   :param poll_interval_seconds: The client's poll interval in seconds. Default: 60 seconds.
+    #   :param on_configuration_changed_callback: You can subscribe to configuration changes with this callback
+    #   :param max_init_wait_time_seconds: maximum waiting time for first configuration fetch in polling mode.
+    #   :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,
+    #   You can provide an implementation of ConfigCache.
+    #   :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
+    #
+    if api_key === nil
+      raise ConfigCatClientException, "API Key is required."
+    end
+    if poll_interval_seconds < 1
+      poll_interval_seconds = 1
+    end
+    if max_init_wait_time_seconds < 0
+      max_init_wait_time_seconds = 0
+    end
+    return ConfigCatClient.new(api_key, poll_interval_seconds, max_init_wait_time_seconds, on_configuration_changed_callback, 0, config_cache_class, base_url)
+  end
+
+  def ConfigCat.create_client_with_lazy_load(api_key, cache_time_to_live_seconds: 60, config_cache_class: nil, base_url: nil)
+    #
+    #   Create an instance of ConfigCatClient and setup Lazy Load mode with custom options
+    #
+    #   :param api_key: ConfigCat ApiKey to access your configuration.
+    #   :param cache_time_to_live_seconds: The cache TTL.
+    #   :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,
+    #   You can provide an implementation of ConfigCache.
+    #   :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
+    #
+    if api_key === nil
+      raise ConfigCatClientException, "API Key is required."
+    end
+    if cache_time_to_live_seconds < 1
+      cache_time_to_live_seconds = 1
+    end
+    return ConfigCatClient.new(api_key, 0, 0, nil, cache_time_to_live_seconds, config_cache_class, base_url)
+  end
+
+  def ConfigCat.create_client_with_manual_poll(api_key, config_cache_class: nil, base_url: nil)
+    #
+    #   Create an instance of ConfigCatClient and setup Manual Poll mode with custom options
+    #
+    #   :param api_key: ConfigCat ApiKey to access your configuration.
+    #   :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,
+    #   You can provide an implementation of ConfigCache.
+    #   :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat
+    #
+    if api_key === nil
+      raise ConfigCatClientException, "API Key is required."
+    end
+    return ConfigCatClient.new(api_key, 0, 0, nil, 0, config_cache_class, base_url)
+  end
+
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: configcat
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ConfigCat
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ConfigCat is a configuration as a service that lets you manage your features
+  and configurations without actually deploying new code.
+email:
+- developer@configcat.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/configcat.rb
+- lib/configcat/autopollingcachepolicy.rb
+- lib/configcat/configcache.rb
+- lib/configcat/configcatclient.rb
+- lib/configcat/configfetcher.rb
+- lib/configcat/interfaces.rb
+- lib/configcat/lazyloadingcachepolicy.rb
+- lib/configcat/manualpollingcachepolicy.rb
+- lib/configcat/rolloutevaluator.rb
+- lib/configcat/user.rb
+- lib/configcat/version.rb
+homepage: https://configcat.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: ConfigCat SDK for Ruby.
+test_files: []