ld-eventsource 1.0.2 → 2.0.1

data/lib/ld-eventsource/impl/backoff.rb

@@ -38,10 +38,6 @@ module SSE
           good_duration = Time.now.to_f - @last_good_time
           @attempts = 0 if good_duration >= @reconnect_reset_interval
         end
-        if @attempts == 0
-          @attempts += 1
-          return 0
-        end
         @last_good_time = nil
         target = ([@base_interval * (2 ** @attempts), @max_interval].min).to_f
         @attempts += 1

data/lib/ld-eventsource/version.rb

@@ -1,3 +1,3 @@
 module SSE
-  VERSION = "1.0.2"
+  VERSION = "2.0.1"
 end

data/spec/backoff_spec.rb

@@ -0,0 +1,52 @@
+require "ld-eventsource"
+
+require "http_stub"
+
+module SSE
+  module Impl
+    describe Backoff do
+      it "increases exponentially with jitter" do
+        initial = 1.5
+        max = 60
+        b = Backoff.new(initial, max)
+        previous = 0
+
+        for i in 1..6 do
+          interval = b.next_interval
+          expect(interval).to be > previous
+          target = initial * (2 ** (i - 1))
+          expect(interval).to be <= target
+          expect(interval).to be >= target / 2
+          previous = i
+        end
+
+        interval = b.next_interval
+        expect(interval).to be >= previous
+        expect(interval).to be <= max
+      end
+
+      it "resets to initial delay if reset threshold has elapsed" do
+        initial = 1.5
+        max = 60
+        threshold = 2
+        b = Backoff.new(initial, max, reconnect_reset_interval: threshold)
+
+        for i in 1..6 do
+          # just cause the backoff to increase quickly, don't actually do these delays
+          b.next_interval
+        end
+
+        b.mark_success
+        sleep(threshold + 0.001)
+
+        interval = b.next_interval
+        expect(interval).to be <= initial
+        expect(interval).to be >= initial / 2
+
+        interval = b.next_interval # make sure it continues increasing after that
+        expect(interval).to be <= (initial * 2)
+        expect(interval).to be >= initial
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -1,6 +1,4 @@
 require "ld-eventsource"
-require "socketry"
-require "http_stub"
 
 #
 # End-to-end tests of the SSE client against a real server
@@ -62,8 +60,11 @@ EOT
         expect(received_req.header).to eq({
           "accept" => ["text/event-stream"],
           "cache-control" => ["no-cache"],
-          "host" => ["127.0.0.1"],
-          "authorization" => ["secret"]
+          "host" => ["127.0.0.1:" + server.port.to_s],
+          "authorization" => ["secret"],
+          "user-agent" => ["ruby-eventsource"],
+          "content-length" => ["0"],
+          "connection" => ["close"]
         })
       end
     end
@@ -85,9 +86,12 @@ EOT
         expect(received_req.header).to eq({
           "accept" => ["text/event-stream"],
           "cache-control" => ["no-cache"],
-          "host" => ["127.0.0.1"],
+          "host" => ["127.0.0.1:" + server.port.to_s],
           "authorization" => ["secret"],
-          "last-event-id" => [id]
+          "last-event-id" => [id],
+          "user-agent" => ["ruby-eventsource"],
+          "content-length" => ["0"],
+          "connection" => ["close"]
         })
       end
     end
@@ -330,7 +334,7 @@ EOT
           expect(event_sink.pop).to eq(simple_event_1)
           if i > 0
             interval = request_times[i] - request_end_times[i - 1]
-            expect(interval).to be <= initial_interval
+            expect(interval).to be <= (initial_interval + 0.1)
           end
         end
       end
@@ -362,7 +366,63 @@ EOT
       with_client(client) do |client|
         expect(event_sink.pop).to eq(simple_event_1)
         interval = request_times[1] - request_times[0]
