ff-ruby-server-sdk 0.0.2 → 1.0.0

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

@@ -0,0 +1,263 @@
+require_relative "operators"
+require_relative "repository_callback"
+require_relative "../common/repository"
+
+class StorageRepository < Repository
+
+  def initialize(cache, callback = nil, store = nil, logger = nil)
+
+    @cache = cache
+    @store = store
+    @callback = callback
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def get_flag(identifier, cacheable = true)
+
+    flag_key = format_flag_key(identifier)
+    flag = @cache.get(flag_key)
+
+    if flag != nil
+
+      return flag
+    end
+
+    if @store != nil
+
+      flag = @store.get(flag_key)
+      if flag != nil && cacheable
+
+        @cache.set(flag_key, flag)
+      end
+
+      return flag
+    end
+
+    nil
+  end
+
+  def get_segment(identifier, cacheable = true)
+
+    segment_key = format_segment_key(identifier)
+    segment = @cache.get(segment_key)
+
+    if segment != nil
+
+      return segment
+    end
+
+    if @store != nil
+
+      segment = @store.get(segment_key)
+      if segment != nil && cacheable
+
+        @cache.set(segment_key, segment)
+      end
+
+      return segment
+    end
+
+    nil
+  end
+
+  def find_flags_by_segment(identifier)
+
+    result = []
+    keys = @cache.keys
+
+    if @store != nil
+
+      keys = @store.keys
+    end
+
+    keys.each do |key|
+
+      flag = get_flag(key)
+
+      if flag != nil && !flag.rules.length > 0
+
+        flag.rules.each do |rule|
+
+          rule.clauses.each do |clause|
+
+            if clause.op == Operators.SEGMENT_MATCH && clause.values.include(identifier)
+
+              result.push(flag.feature)
+            end
+          end
+        end
+      end
+    end
+
+    result
+  end
+
+  def set_flag(identifier, feature_config)
+
+    if is_flag_outdated(identifier, feature_config)
+
+      @logger.debug "Flag " + identifier + " already exists"
+      return
+    end
+
+    flag_key = format_flag_key(identifier)
+
+    if @store != nil
+
+      @store.set(flag_key, feature_config)
+      @cache.delete(flag_key)
+
+      @logger.debug "Flag " + identifier + " successfully stored and cache invalidated"
+    else
+
+      @cache.set(flag_key, feature_config)
+
+      @logger.debug "Flag " + identifier + " successfully cached"
+    end
+
+    if @callback != nil
+
+      unless @callback.kind_of?(RepositoryCallback)
+
+        raise "The 'callback' parameter must be of '" + RepositoryCallback.to_s + "' data type"
+      end
+
+      @callback.on_flag_stored(identifier)
+    end
+  end
+
+  def set_segment(identifier, segment)
+
+    if is_segment_outdated(identifier, segment)
+
+      @logger.debug "Segment " + identifier + " already exists"
+      return
+    end
+
+    segment_key = format_segment_key(identifier)
+
+    if @store != nil
+
+      @store.set(segment_key, segment)
+      @cache.delete(segment_key)
+
+      @logger.debug "Segment " + identifier + " successfully stored and cache invalidated"
+    else
+
+      @cache.set(segment_key, segment)
+
+      @logger.debug "Segment " + identifier + " successfully cached"
+    end
+
+    if @callback != nil
+
+      unless @callback.kind_of?(RepositoryCallback)
+
+        raise "The 'callback' parameter must be of '" + RepositoryCallback.to_s + "' data type"
+      end
+
+      @callback.on_segment_stored(identifier)
+    end
+  end
+
+  def delete_flag(identifier)
+
+    flag_key = format_flag_key(identifier)
+
+    if @store != nil
+
+      @store.delete(flag_key)
+
+      @logger.debug "Flag " + identifier + " successfully deleted from store"
+    end
+
+    @cache.delete(flag_key)
+
+    @logger.debug "Flag " + identifier + " successfully deleted from cache"
+
+    if @callback != nil
+
+      unless @callback.kind_of?(RepositoryCallback)
+
+        raise "The 'callback' parameter must be of '" + RepositoryCallback.to_s + "' data type"
+      end
+
+      @callback.on_flag_deleted(identifier)
+    end
+  end
+
+  def delete_segment(identifier)
+
+    segment_key = format_segment_key(identifier)
+
+    if @store != nil
+
+      @store.delete(segment_key)
+
+      @logger.debug "Segment " + identifier + " successfully deleted from store"
+    end
+
+    @cache.delete(segment_key)
+
+    @logger.debug "Segment " + identifier + " successfully deleted from cache"
+
+    if @callback != nil
+
+      unless @callback.kind_of?(RepositoryCallback)
+
+        raise "The 'callback' parameter must be of '" + RepositoryCallback.to_s + "' data type"
+      end
+
+      @callback.on_segment_deleted(identifier)
+    end
+  end
+
+  def close
+
+    if @store != nil
+
+      @store.close
+    end
+  end
+
+  protected
+
+  def is_flag_outdated(identifier, new_feature_config)
+
+    flag = get_flag(identifier, false)
+    if flag != nil && flag.version != new_feature_config.version
+
+      return flag.version >= new_feature_config.version
+    end
+
+    false
+  end
+
+  def is_segment_outdated(identifier, new_segment)
+
+    segment = get_segment(identifier, false)
+    if segment != nil && segment.version != new_segment.version
+
+      return segment.version >= new_segment.version
+    end
+
+    false
+  end
+
+  def format_flag_key(identifier)
+
+    "flags_" + identifier
+  end
+
+  def format_segment_key(identifier)
+
+    "segments_" + identifier
+  end
+end

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

