ld-eventsource 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 294a32bc78de81b8f7c5ffa0a8b9ffc25847b0ecd20eee8f27caea576ae2b6fc
-  data.tar.gz: 5c0bb7736f090364098525477ec192b89ee02b96e0d12542bf72f08112180ba2
+SHA1:
+  metadata.gz: 385c043867b40ba6ddb46cb1c9b62837018b06cb
+  data.tar.gz: a64958fc36954f72b93c59d076ebdfb06787e13e
 SHA512:
-  metadata.gz: b6466b0b4c060b681640e2b47cc1844bb93a9588076fbcc901a5922be303860538d6e064d1f9ea897062ffeafcb86690e68e26e0c28d6f795ea68bb41dc7d364
-  data.tar.gz: 67a62d448f673893e9fc397cb536ad6ba4194292e3f8c3058d96bcc39b0f8bf3ce6bf12b1bdeb8e843ff962e3324505b9cddc3e42486cdb915456dbe1dba4dcc
+  metadata.gz: 96cc3666962b0009ea86ec049ac1f0cac778c630c33037730007b7fa5eb338fbe779726004f0b63fa9a3bd4f6ad137879d731a3415ec1e2012de193fef609743
+  data.tar.gz: 485e8d424a5a9afb394d780fb06790af17f8bc81f03e7c9a5a2eef391c66cfe7fd006e30317b472150cadc3c73ddae712f75e6444d2e7419020e34e065db99c0

data/.circleci/config.yml

@@ -4,11 +4,10 @@ workflows:
   version: 2
   test:
     jobs:
-      - test-misc-rubies
-      - test-2.2
-      - test-2.3
-      - test-2.4
       - test-2.5
+      - test-2.6
+      - test-2.7
+      - test-3.0
       - test-jruby-9.2
 
 ruby-docker-template: &ruby-docker-template
@@ -18,6 +17,7 @@ ruby-docker-template: &ruby-docker-template
         if [[ $CIRCLE_JOB == test-jruby* ]]; then
           gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
         fi
+    - run: sudo apt-get update -y && sudo apt-get install -y build-essential
     - run: ruby -v
     - run: gem install bundler -v "~> 1.17"
     - run: bundle install
@@ -29,62 +29,23 @@ ruby-docker-template: &ruby-docker-template
         path: ./rspec
 
 jobs:
-  test-2.2:
+  test-2.5:
     <<: *ruby-docker-template
     docker:
-      - image: circleci/ruby:2.2.10-jessie
-  test-2.3:
+      - image: circleci/ruby:2.5
+  test-2.6:
     <<: *ruby-docker-template
     docker:
-      - image: circleci/ruby:2.3.7-jessie
-  test-2.4:
+      - image: circleci/ruby:2.6
+  test-2.7:
     <<: *ruby-docker-template
     docker:
-      - image: circleci/ruby:2.4.5-stretch
-  test-2.5:
+      - image: circleci/ruby:2.7
+  test-3.0:
     <<: *ruby-docker-template
     docker:
-      - image: circleci/ruby:2.5.3-stretch
+      - image: circleci/ruby:3.0
   test-jruby-9.2:
     <<: *ruby-docker-template
     docker:
-      - image: circleci/jruby:9-jdk
-
-  # The following very slow job uses an Ubuntu container to run the Ruby versions that
-  # CircleCI doesn't provide Docker images for.
-  test-misc-rubies:
-    machine:
-      image: circleci/classic:latest
-    environment:
-      - RUBIES: "jruby-9.1.17.0"
-    steps:
-      - checkout
-      - run:
-          name: install all Ruby versions
-          command: "parallel rvm install ::: $RUBIES"
-      - run:
-          name: bundle install for all versions
-          shell: /bin/bash -leo pipefail # need -l in order for "rvm use" to work
-          command: |
-            set -e;
-            for i in $RUBIES;
-            do
-              rvm use $i;
-              if [[ $i == jruby* ]]; then
-                gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
-              fi
-              gem install bundler -v "~> 1.17";
-              bundle install;
-              mv Gemfile.lock "Gemfile.lock.$i"
-            done
-      - run:
-          name: run tests for all versions
-          shell: /bin/bash -leo pipefail
-          command: |
-            set -e;
-            for i in $RUBIES;
-            do
-              rvm use $i;
-              cp "Gemfile.lock.$i" Gemfile.lock;
-              bundle exec rspec spec;
-            done
+      - image: circleci/jruby:9.2-jdk

