ld-celluloid-eventsource 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8bd8fda8554cfa1dba5eb39bbf50070aa0d7106b
-  data.tar.gz: a16e16201da0c651b4528b4f213230e0200b743e
+  metadata.gz: d2311a2b7704096d17f374aac47e599e87c69541
+  data.tar.gz: 03e6a782b9ae04bfc6f52da8958baa8344755a75
 SHA512:
-  metadata.gz: d1d605c0cebbb138c600e8893760c7819237238c58cd20650c419cc9a79f98d3edea814698e25a627ad1767b2fe14e840696ae2de668dcaf10853a4709017dce
-  data.tar.gz: 8771be4c7e0dafce34b50018d4d9719460940c15eb86ea059c6bc140d96dbc2e0e1db079308868e09e48dd8869d80a50b5904f8bd16d5dc003a460354a93f993
+  metadata.gz: 10e03560e84e12a05124523bbc0580dd4c72baaa67f59fb42c9747b7fbd485371a1d40a858f1627bc8ecba632e6e8742af0eee2b32f92c37dc9e0e507c689b28
+  data.tar.gz: 2bd535c2616ca1189558078d658e69ccafd05f68cc5286fc9298a07c5a14142bf9d2d8938952a569d032d4d5d8be373127176b251e89c060b72a4e2fe785d0f0

data/ld-celluloid-eventsource.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'celluloid-io', '~> 0.17.3'
   spec.add_dependency 'celluloid', '~> 0.18.0.pre'
-  spec.add_dependency 'nio4r', '~> 1.1'
+  spec.add_dependency 'nio4r', '>= 1.1'
   spec.add_dependency 'http_parser.rb', '~> 0.6.0'
 
   spec.add_development_dependency 'atomic', '~> 1.1'

data/lib/celluloid/eventsource.rb

@@ -1,6 +1,7 @@
 require 'celluloid/current'
 require 'celluloid/eventsource/version'
 require 'celluloid/io'
+require 'celluloid/eventsource/event_parser'
 require 'celluloid/eventsource/response_parser'
 require 'uri'
 require 'base64'
@@ -8,8 +9,15 @@ require 'base64'
 module Celluloid
   class EventSource
     include Celluloid::IO
+    include Celluloid::Internals::Logger
     Celluloid.boot
 
+    class UnexpectedContentType < StandardError
+    end
+
+    class ReadTimeout < StandardError
+    end
+
     attr_reader :url, :with_credentials
     attr_reader :ready_state
 
@@ -17,14 +25,28 @@ module Celluloid
     OPEN = 1
     CLOSED = 2
 
+    MAX_RECONNECT_TIME = 30
+
     execute_block_on_receiver :initialize
 
+    #
+    # Constructor for an EventSource.
+    #
+    # @param uri [String] the event stream URI
+    # @param opts [Hash] the configuration options
+    # @option opts [Hash] :headers Headers to send with the request
+    # @option opts [Float] :read_timeout Timeout (in seconds) after which to restart the connection if
+    #  the server has sent no data
+    # @option opts [Float] :reconnect_delay Initial delay (in seconds) between connection attempts; this will
+    #  be increased exponentially if there are repeated failures
+    #
     def initialize(uri, options = {})
       self.url = uri
       options  = options.dup
       @ready_state = CONNECTING
       @with_credentials = options.delete(:with_credentials) { false }
       @headers = default_request_headers.merge(options.fetch(:headers, {}))
+      @read_timeout = options.fetch(:read_timeout, 0).to_i
       proxy = ENV['HTTP_PROXY'] || ENV['http_proxy'] || options[:proxy]
       if proxy
         proxyUri = URI(proxy)
@@ -33,15 +55,8 @@ module Celluloid
         end
       end
 
-      @event_type_buffer = ""
-      @last_event_id_buffer = ""
-      @data_buffer = ""
-
-      @last_event_id = String.new
-
-      @reconnect_timeout = 1
+      @reconnect_timeout = options.fetch(:reconnect_delay, 1)
       @on = { open: ->{}, message: ->(_) {}, error: ->(_) {} }
