splitclient-rb 7.0.4.pre.rc3 → 7.1.0.pre.rc1

data/lib/splitclient-rb/sse/event_source/client.rb

@@ -8,7 +8,7 @@ module SplitIoClient
   module SSE
     module EventSource
       class Client
-        DEFAULT_READ_TIMEOUT = 200
+        DEFAULT_READ_TIMEOUT = 70
         KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
 
         def initialize(url, config, read_timeout: DEFAULT_READ_TIMEOUT)
@@ -17,13 +17,13 @@ module SplitIoClient
           @read_timeout = read_timeout
           @connected = Concurrent::AtomicBoolean.new(false)
           @socket = nil
+          @back_off = BackOff.new(@config.streaming_reconnect_back_off_base)
 
-          @on = { event: ->(_) {}, error: ->(_) {} }
+          @on = { event: ->(_) {}, connected: ->(_) {}, disconnect: ->(_) {} }
 
           yield self if block_given?
 
           connect_thread
-
           connect_passenger_forked if defined?(PhusionPassenger)
         end
 
@@ -31,28 +31,29 @@ module SplitIoClient
           @on[:event] = action
         end
 
-        def on_error(&action)
-          @on[:error] = action
+        def on_connected(&action)
+          @on[:connected] = action
+        end
+
+        def on_disconnect(&action)
+          @on[:disconnect] = action
         end
 
         def close
+          dispatch_disconnect
           @connected.make_false
           @socket&.close
           @socket = nil
         end
 
-        def status
-          return Status::CONNECTED if @connected.value
-
-          Status::DISCONNECTED
+        def connected?
+          @connected.value
         end
 
         private
 
         def connect_thread
-          @config.threads[:connect_stream] = Thread.new do
-            connect_stream
-          end
+          @config.threads[:connect_stream] = Thread.new { connect_stream }
         end
 
         def connect_passenger_forked
@@ -60,54 +61,58 @@ module SplitIoClient
         end
 
         def connect_stream
-          @config.logger.info("Connecting to #{@uri.host}...")
+          interval = @back_off.interval
+          sleep(interval) if interval.positive?
 
-          begin
-            @socket = socket_connect
+          @config.logger.info("Connecting to #{@uri.host}...")
 
-            @socket.write(build_request(@uri))
-            @connected.make_true
-          rescue StandardError => e
-            dispatch_error(e.inspect)
-          end
+          socket_write
 
           while @connected.value
             begin
               partial_data = @socket.readpartial(2048, timeout: @read_timeout)
             rescue Socketry::TimeoutError
-              @config.logger.error("Socket read time out in #{@read_timeout}")
-              @connected.make_false
+              @config.logger.error("Socket read time out in #{@read_timeout} seconds")
+              close
               connect_stream
             end
 
-            proccess_data(partial_data) unless partial_data == KEEP_ALIVE_RESPONSE
+            process_data(partial_data)
           end
         end
 
+        def socket_write
+          @socket = socket_connect
+          @socket.write(build_request(@uri))
+          dispatch_connected
+        rescue StandardError => e
+          @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
+          close
+        end
+
         def socket_connect
           return Socketry::SSL::Socket.connect(@uri.host, @uri.port) if @uri.scheme.casecmp('https').zero?
 
           Socketry::TCP::Socket.connect(@uri.host, @uri.port)
         end
 
-        def proccess_data(partial_data)
-          unless partial_data.nil?
+        def process_data(partial_data)
+          unless partial_data.nil? || partial_data == KEEP_ALIVE_RESPONSE
             @config.logger.debug("Event partial data: #{partial_data}")
             buffer = read_partial_data(partial_data)
-            event = parse_event(buffer)
+            events = parse_event(buffer)
 
-            dispatch_event(event)
+            dispatch_event(events)
           end
         rescue StandardError => e
-          dispatch_error(e.inspect)
+          @config.logger.error("Error during processing data: #{e.inspect}")
         end
 
         def build_request(uri)
           req = "GET #{uri.request_uri} HTTP/1.1\r\n"
           req << "Host: #{uri.host}\r\n"
           req << "Accept: text/event-stream\r\n"
-          req << "Cache-Control: no-cache\r\n"
-          req << "\r\n"
+          req << "Cache-Control: no-cache\r\n\r\n"
           @config.logger.debug("Request info: #{req}")
           req
         end
@@ -120,43 +125,61 @@ module SplitIoClient
         end
 
         def parse_event(buffer)
