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

data/lib/splitclient-rb/split_config.rb

@@ -102,7 +102,11 @@ module SplitIoClient
       @split_validator = SplitIoClient::Validators.new(self)
       @localhost_mode = opts[:localhost_mode]
 
-      @push_notification_enabled = opts[:push_notification_enabled].nil? ? true : false
+      @streaming_enabled = consumer? ? false : (opts[:streaming_enabled].nil? ? SplitConfig.default_streaming_enabled : opts[:streaming_enabled])
+      @streaming_service_url = opts[:streaming_service_url] || SplitConfig.default_streaming_service_url
+      @auth_service_url = opts[:auth_service_url] || SplitConfig.default_auth_service_url
+      @auth_retry_back_off_base = SplitConfig.init_auth_retry_back_off(opts[:auth_retry_back_off_base] || SplitConfig.default_auth_retry_back_off_base)
+      @streaming_reconnect_back_off_base = SplitConfig.init_streaming_reconnect_back_off(opts[:streaming_reconnect_back_off_base] || SplitConfig.default_streaming_reconnect_back_off_base)
 
       startup_log
     end
@@ -256,7 +260,43 @@ module SplitIoClient
 
     attr_accessor :ip_addresses_enabled
 
-    attr_accessor :push_notification_enabled
+    attr_accessor :auth_service_url
+
+    attr_accessor :auth_retry_back_off_base
+
+    attr_accessor :streaming_service_url
+
+    attr_accessor :streaming_reconnect_back_off_base
+
+    attr_accessor :streaming_enabled
+
+    def self.default_streaming_enabled
+      false
+    end
+
+    def self.default_streaming_service_url
+      'https://split-realtime.ably.io/event-stream'
+    end
+
+    def self.default_auth_service_url
+      'https://auth.split.io/api/auth'
+    end
+
+    def self.default_auth_retry_back_off_base
+      1
+    end
+
+    def self.default_streaming_reconnect_back_off_base
+      1
+    end
+
+    def self.init_auth_retry_back_off(auth_retry_back_off)
+      auth_retry_back_off < 1 ? SplitConfig.default_auth_retry_back_off_base : auth_retry_back_off
+    end
+
+    def self.init_streaming_reconnect_back_off(streaming_reconnect_back_off)
+      streaming_reconnect_back_off < 1 ? SplitConfig.default_streaming_reconnect_back_off_base : streaming_reconnect_back_off
+    end
 
     #
     # The default split client configuration
@@ -385,8 +425,6 @@ module SplitIoClient
        end
     end
 
-
-
     #
     # The default debug value
     #

data/lib/splitclient-rb/split_factory.rb

@@ -6,6 +6,7 @@ module SplitIoClient
 
     include SplitIoClient::Cache::Repositories
     include SplitIoClient::Cache::Stores
+    include SplitIoClient::Cache::Senders
 
     attr_reader :adapter, :client, :manager, :config
 
@@ -29,16 +30,14 @@ module SplitIoClient
       @splits_repository = SplitsRepository.new(@config)
       @segments_repository = SegmentsRepository.new(@config)
       @impressions_repository = ImpressionsRepository.new(@config)
-      @metrics_repository = MetricsRepository.new(@config)
       @events_repository = EventsRepository.new(@config, @api_key)
-
+      @metrics_repository = MetricsRepository.new(@config)
       @sdk_blocker = SDKBlocker.new(@splits_repository, @segments_repository, @config)
+      @metrics = Metrics.new(100, @metrics_repository)
 
-      @adapter = start!
+      start!
 
-      start_sse!
-
-      @client = SplitClient.new(@api_key, @adapter, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config, @sse_handler)
+      @client = SplitClient.new(@api_key, @metrics, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config)
       @manager = SplitManager.new(@splits_repository, @sdk_blocker, @config)
 
       validate_api_key
@@ -49,7 +48,11 @@ module SplitIoClient
     end
 
     def start!
-      SplitAdapter.new(@api_key, @splits_repository, @segments_repository, @impressions_repository, @metrics_repository, @events_repository, @sdk_blocker, @config)
+      if @config.localhost_mode
+        start_localhost_components
+      else
+        SplitIoClient::Engine::SyncManager.new(repositories, @api_key, @config, @sdk_blocker, @metrics).start
+      end
     end
 
     def stop!
@@ -118,15 +121,22 @@ module SplitIoClient
       end
     end
 
