kameleoon-client-ruby 3.22.1 → 3.23.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,106 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- # Kameleoon Real Time Event Service
4
-
5
- require 'json'
6
- require 'kameleoon/logging/kameleoon_logger'
7
- require 'kameleoon/real_time/real_time_event'
8
- require 'kameleoon/real_time/sse_request'
9
- require 'kameleoon/real_time/sse_client'
10
-
11
- module Kameleoon
12
- module RealTime
13
- DATA_FILE_UPDATE_EVENT = 'configuration-update-event'
14
-
15
- ##
16
- # RealTimeEventService is used for fetching updates of configuration
17
- # (experiments and feature flags) in real time.
18
- class RealTimeEventService
19
- # Delay before re-establishing a failed SSE connection, so a persistent
20
- # failure does not turn into a hot reconnect loop.
21
- RECONNECT_DELAY_SECONDS = 3
22
-
23
- ##
24
- # Parametrized initializer.
25
- #
26
- # @param url [String]
27
- # @param update_handler [Callable[Kameleoon::RealTime::RealTimeEvent] | NilClass] Handler which
28
- # is synchronously called for gotten RealTimeEvent objects.
29
- # @param reconnect_delay [Numeric] Delay in seconds before a reconnect attempt.
30
- def initialize(url, update_handler, sse_request_source = nil, reconnect_delay: RECONNECT_DELAY_SECONDS)
31
- @url = url
32
- @update_handler = update_handler
33
- @need_close = false
34
- @headers = {
35
- 'Accept': 'text/event-stream',
36
- 'Cache-Control': 'no-cache',
37
- 'Connection': 'Keep-Alive'
38
- }
39
- @sse_request_source = sse_request_source
40
- @reconnect_delay = reconnect_delay
41
- @sse_thread = nil
42
- @sse_client = nil
43
- create_sse_client
44
- end
45
-
46
- ##
47
- # Closes the connection to the server.
48
- def close
49
- return if @need_close
50
-
51
- Logging::KameleoonLogger.info('Real-time event service is shutting down')
52
- @need_close = true
53
- return if @sse_thread.nil?
54
-
55
- @sse_thread.kill
56
- @sse_thread = nil
57
- @sse_client&.call_close_handler
58
- end
59
-
60
- private
61
-
62
- def create_sse_client
63
- @sse_thread = Thread.new { run_sse_client } unless @need_close
64
- end
65
-
66
- def init_sse_client
67
- message_handler = proc do |message|
68
- Logging::KameleoonLogger.debug("Got SSE event: #{message.event}")
69
- if message.event == DATA_FILE_UPDATE_EVENT
70
- event_dict = JSON.parse(message.data)
71
- @update_handler&.call(RealTimeEvent.new(event_dict))
72
- end
73
- end
74
- sse_request = make_sse_request
75
- @sse_client = SseClient.new(sse_request, message_handler)
76
- Logging::KameleoonLogger.info('Created SSE client')
77
- end
78
-
79
- def make_sse_request
80
- open_handler = proc { Logging::KameleoonLogger.info('SSE connection open') }
81
- close_handler = proc { Logging::KameleoonLogger.info('SSE connection closed') }
82
- unexpected_status_code_handler =
83
- proc { |resp| Logging::KameleoonLogger.error("Unexpected status code of SSE response: #{resp.code}") }
84
- if @sse_request_source.nil?
85
- return SseRequest.new(@url, @headers, open_handler, close_handler, unexpected_status_code_handler)
86
- end
87
-
88
- @sse_request_source.call(@url, @headers, open_handler, close_handler, unexpected_status_code_handler)
89
- end
90
-
91
- def run_sse_client
92
- until @need_close
93
- init_sse_client
94
- begin
95
- @sse_client.start
96
- rescue StandardError => e
97
- Logging::KameleoonLogger.error("Error occurred within SSE client: #{e}")
98
- end
99
- # The delay is applied to every re-establishment (a failed connection and
100
- # a dropped stream alike), so a persistent failure cannot produce a hot loop.
101
- sleep(@reconnect_delay) unless @need_close
102
- end
103
- end
104
- end
105
- end
106
- end
@@ -1,113 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require 'kameleoon/real_time/sse_message'
4
-
5
- # TODO: Fix hanging (https://project.kameleoon.net/issues/26520)
6
-
7
- module Kameleoon
8
- module RealTime
9
- ##
10
- # SseClient is used to interpret SSE event stream.
11
- class SseClient
12
- ##
13
- # Parametrized initializer.
14
- #
15
- # @param sse_request [Kameleoon::RealTime::SseRequest] Used to access SSE event stream.
16
- # @param message_handler [Callable[Kameleoon::RealTime::SseMessage] | NilClass] Callable object which
17
- # is synchronously called for received SSE messages.
18
- def initialize(sse_request, message_handler)
19
- @sse_request = sse_request
20
- @message_handler = message_handler
21
-
22
- @cr_prev = nil
23
- @buffer = nil
24
- @data_buffer = nil
25
- @event = nil
26
- @id = nil
27
- @reconnection_time = nil
28
-
29
- @sse_request.resp_char_handler = method(:process_char)
30
- end
31
-
32
- ##
33
- # Starts SSE connection and stay in the loop until close.
34
- def start
35
- @cr_prev = false
36
- @data_buffer = []
37
- @event = nil
38
- @id = nil
39
- @buffer = []
40
- @sse_request.start
41
- end
42
-
43
- ##
44
- # Calls @sse_request@close_handler if it is not nil.
45
- def call_close_handler
46
- @sse_request.call_close_handler
47
- end
48
-
49
- private
50
-
51
- def process_char(ch)
52
- if @cr_prev && (ch == "\n")
53
- @cr_prev = false
54
- return
55
- end
56
- @cr_prev = ch == "\r"
57
- if @cr_prev || (ch == "\n")
58
- line = @buffer.join
59
- @buffer.clear
60
- if line.empty?
61
- dispatch_event
62
- else
63
- handle_line(line)
64
- end
65
- return
66
- end
67
- @buffer << ch
68
- end
69
-
70
- def handle_line(line)
71
- field, value = parse_line(line)
72
- return if field.nil?
73
-
74
- case field
75
- when 'event'
76
- @event = value
77
- when 'data'
78
- @data_buffer << value
79
- when 'id'
80
- @id = value
81
- when 'retry'
82
- @reconnection_time = value.to_i # This does not affect anything
83
- end
84
- end
85
-
86
- def parse_line(line)
87
- colon_index = line.index(':')
88
- return line, nil if colon_index.nil?
89
- return nil, nil if colon_index.zero?
90
-
91
- field = line[0, colon_index]
92
- return field, '' if colon_index + 1 == line.length
93
-
94
- value = if line[colon_index + 1] == ' '
95
- line[colon_index + 2..]
96
- else
97
- line[colon_index + 1..]
98
- end
99
- [field, value]
100
- end
101
-
102
- def dispatch_event
103
- return unless !@event.nil? || !@data_buffer.empty? # Ignoring empty events
104
-
105
- data = @data_buffer.join("\n")
106
- message = SseMessage.new(@event, @id, data)
107
- @event = nil
108
- @data_buffer.clear
109
- @message_handler&.call(message)
110
- end
111
- end
112
- end
113
- end
@@ -1,23 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- module Kameleoon
4
- module RealTime
5
- ##
6
- # SseMessage is a container for a received SSE message.
7
- class SseMessage
8
- attr_reader :event, :id, :data
9
-
10
- ##
11
- # Parametrized initializer.
12
- #
13
- # @param event [String]
14
- # @param id [String]
15
- # @param data [String]
16
- def initialize(event, id, data)
17
- @event = event
18
- @id = id
19
- @data = data
20
- end
21
- end
22
- end
23
- end
@@ -1,59 +0,0 @@
1
- # frozen_string_literal: true
2
-
3
- require 'restclient'
4
-
5
- module Kameleoon
6
- module RealTime
7
- ##
8
- # SseRequest is used keep SSE connection and read from its stream.
9
- class SseRequest
10
- attr_writer :resp_char_handler
11
-
12
- ##
13
- # Parametrized initializer.
14
- #
15
- # @param url [String]
16
- # @param headers [Hash]
17
- # @param open_handler [Callable | NilClass] Handler which is synchronously called when SSE connection is open.
18
- # @param close_handler [Callable | NilClass] Handler which is synchronously called when SSE connection is closed.
19
- # @param unexpected_status_code_handler [Callable[Net::HTTPResponse] | NilClass] Handler whick
20
- # is synchronously called for responses with not 200 status code.
21
- def initialize(url, headers, open_handler, close_handler, unexpected_status_code_handler)
22
- @url = url
23
- @headers = headers
24
- @open_handler = open_handler
25
- @close_handler = close_handler
26
- @unexpected_status_code_handler = unexpected_status_code_handler
27
-
28
- @resp_char_handler = nil
29
- end
30
-
31
- ##
32
- # Starts SSE connection and stay in the loop until close.
33
- def start
34
- RestClient::Request.execute(method: :get, url: @url, headers: @headers, read_timeout: nil,
35
- block_response: method(:handle_resp))
36
- end
37
-
38
- ##
39
- # Calls @close_handler if it is not nil.
40
- def call_close_handler
41
- @close_handler&.call
42
- end
43
-
44
- private
45
-
46
- def handle_resp(resp)
47
- @open_handler&.call
48
- if resp.code == '200'
49
- resp.read_body do |chunk|
50
- chunk.each_char { |ch| @resp_char_handler&.call(ch) }
51
- end
52
- else
53
- @unexpected_status_code_handler&.call(resp)
54
- end
55
- call_close_handler
56
- end
57
- end
58
- end
59
- end