ff-ruby-server-sdk 0.0.2 → 1.0.2.rc1

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

@@ -0,0 +1,93 @@
+require "openapi_client"
+
+require_relative "../common/closeable"
+require_relative "inner_client"
+
+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

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

@@ -0,0 +1,29 @@
+
+class Evaluation
+
+  def initialize
+    super
+
+    @tbi = "To be implemented"
+  end
+
+  def bool_variation(identifier, target, default_value, callback)
+
+    raise @tbi
+  end
+
+  def string_variation(identifier, target, default_value, callback)
+
+    raise @tbi
+  end
+
+  def number_variation(identifier, target, default_value, callback)
+
+    raise @tbi
+  end
+
+  def json_variation(identifier, target, default_value, callback)
+
+    raise @tbi
+  end
+end