ff-ruby-server-sdk 0.0.2 → 1.0.0

data/example/example.rb

@@ -1,4 +1,100 @@
-require_relative '../lib/ff/ruby/server/sdk'
+require "logger"
+require "securerandom"
+
+require_relative '../lib/ff/ruby/server/sdk/dto/target'
+require_relative '../lib/ff/ruby/server/sdk/api/config'
+require_relative '../lib/ff/ruby/server/sdk/api/cf_client'
+require_relative '../lib/ff/ruby/server/sdk/api/config_builder'
+
+flag_b = "flag1"
+flag_n = "flag2"
+flag_s = "flag3"
+flag_j = "flag4"
+
+clients = {}
+targets = {}
+
+logger = Logger.new(STDOUT)
+
+executor = Concurrent::FixedThreadPool.new(100)
+
+keys = {
+
+  "Freemium" => "1f3339b4-e004-457a-91f7-9b5ce173eaaf",
+  "Non-Freemium" => "a30cf6aa-67f2-4545-8ac7-f86709f4f3a0"
+}
+
+keys.each do |name, key|
+
+  targets[name] = Target.new("ruby_target_" + name)
+
+  config = ConfigBuilder.new
+                        .logger(logger)
+                        .build
+
+  client = CfClient.new(key, config)
+
+  # .config_url("https://config.feature-flags.uat.harness.io/api/1.0")
+  # .event_url("https://event.feature-flags.uat.harness.io/api/1.0")
+
+  client.init
+
+  config.logger.debug "We will wait for the initialization"
+
+  client.wait_for_initialization
+
+  config.logger.debug "Initialization is complete"
+
+  clients[name] = client
+end
+
+iterations = 10
+
+counted = 0
+count_to = keys.size * iterations
+
+logger.debug "To count: " + count_to.to_s
+
+keys.each do |name, key|
+
+  client = clients[name]
+  target = targets[name]
+
+  executor.post do
+
+    (1..iterations).each do |iteration|
+
+      logger.debug name + " :: iteration no: " + iteration.to_s
+
+      bool_result = client.bool_variation(flag_b, target, false)
+      number_result = client.number_variation(flag_n, target, -1)
+      string_result = client.string_variation(flag_s, target, "unavailable !!!")
+      json_result = client.json_variation(flag_j, target, JSON.parse("{}"))
+
+      logger.debug name + " :: '" + flag_b.to_s + "' has the value of: " + bool_result.to_s
+      logger.debug name + " :: '" + flag_n.to_s + "' has the value of: " + number_result.to_s
+      logger.debug name + " :: '" + flag_s.to_s + "' has the value of: " + string_result.to_s
+      logger.debug name + " :: '" + flag_j.to_s + "' has the value of: " + json_result.to_s
+      logger.debug "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -"
+
+      counted = counted + 1
+
+      logger.debug "Counted: " + counted.to_s
+
+      sleep 10
+    end
+  end
+end
+
+while counted != count_to
+
+  sleep(1)
+end
+
+clients.each do |name, client|
+
+  logger.debug name + " :: closing"
+
+  client.close
+end
 
-client = CfClient.new
-client.hello

data/lib/ff/ruby/server/sdk/api/auth_service.rb