-      @parser = ResponseParser.new
 
       @chunked = false
 
@@ -66,11 +81,13 @@ module Celluloid
       while !closed?
         begin
           establish_connection
-          chunked? ? process_chunked_stream : process_stream
-        rescue
-          # Just reconnect
+          process_stream
+        rescue UnexpectedContentType
+          raise  # Let these flow to the top
+        rescue StandardError => e
+          info "Reconnecting after exception: #{e}"
+          # Just reconnect on runtime errors
         end
-        sleep @reconnect_timeout        
       end
     end
 
@@ -97,54 +114,79 @@ module Celluloid
 
     private
 
-    MessageEvent = Struct.new(:type, :data, :last_event_id)
-
     def ssl?
       url.scheme == 'https'
     end
 
     def establish_connection
-      if @proxy
-        sock = ::TCPSocket.new(@proxy.host, @proxy.port)
-        @socket = Celluloid::IO::TCPSocket.new(sock)
-
-        @socket.write(connect_string)
-        @socket.flush
-        while (line = @socket.readline.chomp) != '' do @parser << line end
+      parser = ResponseParser.new
+      reconnect_attempts = 0
+      reconnect_jitter_rand = Random.new
 
-        unless @parser.status_code == 200
-          @on[:error].call({status_code: @parser.status_code, body: @parser.chunk})
-          return
+      loop do
+        begin
+          if @proxy
+            sock = ::TCPSocket.new(@proxy.host, @proxy.port)
+            @socket = Celluloid::IO::TCPSocket.new(sock)
+
+            @socket.write(connect_string)
+            @socket.flush
+            while (line = readline_with_timeout(@socket).chomp) != '' do parser << line end
+
+            unless parser.status_code == 200
+              @on[:error].call({status_code: parser.status_code, body: parser.chunk})
+              return
+            end
+          else
+            sock = ::TCPSocket.new(@url.host, @url.port)
+            @socket = Celluloid::IO::TCPSocket.new(sock)
+          end
+
+          if ssl?
+            @socket = Celluloid::IO::SSLSocket.new(@socket)
+            @socket.connect
+          end
+
+          @socket.write(request_string)
+          @socket.flush()
+
+          until parser.headers?
+            parser << readline_with_timeout(@socket)
+          end
+
+          if parser.status_code != 200
+            until @socket.eof?
+              parser << readline_with_timeout(@socket)
+            end
+            # If the server returns a non-200, we don't want to close-- we just want to
+            # report an error
+            # close
+            @on[:error].call({status_code: parser.status_code, body: parser.chunk})
+          elsif parser.headers['Content-Type'] && parser.headers['Content-Type'].include?("text/event-stream")
+            @chunked = !parser.headers["Transfer-Encoding"].nil? && parser.headers["Transfer-Encoding"].include?("chunked")
+            @ready_state = OPEN
+            @on[:open].call
+            return  # Success, don't retry
+          else
+            close
+            info "Invalid Content-Type #{parser.headers['Content-Type']}"
+            @on[:error].call({status_code: parser.status_code, body: "Invalid Content-Type #{parser.headers['Content-Type']}. Expected text/event-stream"})
+            raise UnexpectedContentType
+          end
+
+        rescue UnexpectedContentType
+          raise  # Let these flow to the top
+
+        rescue StandardError => e
+          warn "Waiting to try again after exception while connecting: #{e}"
+          # Just try again after a delay for any other exceptions
         end
-      else
-        sock = ::TCPSocket.new(@url.host, @url.port)
-        @socket = Celluloid::IO::TCPSocket.new(sock)
-      end
 
-      if ssl?
-        @socket = Celluloid::IO::SSLSocket.new(@socket)
-        @socket.connect
+        base_sleep_time = ([@reconnect_timeout * (2 ** reconnect_attempts), MAX_RECONNECT_TIME].min).to_f
+        sleep_time = (base_sleep_time / 2) + reconnect_jitter_rand.rand(base_sleep_time / 2)
+        sleep sleep_time
+        reconnect_attempts += 1
       end