@@ -0,0 +1,16 @@
+class SummaryMetrics
+
+  attr_accessor :feature_name, :variation_identifier, :variation_value
+
+  def initialize(
+
+    feature_name,
+    variation_identifier,
+    variation_value
+  )
+
+    @feature_name = feature_name
+    @variation_value = variation_value
+    @variation_identifier = variation_identifier
+  end
+end

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

@@ -0,0 +1,149 @@
+require "concurrent-ruby"
+
+require_relative "../common/closeable"
+
+class UpdateProcessor < Closeable
+
+  def initialize(
+
+    connector,
+    repository,
+    callback,
+    logger
+  )
+
+    @connector = connector
+    @repository = repository
+    @updater = callback
+    @executor = Concurrent::FixedThreadPool.new(100)
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  def start
+
+    @logger.info "Starting updater (EventSource)"
+
+    if @updater != nil
+
+      unless @updater.kind_of?(Updater)
+
+        raise "The 'callback' parameter must be of '" + Updater.to_s + "' data type"
+      end
+    end
+
+    if @connector != nil
+
+      unless @connector.kind_of?(Connector)
+
+        raise "The 'connector' must be of '" + Connector.to_s + "' data type"
+      end
+
+      @executor.post do
+
+        @stream = @connector.stream(@updater)
+        @stream.start
+      end
+    end
+  end
+
+  def stop
+
+    @logger.info "Stopping updater (EventSource)"
+
+    if @stream != nil
+
+      @stream.stop
+    end
+
+    @executor.shutdown
+    @executor.wait_for_termination(3)
+
+    if @executor.shuttingdown?
+
+      @executor.kill
+    end
+
+    @logger.info "Updater stopped (EventSource)"
+  end
+
+  def close
+
+    @logger.info "Closing UpdateProcessor"
+
+    stop
+  end
+
+  def update(message)
+
+    if message["domain"] == "flag"
+
+      @executor.post do
+
+        process_flag(message)
+      end
+
+      return
+    end
+
+    if message["domain"] == "target-segment"
+
+      @executor.post do
+
+        process_segment(message)
+      end
+    end
+  end
+
+  protected
+
+  def process_flag(message)
+
+    @logger.info "Processing flag message: " + message.to_s
+
+    config = @connector.get_flag(message["identifier"])
+
+    if config != nil
+
+      if message["event"] == "create" || message["event"] == "patch"
+
+        @repository.set_flag(message["identifier"], config)
+
+      else
+
+        if message["event"] == "delete"
+
+          @repository.delete_flag(message["identifier"])
+        end
+      end
+    end
+  end
+
+  def process_segment(message)
+
+    @logger.info "Processing segment message: " + message.to_s
+
+    segment = @connector.get_segment(message["identifier"])
+
+    if segment != nil
+
+      if message["event"] == "create" || message["event"] == "patch"
+
+        @repository.set_segment(message.identifier, segment)
+
+      else
+
+        if message["event"] == "delete"
+
+          @repository.delete_segment(message["identifier"])
+        end
+      end
+    end
+  end
+end

data/lib/ff/ruby/server/sdk/common/cache.rb

@@ -0,0 +1,27 @@
+class Cache
+
+  def initialize
+
+    @tbi = "To be implemented"
+  end
+
+  def set(key, value)
+
+    raise @tbi
+  end
+
+  def get(key)
+
+    raise @tbi
+  end
+
+  def delete(key)
+    
+    raise @tbi
+  end
+
+  def keys
+
+    raise @tbi
+  end
+end