@@ -0,0 +1,91 @@
+require_relative "../common/closeable"
+
+class AuthService < Closeable
+
+  def initialize(connector = nil, poll_interval_in_sec = 60, callback = nil, logger = nil)
+
+    unless connector.kind_of?(Connector)
+
+      raise "The 'connector' parameter must be of '" + Connector.to_s + "' data type"
+    end
+
+    unless callback.kind_of?(ClientCallback)
+
+      raise "The 'callback' parameter must be of '" + ClientCallback.to_s + "' data type"
+    end
+
+    @callback = callback
+    @connector = connector
+    @poll_interval_in_sec = poll_interval_in_sec
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def start_async
+
+    @logger.debug "Async starting: " + self.to_s
+
+    @ready = true
+
+    @thread = Thread.new do
+
+      @logger.debug "Async started: " + self.to_s
+
+      while @ready do
+
+        @logger.debug "Async auth iteration"
+
+        if @connector.authenticate
+
+          @callback.on_auth_success
+          stop_async
+          @logger.info "Stopping Auth service"
+        else
+
+          @logger.error "Exception while authenticating, retry in " + @poll_interval_in_sec.to_s + " seconds"
+        end
+
+        sleep(@poll_interval_in_sec)
+      end
+    end
+
+    @thread.run
+  end
+
+  def close
+
+    stop_async
+  end
+
+  def on_auth_success
+
+    unless @callback == nil
+
+      unless @callback.kind_of?(ClientCallback)
+
+        raise "Expected '" + ClientCallback.to_s + "' data type for the callback"
+      end
+
+      @callback.on_auth_success
+    end
+  end
+
+  protected
+
+  def stop_async
+
+    @ready = false
+
+    if @thread != nil
+
+      @thread.exit
+      @thread = nil
+    end
+  end
+end

data/lib/ff/ruby/server/sdk/api/cf_client.rb

@@ -0,0 +1,93 @@
+require "openapi_client"
+
+require_relative "inner_client"
+require_relative "../common/closeable"
+
+class CfClient < Closeable
+
+  # Static:
+  class << self
+
+    @@instance = CfClient.new
+
+    def instance
+
+      @@instance
+    end
+  end
+
+  # Static - End
+
+  def initialize(api_key = nil, config = nil, connector = nil)
+
+    if config == nil
+
+      @config = ConfigBuilder.new.build
+    else
+
+      @config = config
+    end
+
+    @client = InnerClient.new(api_key, config, connector)
+
+    @config.logger.debug "Client (1): " + @client.to_s
+  end
+
+  def init(api_key = nil, config = nil, connector = nil)
+
+    if @client == nil
+
+      @config = config
+
+      @client = InnerClient.new(
+
+        api_key = api_key,
+        config = config,
+        connector = connector
+      )
+
+      @config.logger.debug "Client (2): " + @client.to_s
+    end
+  end
+
+  def wait_for_initialization
+
+    if @client != nil
+
+      @client.wait_for_initialization
+    end
+  end
+
+  def bool_variation(identifier, target, default_value)
+
+    @client.bool_variation(identifier, target, default_value)
+  end
+
+  def string_variation(identifier, target, default_value)
+
+    @client.string_variation(identifier, target, default_value)
+  end
+
+  def number_variation(identifier, target, default_value)
+
+    @client.number_variation(identifier, target, default_value)
+  end
+
+  def json_variation(identifier, target, default_value)
+
+    @client.json_variation(identifier, target, default_value)
+  end
+
+  def destroy
+
+    close
+  end
+
+  def close
+
+    if @client != nil
+
+      @client.close
+    end
+  end
+end

data/lib/ff/ruby/server/sdk/api/client_callback.rb

@@ -0,0 +1,45 @@
+require_relative "../common/closeable"
+
+class ClientCallback < Closeable
+
+  def initialize
+    super
+
+    @tbi = "To be implemented"
+  end
+
+  def on_auth_success
+
+    raise @tbi
+  end
+
+  def on_authorized
+
+    raise @tbi
+  end
+
+  def is_closing
+
+    raise @tbi
+  end
+
+  def on_processor_ready(processor)
+
+    raise @tbi
+  end
+
+  def on_update_processor_ready
+
+    raise @tbi
+  end
+
+  def on_metrics_processor_ready
+
+    raise @tbi
+  end
+
+  def update(message, manual)
+
+    raise @tbi
+  end
+end

data/lib/ff/ruby/server/sdk/api/config.rb