data/.gitignore

@@ -13,3 +13,4 @@
 mkmf.log
 *.gem
 .DS_Store
+rspec

data/.ldrelease/config.yml

@@ -0,0 +1,17 @@
+repo:
+  public: ruby-eventsource
+
+publications:
+  - url: https://rubygems.org/gems/ld-eventsource
+    description: RubyGems
+  - url: https://www.rubydoc.info/gems/ld-eventsource
+    description: documentation
+
+releasableBranches:
+  - name: master
+    description: 2.x - based on the http gem
+  - name: 1.x
+    description: 1.x - based on the socketry gem
+
+template:
+  name: ruby

data/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to the LaunchDarkly SSE Client for Ruby will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
 
+## [1.0.3] - 2020-03-17
+### Fixed:
+- The backoff delay logic for reconnecting after a stream failure was broken so that if a failure occurred after a stream had been active for at least `reconnect_reset_interval` (default 60 seconds), retries would use _no_ delay, potentially causing a flood of requests and a spike in CPU usage.
+
+## [1.0.2] - 2020-03-10
+### Removed:
+- Removed an unused dependency on `rake`. There are no other changes in this release.
+
+
+## [1.0.1] - 2019-07-10
+### Fixed:
+- Calling `close` on the client could cause a misleading warning message in the log, such as `Unexpected error from event source: #<IOError: stream closed in another thread>`.
+
 ## [1.0.0] - 2019-01-03
 
 Initial release.

data/Gemfile.lock

@@ -1,19 +1,36 @@
 PATH
   remote: .
   specs:
-    ld-eventsource (1.0.0)
+    ld-eventsource (2.0.0)
       concurrent-ruby (~> 1.0)