data/lib/ff/ruby/server/sdk/common/closeable.rb

@@ -0,0 +1,7 @@
+class Closeable
+
+  def close
+
+    raise "Not implemented"
+  end
+end

data/lib/ff/ruby/server/sdk/common/destroyable.rb

@@ -0,0 +1,12 @@
+class Destroyable
+
+  def initialize
+
+    @tbi = "to be implemented"
+  end
+
+  def destroy
+
+    raise @tbi
+  end
+end

data/lib/ff/ruby/server/sdk/common/repository.rb

@@ -0,0 +1,45 @@
+require_relative "closeable"
+
+class Repository < Closeable
+
+  def initialize
+    super
+
+    @tbi = "To be implemented"
+  end
+
+  def get_flag(identifier, cacheable = true)
+
+    raise @tbi
+  end
+
+  def get_segment(identifier, cacheable = true)
+
+    raise @tbi
+  end
+
+  def find_flags_by_segment(identifier)
+
+    raise @tbi
+  end
+
+  def set_flag(identifier, feature_config)
+
+    raise @tbi
+  end
+
+  def set_segment(identifier, segment)
+
+    raise @tbi
+  end
+
+  def delete_flag(identifier)
+
+    raise @tbi
+  end
+
+  def delete_segment(identifier)
+
+    raise @tbi
+  end
+end

data/lib/ff/ruby/server/sdk/common/storage.rb

@@ -0,0 +1,29 @@
+require_relative "closeable"
+
+class Storage < Closeable
+
+  def initialize
+
+    @tbi = "To be implemented"
+  end
+
+  def set(key, value)
+
+    raise @tbi
+  end
+
+  def get(key)
+
+    raise @tbi
+  end
+
+  def delete(key)
+
+    raise @tbi
+  end
+
+  def keys
+
+    raise @tbi
+  end
+end

data/lib/ff/ruby/server/sdk/connector/connector.rb

@@ -0,0 +1,44 @@
+require_relative '../common/closeable'
+
+class Connector < Closeable
+
+  def initialize
+
+    @tbi = "To be implemented"
+  end
+
+  def authenticate
+
+    raise @tbi
+  end
+
+  def get_flags
+
+    raise @tbi
+  end
+
+  def get_flag(identifier)
+
+    raise @tbi
+  end
+
+  def get_segments
+
+    raise @tbi
+  end
+
+  def get_segment(identifier)
+
+    raise @tbi
+  end
+
+  def post_metrics(metrics)
+
+    raise @tbi
+  end
+
+  def stream(updater)
+
+    raise @tbi
+  end
+end

data/lib/ff/ruby/server/sdk/connector/events.rb

@@ -0,0 +1,118 @@
+require "json"
+require "sse-client"
+
+require_relative './service'
+
+class Events < Service
+
+  def initialize(
+
+    url,
+    headers,
+    updater,
+    logger = nil
+  )
+
+    if @updater != nil
+
+      unless @updater.kind_of?(Updater)
+
+        raise "The 'callback' parameter must be of '" + Updater.to_s + "' data type"
+      end
+    end
+
+    @updater = updater
+
+    if logger != nil
+
+      @logger = logger
+    else
+
+      @logger = Logger.new(STDOUT)
+    end
+
+    @sse = SSE::EventSource.new(
+
+      url = url,
+      query = {},
+      headers = headers
+    )
+
+    @sse.open do
+
+      on_open
+    end
+
+    @sse.error do |error|
+
+      if error != nil
+
+        @logger.error "SSE ERROR: " + error.body
+      end
+
+      on_error
+    end
+
+    @sse.message do |message|
+
+      on_message(message)
+    end
+
+    @sse.on("*") do |message|
+
+      on_message(message)
+    end
+
+    @updater.on_ready
+  end
+
+  def start
+
+    @logger.info "Starting EventSource service"
+
+    @sse.start
+  end
+
+  def stop
+
+    @logger.info "Stopping EventSource service"
+
+    on_closed
+  end
+
+  def close
+
+    stop
+  end
+
+  def on_open
+
+    @logger.info "EventSource connected"
+
+    @updater.on_connected
+  end
+
+  def on_error
+
+    @logger.error "EventSource error"
+
+    @updater.on_error
+
+    stop
+  end
+
+  def on_closed
+
+    @logger.info "EventSource disconnected"
+
+    @updater.on_disconnected
+  end
+
+  def on_message(message)
+
+    @logger.debug "EventSource message received " + message.to_s
+
+    msg = JSON.parse(message)
+    @updater.update(msg)
+  end
+end