-    def start_sse!
-      if @config.push_notification_enabled
-        @splits_worker = SSE::Workers::SplitsWorker.new(@adapter, @config, @splits_repository)
-        @segments_worker = SSE::Workers::SegmentsWorker.new(@adapter, @config, @segments_repository)
-        @control_worker = SSE::Workers::ControlWorker.new(@adapter, @config)
+    def repositories
+      repos = {}
+      repos[:splits] = @splits_repository
+      repos[:segments] = @segments_repository
+      repos[:impressions] = @impressions_repository
+      repos[:events] = @events_repository
+      repos[:metrics] = @metrics_repository
 
-        options = { channels:  'mauro-c', key: 'fake_key', url_host: 'fake-url' }
-        @sse_handler = SSE::SSEHandler.new(@config, options, @splits_worker, @segments_worker, @control_worker)
-      end
+      repos
+    end
+
+    def start_localhost_components
+      LocalhostSplitStore.new(@splits_repository, @config, @sdk_blocker).call
+
+      # Starts thread which loops constantly and cleans up repositories to avoid memory issues in localhost mode
+      LocalhostRepoCleaner.new(@impressions_repository, @metrics_repository, @events_repository, @config).call
     end
   end
 end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class BackOff
+        def initialize(back_off_base, attempt = 0)
+          @attempt = attempt
+          @back_off_base = back_off_base
+        end
+
+        def interval
+          interval = (@back_off_base * (2**@attempt)) if @attempt.positive?
+          @attempt += 1
+
+          interval || 0
+        end
+
+        def reset
+          @attempt = 0
+        end
+      end
+    end
+  end
+end

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

@@ -8,107 +8,117 @@ 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)
-          @uri = URI(url)
+        def initialize(config, read_timeout: DEFAULT_READ_TIMEOUT)
           @config = config
           @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
 
         def on_event(&action)
           @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
+          SplitIoClient::Helpers::ThreadHelper.stop(:connect_stream, @config)
           @socket&.close
-          @socket = nil
+        rescue StandardError => e
+          @config.logger.error("SSEClient close Error: #{e.inspect}")
         end
 
-        def status
-          return Status::CONNECTED if @connected.value
+        def start(url)
+          @uri = URI(url)
 
-          Status::DISCONNECTED
+          connect_thread
+        rescue StandardError => e
+          @config.logger.error("SSEClient start Error: #{e.inspect}")
+        end
+
+        def connected?
+          @connected.value
         end
 
         private
 
         def connect_thread
           @config.threads[:connect_stream] = Thread.new do
+            @config.logger.info('Starting connect_stream thread ...') if @config.debug_enabled
             connect_stream
           end
         end
 
-        def connect_passenger_forked
-          PhusionPassenger.on_event(:starting_worker_process) { |forked| connect_thread if forked }
-        end
-
         def connect_stream
-          @config.logger.info("Connecting to #{@uri.host}...")
+          interval = @back_off.interval
+          sleep(interval) if interval.positive?
 
-          begin
-            @socket = socket_connect
-
-            @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}")
+              partial_data = @socket.readpartial(10_000, timeout: @read_timeout)
+
+              raise 'eof exception' if partial_data == :eof
+            rescue StandardError => e
+              @config.logger.error(e.inspect) if @config.debug_enabled
               @connected.make_false
+              @socket&.close
+              @socket = nil
               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?
-            @config.logger.debug("Event partial data: #{partial_data}")
+        def process_data(partial_data)
+          unless partial_data.nil? || partial_data == KEEP_ALIVE_RESPONSE
+            @config.logger.debug("Event partial data: #{partial_data}") if @config.debug_enabled
             buffer = read_partial_data(partial_data)
-            event = parse_event(buffer)
-
-            dispatch_event(event)
+            parse_event(buffer)
           end
         rescue StandardError => e
-          dispatch_error(e.inspect)
+          @config.logger.error("process_data error: #{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"
-          @config.logger.debug("Request info: #{req}")
+          req << "Cache-Control: no-cache\r\n\r\n"
+          @config.logger.debug("Request info: #{req}") if @config.debug_enabled
           req
         end
 
@@ -120,43 +130,58 @@ module SplitIoClient
         end
 
         def parse_event(buffer)
-          event_type = nil
-          parsed_data = nil
-          client_id = nil
+          type = nil
 
           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)
+              unless type.nil? || data[:data].nil?
+                event = StreamData.new(type, data[:client_id], data[:data], data[:channel])
+                dispatch_event(event)
+              end
             end
           end
+        rescue StandardError => e
+          @config.logger.error("Error during parsing a event: #{e.inspect}")
+        end
 
-          return StreamData.new(event_type, client_id, parsed_data) unless event_type.nil? || parsed_data.nil?
+        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'
 