-
-      @socket.write(request_string)
-      @socket.flush()
-
-      until @parser.headers?
-        @parser << @socket.readline
-      end
-
-      if @parser.status_code != 200
-        until @socket.eof?
-          @parser << @socket.readline
-        end
-        # If the server returns a non-200, we don't want to close-- we just want to
-        # report an error
-        # close
-        @on[:error].call({status_code: @parser.status_code, body: @parser.chunk})
-        return
-      end
-
-      handle_headers(@parser.headers)
     end
 
     def default_request_headers
@@ -155,100 +197,59 @@ module Celluloid
       }
     end
 
-    def clear_buffers!
-      @data_buffer = ""
-      @event_type_buffer = ""
-    end
-
-    def dispatch_event(event)
-      unless closed?
-        @on[event.type] && @on[event.type].call(event)
-      end
-    end
-
     def chunked?
       @chunked
     end
 
-    def process_chunked_stream
-      until closed? || @socket.eof?
-        handle_chunked_stream
-      end
-    end
-
-    def process_stream
-      until closed? || @socket.eof?
-        line = @socket.readline
-        line.strip.empty? ? process_event : parse_line(line)
-      end
-    end
-
-    def handle_chunked_stream
-      chunk_header = @socket.readline
-      bytes_to_read = chunk_header.to_i(16)
-      bytes_read = 0
-      while bytes_read < bytes_to_read do
-        line = @socket.readline
-        bytes_read += line.size
-
-        line.strip.empty? ? process_event : parse_line(line)
-      end
-
-      if !line.nil? && line.strip.empty?
-        process_event
+    def read_chunked_lines(socket)
+      Enumerator.new do |lines|
+        chunk_header = readline_with_timeout(socket)
+        bytes_to_read = chunk_header.to_i(16)
+        bytes_read = 0
+        while bytes_read < bytes_to_read do
+          line = readline_with_timeout(@socket)
+          bytes_read += line.size
+          lines << line
+        end
       end
     end
 
-    def parse_line(line)
-      case line
-      when /^:.*$/
-      when /^(\w+): ?(.*)$/
-        process_field($1, $2)
-      else
-        if chunked? && !@data_buffer.empty?
-          @data_buffer.rstrip!
-          process_field("data", line.rstrip)
+    def read_lines
+      Enumerator.new do |lines|
+        loop do
+          break if closed?
+          if chunked?
+            for line in read_chunked_lines(@socket) do
+              break if closed?
+              lines << line
+            end
+          else
+            lines << readline_with_timeout(@socket)
+          end
         end
       end
     end
 
-    def process_event
-      @last_event_id = @last_event_id_buffer
-
-      return if @data_buffer.empty?
-
-      @data_buffer.chomp!("\n") if @data_buffer.end_with?("\n")
-      event = MessageEvent.new(:message, @data_buffer, @last_event_id)
-      event.type = @event_type_buffer.to_sym unless @event_type_buffer.empty?
-
-      dispatch_event(event)
-    ensure
-      clear_buffers!
-    end
-
-    def process_field(field_name, field_value)
-      case field_name
-      when "event"
-        @event_type_buffer = field_value
-      when "data"
-        @data_buffer << field_value.concat("\n")
-      when "id"
-        @last_event_id_buffer = field_value
-      when "retry"
-        if /^(?<num>\d+)$/ =~ field_value
-          @reconnect_timeout = num.to_i
-        end
+    def process_stream
+      parser = EventParser.new(read_lines, @chunked,->(timeout) { @read_timeout = timeout })
+      parser.each do |event|
+        @on[event.type] && @on[event.type].call(event)
+        @last_event_id = event.id
       end
     end
 
-    def handle_headers(headers)
-      if headers['Content-Type'].include?("text/event-stream")
-        @chunked = !headers["Transfer-Encoding"].nil? && headers["Transfer-Encoding"].include?("chunked")
-        @ready_state = OPEN
-        @on[:open].call
+    def readline_with_timeout(socket)
+      if @read_timeout > 0
+        begin
+          timeout(@read_timeout) do
+            socket.readline
+          end
+        rescue Celluloid::TaskTimeout
+          @on[:error].call({body: "Read timeout, will attempt reconnection"})
+          raise ReadTimeout
+        end
       else