@@ -0,0 +1,140 @@
+require "logger"
+
+require_relative "default_cache"
+
+class Config
+
+  attr_accessor :config_url, :event_url, :stream_enabled, :poll_interval_in_seconds, :analytics_enabled,
+                :frequency, :buffer_size, :all_attributes_private, :private_attributes, :connection_timeout,
+                :read_timeout, :write_timeout, :debugging, :metrics_service_acceptable_duration, :cache, :store,
+                :logger
+
+  # Static:
+  class << self
+
+    @@min_frequency = 60
+
+    def min_frequency
+
+      @@min_frequency
+    end
+  end
+  # Static - End
+
+  def initialize
+    super
+
+    @config_url = "https://config.ff.harness.io/api/1.0"
+    @event_url = "https://events.ff.harness.io/api/1.0"
+
+    @stream_enabled = true
+
+    @poll_interval_in_seconds = @@min_frequency
+
+    @analytics_enabled = true
+
+    @frequency = @@min_frequency
+
+    @buffer_size = 1024
+
+    @all_attributes_private = false
+
+    @private_attributes = Set[]
+
+    @connection_timeout = 10 * 1000
+
+    @read_timeout = 30 * 1000
+
+    @write_timeout = 10 * 1000
+
+    @debugging = false
+
+    @logger = Logger.new(STDOUT)
+
+    @metrics_service_acceptable_duration = 10 * 1000
+
+    @cache = DefaultCache.new(@logger)
+
+    # TODO: Storage goes here
+
+    @store = nil
+  end
+
+  def get_frequency
+
+    [@frequency, @@min_frequency].max
+  end
+
+  def verify_ssl_host
+
+    true
+  end
+
+  def params_encoding
+
+    nil
+  end
+
+  def timeout
+
+    @connection_timeout
+  end
+
+  def verify_ssl
+
+    nil
+  end
+
+  def cert_file
+
+    nil
+  end
+
+  def key_file
+
+    nil
+  end
+
+  def ssl_ca_cert
+
+    nil
+  end
+
+  def client_side_validation
+
+    nil
+  end
+
+  def auth_settings
+
+    {}
+  end
+
+  def base_url(args)
+
+    @config_url
+  end
+
+  def describe
+
+    to_s + "\n" +
+      "\tmin_frequency = " + @@min_frequency.to_s + "\n" +
+      "\tconfig_url = " + @config_url + "\n" +
+      "\tevent_url = " + @event_url + "\n" +
+      "\tstream_enabled = " + @stream_enabled.to_s + "\n" +
+      "\tpoll_interval_in_seconds = " + @poll_interval_in_seconds.to_s + "\n" +
+      "\tanalytics_enabled = " + @analytics_enabled.to_s + "\n" +
+      "\tfrequency = " + @frequency.to_s + "\n" +
+      "\tget_frequency = " + get_frequency.to_s + "\n" +
+      "\tbuffer_size = " + @buffer_size.to_s + "\n" +
+      "\tall_attributes_private = " + @all_attributes_private.to_s + "\n" +
+      "\tprivate_attributes = " + @private_attributes.to_s + "\n" +
+      "\tconnection_timeout = " + @connection_timeout.to_s + "\n" +
+      "\tread_timeout = " + @read_timeout.to_s + "\n" +
+      "\twrite_timeout = " + @write_timeout.to_s + "\n" +
+      "\tdebug = " + @debugging.to_s + "\n" +
+      "\tmetrics_service_acceptable_duration = " + @metrics_service_acceptable_duration.to_s + "\n" +
+      "\tcache = " + @cache.to_s + "\n" +
+      "\tstore = " + @store.to_s
+  end
+end

data/lib/ff/ruby/server/sdk/api/config_builder.rb