-          raise 'Invalid event format.'
-        rescue StandardError => e
-          dispatch_error(e.inspect)
-          nil
+          { 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?
+          raise SSEClientException.new(event), 'Error event' if event.event_type == 'error'
+
+          @config.logger.debug("Dispatching event: #{event.event_type}, #{event.channel}") if @config.debug_enabled
+          @on[:event].call(event)
+        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') if @config.debug_enabled
+          @on[:connected].call
         end
-      end
 
-      StreamData = Struct.new(:event_type, :client_id, :data)
+        def dispatch_disconnect
+          @config.logger.debug('Dispatching disconnect') if @config.debug_enabled
+          @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,71 @@
+# frozen_string_literal: true
+
+require 'concurrent/atomics'
+
+module SplitIoClient
+  module SSE
+    class NotificationManagerKeeper
+      def initialize(config)
+        @config = config
+        @publisher_available = Concurrent::AtomicBoolean.new(true)
+        @on = { occupancy: ->(_) {}, push_shutdown: ->(_) {} }
+
+        yield self if block_given?
+      end
+
+      def handle_incoming_occupancy_event(event)
+        if event.data['type'] == 'CONTROL'
+          process_event_control(event.data['controlType'])
+        elsif event.channel == SplitIoClient::Constants::CONTROL_PRI
+          process_event_occupancy(event.data['metrics']['publishers'])
+        end
+      rescue StandardError => e
+        @config.logger.error(e)
+      end
+
+      def on_occupancy(&action)
+        @on[:occupancy] = action
+      end
+
+      def on_push_shutdown(&action)
+        @on[:push_shutdown] = action
+      end
+
+      private
+
+      def process_event_control(type)
+        case type
+        when 'STREAMING_PAUSED'
+          dispatch_occupancy_event(false)
+        when 'STREAMING_RESUMED'
+          dispatch_occupancy_event(true) if @publisher_available.value
+        when 'STREAMING_DISABLED'
+          dispatch_push_shutdown
+        else
+          @config.logger.error("Incorrect event type: #{incoming_notification}")
+        end
+      end
+
+      def process_event_occupancy(publishers)
+        @config.logger.debug("Occupancy process event with #{publishers} publishers") if @config.debug_enabled
+        if publishers <= 0 && @publisher_available.value
+          @publisher_available.make_false
+          dispatch_occupancy_event(false)
+        elsif publishers >= 1 && !@publisher_available.value
+          @publisher_available.make_true
+          dispatch_occupancy_event(true)
+        end
+      end
+
+      def dispatch_occupancy_event(push_enable)
+        @config.logger.debug("Dispatching occupancy event with publisher avaliable: #{push_enable}")
+        @on[:occupancy].call(push_enable)
+      end
+
+      def dispatch_push_shutdown
+        @config.logger.debug('Dispatching push shutdown')
+        @on[:push_shutdown].call
+      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}") if @config.debug_enabled
+        @splits_worker.add_to_queue(notification.data['changeNumber'])
+      end
+
+      def process_split_kill(notification)
+        @config.logger.debug("SPLIT KILL notification received: #{notification}") if @config.debug_enabled
+        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}") if @config.debug_enabled
+        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,73 @@ 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
-
-        @sse_client = start_sse_client
-      end
-
-      private
+        @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)
+        @notification_processor = SplitIoClient::SSE::NotificationProcessor.new(config, @splits_worker, @segments_worker)
+        @sse_client = SSE::EventSource::Client.new(@config) do |client|
+          client.on_event { |event| handle_incoming_message(event) }
+          client.on_connected { process_connected }
+          client.on_disconnect { process_disconnect }
+        end
 
-      def start_sse_client
-        url = "#{@options[:url_host]}/event-stream?channels=#{@options[:channels]}&v=1.1&key=#{@options[:key]}"
+        @on = { connected: ->(_) {}, disconnect: ->(_) {} }
 
-        sse_client = SSE::EventSource::Client.new(url, @config) do |client|
-          client.on_event do |event|
-            process_event(event)
-          end
+        yield self if block_given?
+      end
 
-          client.on_error do |error|
-            process_error(error)
-          end
-        end
+      def start(token_jwt, channels)
+        url = "#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}"
+        @sse_client.start(url)
+      end
 
-        sse_client
+      def stop
+        @sse_client.close
+        stop_workers
+      rescue StandardError => e
+        @config.logger.debug("SSEHandler stop error: #{e.inspect}") if @config.debug_enabled
       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
       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
       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