-      http_tools (~> 0.4.5)
-      socketry (~> 0.5.1)
+      http (~> 4.4.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    concurrent-ruby (1.0.5)
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    concurrent-ruby (1.1.8)
     diff-lcs (1.3)
-    hitimes (1.3.0)
-    http_tools (0.4.5)
-    rake (10.5.0)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    ffi (1.14.2)
+    ffi (1.14.2-java)
+    ffi-compiler (1.0.1)
+      ffi (>= 1.0.0)
+      rake
+    http (4.4.1)
+      addressable (~> 2.3)
+      http-cookie (~> 1.0)
+      http-form_data (~> 2.2)
+      http-parser (~> 1.2.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    http-form_data (2.3.0)
+    http-parser (1.2.3)
+      ffi-compiler (>= 1.0, < 2.0)
+    public_suffix (4.0.6)
+    rake (13.0.3)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
       rspec-expectations (~> 3.7.0)
@@ -29,8 +46,11 @@ GEM
     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)
+    unf (0.1.4)
+      unf_ext
+    unf (0.1.4-java)
+    unf_ext (0.0.7.7)
+    webrick (1.7.0)
 
 PLATFORMS
   java
@@ -39,9 +59,9 @@ PLATFORMS
 DEPENDENCIES
   bundler (~> 1.7)
   ld-eventsource!
-  rake (~> 10.0)
   rspec (~> 3.2)
   rspec_junit_formatter (~> 0.3.0)
+  webrick (~> 1.7)
 
 BUNDLED WITH
    1.17.3

data/README.md

@@ -3,14 +3,14 @@ LaunchDarkly SSE Client for Ruby
 
 [![Gem Version](https://badge.fury.io/rb/ld-eventsource.svg)](http://badge.fury.io/rb/ld-eventsource) [![Circle CI](https://circleci.com/gh/launchdarkly/ruby-eventsource/tree/master.svg?style=svg)](https://circleci.com/gh/launchdarkly/ruby-eventsource/tree/master)
 
-A client for the [Server-Sent Events](https://www.w3.org/TR/eventsource/) protocol. This implementation runs on a worker thread, and uses the [`socketry`](https://rubygems.org/gems/socketry) gem to manage a persistent connection. Its primary purpose is to support the [LaunchDarkly SDK for Ruby](https://github.com/launchdarkly/ruby-client), but it can be used independently.
+A client for the [Server-Sent Events](https://www.w3.org/TR/eventsource/) protocol. This implementation runs on a worker thread, and uses the [`http`](https://rubygems.org/gems/http) gem to manage a persistent connection. Its primary purpose is to support the [LaunchDarkly SDK for Ruby](https://github.com/launchdarkly/ruby-client), but it can be used independently.
 
 Parts of this code are based on https://github.com/Tonkpils/celluloid-eventsource, but it does not use Celluloid.
 
 Supported Ruby versions
 -----------------------
 
-This gem has a minimum Ruby version of 2.2.6, or 9.1.6 for JRuby.
+This gem has a minimum Ruby version of 2.5, or 9.2 for JRuby.
 
 Quick setup
 -----------

data/ld-eventsource.gemspec

@@ -22,10 +22,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
+  spec.add_development_dependency "webrick", "~> 1.7"
 
   spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "http_tools", '~> 0.4.5'
-  spec.add_runtime_dependency "socketry", "~> 0.5.1"
+  spec.add_runtime_dependency "http", "~> 4.4.1"
 end

data/lib/ld-eventsource/client.rb

@@ -1,6 +1,5 @@
 require "ld-eventsource/impl/backoff"
 require "ld-eventsource/impl/event_parser"
-require "ld-eventsource/impl/streaming_http"
 require "ld-eventsource/events"
 require "ld-eventsource/errors"
 
@@ -8,6 +7,7 @@ require "concurrent/atomics"
 require "logger"
 require "thread"
 require "uri"
+require "http"
 
 module SSE
   #
@@ -80,6 +80,9 @@ module SSE
     #   proxy with the `HTTP_PROXY` or `HTTPS_PROXY` environment variable)
     # @param logger [Logger]  a Logger instance for the client to use for diagnostic output;
     #   defaults to a logger with WARN level that goes to standard output
+    # @param socket_factory [#open] (nil)  an optional factory object for creating sockets,
+    #   if you want to use something other than the default `TCPSocket`; it must implement
+    #   `open(uri, timeout)` to return a connected `Socket`
     # @yieldparam [Client] client  the new client instance, before opening the connection
     # 
     def initialize(uri,
@@ -90,7 +93,8 @@ module SSE
           reconnect_reset_interval: DEFAULT_RECONNECT_RESET_INTERVAL,
           last_event_id: nil,
           proxy: nil,
-          logger: nil)
+          logger: nil,
+          socket_factory: nil)
       @uri = URI(uri)
       @stopped = Concurrent::AtomicBoolean.new(false)
 
@@ -98,7 +102,11 @@ module SSE
       @connect_timeout = connect_timeout
       @read_timeout = read_timeout
       @logger = logger || default_logger
-
+      http_client_options = {}
+      if socket_factory
+        http_client_options["socket_class"] = socket_factory
+      end
+      
       if proxy
         @proxy = proxy
       else
@@ -108,6 +116,21 @@ module SSE
         end
       end
 
+      if @proxy
+        http_client_options["proxy"] = {
+          :proxy_address => @proxy.host,
+          :proxy_port => @proxy.port
+        }
+      end
+
+      @http_client = HTTP::Client.new(http_client_options)
+        .timeout({
+          read: read_timeout,
+          connect: connect_timeout
+        })
+      @buffer = ""
+      @lock = Mutex.new
+
       @backoff = Impl::Backoff.new(reconnect_time || DEFAULT_RECONNECT_TIME, MAX_RECONNECT_TIME,
         reconnect_reset_interval: reconnect_reset_interval)
 
@@ -163,12 +186,56 @@ module SSE
     #
     def close
       if @stopped.make_true
-        @cxn.close if !@cxn.nil?
-        @cxn = nil
+        reset_http
       end
     end
 
     private
+    
+    def reset_http
+      @http_client.close if !@http_client.nil?
+      @cxn = nil
+      @buffer = ""
+    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_line
+      loop do
+        @lock.synchronize do
+          i = @buffer.index(/[\r\n]/)
+          if !i.nil? && !(i == @buffer.length - 1 && @buffer[i] == "\r")
+            i += 1 if (@buffer[i] == "\r" && @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
+    
+    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 = @cxn.readpartial
+      rescue HTTP::TimeoutError 
+        # We rethrow this as our own type so the caller doesn't have to know the httprb API
+        raise Errors::ReadTimeoutError.new(@read_timeout)
+      end
+      return false if data == nil
+      @buffer << 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
 
     def default_logger
       log = ::Logger.new($stdout)
@@ -186,15 +253,17 @@ module SSE
           # connected but before @cxn was set. Checking the variable again is a bit clunky but avoids that.
           return if @stopped.value
           read_stream(@cxn) if !@cxn.nil?
-        rescue Errno::EBADF
-          # Don't log this as an error - it probably means we closed our own connection deliberately
-          @logger.info { "Stream connection closed" }
-        rescue StandardError => e
-          # This should not be possible because connect catches all StandardErrors
-          log_and_dispatch_error(e, "Unexpected error from event source")
+        rescue => e
+          # When we deliberately close the connection, it will usually trigger an exception. The exact type
+          # of exception depends on the specific Ruby runtime. But @stopped will always be set in this case.
+          if @stopped.value
+            @logger.info { "Stream connection closed" }
+          else
+            log_and_dispatch_error(e, "Unexpected error from event source")
+          end
         end
         begin
-          @cxn.close if !@cxn.nil?
+          reset_http
         rescue StandardError => e
           log_and_dispatch_error(e, "Unexpected error while closing stream")
         end
@@ -210,36 +279,32 @@ module SSE
           @logger.info { "Will retry connection after #{'%.3f' % interval} seconds" } 
           sleep(interval)
         end
+        cxn = nil
         begin
           @logger.info { "Connecting to event stream at #{@uri}" }
-          cxn = Impl::StreamingHTTPConnection.new(@uri,
-            proxy: @proxy,
-            headers: build_headers,
-            connect_timeout: @connect_timeout,
-            read_timeout: @read_timeout
-          )
-          if cxn.status == 200
+          cxn = @http_client.request("GET", @uri, {
+            headers: build_headers
+          })
+          if cxn.status.code == 200
             content_type = cxn.headers["content-type"]
             if content_type && content_type.start_with?("text/event-stream")
               return cxn  # we're good to proceed
             else
-              cxn.close
+              reset_http
               err = Errors::HTTPContentTypeError.new(cxn.headers["content-type"])
               @on[:error].call(err)
               @logger.warn { "Event source returned unexpected content type '#{cxn.headers["content-type"]}'" }
             end
           else
-            body = cxn.read_all  # grab the whole response body in case it has error details
-            cxn.close
-            @logger.info { "Server returned error status #{cxn.status}" }
-            err = Errors::HTTPStatusError.new(cxn.status, body)
+            body = cxn.to_s  # grab the whole response body in case it has error details
+            reset_http
+            @logger.info { "Server returned error status #{cxn.status.code}" }
+            err = Errors::HTTPStatusError.new(cxn.status.code, body)
             @on[:error].call(err)
           end
-        rescue Errno::EBADF
-          raise # See EBADF comment in run_stream
-        rescue StandardError => e
-          cxn.close if !cxn.nil?
-          log_and_dispatch_error(e, "Unexpected error from event source")
+        rescue
+          reset_http
+          raise  # will be handled in run_stream
         end
         # if unsuccessful, continue the loop to connect again
       end
@@ -252,7 +317,7 @@ module SSE
       # it can automatically reset itself if enough time passes between failures.
       @backoff.mark_success
 
-      event_parser = Impl::EventParser.new(cxn.read_lines)
+      event_parser = Impl::EventParser.new(read_lines)
       event_parser.items.each do |item|
         return if @stopped.value
         case item
@@ -287,7 +352,8 @@ module SSE
     def build_headers
       h = {
         'Accept' => 'text/event-stream',
-        'Cache-Control' => 'no-cache'
+        'Cache-Control' => 'no-cache',
+        'User-Agent' => 'ruby-eventsource'
       }
       h['Last-Event-Id'] = @last_id if !@last_id.nil?
       h.merge(@headers)

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.0"
+  VERSION = "2.0.0"
 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
@@ -112,6 +116,29 @@ EOT
     end
   end
 
+  it "does not trigger an error when stream is closed" do
+    events_body = simple_event_1_text + simple_event_2_text
+    with_server do |server|
+      server.setup_response("/") do |req,res|
+        send_stream_content(res, events_body, keep_open: true)
+      end
+
+      event_sink = Queue.new
+      error_sink = Queue.new
+      client = subject.new(server.base_uri) do |c|
+        c.on_event { |event| event_sink << event }
+        c.on_error { |error| error_sink << error }
+      end
+
+      with_client(client) do |client|
+        event_sink.pop  # wait till we have definitely started reading the stream
+        client.close
+        sleep 0.25  # there's no way to really know when the stream thread has finished
+        expect(error_sink.empty?).to be true
+      end
+    end
+  end
+
   it "reconnects after error response" do
     events_body = simple_event_1_text
     with_server do |server|
@@ -307,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
@@ -339,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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ld-eventsource
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-05 00:00:00.000000000 Z
+date: 2021-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -39,33 +39,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.2'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec_junit_formatter
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
-  name: rspec_junit_formatter
+  name: webrick
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -81,33 +81,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: http_tools
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.4.5
-- !ruby/object:Gem::Dependency
-  name: socketry
+  name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 4.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: 4.4.1
 description: LaunchDarkly SSE client for Ruby
 email:
 - team@launchdarkly.com
@@ -117,12 +103,12 @@ extra_rdoc_files: []
 files:
 - ".circleci/config.yml"
 - ".gitignore"
+- ".ldrelease/config.yml"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
-- Rakefile
 - ld-eventsource.gemspec
 - lib/ld-eventsource.rb
 - lib/ld-eventsource/client.rb
@@ -130,14 +116,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
@@ -158,12 +143,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.5.2.3
 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/Rakefile

@@ -1,5 +0,0 @@
-require "bundler/gem_tasks"
-
-require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new(:spec)
-task default: :spec

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

data/spec/streaming_http_spec.rb

@@ -1,263 +0,0 @@
-require "ld-eventsource/impl/streaming_http"
-require "socketry"
-require "http_stub"
-
-#
-# End-to-end tests of HTTP requests against a real server
-#
-describe SSE::Impl::StreamingHTTPConnection do
-  subject { SSE::Impl::StreamingHTTPConnection }
-
-  def with_connection(cxn)
-    begin
-      yield cxn
-    ensure
-      cxn.close
-    end
-  end
-
-  it "makes HTTP connection and sends request" do
-    with_server do |server|
-      requests = Queue.new
-      server.setup_response("/foo") do |req,res|
-        requests << req
-        res.status = 200
-      end
-      headers = {
-        "Accept" => "text/plain"
-      }
-      with_connection(subject.new(server.base_uri.merge("/foo?bar"), headers: headers)) do
-        received_req = requests.pop
-        expect(received_req.unparsed_uri).to eq("/foo?bar")
-        expect(received_req.header).to eq({
-          "accept" => ["text/plain"],
-          "host" => [server.base_uri.host]
-        })
-      end
-    end
-  end
-
-  it "receives response status" do
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res.status = 204
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"))) do |cxn|
-        expect(cxn.status).to eq(204)
-      end
-    end
-  end
-
-  it "receives response headers" do
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res["Content-Type"] = "application/json"
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"))) do |cxn|
-        expect(cxn.headers["content-type"]).to eq("application/json")
-      end
-    end
-  end
-
-  it "can read response as lines" do
-    body = <<-EOT
-This is
-a response
-EOT
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res.body = body
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"))) do |cxn|
-        lines = cxn.read_lines
-        expect(lines.next).to eq("This is\n")
-        expect(lines.next).to eq("a response\n")
-      end
-    end
-  end
-
-  it "can read entire response body" do
-    body = <<-EOT
-This is
-a response
-EOT
-    with_server do |server|
-      server.setup_response("/foo") do |req,res|
-        res.body = body
-      end
-      with_connection(subject.new(server.base_uri.merge("/foo"))) do |cxn|
-        read_body = cxn.read_all
-        expect(read_body).to eq("This is\na response\n")
-      end
-    end
-  end
-
-  it "enforces read timeout" do
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        sleep(2)
-        res.status = 200
-      end
-      expect { subject.new(server.base_uri, read_timeout: 0.25) }.to raise_error(SSE::Errors::ReadTimeoutError)
-    end
-  end
-
-  it "connects to HTTP server through proxy" do
-    body = "hi"
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        res.body = body
-      end
-      with_server(StubProxyServer.new) do |proxy|
-        with_connection(subject.new(server.base_uri, proxy: proxy.base_uri)) do |cxn|
-          read_body = cxn.read_all
-          expect(read_body).to eq("hi")
-          expect(proxy.request_count).to eq(1)
-        end
-      end
-    end
-  end
-
-  it "throws error if proxy responds with error status" do
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        res.body = body
-      end
-      with_server(StubProxyServer.new) do |proxy|
-        proxy.connect_status = 403
-        expect { subject.new(server.base_uri, proxy: proxy.base_uri) }.to raise_error(SSE::Errors::HTTPProxyError)
-      end
-    end
-  end
-
-  # The following 2 tests were originally written to connect to an embedded HTTPS server made with
-  # WEBrick. Unfortunately, some unknown problem prevents WEBrick's self-signed certificate feature
-  # from working in JRuby 9.1 (but not in any other Ruby version). Therefore these tests currently
-  # hit an external URL.
-
-  it "connects to HTTPS server" do
-    with_connection(subject.new(URI("https://app.launchdarkly.com"))) do |cxn|
-      expect(cxn.status).to eq 200
-    end
-  end
-  
-  it "connects to HTTPS server through proxy" do
-    with_server(StubProxyServer.new) do |proxy|
-      with_connection(subject.new(URI("https://app.launchdarkly.com"), proxy: proxy.base_uri)) do |cxn|
-        expect(cxn.status).to eq 200
-        expect(proxy.request_count).to eq(1)
-      end
-    end
-  end
-end
-
-#
-# Tests of response parsing functionality without a real HTTP request
-#
-describe SSE::Impl::HTTPResponseReader do
-  subject { SSE::Impl::HTTPResponseReader }
-
-  let(:simple_response) { <<-EOT
-HTTP/1.1 200 OK
-Cache-Control: no-cache
-Content-Type: text/event-stream
-
-line1\r
-line2
-\r
-EOT
-  }
-
-  def make_chunks(str)
-    # arbitrarily split content into 5-character blocks
-    str.scan(/.{1,5}/m).to_enum
-  end
-
-  def mock_socket_without_timeout(chunks)
-    mock_socket(chunks) { :eof }
-  end
-
-  def mock_socket_with_timeout(chunks)
-    mock_socket(chunks) { raise Socketry::TimeoutError }
-  end
-
-  def mock_socket(chunks)
-    sock = double
-    allow(sock).to receive(:readpartial) do
-      begin
-        chunks.next
-      rescue StopIteration
-        yield
-      end
-    end
-    sock
-  end
-
-  it "parses status code" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.status).to eq(200)
-  end
-
-  it "parses headers" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.headers).to eq({
-      'cache-control' => 'no-cache',
-      'content-type' => 'text/event-stream'
-    })
-  end
-
-  it "can read entire response body" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.read_all).to eq("line1\r\nline2\n\r\n")
-  end
-
-  it "can read response body as lines" do
-    socket = mock_socket_without_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    expect(reader.read_lines.to_a).to eq([
-      "line1\r\n",
-      "line2\n",
-      "\r\n"
-    ])
-  end
-
-  it "handles chunked encoding" do
-    chunked_response = <<-EOT
-HTTP/1.1 200 OK
-Content-Type: text/plain
-Transfer-Encoding: chunked
-
-6\r
-things\r
-A\r
- and stuff\r
-0\r
-\r
-EOT
-    socket = mock_socket_without_timeout(make_chunks(chunked_response))
-    reader = subject.new(socket, 0)
-    expect(reader.read_all).to eq("things and stuff")
-  end
-
-  it "raises error if response ends without complete headers" do
-    malformed_response = <<-EOT
-HTTP/1.1 200 OK
-Cache-Control: no-cache
-EOT
-    socket = mock_socket_without_timeout(make_chunks(malformed_response))
-    expect { subject.new(socket, 0) }.to raise_error(EOFError)
-  end
-
-  it "throws timeout if thrown by socket read" do
-    socket = mock_socket_with_timeout(make_chunks(simple_response))
-    reader = subject.new(socket, 0)
-    lines = reader.read_lines
-    lines.next
-    lines.next
-    lines.next
-    expect { lines.next }.to raise_error(SSE::Errors::ReadTimeoutError)
-  end
-end