-          event_type = nil
-          parsed_data = nil
-          client_id = nil
+          type = nil
+          events = []
 
           buffer.each do |d|
             splited_data = d.split(':')
 
             case splited_data[0]
             when 'event'
-              event_type = splited_data[1].strip
+              type = splited_data[1].strip
             when 'data'
-              event_data = JSON.parse(d.sub('data: ', ''))
-              client_id = event_data['clientId']&.strip
-              parsed_data = JSON.parse(event_data['data'])
+              data = parse_event_data(d, type)
+              events << StreamData.new(type, data[:client_id], data[:data], data[:channel]) unless type.nil? || data[:data].nil?
             end
           end
 
-          return StreamData.new(event_type, client_id, parsed_data) unless event_type.nil? || parsed_data.nil?
-
-          raise 'Invalid event format.'
+          events
         rescue StandardError => e
-          dispatch_error(e.inspect)
-          nil
+          @config.logger.error("Error during parsing a event: #{e.inspect}")
+          []
+        end
+
+        def parse_event_data(data, type)
+          event_data = JSON.parse(data.sub('data: ', ''))
+          client_id = event_data['clientId']&.strip
+          channel = event_data['channel']&.strip
+          parsed_data = JSON.parse(event_data['data']) unless type == 'error'
+          parsed_data = event_data if type == 'error'
+
+          { client_id: client_id, channel: channel, data: parsed_data }
         end
 
-        def dispatch_event(event)
-          @config.logger.debug("Dispatching event: #{event}") unless event.nil?
-          @on[:event].call(event) unless event.nil?
+        def dispatch_event(events)
+          events.each do |event|
+            raise SSEClientException.new(event), 'Error event' if event.event_type == 'error'
+
+            @config.logger.debug("Dispatching event: #{event.event_type}, #{event.channel}")
+            @on[:event].call(event)
+          end
+        rescue SSEClientException => e
+          @config.logger.error("Event error: #{e.event.event_type}, #{e.event.data}")
+          close
         end
 
-        def dispatch_error(error)
-          @config.logger.debug("Dispatching error: #{error}")
-          @on[:error].call(error)
+        def dispatch_connected
+          @connected.make_true
+          @back_off.reset
+          @config.logger.debug('Dispatching connected')
+          @on[:connected].call
         end
-      end
 
-      StreamData = Struct.new(:event_type, :client_id, :data)
+        def dispatch_disconnect
+          @config.logger.debug('Dispatching disconnect')
+          @on[:disconnect].call
+        end
+      end
     end
   end
 end

data/lib/splitclient-rb/sse/event_source/stream_data.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class StreamData
+        attr_reader :event_type, :channel, :data, :client_id
+
+        def initialize(event_type, client_id, data, channel)
+          @event_type = event_type
+          @client_id = client_id
+          @data = data
+          @channel = channel&.gsub(SplitIoClient::Constants::OCCUPANCY_CHANNEL_PREFIX, '')
+        end
+
+        def occupancy?
+          @channel.include? 'control'
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/sse/notification_manager_keeper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'concurrent/atomics'
+
+module SplitIoClient
+  module SSE
+    class NotificationManagerKeeper
+      def initialize(config)
+        @config = config
+        @polling_on = Concurrent::AtomicBoolean.new(false)
+        @on = { occupancy: ->(_) {} }
+
+        yield self if block_given?
+      end
+
+      def handle_incoming_occupancy_event(event)
+        process_event(event.data['metrics']['publishers']) if event.channel == SplitIoClient::Constants::CONTROL_PRI
+      rescue StandardError => e
+        @config.logger.error(e)
+      end
+
+      def on_occupancy(&action)
+        @on[:occupancy] = action
+      end
+
+      private
+
+      def process_event(publishers)
+        @config.logger.debug("Occupancy process event with #{publishers} publishers and polling on: #{@polling_on.value}")
+        if publishers <= 0 && !@polling_on.value
+          @polling_on.make_true
+          dispatch_occupancy_event(false)
+        elsif publishers >= 1 && @polling_on.value
+          @polling_on.make_false
+          dispatch_occupancy_event(true)
+        end
+      end
+
+      def dispatch_occupancy_event(publisher_available)
+        @config.logger.debug("Dispatching occupancy event with publisher avaliable: #{publisher_available}")
+        @on[:occupancy].call(publisher_available)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/sse/notification_processor.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    class NotificationProcessor
+      def initialize(config, splits_worker, segments_worker)
+        @config = config
+        @splits_worker = splits_worker
+        @segments_worker = segments_worker
+      end
+
+      def process(incoming_notification)
+        case incoming_notification.data['type']
+        when SSE::EventSource::EventTypes::SPLIT_UPDATE
+          process_split_update(incoming_notification)
+        when SSE::EventSource::EventTypes::SPLIT_KILL
+          process_split_kill(incoming_notification)
+        when SSE::EventSource::EventTypes::SEGMENT_UPDATE
+          process_segment_update(incoming_notification)
+        else
+          @config.logger.error("Incorrect event type: #{incoming_notification}")
+        end
+      end
+
+      private
+
+      def process_split_update(notification)
+        @config.logger.debug("SPLIT UPDATE notification received: #{notification}")
+        @splits_worker.add_to_queue(notification.data['changeNumber'])
+      end
+
+      def process_split_kill(notification)
+        @config.logger.debug("SPLIT KILL notification received: #{notification}")
+        change_number = notification.data['changeNumber']
+        default_treatment = notification.data['defaultTreatment']
+        split_name = notification.data['splitName']
+
+        @splits_worker.kill_split(change_number, split_name, default_treatment)
+      end
+
+      def process_segment_update(notification)
+        @config.logger.debug("SEGMENT UPDATE notification received: #{notification}")
+        change_number = notification.data['changeNumber']
+        segment_name = notification.data['segmentName']
+
+        @segments_worker.add_to_queue(change_number, segment_name)
+      end
+    end
+  end
+end

