ff-ruby-server-sdk 0.0.2 → 1.0.0

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

@@ -0,0 +1,311 @@
+require_relative "evaluator"
+require_relative "evaluation"
+require_relative "auth_service"
+require_relative "client_callback"
+require_relative "update_processor"
+require_relative "polling_processor"
+require_relative "metrics_processor"
+require_relative "storage_repository"
+require_relative "inner_client_updater"
+require_relative "inner_client_metrics_callback"
+require_relative "inner_client_repository_callback"
+require_relative "inner_client_flag_evaluate_callback"
+
+require_relative "../connector/harness_connector"
+
+class InnerClient < ClientCallback
+
+  def initialize(api_key = nil, config = nil, connector = nil)
+
+    if api_key == nil || api_key == ""
+
+      raise "SDK key is not provided"
+    end
+
+    if config == nil
+
+      @config = ConfigBuilder.new.build
+    else
+
+      unless config.kind_of?(Config)
+
+        raise "The 'config' parameter must be of '" + Config.to_s + "' data type"
+      end
+
+      @config = config
+    end
+
+    @config.logger.debug "Ruby SDK version: " + Ff::Ruby::Server::Sdk::VERSION
+
+    if connector == nil
+
+      @connector = HarnessConnector.new(api_key, config = @config, on_unauthorized = self)
+
+    else
+
+      unless connector.kind_of?(Connector)
+
+        raise "The 'connector' parameter must be of '" + Connector.to_s + "' data type"
+      end
+
+      @connector = connector
+    end
+
+    @closing = false
+    @failure = false
+    @initialized = false
+    @poller_ready = false
+    @stream_ready = false
+    @metrics_ready = false
+
+    @my_mutex = Mutex.new
+
+    @repository_callback = InnerClientRepositoryCallback.new(@config.logger)
+
+    setup
+  end
+
+  def bool_variation(identifier, target, default_value)
+
+    @evaluator.bool_variation(identifier, target, default_value, @evaluator_callback)
+  end
+
+  def string_variation(identifier, target, default_value)
+
+    @evaluator.string_variation(identifier, target, default_value, @evaluator_callback)
+  end
+
+  def number_variation(identifier, target, default_value)
+
+    @evaluator.number_variation(identifier, target, default_value, @evaluator_callback)
+  end
+
+  def json_variation(identifier, target, default_value)
+
+    @evaluator.json_variation(identifier, target, default_value, @evaluator_callback)
+  end
+
+  def on_auth_success
+
+    @config.logger.info "SDK successfully logged in"
+
+    if @closing
+
+      return
+    end
+
+    @poll_processor.start
+
+    if @config.stream_enabled
+
+      @update_processor.start
+    end
+
+    if @config.analytics_enabled
+
+      @metrics_processor.start
+    end
+
+  end
+
+  def close
+
+    @config.logger.info "Closing the client: " + self.to_s
+
+    @closing = true
+
+    off
+
+    @auth_service.close
+    @repository.close
+    @poll_processor.close
+    @update_processor.close
+    @metrics_processor.close
+    @connector.close
+  end
+
+  def is_closing
+
+    @closing
+  end
+
+  def off
+
+    # TODO: Implement - Reactivity support
+  end
+
+  def on_unauthorized
+
+    if @closing
+
+      return
+    end
+
+    @poll_processor.stop
+
+    if @config.stream_enabled
+
+      @update_processor.stop
+    end
+
+    if @config.analytics_enabled
+
+      @metrics_processor.stop
+    end
+
+    @auth_service.start_async
+  end
+
+  def on_poller_ready(poller)
+
+    on_processor_ready(poller)
+  end
+
+  def on_poller_error(e)
+
+    @config.logger.error "Poller error: " + e.to_s
+  end
+
+  def on_poller_iteration(poller)
+
+    @config.logger.debug "Poller iterated" + poller.to_s
+  end
+
+  def update(message, manual)
+
+    if @config.stream_enabled && manual
+
+      @config.logger.warn "You run the update method manually with the stream enabled. Please turn off the stream in this case."
+    end
+
+    @update_processor.update(message)
+  end
+
+  def on_update_processor_ready
+
+    on_processor_ready(@update_processor)
+  end
+
+  def on_metrics_processor_ready
+
+    on_processor_ready(@metrics_processor)
+  end
+
+  def on_processor_ready(processor)
+
+    if @closing
+
+      return
+    end
+
+    if processor == @poll_processor
+
+      @poller_ready = true
+      @config.logger.info "PollingProcessor ready"
+    end
+
+    if processor == @update_processor
+
+      @stream_ready = true
+      @config.logger.info "Updater ready"
+    end
+
+    if processor == @metrics_processor
+
+      @metrics_ready = true
+      @config.logger.info "Metrics ready"
+    end
+
+    if (@config.stream_enabled && !@stream_ready) ||
+      (@config.analytics_enabled && !@metrics_ready) ||
+      !@poller_ready
+
+      return
+    end
+
+    @initialized = true
+
+    # TODO: notify - Reactivity support
+    # TODO: notify_consumers - Reactivity support
+
+    @config.logger.info "Initialization is completed"
+  end
+
+  def wait_for_initialization
+
+    synchronize do
+
+      @config.logger.info "Waiting for the initialization to finish"
+
+      until @initialized
+
+        sleep(1)
+      end
+
+      if @failure
+
+        raise "Initialization failed"
+      end
+
+      @config.logger.info "Waiting for the initialization completed"
+    end
+  end
+
+  protected
+
+  def setup
+
+    @config.logger.info "SDK is not initialized yet! If store is used then values will be loaded from store" +
+           " otherwise default values will be used in meantime. You can use waitForInitialization method for SDK" +
+           " to be ready."
+
+    @repository = StorageRepository.new(@config.cache, @repository_callback, @config.store, @config.logger)
+
+    @metrics_callback = InnerClientMetricsCallback.new(self, @config.logger)
+    @metrics_processor = MetricsProcessor.new(@connector, @config, @metrics_callback)
+
+    @evaluator = Evaluator.new(@repository, logger = @config.logger)
+    @evaluator_callback = InnerClientFlagEvaluateCallback.new(@metrics_processor, logger = @config.logger)
+
+    @auth_service = AuthService.new(
+
+      connector = @connector,
+      poll_interval_in_sec = @config.poll_interval_in_seconds,
+      callback = self,
+      logger = @config.logger
+    )
+
+    @poll_processor = PollingProcessor.new(
+
+      connector = @connector,
+      repository = @repository,
+      poll_interval_in_sec = @config.poll_interval_in_seconds,
+      callback = self,
+      logger = @config.logger
+    )
+
+    @updater = InnerClientUpdater.new(
+
+      poll_processor = @poll_processor,
+      client_callback = self,
+      logger = @config.logger
+    )
+
+    @update_processor = UpdateProcessor.new(
+
+      connector = @connector,
+      repository = @repository,
+      callback = @updater,
+      logger = @config.logger
+    )
+
+    @auth_service.start_async
+  end
+
+  private
+
+  def synchronize(&block)
+
+    @my_mutex.synchronize(&block)
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative "metrics_processor"
+require_relative "flag_evaluate_callback"
+
+class InnerClientFlagEvaluateCallback < FlagEvaluateCallback
+
+  def initialize(metrics_processor, logger = nil)
+
+    unless metrics_processor.kind_of?(MetricsProcessor)
+
+      raise "The 'metrics_processor' parameter must be of '" + MetricsProcessor.to_s + "' data type"
+    end
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+
+    @metrics_processor = metrics_processor
+  end
+
+  def process_evaluation(feature_config, target, variation)
+
+    @logger.debug "Processing evaluation: " + feature_config.feature.to_s + ", " + target.identifier.to_s
+
+    @metrics_processor.push_to_queue(target, feature_config, variation)
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative "client_callback"
+require_relative "metrics_callback"
+
+class InnerClientMetricsCallback < MetricsCallback
+
+  def initialize(client_callback, logger = nil)
+
+    unless client_callback.kind_of?(ClientCallback)
+
+      raise "The 'client_callback' parameter must be of '" + ClientCallback.to_s + "' data type"
+    end
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+
+    @client_callback = client_callback
+  end
+
+  def on_metrics_ready
+
+    @client_callback.on_metrics_processor_ready
+  end
+
+  def on_metrics_error(error)
+
+    @logger.error "Metrics error: " + error.to_s
+  end
+end

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