-        close
-        @on[:error].call({status_code: @parser.status_code, body: "Invalid Content-Type #{headers['Content-Type']}. Expected text/event-stream"})
+        return socket.readline
       end
     end
 
@@ -267,7 +268,5 @@ module Celluloid
       end
       req << "\r\n"
     end
-
   end
-
 end

data/lib/celluloid/eventsource/event_parser.rb

@@ -0,0 +1,76 @@
+module Celluloid
+  class EventSource
+    class EventParser
+      include Enumerable
+
+      def initialize(lines, chunked, on_retry)
+        @lines = lines
+        @chunked = chunked
+        clear_buffers!
+        @on_retry = on_retry
+      end
+
+      def each
+        @lines.each do |line|
+          if line.strip.empty?
+            begin
+              event = create_event
+              yield event unless event.nil?
+            ensure
+              clear_buffers!
+            end
+          else
+            parse_line(line)
+          end
+        end
+      end
+
+      private
+
+      MessageEvent = Struct.new(:type, :data, :id)
+
+      def clear_buffers!
+        @id_buffer = ''
+        @data_buffer = ''
+        @type_buffer = ''
+      end
+
+      def parse_line(line)
+        case line
+          when /^:.*$/
+          when /^(\w+): ?(.*)$/
+            process_field($1, $2)
+          else
+            if @chunked && !@data_buffer.empty?
+              @data_buffer.rstrip!
+              process_field("data", line.rstrip)
+            end
+        end
+      end
+
+      def create_event
+        return nil if @data_buffer.empty?
+
+        @data_buffer.chomp!("\n") if @data_buffer.end_with?("\n")
+        event = MessageEvent.new(:message, @data_buffer, @id_buffer)
+        event.type = @type_buffer.to_sym unless @type_buffer.empty?
+        event
+      end
+
+      def process_field(field_name, field_value)
+        case field_name
+          when "event"
+            @type_buffer = field_value
+          when "data"
+            @data_buffer << field_value.concat("\n")
+          when "id"
+            @id_buffer = field_value
+          when "retry"
+            if /^(?<num>\d+)$/ =~ field_value
+              @on_retry.call(num.to_i)
+            end
+        end
+      end
+    end
+  end
+end

data/lib/celluloid/eventsource/version.rb

@@ -1,5 +1,5 @@
 module Celluloid
   class EventSource
-    VERSION = "0.10.0"
+    VERSION = "0.11.0"
   end
 end

data/spec/celluloid/eventsource/event_parser_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+RSpec.describe Celluloid::EventSource::EventParser do
+  it 'converts lines to events' do
+    lines =  <<LINES
+id: 123
+event: my-event
+data: my-data
+
+LINES
+    events = Celluloid::EventSource::EventParser.new(lines.lines, false, ->(r) {}).to_a
+    expect(events.length).to eq 1
+    expect(events[0].id).to eq '123'
+    expect(events[0].type).to eq 'my-event'.to_sym
+    expect(events[0].data).to eq 'my-data'
+  end
+
+  it 'ignores comments' do
+    lines =  <<LINES
+: comment
+id: 123
+event: my-event
+data: my-data
+
+
+LINES
+    events = Celluloid::EventSource::EventParser.new(lines.lines, false, ->(r) {}).to_a
+    expect(events.length).to eq 1
+    expect(events[0].id).to eq '123'
+  end
+
+  it 'resets values after each event' do
+    lines =  <<LINES
+id: 123
+event: my-event
+data: my-data
+
+event: my-event2
+data: my-data2
+
+LINES
+    events = Celluloid::EventSource::EventParser.new(lines.lines, false, ->(r) {}).to_a
+    expect(events.length).to eq 2
+    expect(events[0].id).to eq '123'
+    expect(events[0].type).to eq 'my-event'.to_sym
+    expect(events[0].data).to eq 'my-data'
+    expect(events[1].id).to eq ''
+    expect(events[1].type).to eq 'my-event2'.to_sym
+    expect(events[1].data).to eq 'my-data2'
+  end
+
+  it 'sets the default event type to message' do
+    lines =  <<LINES
+data: my-data
+
+LINES
+    events = Celluloid::EventSource::EventParser.new(lines.lines, false, ->(r) {}).to_a
+    expect(events.length).to eq 1
+    expect(events[0].id).to eq ''
+    expect(events[0].type).to eq :message
+    expect(events[0].data).to eq 'my-data'
+  end
+
+  it 'does not generate events unless data is provided' do
+    lines =  <<LINES
+event: my-event
+
+LINES
+    events = Celluloid::EventSource::EventParser.new(lines.lines, false, ->(r) {}).to_a
+    expect(events.length).to eq 0
+  end
+
+  it 'extends data with unprefixed lines as data in chunked mode' do
+    lines =  <<LINES
+data:
+my-data
+
+LINES
+    events = Celluloid::EventSource::EventParser.new(lines.lines, true, ->(r) {}).to_a
+    expect(events.length).to eq 1
+    expect(events[0].id).to eq ''
+    expect(events[0].type).to eq :message
+    expect(events[0].data).to eq 'my-data'
+  end
+
+  it 'reports retry updates to the provided function' do
+    lines =  <<LINES
+retry: 123
+LINES
+    received_retry_args = []
+    set_retry = lambda { |r| received_retry_args << r }
+    events = Celluloid::EventSource::EventParser.new(lines.lines, true, set_retry).to_a
+    expect(received_retry_args).to eq [123]
+    expect(events.length).to eq 0
+  end
+
+end

