kameleoon-client-ruby 2.0.0 → 2.1.1

data/lib/kameleoon/real_time/real_time_configuration_service.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# Kameleoon Real Time Configuration Service
+
+require 'json'
+require 'kameleoon/real_time/real_time_event'
+require 'kameleoon/real_time/sse_request'
+require 'kameleoon/real_time/sse_client'
+
+module Kameleoon
+  module RealTime
+    CONFIGURATION_UPDATE_EVENT = 'configuration-update-event'
+
+    ##
+    # RealTimeConfigurationService is used for fetching updates of configuration
+    # (experiments and feature flags) in real time.
+    class RealTimeConfigurationService
+      ##
+      # Parametrized initializer.
+      #
+      # @param url [String]
+      # @param update_handler [Callable[Kameleoon::RealTime::RealTimeEvent] | NilClass] Handler which
+      # is synchronously called for gotten RealTimeEvent objects.
+      # @param log_func [Callable[String] | NilClass] Callable object which synchronously called to log.
+      def initialize(url, update_handler, log_func, sse_request_source = nil)
+        @url = url
+        @update_handler = update_handler
+        @need_close = false
+        @headers = {
+          'Accept': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'Keep-Alive'
+        }
+        @log_func = log_func
+        @sse_request_source = sse_request_source
+        @sse_thread = nil
+        @sse_client = nil
+        create_sse_client
+      end
+
+      ##
+      # Closes the connection to the server.
+      def close
+        return if @need_close
+
+        @log_func&.call('Real-time configuration service is shutting down')
+        @need_close = true
+        return if @sse_thread.nil?
+
+        @sse_thread.kill
+        @sse_thread = nil
+        @sse_client.call_close_handler
+      end
+
+      private
+
+      def create_sse_client
+        @sse_thread = Thread.new { run_sse_client } unless @need_close
+      end
+
+      def init_sse_client
+        message_handler = proc do |message|
+          @log_func&.call("Got SSE event: #{message.event}")
+          if message.event == CONFIGURATION_UPDATE_EVENT
+            event_dict = JSON.parse(message.data)
+            @update_handler&.call(RealTimeEvent.new(event_dict))
+          end
+        end
+        sse_request = make_sse_request
+        @sse_client = SseClient.new(sse_request, message_handler)
+        @log_func&.call('Created SSE client')
+      end
+
+      def make_sse_request
+        open_handler = proc { @log_func&.call('SSE connection open') }
+        close_handler = proc { @log_func&.call('SSE connection closed') }
+        unexpected_status_code_handler =
+          proc { |resp| @log_func&.call("Unexpected status code of SSE response: #{resp.code}") }
+        if @sse_request_source.nil?
+          return SseRequest.new(@url, @headers, open_handler, close_handler, unexpected_status_code_handler)
+        end
+
+        @sse_request_source.call(@url, @headers, open_handler, close_handler, unexpected_status_code_handler)
+      end
+
+      def run_sse_client
+        until @need_close
+          init_sse_client
+          begin
+            @sse_client.start
+          rescue StandardError => e
+            @log_func&.call("Error occurred within SSE client: #{e}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kameleoon/real_time/real_time_event.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Kameleoon Real Time Event
+
+module Kameleoon
+  module RealTime
+    ##
+    # RealTimeEvent contains information about timestamp when configuration was updated.
+    # Timestamp parameter is used to fetch the latest configuration.
+    class RealTimeEvent
+      attr_reader :time_stamp
+
+      ##
+      # Parametrized initializer. Gets the new time stamp from a JSON message.
+      #
+      # @param event_dict [Hash] Hash of SSE message data.
+      def initialize(event_dict)
+        @time_stamp = event_dict['ts']
+      end
+    end
+  end
+end

data/lib/kameleoon/real_time/sse_client.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'kameleoon/real_time/sse_message'
+
+module Kameleoon
+  module RealTime
+    ##
+    # SseClient is used to interpret SSE event stream.
+    class SseClient
+      ##
+      # Parametrized initializer.
+      #
+      # @param sse_request [Kameleoon::RealTime::SseRequest] Used to access SSE event stream.
+      # @param message_handler [Callable[Kameleoon::RealTime::SseMessage] | NilClass] Callable object which
+      # is synchronously called for received SSE messages.
+      def initialize(sse_request, message_handler)
+        @sse_request = sse_request
+        @message_handler = message_handler
+
+        @cr_prev = nil
+        @buffer = nil
+        @data_buffer = nil
+        @event = nil
+        @id = nil
+        @reconnection_time = nil
+
+        @sse_request.resp_char_handler = method(:process_char)
+      end
+
+      ##
+      # Starts SSE connection and stay in the loop until close.
+      def start
+        @cr_prev = false
+        @data_buffer = []
+        @event = nil
+        @id = nil
+        @buffer = []
+        @sse_request.start
+      end
+
+      ##
+      # Calls @sse_request@close_handler if it is not nil.
+      def call_close_handler
+        @sse_request.call_close_handler
+      end
+
+      private
+
+      def process_char(ch)
+        if @cr_prev && (ch == "\n")
+          @cr_prev = false
+          return
+        end
+        @cr_prev = ch == "\r"
+        if @cr_prev || (ch == "\n")
+          line = @buffer.join
+          @buffer.clear
+          if line.empty?
+            dispatch_event
+          else
+            handle_line(line)
+          end
+          return
+        end
+        @buffer << ch
+      end
+
+      def handle_line(line)
+        field, value = parse_line(line)
+        return if field.nil?
+
+        case field
+        when 'event'
+          @event = value
+        when 'data'
+          @data_buffer << value
+        when 'id'
+          @id = value
+        when 'retry'
+          @reconnection_time = value.to_i # This does not affect anything
+        end
+      end
+
+      def parse_line(line)
+        colon_index = line.index(':')
+        return line, nil if colon_index.nil?
+        return nil, nil if colon_index.zero?
+
+        field = line[0, colon_index]
+        return field, '' if colon_index + 1 == line.length
+
+        value = if line[colon_index + 1] == ' '
+                  line[colon_index + 2..]
+                else
+                  line[colon_index + 1..]
+                end
+        [field, value]
+      end
+
+      def dispatch_event
+        return unless !@event.nil? || !@data_buffer.empty? # Ignoring empty events
+
+        data = @data_buffer.join("\n")
+        message = SseMessage.new(@event, @id, data)
+        @event = nil
+        @data_buffer.clear
+        @message_handler&.call(message)
+      end
+    end
+  end
+end

data/lib/kameleoon/real_time/sse_message.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kameleoon
+  module RealTime
+    ##
+    # SseMessage is a container for a received SSE message.
+    class SseMessage
+      attr_reader :event, :id, :data
+
+      ##
+      # Parametrized initializer.
+      #
+      # @param event [String]
+      # @param id [String]
+      # @param data [String]
+      def initialize(event, id, data)
+        @event = event
+        @id = id
+        @data = data
+      end
+    end
+  end
+end

data/lib/kameleoon/real_time/sse_request.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'restclient'
+
+module Kameleoon
+  module RealTime
+    ##
+    # SseRequest is used keep SSE connection and read from its stream.
+    class SseRequest
+      attr_writer :resp_char_handler
+
+      ##
+      # Parametrized initializer.
+      #
+      # @param url [String]
+      # @param headers [Hash]
+      # @param open_handler [Callable | NilClass] Handler which is synchronously called when SSE connection is open.
+      # @param close_handler [Callable | NilClass] Handler which is synchronously called when SSE connection is closed.
+      # @param unexpected_status_code_handler [Callable[Net::HTTPResponse] | NilClass] Handler whick
+      # is synchronously called for responses with not 200 status code.
+      def initialize(url, headers, open_handler, close_handler, unexpected_status_code_handler)
+        @url = url
+        @headers = headers
+        @open_handler = open_handler
+        @close_handler = close_handler
+        @unexpected_status_code_handler = unexpected_status_code_handler
+
+        @resp_char_handler = nil
+      end
+
+      ##
+      # Starts SSE connection and stay in the loop until close.
+      def start
+        RestClient::Request.execute(method: :get, url: @url, headers: @headers, read_timeout: nil,
+                                    block_response: method(:handle_resp))
+      end
+
+      ##
+      # Calls @close_handler if it is not nil.
+      def call_close_handler
+        @close_handler&.call
+      end
+
+      private
+
+      def handle_resp(resp)
+        @open_handler&.call
+        if resp.code == '200'
+          resp.read_body do |chunk|
+            chunk.each_char { |ch| @resp_char_handler&.call(ch) }
+          end
+        else
+          @unexpected_status_code_handler&.call(resp)
+        end
+        call_close_handler
+      end
+    end
+  end
+end

data/lib/kameleoon/request.rb

@@ -7,27 +7,24 @@ module Kameleoon
   module Request
     protected
 
-    API_URL = 'https://api.kameleoon.com'.freeze
-    CLIENT_CONFIG_URL = 'https://client-config.kameleoon.com'.freeze
-
     module Method
       GET = 'get'.freeze
       POST = 'post'.freeze
     end
 
-    def get(request_options, url = API_URL, connexion_options = {})
+    def get(request_options, url, connexion_options = {})
       request(Method::GET, request_options, url, connexion_options)
     end
 
-    def post(request_options, url = API_URL, connexion_options = {})
+    def post(request_options, url, connexion_options = {})
       request(Method::POST, request_options, url, connexion_options)
     end
 
-    def get_sync(url = API_URL, connexion_options = {})
+    def get_sync(url, connexion_options = {})
       request_sync(Method::GET, url, connexion_options, {})
     end
 
-    def post_sync(request_options, url = API_URL, connexion_options = {})
+    def post_sync(request_options, url, connexion_options = {})
       request_sync(Method::POST, url, connexion_options, request_options)
     end
 
@@ -35,7 +32,6 @@ module Kameleoon
 
     def request(method, request_options, url, connexion_options)
       connexion_options[:tls] = { verify_peer: false }
-      add_user_agent(request_options)
       case method
         when Method::POST then
           return EventMachine::HttpRequest.new(url, connexion_options).apost request_options
@@ -49,7 +45,6 @@ module Kameleoon
 
     def request_sync(method, url, connexion_options, request_options)
       request_options = {} if request_options.nil?
-      add_user_agent(request_options)
       case method
         when Method::GET then
           uri = URI(url)
@@ -60,7 +55,7 @@ module Kameleoon
           uri = URI.parse(url)
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = true
-          request = Net::HTTP::Post.new(request_options[:path], initheader = request_options[:head])
+          request = Net::HTTP::Post.new(uri, initheader = request_options[:head])
           request.body = request_options[:body]
           response = http.request(request)
           response
@@ -77,14 +72,5 @@ module Kameleoon
     def successful_sync?(response)
       !response.nil? && response != false && response.is_a?(Net::HTTPSuccess)
     end
-
-    def add_user_agent(request_options)
-      sdk_version = "sdk/ruby/#{Kameleoon::VERSION}"
-      if request_options[:head].nil?
-        request_options[:head] = { 'Kameleoon-Client' => sdk_version }
-      else
-        request_options[:head].store('Kameleoon-Client', sdk_version)
-      end
-    end
   end
 end

data/lib/kameleoon/storage/cache.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module Kameleoon
+  module Storage
+    # Will be useful for Ruby 3.0
+    # Abstract Cache class (interface)
+    class Cache
+      def get(_key)
+        raise 'Abstract method `read` called'
+      end
+
+      def set(_key, _value)
+        raise 'Abstract method `write` called'
+      end
+
+      def active_items
+        raise 'Abstract method `active_items` called'
+      end
+    end
+
+    # Implementation of Cache with auto cleaning feature
+    class CacheImpl < Cache
+      def initialize(expiration_time, cleaning_interval)
+        super()
+        @mutex = Mutex.new
+        @expiration_time = expiration_time
+        @cleaning_interval = cleaning_interval
+        @cache = {}
+      end
+
+      def set(key, value)
+        @mutex.synchronize do
+          start_cleaner_timer if @cleaning_interval.positive? && @cleaner_timer.nil?
+          @cache[key] = { value: value, expired: Time.now + @expiration_time }
+        end
+      end
+
+      def get(key)
+        entry = @cache[key]
+        return entry[:value] unless entry.nil? || expired?(entry)
+
+        @mutex.synchronize { @cache.delete(key) }
+        nil
+      end
+
+      def active_items
+        active_items = {}
+        remove_expired_entries
+        @mutex.synchronize do
+          @cache.each_pair { |key, entry| active_items[key] = entry[:value] }
+        end
+        active_items
+      end
+
+      private
+
+      def start_cleaner_timer
+        @cleaner_timer = Concurrent::TimerTask.new(execution_interval: @cleaning_interval) do
+          remove_expired_entries
+        end
+        @cleaner_timer.execute
+      end
+
+      def stop_cleaner_timer
+        @cleaner_timer&.shutdown
+        @cleaner_timer = nil
+      end
+
+      def remove_expired_entries
+        time = Time.now
+        @mutex.synchronize do
+          @cache.delete_if { |_, entry| expired?(entry, time) }
+          stop_cleaner_timer if @cache.empty?
+        end
+      end
+
+      def expired?(entry, time = Time.now)
+        entry[:expired] <= time
+      end
+    end
+  end
+end

data/lib/kameleoon/storage/cache_factory.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+require_relative 'cache'
+
+module Kameleoon
+  module Storage
+    # Will be useful for Ruby 3.0
+    # Abstract CacheFactory class (interface)
+    class CacheFactory
+      def create(_experiration_time, _cleaning_time)
+        raise 'Abstract method `create` called'
+      end
+    end
+
+    # Implementation of CacheFactory with auto cleaning feature
+    class CacheFactoryImpl < CacheFactory
+      def create(expiration_time, cleaning_interval)
+        CacheImpl.new(expiration_time, cleaning_interval)
+      end
+    end
+  end
+end

data/lib/kameleoon/targeting/condition.rb

@@ -1,28 +1,57 @@
 # frozen_string_literal: true
+require 'kameleoon/exceptions'
 
 module Kameleoon
   # @api private
   module Targeting
+    module ConditionType
+      CUSTOM_DATUM = 'CUSTOM_DATUM'
+      TARGET_EXPERIMENT = 'TARGET_EXPERIMENT'
+      EXCLUSIVE_EXPERIMENT = 'EXCLUSIVE_EXPERIMENT'
+      PAGE_URL = 'PAGE_URL'
+      PAGE_TITLE = 'PAGE_TITLE'
+      VISITOR_CODE = 'VISITOR_CODE'
+      DEVICE_TYPE = 'DEVICE_TYPE'
+      BROWSER = 'BROWSER'
+      SDK_LANGUAGE = 'SDK_LANGUAGE'
+      CONVERSIONS = 'CONVERSIONS'
+    end
+
+    module Operator
+      UNDEFINED = 'UNDEFINED'
+      CONTAINS = 'CONTAINS'
+      EXACT = 'EXACT'
+      REGULAR_EXPRESSION = 'REGULAR_EXPRESSION'
+      LOWER = 'LOWER'
+      EQUAL = 'EQUAL'
+      GREATER = 'GREATER'
+      IS_TRUE = 'TRUE'
+      IS_FALSE = 'FALSE'
+      AMONG_VALUES = 'AMONG_VALUES'
+      ANY = 'ANY'
+      UNKNOWN = 'UNKNOWN'
+    end
+
+    # Base class for all targeting conditions
     class Condition
-      attr_accessor :type, :include
+      attr_reader :type, :include
 
       def initialize(json_condition)
-        if json_condition['targetingType'].nil?
-          raise Exception::NotFoundError.new('targetingType'), 'targetingType missed'
-        end
+        raise Exception::NotFound.new('targetingType'), 'targetingType missed' if json_condition['targetingType'].nil?
 
         @type = json_condition['targetingType']
+        @include = json_condition['isInclude'].nil? ? true : json_condition['isInclude']
+      end
 
-        if json_condition['include'].nil? && json_condition['isInclude'].nil?
-          raise Exception::NotFoundError.new('include / isInclude missed'), 'include / isInclude missed'
-        end
-
-        @include = json_condition['include'] || json_condition['isInclude']
+      def check(_data)
+        raise 'Abstract method `check` call'
       end
 
-      def check(conditions)
-        raise "Todo: Implement check method in condition"
+      protected
+
+      def get_last_targeting_data(list_data, data_type)
+        list_data.select { |data| data.instance == data_type }.last
       end
     end
   end
-end
+end

data/lib/kameleoon/targeting/condition_factory.rb

@@ -1,22 +1,45 @@
-require 'kameleoon/targeting/conditions/custom_datum'
-require 'kameleoon/targeting/conditions/target_experiment'
-require 'kameleoon/targeting/conditions/exclusive_experiment'
+require_relative 'conditions/custom_datum'
+require_relative 'conditions/target_experiment'
+require_relative 'conditions/exclusive_experiment'
+require_relative 'conditions/page_title_condition'
+require_relative 'conditions/page_url_condition'
+require_relative 'conditions/visitor_code_condition'
+require_relative 'conditions/device_condition'
+require_relative 'conditions/conversion_condition'
+require_relative 'conditions/browser_condition'
+require_relative 'conditions/sdk_language_condition'
+require_relative 'conditions/unknown_condition'
 
 module Kameleoon
-  #@api private
+  # @api private
   module Targeting
+    # Module for create different targeting conditions
     module ConditionFactory
       def get_condition(condition_json)
-        condition = nil
         case condition_json['targetingType']
-        when ConditionType::CUSTOM_DATUM.to_s
-          condition = CustomDatum.new(condition_json)
-        when ConditionType::TARGET_EXPERIMENT.to_s
-          condition = TargetExperiment.new(condition_json)
-        when ConditionType::EXCLUSIVE_EXPERIMENT.to_s
-          condition = ExclusiveExperiment.new(condition_json)
+        when ConditionType::CUSTOM_DATUM
+          CustomDatum.new(condition_json)
+        when ConditionType::TARGET_EXPERIMENT
+          TargetExperiment.new(condition_json)
+        when ConditionType::EXCLUSIVE_EXPERIMENT
+          ExclusiveExperiment.new(condition_json)
+        when ConditionType::PAGE_URL
+          PageUrlCondition.new(condition_json)
+        when ConditionType::PAGE_TITLE
+          PageTitleCondition.new(condition_json)
+        when ConditionType::VISITOR_CODE
+          VisitorCodeCondition.new(condition_json)
+        when ConditionType::DEVICE_TYPE
+          DeviceCondition.new(condition_json)
+        when ConditionType::CONVERSIONS
+          ConversionCondition.new(condition_json)
+        when ConditionType::BROWSER
+          BrowserCondition.new(condition_json)
+        when ConditionType::SDK_LANGUAGE
+          SdkLanguageCondition.new(condition_json)
+        else
+          UnknownCondition.new(condition_json)
         end
-        condition
       end
     end
   end

data/lib/kameleoon/targeting/conditions/browser_condition.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'kameleoon/data/browser'
+require 'kameleoon/version'
+
+module Kameleoon
+  # @api private
+  module Targeting
+
+    CHROME = 'CHROME'
+    INTERNET_EXPLORER = 'IE'
+    FIREFOX = 'FIREFOX'
+    SAFARI = 'SAFARI'
+    OPERA = 'OPERA'
+
+    # BrowserCondition is a condition for checking targeting with browser's type and version
+    class BrowserCondition < Condition
+      def initialize(json_condition)
+        super(json_condition)
+        @browser_type = browser_index_from_name(json_condition['browser'])
+        @version = json_condition['version']
+        @version_match_type = json_condition['versionMatchType']
+      end
+
+      def check(list_data)
+        browser = get_last_targeting_data(list_data, Kameleoon::DataType::BROWSER)
+        browser && check_targeting(browser)
+      end
+
+      private
+
+      def check_targeting(browser)
+        return false if @browser_type != browser.type
+
+        return true if @version.nil?
+
+        version_number = SdkVersion.get_float_version(@version)
+        return false if version_number.nan?
+
+        case @version_match_type
+        when Operator::EQUAL
+          browser.version == version_number
+        when Operator::GREATER
+          browser.version > version_number
+        when Operator::LOWER
+          browser.version < version_number
+        else
+          puts "Unexpected comparing operation for Browser condition: #{@version_match_type}"
+          false
+        end
+      end
+
+      def browser_index_from_name(name)
+        case name
+        when CHROME
+          BrowserType::CHROME
+        when INTERNET_EXPLORER
+          BrowserType::INTERNET_EXPLORER
+        when FIREFOX
+          BrowserType::FIREFOX
+        when SAFARI
+          BrowserType::SAFARI
+        when OPERA
+          BrowserType::OPERA
+        else
+          BrowserType::OTHER
+        end
+      end
+    end
+  end
+end