data/lib/splitclient-rb/sse/sse_handler.rb

@@ -5,78 +5,74 @@ module SplitIoClient
     class SSEHandler
       attr_reader :sse_client
 
-      def initialize(config, options, splits_worker, segments_worker, control_worker)
+      def initialize(config, synchronizer, splits_repository, segments_repository, notification_manager_keeper)
         @config = config
-        @options = options
-        @splits_worker = splits_worker
-        @segments_worker = segments_worker
-        @control_worker = control_worker
+        @notification_manager_keeper = notification_manager_keeper
+        @splits_worker = SplitIoClient::SSE::Workers::SplitsWorker.new(synchronizer, config, splits_repository)
+        @segments_worker = SplitIoClient::SSE::Workers::SegmentsWorker.new(synchronizer, config, segments_repository)
+        @control_worker = SplitIoClient::SSE::Workers::ControlWorker.new(config)
+        @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(config, @splits_worker, @segments_worker)
 
-        @sse_client = start_sse_client
-      end
-
-      private
+        @on = { connected: ->(_) {}, disconnect: ->(_) {} }
 
-      def start_sse_client
-        url = "#{@options[:url_host]}/event-stream?channels=#{@options[:channels]}&v=1.1&key=#{@options[:key]}"
+        yield self if block_given?
+      end
 
-        sse_client = SSE::EventSource::Client.new(url, @config) do |client|
-          client.on_event do |event|
-            process_event(event)
-          end
+      def start(token_jwt, channels)
+        url = "#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}"
 
-          client.on_error do |error|
-            process_error(error)
-          end
+        @sse_client = SSE::EventSource::Client.new(url, @config) do |client|
+          client.on_event { |event| handle_incoming_message(event) }
+          client.on_connected { process_connected }
+          client.on_disconnect { process_disconnect }
         end
+      end
 
-        sse_client
+      def stop
+        @sse_client&.close
+        @sse_client = nil
       end
 
-      def process_event(event)
-        case event.data['type']
-        when SSE::EventSource::EventTypes::SPLIT_UPDATE
-          split_update_notification(event)
-        when SSE::EventSource::EventTypes::SPLIT_KILL
-          split_kill_notification(event)
-        when SSE::EventSource::EventTypes::SEGMENT_UPDATE
-          segment_update_notification(event)
-        when SSE::EventSource::EventTypes::CONTROL
-          control_notification(event)
-        else
-          @config.logger.error("Incorrect event type: #{event}")
-        end
+      def connected?
+        @sse_client&.connected? || false
       end
 
-      def process_error(error)
-        @config.logger.error("SSE::EventSource::Client error: #{error}")
+      def start_workers
+        @splits_worker.start
+        @segments_worker.start
+        @control_worker.start
       end
 