data/spec/celluloid/eventsource_spec.rb

@@ -105,7 +105,7 @@ RSpec.describe Celluloid::EventSource do
 
         Celluloid::EventSource.new(dummy.endpoint) do |conn|
           conn.on_message do |message|
-            if '3' == message.last_event_id
+            if '3' == message.id
               future.signal(value_class.new({ msg: message, state: conn.ready_state }))
               conn.close
             end
@@ -113,9 +113,9 @@ RSpec.describe Celluloid::EventSource do
         end
 
         payload = future.value
-        expect(payload[:msg]).to be_a(Celluloid::EventSource::MessageEvent)
+        expect(payload[:msg]).to be_a(Celluloid::EventSource::EventParser::MessageEvent)
         expect(payload[:msg].type).to eq(:message)
-        expect(payload[:msg].last_event_id).to eq('3')
+        expect(payload[:msg].id).to eq('3')
         expect(payload[:state]).to eq(Celluloid::EventSource::OPEN)
       end
 
@@ -189,9 +189,9 @@ RSpec.describe Celluloid::EventSource do
         end
 
         payload = future.value
-        expect(payload[:msg]).to be_a(Celluloid::EventSource::MessageEvent)
+        expect(payload[:msg]).to be_a(Celluloid::EventSource::EventParser::MessageEvent)
         expect(payload[:msg].type).to eq(custom)
-        expect(payload[:msg].last_event_id).to eq('1')
+        expect(payload[:msg].id).to eq('1')
         expect(payload[:state]).to eq(Celluloid::EventSource::OPEN)
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ld-celluloid-eventsource
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-05 00:00:00.000000000 Z
+date: 2017-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
@@ -42,14 +42,14 @@ dependencies:
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
@@ -154,9 +154,11 @@ files:
 - Rakefile
 - ld-celluloid-eventsource.gemspec
 - lib/celluloid/eventsource.rb
+- lib/celluloid/eventsource/event_parser.rb
 - lib/celluloid/eventsource/response_parser.rb
 - lib/celluloid/eventsource/version.rb
 - log/.gitignore
+- spec/celluloid/eventsource/event_parser_spec.rb
 - spec/celluloid/eventsource/response_parser_spec.rb
 - spec/celluloid/eventsource_spec.rb
 - spec/spec_helper.rb
@@ -182,11 +184,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: ld-celluloid-eventsource is a gem to consume SSE streaming API.
 test_files:
+- spec/celluloid/eventsource/event_parser_spec.rb
 - spec/celluloid/eventsource/response_parser_spec.rb
 - spec/celluloid/eventsource_spec.rb
 - spec/spec_helper.rb