@@ -0,0 +1,116 @@
+class ConfigBuilder
+
+  def build
+
+    @config
+  end
+
+  def initialize
+
+    @config = Config.new
+    @config.cache = DefaultCache.new(@config.logger)
+  end
+
+  def config_url(config_url)
+
+    @config.config_url = config_url
+    self
+  end
+
+  def event_url(event_url)
+
+    @config.event_url = event_url
+    self
+  end
+
+  def stream_enabled(stream_enabled)
+
+    @config.stream_enabled = stream_enabled
+    self
+  end
+
+  def poll_interval_in_seconds(poll_interval_in_seconds)
+
+    @config.poll_interval_in_seconds = poll_interval_in_seconds
+    self
+  end
+
+  def analytics_enabled(analytics_enabled)
+
+    @config.analytics_enabled = analytics_enabled
+    self
+  end
+
+  def frequency(frequency)
+
+    @config.frequency = frequency
+    self
+  end
+
+  def buffer_size(buffer_size)
+
+    @config.buffer_size = buffer_size
+    self
+  end
+
+  def all_attributes_private(all_attributes_private)
+
+    @config.all_attributes_private = all_attributes_private
+    self
+  end
+
+  def private_attributes(private_attributes)
+
+    @config.private_attributes = private_attributes
+    self
+  end
+
+  def connection_timeout(connection_timeout)
+
+    @config.connection_timeout = connection_timeout
+    self
+  end
+
+  def read_timeout(read_timeout)
+
+    @config.read_timeout = read_timeout
+    self
+  end
+
+  def write_timeout(write_timeout)
+
+    @config.write_timeout = write_timeout
+    self
+  end
+
+  def logger(logger)
+
+    @config.logger = logger
+    @config.cache.logger = logger
+    self
+  end
+
+  def debugging(debug)
+
+    @config.debugging = debug
+    self
+  end
+
+  def metrics_service_acceptable_duration(metrics_service_acceptable_duration)
+
+    @config.metrics_service_acceptable_duration = metrics_service_acceptable_duration
+    self
+  end
+
+  def cache(cache)
+
+    @config.cache = cache
+    self
+  end
+
+  def store(store)
+
+    @config.store = store
+    self
+  end
+end

data/lib/ff/ruby/server/sdk/api/default_cache.rb

@@ -0,0 +1,112 @@
+require "set"
+require "fileutils"
+require "libcache"
+
+class DefaultCache < Cache
+
+  attr_accessor :logger
+
+  def initialize(logger = nil)
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+
+    @keys = Set[]
+    @capacity = 10 * 1000
+
+    lambda = lambda { |*key| @logger.debug "Retrieved #{key}" }
+
+    cache_dir = "./cache"
+    unless directory_exists?(cache_dir)
+
+      FileUtils.mkdir_p cache_dir
+      unless directory_exists?(cache_dir)
+
+        raise "Failed to initialize filesystem cache at: " + cache_dir
+      end
+    end
+
+    @filesystem = CacheBuilder.with(FileCache)
+                              .set_store(cache_dir)
+                              .set_max(@capacity)
+                              .set_post_get(lambda)
+                              .build
+
+    @in_memory = CacheBuilder.with(Cache)
+                             .set_max(@capacity)
+                             .set_post_get(lambda)
+                             .build
+  end
+
+  def verify
+
+    @in_memory != nil && @filesystem != nil && @capacity > 0
+  end
+
+  def set(key, value)
+
+    begin
+      @in_memory.put(key, value)
+      @filesystem.put(key, value)
+      keys.add(key)
+
+    rescue ArgumentError => e
+
+      @logger.error "ERROR: " + e.to_s
+
+      raise "Invalid arguments passed to the 'set' method: key='" + key.to_s + "', value='" + value.to_s + "'"
+    end
+  end
+
+  def get(key)
+
+    value = @in_memory.get(key)
+
+    if value == nil
+
+      value = @filesystem.get(key)
+      if value != nil
+
+        @in_memory.put(key, value)
+      end
+    end
+    value
+  end
+
+  def delete(key)
+
+    if key == nil
+
+      raise "Key is nil"
+    end
+
+    if @in_memory.exists?(key)
+
+      @in_memory.invalidate(key)
+    end
+
+    if @filesystem.exists?(key)
+
+      @filesystem.invalidate(key)
+    end
+
+    @keys.delete(key)
+  end
+
+  def keys
+
+    @keys
+  end
+
+  private
+
+  def directory_exists?(directory)
+
+    File.directory?(directory)
+  end
+end