-      def split_update_notification(event)
-        @config.logger.debug("SPLIT UPDATE notification received: #{event}")
-        @splits_worker.add_to_queue(event.data['changeNumber'])
+      def stop_workers
+        @splits_worker.stop
+        @segments_worker.stop
+        @control_worker.stop
       end
 
-      def split_kill_notification(event)
-        @config.logger.debug("SPLIT KILL notification received: #{event}")
+      def on_connected(&action)
+        @on[:connected] = action
+      end
 
-        change_number = event.data['changeNumber']
-        default_treatment = event.data['defaultTreatment']
-        split_name = event.data['splitName']
+      def on_disconnect(&action)
+        @on[:disconnect] = action
+      end
 
-        @splits_worker.kill_split(change_number, split_name, default_treatment)
+      def process_disconnect
+        @on[:disconnect].call
       end
 
-      def segment_update_notification(event)
-        @config.logger.debug("SEGMENT UPDATE notification received: #{event}")
-        change_number = event.data['changeNumber']
-        segment_name = event.data['segmentName']
+      private
 
-        @segments_worker.add_to_queue(change_number, segment_name)
+      def process_connected
+        @on[:connected].call
       end
 
-      def control_notification(event)
-        @config.logger.debug("CONTROL notification received: #{event}")
+      def handle_incoming_message(notification)
+        if notification.occupancy?
+          @notification_manager_keeper.handle_incoming_occupancy_event(notification)
+        else
+          @notification_processor.process(notification)
+        end
       end
     end
   end

data/lib/splitclient-rb/sse/workers/control_worker.rb

@@ -4,23 +4,28 @@ module SplitIoClient
   module SSE
     module Workers
       class ControlWorker
-        def initialize(adapter, config)
-          @adapter = adapter
+        def initialize(config)
           @config = config
+        end
 
+        def start
           perform_thread
-
           perform_passenger_forked if defined?(PhusionPassenger)
         end
 
+        def stop
+          SplitIoClient::Helpers::ThreadHelper.stop(:control_worker, @config)
+        end
+
         private
 
         def perform
-          # TODO: IMPLEMENT THIS METHOD
+          # TODO: IMPLEMENT THIS METHOD.
         end
 
         def perform_thread
-          @config.threads[:segment_update_worker] = Thread.new do
+          @config.threads[:control_worker] = Thread.new do
+            @config.logger.debug('Starting control worker ...')
             perform
           end
         end

data/lib/splitclient-rb/sse/workers/segments_worker.rb

@@ -4,22 +4,28 @@ module SplitIoClient
   module SSE
     module Workers
       class SegmentsWorker
-        def initialize(adapter, config, segments_repository)
-          @adapter = adapter
+        def initialize(synchronizer, config, segments_repository)
+          @synchronizer = synchronizer
           @config = config
           @segments_repository = segments_repository
           @queue = Queue.new
+        end
 
+        def start
           perform_thread
-
           perform_passenger_forked if defined?(PhusionPassenger)
         end
 
         def add_to_queue(change_number, segment_name)
           item = { change_number: change_number, segment_name: segment_name }
+          @config.logger.debug("SegmentsWorker add to queue #{item}")
           @queue.push(item)
         end
 
+        def stop
+          SplitIoClient::Helpers::ThreadHelper.stop(:segment_update_worker, @config)
+        end
+
         private
 
         def perform
@@ -28,12 +34,16 @@ module SplitIoClient
             change_number = item[:change_number]
             since = @segments_repository.get_change_number(segment_name)
 
-            @adapter.segment_fetcher.fetch_segment(segment_name) unless since >= change_number
+            unless since >= change_number
+              @config.logger.debug("SegmentsWorker fetch_segment with #{since}")
+              @synchronizer.fetch_segment(segment_name)
+            end
           end
         end
 
         def perform_thread
           @config.threads[:segment_update_worker] = Thread.new do
+            @config.logger.debug('Starting segments worker ...')
             perform
           end
         end

data/lib/splitclient-rb/sse/workers/splits_worker.rb

@@ -4,37 +4,49 @@ module SplitIoClient
   module SSE
     module Workers
       class SplitsWorker
-        def initialize(adapter, config, splits_repository)
-          @adapter = adapter
+        def initialize(synchronizer, config, splits_repository)
+          @synchronizer = synchronizer
           @config = config
           @splits_repository = splits_repository
           @queue = Queue.new
+        end
 
+        def start
           perform_thread