@@ -0,0 +1,44 @@
+require_relative "inner_client"
+require_relative "repository_callback"
+
+class InnerClientRepositoryCallback < RepositoryCallback
+
+  def initialize(logger = nil)
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def on_flag_stored(identifier)
+
+    @logger.debug "On flag stored: " + identifier
+
+    # TODO: Notify consumers
+  end
+
+  def on_flag_deleted(identifier)
+
+    @logger.debug "On flag deleted: " + identifier
+
+    # TODO: Notify consumers
+  end
+
+  def on_segment_stored(identifier)
+
+    @logger.debug "On segment stored: " + identifier
+
+    # TODO: Notify consumers
+  end
+
+  def on_segment_deleted(identifier)
+
+    @logger.debug "On segment deleted: " + identifier
+
+    # TODO: Notify consumers
+  end
+end

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

@@ -0,0 +1,63 @@
+require "logger"
+
+require_relative "../connector/updater"
+
+class InnerClientUpdater < Updater
+
+  def initialize(
+
+    poll_processor,
+    client_callback,
+    logger = nil
+  )
+
+    unless poll_processor.kind_of?(PollingProcessor)
+
+      raise "The 'poll_processor' parameter must be of '" + PollingProcessor.to_s + "' data type"
+    end
+
+    unless client_callback.kind_of?(ClientCallback)
+
+      raise "The 'client_callback' parameter must be of '" + ClientCallback.to_s + "' data type"
+    end
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+
+    @poll_processor = poll_processor
+    @client_callback = client_callback
+  end
+
+  def on_connected
+
+    @poll_processor.stop
+  end
+
+  def on_disconnected
+
+    unless @client_callback.is_closing
+
+      @poll_processor.start
+    end
+  end
+
+  def on_ready
+
+    @client_callback.on_update_processor_ready()
+  end
+
+  def on_error
+
+    @logger.error "Error occurred"
+  end
+
+  def update(message)
+
+    @client_callback.update(message, false)
+  end
+end

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

@@ -0,0 +1,19 @@
+
+class MetricsCallback
+
+  def initialize
+    super
+
+    @tbi = "To be implemented"
+  end
+
+  def on_metrics_ready
+
+    raise @tbi
+  end
+
+  def on_metrics_error(error)
+
+    raise @tbi
+  end
+end

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

@@ -0,0 +1,16 @@
+class MetricsEvent
+
+  attr_accessor :feature_config, :target, :variation
+
+  def initialize(
+
+    feature_config,
+    target,
+    variation
+  )
+
+    @target = target
+    @variation = variation
+    @feature_config = feature_config
+  end
+end