-        expect(interval).to be < ((retry_ms.to_f / 1000) + 0.1)
+        expect(interval).to be < 0.5
+      end
+    end
+  end
+
+  it "connects to HTTP server through proxy" do
+    events_body = simple_event_1_text
+    with_server do |server|
+      server.setup_response("/") do |req,res|
+        send_stream_content(res, events_body, keep_open: false)
+      end
+      with_server(StubProxyServer.new) do |proxy|
+        event_sink = Queue.new
+        client = subject.new(server.base_uri, proxy: proxy.base_uri) do |c|
+          c.on_event { |event| event_sink << event }
+        end
+
+        with_client(client) do |client|
+          expect(event_sink.pop).to eq(simple_event_1)
+          expect(proxy.request_count).to eq(1)
+        end
+      end
+    end
+  end
+
+  it "resets read timeout between events" do
+    event_body = simple_event_1_text
+    with_server do |server|
+      attempt = 0
+      server.setup_response("/") do |req,res|
+        attempt += 1
+        if attempt == 1
+          stream = send_stream_content(res, event_body, keep_open: true)
+          Thread.new do
+            2.times {
+              # write within timeout interval
+              sleep(0.75)
+              stream.write(event_body)
+            }
+            # cause timeout
+            sleep(1.25)
+          end
+        elsif attempt == 2
+          send_stream_content(res, event_body, keep_open: false)
+        end
+      end
+
+      event_sink = Queue.new
+      client = subject.new(server.base_uri, reconnect_time: reconnect_asap, read_timeout: 1) do |c|
+        c.on_event { |event| event_sink << event }
+      end
+
+      with_client(client) do |client|
+        4.times {
+          expect(event_sink.pop).to eq(simple_event_1)
+        }
+        expect(attempt).to eq 2
       end
     end
   end

data/spec/http_stub.rb

@@ -3,6 +3,8 @@ require "webrick/httpproxy"
 require "webrick/https"
 
 class StubHTTPServer
+  attr_reader :port
+
   def initialize
     @port = 50000
     begin

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ld-eventsource
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.1
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-10 00:00:00.000000000 Z
+date: 2021-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 2.2.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 2.2.10
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -53,47 +53,53 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.3.0
 - !ruby/object:Gem::Dependency
-  name: concurrent-ruby
+  name: webrick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
+        version: '1.7'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: http_tools
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.4.5
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: socketry
+  name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.4.1
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 6.0.0
 description: LaunchDarkly SSE client for Ruby
 email:
 - team@launchdarkly.com
@@ -103,10 +109,18 @@ extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
 - ".gitignore"
+- ".ldrelease/circleci/linux/execute.sh"
+- ".ldrelease/circleci/mac/execute.sh"
+- ".ldrelease/circleci/template/build.sh"
+- ".ldrelease/circleci/template/gems-setup.sh"
+- ".ldrelease/circleci/template/prepare.sh"
+- ".ldrelease/circleci/template/publish.sh"
+- ".ldrelease/circleci/template/test.sh"
+- ".ldrelease/circleci/template/update-version.sh"
+- ".ldrelease/circleci/windows/execute.ps1"
 - ".ldrelease/config.yml"
 - CHANGELOG.md
 - Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
 - ld-eventsource.gemspec
@@ -116,14 +130,13 @@ files:
 - lib/ld-eventsource/events.rb
 - lib/ld-eventsource/impl/backoff.rb
 - lib/ld-eventsource/impl/event_parser.rb
-- lib/ld-eventsource/impl/streaming_http.rb
 - lib/ld-eventsource/version.rb
 - scripts/gendocs.sh
 - scripts/release.sh
+- spec/backoff_spec.rb
 - spec/client_spec.rb
 - spec/event_parser_spec.rb
 - spec/http_stub.rb
-- spec/streaming_http_spec.rb
 homepage: https://github.com/launchdarkly/ruby-eventsource
 licenses:
 - Apache-2.0
@@ -143,13 +156,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SSE client
 test_files:
+- spec/backoff_spec.rb
 - spec/client_spec.rb
 - spec/event_parser_spec.rb
 - spec/http_stub.rb
-- spec/streaming_http_spec.rb

data/Gemfile.lock