-
           perform_passenger_forked if defined?(PhusionPassenger)
         end
 
         def add_to_queue(change_number)
+          @config.logger.debug("SplitsWorker add to queue #{change_number}")
           @queue.push(change_number)
         end
 
         def kill_split(change_number, split_name, default_treatment)
+          @config.logger.debug("SplitsWorker kill #{split_name}, #{change_number}")
           @splits_repository.kill(change_number, split_name, default_treatment)
           add_to_queue(change_number)
         end
 
+        def stop
+          SplitIoClient::Helpers::ThreadHelper.stop(:split_update_worker, @config)
+        end
+
         private
 
         def perform
           while (change_number = @queue.pop)
             since = @splits_repository.get_change_number
-            @adapter.split_fetcher.fetch_splits unless since >= change_number
+
+            unless since.to_i >= change_number
+              @config.logger.debug("SplitsWorker fetch_splits with #{since}")
+              @synchronizer.fetch_splits
+            end
           end
         end
 
         def perform_thread
           @config.threads[:split_update_worker] = Thread.new do
+            @config.logger.debug('Starting splits worker ...')
             perform
           end
         end

data/lib/splitclient-rb/version.rb

@@ -1,3 +1,3 @@
 module SplitIoClient
-  VERSION = '7.0.4.pre.rc3'
+  VERSION = '7.1.0.pre.rc1'
 end

data/lib/splitclient-rb.rb

@@ -2,6 +2,7 @@ require 'forwardable'
 
 require 'splitclient-rb/version'
 
+require 'splitclient-rb/constants'
 require 'splitclient-rb/exceptions'
 require 'splitclient-rb/cache/routers/impression_router'
 require 'splitclient-rb/cache/adapters/memory_adapters/map_adapter'
@@ -35,6 +36,7 @@ require 'splitclient-rb/cache/stores/localhost_split_store'
 
 require 'splitclient-rb/clients/split_client'
 require 'splitclient-rb/managers/split_manager'
+require 'splitclient-rb/helpers/thread_helper'
 require 'splitclient-rb/split_factory'
 require 'splitclient-rb/split_factory_builder'
 require 'splitclient-rb/split_config'
@@ -52,7 +54,6 @@ require 'splitclient-rb/engine/api/splits'
 require 'splitclient-rb/engine/api/events'
 require 'splitclient-rb/engine/parser/condition'
 require 'splitclient-rb/engine/parser/partition'
-require 'splitclient-rb/engine/parser/split_adapter'
 require 'splitclient-rb/engine/parser/evaluator'
 require 'splitclient-rb/engine/matchers/matcher'
 require 'splitclient-rb/engine/matchers/combiners'
@@ -83,18 +84,25 @@ require 'splitclient-rb/engine/metrics/binary_search_latency_tracker'
 require 'splitclient-rb/engine/models/split'
 require 'splitclient-rb/engine/models/label'
 require 'splitclient-rb/engine/models/treatment'
+require 'splitclient-rb/engine/auth_api_client'
+require 'splitclient-rb/engine/push_manager'
+require 'splitclient-rb/engine/sync_manager'
+require 'splitclient-rb/engine/synchronizer'
 require 'splitclient-rb/utilitites'
 
 # redis metrics fixer
 require 'splitclient-rb/redis_metrics_fixer'
 
 # SSE 
+require 'splitclient-rb/sse/event_source/back_off'
 require 'splitclient-rb/sse/event_source/client'
 require 'splitclient-rb/sse/event_source/event_types'
-require 'splitclient-rb/sse/event_source/status'
+require 'splitclient-rb/sse/event_source/stream_data'
 require 'splitclient-rb/sse/workers/control_worker'
 require 'splitclient-rb/sse/workers/segments_worker'
 require 'splitclient-rb/sse/workers/splits_worker'
+require 'splitclient-rb/sse/notification_manager_keeper'
+require 'splitclient-rb/sse/notification_processor'
 require 'splitclient-rb/sse/sse_handler'
 
 # C extension

data/splitclient-rb.gemspec

@@ -51,6 +51,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_runtime_dependency 'faraday', '>= 0.8'
   spec.add_runtime_dependency 'json', '>= 1.8'
+  spec.add_runtime_dependency 'jwt', '>= 2.2.1'
   spec.add_runtime_dependency 'lru_redux'
   spec.add_runtime_dependency 'net-http-persistent', '>= 2.9'
   spec.add_runtime_dependency 'redis', '>= 3.2'