splitclient-rb 6.3.0 → 8.11.0

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

@@ -0,0 +1,263 @@
+# frozen_string_literal: false
+
+require 'socket'
+require 'openssl'
+require 'uri'
+require 'timeout'
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class Client
+        DEFAULT_READ_TIMEOUT = 70
+        CONNECT_TIMEOUT = 30_000
+        OK_CODE = 200
+        KEEP_ALIVE_RESPONSE = "c\r\n:keepalive\n\n\r\n".freeze
+        ERROR_EVENT_TYPE = 'error'.freeze
+
+        def initialize(config,
+                       api_key,
+                       telemetry_runtime_producer,
+                       event_parser,
+                       notification_manager_keeper,
+                       notification_processor,
+                       status_queue,
+                       read_timeout: DEFAULT_READ_TIMEOUT)
+          @config = config
+          @api_key = api_key
+          @telemetry_runtime_producer = telemetry_runtime_producer
+          @event_parser = event_parser
+          @notification_manager_keeper = notification_manager_keeper
+          @notification_processor = notification_processor
+          @status_queue = status_queue
+          @read_timeout = read_timeout
+          @connected = Concurrent::AtomicBoolean.new(false)
+          @first_event = Concurrent::AtomicBoolean.new(true)
+          @socket = nil
+        end
+
+        def close(status = nil)
+          unless connected?
+            @config.logger.debug('SSEClient already disconected.') if @config.debug_enabled
+            return
+          end
+          @config.logger.debug("Closing SSEClient socket") if @config.debug_enabled
+
+          push_status(status)
+          @connected.make_false
+          @socket.sync_close = true if @socket.is_a? OpenSSL::SSL::SSLSocket
+          @socket.close
+          @config.logger.debug("SSEClient socket state #{@socket.state}") if @socket.is_a? OpenSSL::SSL::SSLSocket && @config.debug_enabled
+        rescue StandardError => e
+          @config.logger.error("SSEClient close Error: #{e.inspect}")
+        end
+
+        def start(url)
+          if connected?
+            @config.logger.debug('SSEClient already running.') if @config.debug_enabled
+            return true
+          end
+
+          @uri = URI(url)
+          latch = Concurrent::CountDownLatch.new(1)
+          connect_thread(latch)
+
+          return false unless latch.wait(CONNECT_TIMEOUT)
+
+          connected?
+        rescue StandardError => e
+          @config.logger.error("SSEClient start Error: #{e.inspect}")
+          connected?
+        end
+
+        def connected?
+          @connected.value
+        end
+
+        private
+
+        def connect_thread(latch)
+          @config.threads[:connect_stream] = Thread.new do
+            @config.logger.info('Starting connect_stream thread ...')
+            new_status = connect_stream(latch)
+            push_status(new_status)
+            @config.logger.info('connect_stream thread finished.')
+          end
+        end
+
+        def connect_stream(latch)
+          return Constants::PUSH_NONRETRYABLE_ERROR unless socket_write(latch)
+          while connected? || @first_event.value
+            begin 
+              if IO.select([@socket], nil, nil, @read_timeout)
+                begin
+                  partial_data = @socket.readpartial(10_000)
+                  read_first_event(partial_data, latch)
+
+                  raise 'eof exception' if partial_data == :eof
+                rescue IO::WaitReadable => e
+                  @config.logger.debug("SSE client IO::WaitReadable transient error: #{e.inspect}") if @config.debug_enabled
+                  IO.select([@socket], nil, nil, @read_timeout)
+                  retry
+                rescue  Errno::EAGAIN => e
+                  @config.logger.debug("SSE client transient error: #{e.inspect}") if @config.debug_enabled
+                  IO.select([@socket], nil, nil, @read_timeout)
+                  retry
+                rescue Errno::ETIMEDOUT => e
+                  @config.logger.error("SSE read operation timed out!: #{e.inspect}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                rescue EOFError => e
+                  @config.logger.error("SSE read operation EOF Exception!: #{e.inspect}")
+                  raise 'eof exception'
+                rescue Errno::EBADF, IOError => e
+                  @config.logger.error("SSE read operation EBADF or IOError: #{e.inspect}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                rescue StandardError => e
+                  @config.logger.error("SSE read operation StandardError: #{e.inspect}")
+                  return nil if ENV['SPLITCLIENT_ENV'] == 'test'
+
+                  @config.logger.error("Error reading partial data: #{e.inspect}")
+                  return Constants::PUSH_RETRYABLE_ERROR
+                end
+              else
+                @config.logger.error("SSE read operation timed out, no data available.")
+                return Constants::PUSH_RETRYABLE_ERROR
+              end
+            rescue Errno::EBADF
+              @config.logger.debug("SSE socket is not connected (Errno::EBADF)") if @config.debug_enabled
+              break
+            rescue RuntimeError
+              raise 'eof exception'
+            rescue Exception => e
+              @config.logger.debug("SSE socket is not connected: #{e.inspect}") if @config.debug_enabled
+              break
+            end
+
+            process_data(partial_data)
+          end
+          @config.logger.info("SSE read operation exited: #{connected?}")
+
+          nil
+        end
+
+        def socket_write(latch)
+          @first_event.make_true
+          @socket = socket_connect
+          @socket.puts(build_request(@uri))
+          true
+        rescue StandardError => e
+          @config.logger.error("Error during connecting to #{@uri.host}. Error: #{e.inspect}")
+          latch.count_down
+          false
+        end
+
+        def read_first_event(data, latch)
+          return unless @first_event.value
+
+          response_code = @event_parser.first_event(data)
+          @config.logger.debug("SSE client first event code: #{response_code}") if @config.debug_enabled
+
+          error_event = false
+          events = @event_parser.parse(data)
+          events.each { |e| error_event = true if e.event_type == ERROR_EVENT_TYPE }
+          @first_event.make_false
+
+          if response_code == OK_CODE && !error_event
+            @connected.make_true
+            @config.logger.debug("SSE client first event Connected is true") if @config.debug_enabled
+            @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::SSE_CONNECTION_ESTABLISHED, nil)
+            push_status(Constants::PUSH_CONNECTED)
+          end
+
+          latch.count_down
+        end
+
+        def socket_connect
+          tcp_socket = TCPSocket.new(@uri.host, @uri.port)
+          if @uri.scheme.casecmp('https').zero?
+            begin
+              ssl_context = OpenSSL::SSL::SSLContext.new
+              ssl_socket = OpenSSL::SSL::SSLSocket.new(tcp_socket, ssl_context)
+              ssl_socket.hostname = @uri.host
+
+              begin
+                ssl_socket.connect_nonblock
+              rescue IO::WaitReadable
+                IO.select([ssl_socket])
+                retry
+              rescue IO::WaitWritable
+                IO.select(nil, [ssl_socket])
+                retry
+              end
+              return ssl_socket
+
+            rescue Exception => e
+              @config.logger.error("socket connect error: #{e.inspect}")
+              return nil
+            end
+          end
+
+          tcp_socket
+        end
+
+        def process_data(partial_data)
+          @config.logger.debug("Event partial data: #{partial_data}") if @config.debug_enabled
+          return if partial_data.nil? || partial_data == KEEP_ALIVE_RESPONSE
+
+          events = @event_parser.parse(partial_data)
+          events.each { |event| process_event(event) }
+        rescue StandardError => e
+          @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 << "SplitSDKVersion: #{@config.language}-#{@config.version}\r\n"
+          req << "SplitSDKMachineIP: #{@config.machine_ip}\r\n"
+          req << "SplitSDKMachineName: #{@config.machine_name}\r\n"
+          req << "SplitSDKClientKey: #{@api_key.split(//).last(4).join}\r\n" unless @api_key.nil?
+          req << "Cache-Control: no-cache\r\n\r\n"
+          @config.logger.debug("Request info: #{req}") if @config.debug_enabled
+          req
+        end
+
+        def process_event(event)
+          case event.event_type
+          when ERROR_EVENT_TYPE
+            dispatch_error(event)
+          else
+            dispatch_event(event)
+          end
+        end
+
+        def dispatch_error(event)
+          @config.logger.error("Event error: #{event.event_type}, #{event.data}")
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::ABLY_ERROR, event.data['code'])
+
+          if event.data['code'] >= 40_140 && event.data['code'] <= 40_149
+            close(Constants::PUSH_RETRYABLE_ERROR)
+          elsif event.data['code'] >= 40_000 && event.data['code'] <= 49_999
+            close(Constants::PUSH_NONRETRYABLE_ERROR)
+          end
+        end
+
+        def dispatch_event(event)
+          if event.occupancy?
+            @notification_manager_keeper.handle_incoming_occupancy_event(event)
+          else
+            @notification_processor.process(event)
+          end
+        end
+
+        def push_status(status)
+          return if status.nil?
+          
+          @config.logger.debug("Pushing new sse status: #{status}") if @config.debug_enabled
+          @status_queue.push(status)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: false
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class EventParser
+        BAD_REQUEST_CODE = 400
+
+        def initialize(config)
+          @config = config
+        end
+
+        def parse(raw_event)
+          type = nil
+          events = []
+          buffer = read_partial_data(raw_event)
+
+          buffer.each do |d|
+            splited_data = d.split(':')
+
+            case splited_data[0]
+            when 'event'
+              type = splited_data[1].strip
+            when '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
+
+          events
+        rescue StandardError => e
+          @config.logger.debug("Error during parsing a event: #{e.inspect}") if @config.debug_enabled
+          []
+        end
+
+        def first_event(raw_data)
+          raw_data.split("\n")[0].split(' ')[1].to_i
+        rescue StandardError => e
+          @config.logger.error("Error parsing first event: #{e.inspect}")
+          BAD_REQUEST_CODE
+        end
+
+        private
+
+        def parse_event_data(data, type)
+          data_value = data.sub('data:', '')
+          event_data = JSON.parse(data_value.strip)
+          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 read_partial_data(data)
+          buffer = ''
+          buffer << data
+          buffer.chomp!
+          buffer.split("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    module EventSource
+      class EventTypes
+        SPLIT_UPDATE = 'SPLIT_UPDATE'
+        SPLIT_KILL = 'SPLIT_KILL'
+        SEGMENT_UPDATE = 'SEGMENT_UPDATE'
+        CONTROL = 'CONTROL'
+        RB_SEGMENT_UPDATE = 'RB_SEGMENT_UPDATE'
+      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,84 @@
+# frozen_string_literal: true
+
+require 'concurrent'
+
+module SplitIoClient
+  module SSE
+    class NotificationManagerKeeper
+      DISABLED = 0
+      ENABLED = 1
+      PAUSED = 2
+
+      def initialize(config, telemetry_runtime_producer, status_queue)
+        @config = config
+        @telemetry_runtime_producer = telemetry_runtime_producer
+        @status_queue = status_queue
+        @publisher_available = Concurrent::AtomicBoolean.new(true)
+        @publishers_pri = Concurrent::AtomicFixnum.new(2)
+        @publishers_sec = Concurrent::AtomicFixnum.new(2)
+      end
+
+      def handle_incoming_occupancy_event(event)
+        if event.data['type'] == 'CONTROL'
+          process_event_control(event.data['controlType'])
+        else
+          process_event_occupancy(event.channel, event.data['metrics']['publishers'])
+        end
+      rescue StandardError => e
+        @config.logger.error(e)
+      end
+
+      private
+
+      def process_event_control(type)
+        case type
+        when 'STREAMING_PAUSED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, PAUSED)
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
+        when 'STREAMING_RESUMED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, ENABLED)
+          push_status(Constants::PUSH_SUBSYSTEM_READY) if @publisher_available.value
+        when 'STREAMING_DISABLED'
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::STREAMING_STATUS, DISABLED)
+          push_status(Constants::PUSH_SUBSYSTEM_OFF)
+        else
+          @config.logger.error("Incorrect event type: #{incoming_notification}") if @config.debug_enabled
+        end
+      end
+
+      def process_event_occupancy(channel, publishers)
+        @config.logger.debug("Processed occupancy event with #{publishers} publishers. Channel: #{channel}") if @config.debug_enabled
+
+        update_publishers(channel, publishers)
+
+        if !are_publishers_available? && @publisher_available.value
+          @publisher_available.make_false
+          push_status(Constants::PUSH_SUBSYSTEM_DOWN)
+        elsif are_publishers_available? && !@publisher_available.value
+          @publisher_available.make_true
+          push_status(Constants::PUSH_SUBSYSTEM_READY)
+        end
+      end
+
+      def update_publishers(channel, publishers)
+        case channel
+        when Constants::CONTROL_PRI
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::OCCUPANCY_PRI, publishers)
+          @publishers_pri.value = publishers
+        when Constants::CONTROL_SEC
+          @telemetry_runtime_producer.record_streaming_event(Telemetry::Domain::Constants::OCCUPANCY_SEC, publishers)
+          @publishers_sec.value = publishers
+        end
+      end
+
+      def are_publishers_available?
+        @publishers_pri.value.positive? || @publishers_sec.value.positive?
+      end
+
+      def push_status(status)
+        @config.logger.debug("Pushing occupancy status: #{status}") if @config.debug_enabled
+        @status_queue.push(status)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# 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::RB_SEGMENT_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("#{notification.event_type} notification received: #{notification}") if @config.debug_enabled
+        @splits_worker.add_to_queue(notification)
+      end
+
+      def process_split_kill(notification)
+        @config.logger.debug("SPLIT KILL notification received: #{notification}") if @config.debug_enabled
+        @splits_worker.add_to_queue(notification)
+      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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    class SSEHandler
+      attr_reader :sse_client
+
+      def initialize(config,
+                     splits_worker,
+                     segments_worker,
+                     sse_client)
+        @config = config
+        @splits_worker = splits_worker
+        @segments_worker = segments_worker
+        @sse_client = sse_client
+      end
+
+      def start(token_jwt, channels)
+        @sse_client.start("#{@config.streaming_service_url}?channels=#{channels}&v=1.1&accessToken=#{token_jwt}")
+      end
+
+      def stop
+        @sse_client.close(Constants::PUSH_FORCED_STOP)
+        stop_workers
+      rescue StandardError => e
+        @config.logger.debug("SSEHandler stop error: #{e.inspect}") if @config.debug_enabled
+      end
+
+      def connected?
+        @sse_client&.connected? || false
+      end
+
+      def start_workers
+        @splits_worker.start
+        @segments_worker.start
+      end
+
+      def stop_workers
+        @splits_worker.stop
+        @segments_worker.stop
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SplitIoClient
+  module SSE
+    module Workers
+      class SegmentsWorker
+        def initialize(synchronizer, config, segments_repository)
+          @synchronizer = synchronizer
+          @config = config
+          @segments_repository = segments_repository
+          @queue = Queue.new
+          @running = Concurrent::AtomicBoolean.new(false)
+        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}") if @config.debug_enabled
+          @queue.push(item)
+        end
+
+        def start
+          if @running.value
+            @config.logger.debug('segments worker already running.') if @config.debug_enabled
+            return
+          end
+
+          @running.make_true
+          perform_thread
+        end
+
+        def stop
+          unless @running.value
+            @config.logger.debug('segments worker not running.') if @config.debug_enabled
+            return
+          end
+
+          @running.make_false
+          SplitIoClient::Helpers::ThreadHelper.stop(:segment_update_worker, @config)
+        end
+
+        private
+
+        def perform
+          while (item = @queue.pop)
+            segment_name = item[:segment_name]
+            cn = item[:change_number]
+            @config.logger.debug("SegmentsWorker change_number dequeue #{segment_name}, #{cn}") if @config.debug_enabled
+
+            @synchronizer.fetch_segment(segment_name, cn)
+          end
+        end
+
+        def perform_thread
+          @config.threads[:segment_update_worker] = Thread.new do
+            @config.logger.debug('Starting segments worker ...') if @config.debug_enabled
+            perform
+          end
+        end
+      end
+    end
+  end
+end