@@ -1,46 +0,0 @@
-PATH
-  remote: .
-  specs:
-    ld-eventsource (1.0.2)
-      concurrent-ruby (~> 1.0)
-      http_tools (~> 0.4.5)
-      socketry (~> 0.5.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    concurrent-ruby (1.1.6)
-    diff-lcs (1.3)
-    hitimes (1.3.1)
-    hitimes (1.3.1-java)
-    http_tools (0.4.5)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.0)
-    rspec_junit_formatter (0.3.0)
-      rspec-core (>= 2, < 4, != 2.12.0)
-    socketry (0.5.1)
-      hitimes (~> 1.2)
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.7)
-  ld-eventsource!
-  rspec (~> 3.2)
-  rspec_junit_formatter (~> 0.3.0)
-
-BUNDLED WITH
-   1.17.3

data/lib/ld-eventsource/impl/streaming_http.rb

@@ -1,222 +0,0 @@
-require "ld-eventsource/errors"
-
-require "concurrent/atomics"
-require "http_tools"
-require "socketry"
-
-module SSE
-  module Impl
-    #
-    # Wrapper around a socket providing a simplified HTTP request-response cycle including streaming.
-    # The socket is created and managed by Socketry, which we use so that we can have a read timeout.
-    #
-    class StreamingHTTPConnection
-      attr_reader :status, :headers
-
-      #
-      # Opens a new connection.
-      #
-      # @param [String] uri  the URI to connect o
-      # @param [String] proxy  the proxy server URI, if any
-      # @param [Hash] headers  request headers
-      # @param [Float] connect_timeout  connection timeout
-      # @param [Float] read_timeout  read timeout
-      #
-      def initialize(uri, proxy: nil, headers: {}, connect_timeout: nil, read_timeout: nil)
-        @socket = HTTPConnectionFactory.connect(uri, proxy, connect_timeout, read_timeout)
-        @socket.write(build_request(uri, headers))
-        @reader = HTTPResponseReader.new(@socket, read_timeout)
-        @status = @reader.status
-        @headers = @reader.headers
-        @closed = Concurrent::AtomicBoolean.new(false)
-      end
-
-      #
-      # Closes the connection.
-      #
-      def close
-        if @closed.make_true
-          @socket.close if @socket
-          @socket = nil
-        end
-      end
-      
-      #
-      # Generator that returns one line of the response body at a time (delimited by \r, \n,
-      # or \r\n) until the response is fully consumed or the socket is closed.
-      #
-      def read_lines
-        @reader.read_lines
-      end
-
-      #
-      # Consumes the entire response body and returns it.
-      #
-      # @return [String]  the response body
-      #
-      def read_all
-        @reader.read_all
-      end
-
-      private
-
-      # Build an HTTP request line and headers.
-      def build_request(uri, headers)
-        ret = "GET #{uri.request_uri} HTTP/1.1\r\n"
-        ret << "Host: #{uri.host}\r\n"
-        headers.each { |k, v|
-          ret << "#{k}: #{v}\r\n"
-        }
-        ret + "\r\n"
-      end
-    end
-
-    #
-    # Used internally to send the HTTP request, including the proxy dialogue if necessary.
-    # @private
-    #
-    class HTTPConnectionFactory
-      def self.connect(uri, proxy, connect_timeout, read_timeout)
-        if !proxy
-          return open_socket(uri, connect_timeout)
-        end
-
-        socket = open_socket(proxy, connect_timeout)
-        socket.write(build_proxy_request(uri, proxy))
-
-        # temporarily create a reader just for the proxy connect response
-        proxy_reader = HTTPResponseReader.new(socket, read_timeout)
-        if proxy_reader.status != 200
-          raise Errors::HTTPProxyError.new(proxy_reader.status)
-        end
-
-        # start using TLS at this point if appropriate
-        if uri.scheme.downcase == 'https'
-          wrap_socket_in_ssl_socket(socket)
-        else
-          socket
-        end
-      end
-
-      private
-
-      def self.open_socket(uri, connect_timeout)
-        if uri.scheme.downcase == 'https'
-          Socketry::SSL::Socket.connect(uri.host, uri.port, timeout: connect_timeout)
-        else
-          Socketry::TCP::Socket.connect(uri.host, uri.port, timeout: connect_timeout)
-        end
-      end
-
-      # Build a proxy connection header.
-      def self.build_proxy_request(uri, proxy)
-        ret = "CONNECT #{uri.host}:#{uri.port} HTTP/1.1\r\n"
-        ret << "Host: #{uri.host}:#{uri.port}\r\n"
-        if proxy.user || proxy.password
-          encoded_credentials = Base64.strict_encode64([proxy.user || '', proxy.password || ''].join(":"))
-          ret << "Proxy-Authorization: Basic #{encoded_credentials}\r\n"
-        end
-        ret << "\r\n"
-        ret
-      end
-
-      def self.wrap_socket_in_ssl_socket(socket)
-        io = IO.try_convert(socket)
-        ssl_sock = OpenSSL::SSL::SSLSocket.new(io, OpenSSL::SSL::SSLContext.new)
-        ssl_sock.connect
-        Socketry::SSL::Socket.new.from_socket(ssl_sock)
-      end
-    end
-
-    #
-    # Used internally to read the HTTP response, either all at once or as a stream of text lines.
-    # Incoming data is fed into an instance of HTTPTools::Parser, which gives us the header and
-    # chunks of the body via callbacks.
-    # @private
-    #
-    class HTTPResponseReader
-      DEFAULT_CHUNK_SIZE = 10000
-
-      attr_reader :status, :headers
-
-      def initialize(socket, read_timeout)
-        @socket = socket
-        @read_timeout = read_timeout
-        @parser = HTTPTools::Parser.new
-        @buffer = ""
-        @done = false
-        @lock = Mutex.new
-
-        # Provide callbacks for the Parser to give us the headers and body. This has to be done
-        # before we start piping any data into the parser.
-        have_headers = false
-        @parser.on(:header) do
-          have_headers = true
-        end
-        @parser.on(:stream) do |data|
-          @lock.synchronize { @buffer << data }  # synchronize because we're called from another thread in Socketry
-        end
-        @parser.on(:finish) do
-          @lock.synchronize { @done = true }
-        end
-
-        # Block until the status code and headers have been successfully read.
-        while !have_headers
-          raise EOFError if !read_chunk_into_buffer
-        end
-        @headers = Hash[@parser.header.map { |k,v| [k.downcase, v] }]
-        @status = @parser.status_code
-      end
-
-      def read_lines
-        Enumerator.new do |gen|
-          loop do
-            line = read_line
-            break if line.nil?
-            gen.yield line
-          end
-        end
-      end
-
-      def read_all
-        while read_chunk_into_buffer
-        end
-        @buffer
-      end
-
-      private
-
-      # Attempt to read some more data from the socket. Return true if successful, false if EOF.
-      # A read timeout will result in an exception from Socketry's readpartial method.
-      def read_chunk_into_buffer
-        # If @done is set, it means the Parser has signaled end of response body
-        @lock.synchronize { return false if @done }
-        begin
-          data = @socket.readpartial(DEFAULT_CHUNK_SIZE, timeout: @read_timeout)
-        rescue Socketry::TimeoutError
-          # We rethrow this as our own type so the caller doesn't have to know the Socketry API
-          raise Errors::ReadTimeoutError.new(@read_timeout)
-        end
-        return false if data == :eof
-        @parser << data
-        # We are piping the content through the parser so that it can handle things like chunked
-        # encoding for us. The content ends up being appended to @buffer via our callback.
-        true
-      end
-
-      # Extract the next line of text from the read buffer, refilling the buffer as needed.
-      def read_line
-        loop do
-          @lock.synchronize do
-            i = @buffer.index(/[\r\n]/)
-            if !i.nil?
-              i += 1 if (@buffer[i] == "\r" && i < @buffer.length - 1 && @buffer[i + 1] == "\n")
-              return @buffer.slice!(0, i + 1).force_encoding(Encoding::UTF_8)
-            end
-          end
-          return nil if !read_chunk_into_buffer
-        end
-      end
-    end
-  end
-end