pebblebed 0.3.26 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 14d1b62f07bf96068be143f86a02af3d0e9d3f86
-  data.tar.gz: 52004701d254aa4afd4855e4c0028ac9bf17bb29
+  metadata.gz: 5a72b667ab7760684fba215b9c8b1efcae9c1294
+  data.tar.gz: 2a0663c6a8a01c4996c5e4726d39efbeca6cb97e
 SHA512:
-  metadata.gz: 24d3974b44099d97ef4dad54bfc50a7c13a4dabdd5b693a22da982e8653920c31c780644f7d2f6d9a06e3346c0794e748c15628d61566020a2d25b96ceee9a5b
-  data.tar.gz: 93b67975bc2cffb0f473f1a79a7e18e30d3dd745af5283e13b5220bafafcd9cfc68dbd21ce09cf407ea099c03c60d1467e7440f7aa1a44a4f08067190ceaab48
+  metadata.gz: 22492117f67d35017f0458d5d6b829378f8ae9583b4fcd1d7d6a36d88ddce51e8ea2f886c3b3060072c4834629ca8ef7a722c462dcd82aff232d77e0bcb0f495
+  data.tar.gz: ac85b869fe8d67e0f364ddf3054bb72bf107740c9fa45daf9a3c0174b0ed247a64af2835f8dad39a40c73e60511bd667f1ba00e6c920a371ff8c541b697bfe4d

data/lib/pebblebed/http.rb

@@ -1,12 +1,14 @@
 # A wrapper for all low level http client stuff
 
 require 'uri'
-require 'curl'
+require 'excon'
 require 'yajl/json_gem'
 require 'queryparams'
 require 'nokogiri'
 require 'pathbuilder'
 require 'active_support'
+require 'timeout'
+require 'resolv'
 
 module Pebblebed
 
@@ -32,35 +34,43 @@ module Pebblebed
     end
   end
 
+  class HttpTransportError < StandardError
+    def initialize(e = nil)
+      super e
+      set_backtrace e.backtrace if e
+    end
+  end
+
   class HttpNotFoundError < HttpError; end
+  class HttpSocketError < HttpTransportError; end
+  class HttpTimeoutError < HttpTransportError; end
 
   module Http
 
     DEFAULT_CONNECT_TIMEOUT = 30
-    DEFAULT_REQUEST_TIMEOUT = nil
     DEFAULT_READ_TIMEOUT = 30
+    DEFAULT_WRITE_TIMEOUT = 60
 
     class << self
-      attr_reader :connect_timeout, :request_timeout, :read_timeout
+      attr_reader :connect_timeout, :read_timeout, :write_timeout
       def connect_timeout=(value)
         @connect_timeout = value
-        self.current_easy = nil
-      end
-      def request_timeout=(value)
-        @request_timeout = value
-        self.current_easy = nil
+        Thread.current[:pebblebed_excon] = {}
       end
       def read_timeout=(value)
         @read_timeout = value
-        self.current_easy = nil
+        Thread.current[:pebblebed_excon] = {}
+      end
+      def write_timeout=(value)
+        @write_timeout = value
+        Thread.current[:pebblebed_excon] = {}
       end
     end
 
     class Response
-      def initialize(url, header, body)
+      def initialize(url, status, body)
         @body = body
-        # We parse it ourselves because Curl::Easy fails when there's no text message
-        @status = header.scan(/HTTP\/\d\.\d\s(\d+)\s/).map(&:first).last.to_i
+        @status = status
         @url = url
       end
 
@@ -69,90 +79,123 @@ module Pebblebed
 
     def self.get(url = nil, params = nil, &block)
       url, params = url_and_params_from_args(url, params, &block)
-      return do_easy { |easy|
-        easy.url = url_with_params(url, params)
-        easy.http_get
+      return do_request(url) { |connection|
+        connection.get(
+          :host => url.host,
+          :path => url.path,
+          :query => params,
+          :persistent => true
+        )
       }
     end
 
     def self.post(url, params, &block)
       url, params = url_and_params_from_args(url, params, &block)
       content_type, body = serialize_params(params)
-      return do_easy { |easy|
-        easy.url = url.to_s
-        easy.headers['Accept'] = 'application/json'
-        easy.headers['Content-Type'] = content_type
-        easy.http_post(body)
+      return do_request(url, idempotent: false) { |connection|
+        connection.post(
+          :host => url.host,
+          :path => url.path,
+          :headers => {
+            'Accept' => 'application/json',
+            'Content-Type' => content_type
+          },
+          :body => body,
+          :persistent => true
+        )
       }
     end
 
     def self.put(url, params, &block)
       url, params = url_and_params_from_args(url, params, &block)
       content_type, body = serialize_params(params)
-      return do_easy { |easy|
-        easy.url = url.to_s
-        easy.headers['Accept'] = 'application/json'
-        easy.headers['Content-Type'] = content_type
-        easy.http_put(body)
+      return do_request(url) { |connection|
+        connection.put(
+          :host => url.host,
+          :path => url.path,
+          :headers => {
+            'Accept' => 'application/json',
+            'Content-Type' => content_type
+          },
+          :body => body,
+          :persistent => true
+        )
       }
     end
 
     def self.delete(url, params, &block)
       url, params = url_and_params_from_args(url, params, &block)
-      return do_easy { |easy|
-        easy.url = url_with_params(url, params)
-        easy.http_delete
+      return do_request(url) { |connection|
+        connection.delete(
+          :host => url.host,
+          :path => url.path,
+          :query => params,
+          :persistent => true
+        )
       }
     end
 
-    def self.stream_get(url = nil, params = nil, options = {})
-      return do_easy(cache: false) { |easy|
-        on_data = options[:on_data] or raise "Option :on_data must be specified"
-
-        url, params = url_and_params_from_args(url, params)
+    def self.streamer(on_data)
+      lambda do |chunk, remaining_bytes, total_bytes|
+        on_data.call(chunk)
+        total_bytes
+      end
+    end
 
-        easy.url = url_with_params(url, params)
-        easy.on_body do |data|
-          on_data.call(data)
-          data.length
-        end
-        easy.http_get
+    def self.stream_get(url = nil, params = nil, options = {})
+      on_data = options[:on_data] or raise "Option :on_data must be specified"
+
+      url, params = url_and_params_from_args(url, params)
+      return do_request(url) { |connection|
+        connection.get(
+          :host => url.host,
+          :path => url.path,
+          :query => params,
+          :persistent => false,
+          :response_block => streamer(on_data)
+        )
       }
     end
 
     def self.stream_post(url, params, options = {})
-      return do_easy(cache: false) { |easy|
-        on_data = options[:on_data] or raise "Option :on_data must be specified"
-
-        url, params = url_and_params_from_args(url, params)
-        content_type, body = serialize_params(params)
-
-        easy.url = url.to_s
-        easy.headers['Accept'] = 'application/json'
-        easy.headers['Content-Type'] = content_type
-        easy.on_body do |data|
-          on_data.call(data)
-          data.length
-        end
-        easy.http_post(body)
+      on_data = options[:on_data] or raise "Option :on_data must be specified"
+
+      url, params = url_and_params_from_args(url, params)
+      content_type, body = serialize_params(params)
+
+      return do_request(url) { |connection|
+        connection.post(
+          :host => url.host,
+          :path => url.path,
+          :headers => {
+            'Accept' => 'application/json',
+            'Content-Type' => content_type
+          },
+          :body => body,
+          :persistent => false,
+          :response_block => streamer(on_data)
+        )
       }
     end
 
     def self.stream_put(url, params, options = {})
-      return do_easy(cache: false) { |easy|
-        on_data = options[:on_data] or raise "Option :on_data must be specified"
-
-        url, params = url_and_params_from_args(url, params)
-        content_type, body = serialize_params(params)
-
-        easy.url = url.to_s
-        easy.headers['Accept'] = 'application/json'
-        easy.headers['Content-Type'] = content_type
-        easy.on_body do |data|
-          on_data.call(data)
-          data.length
-        end
-        easy.http_put(body)
+      on_data = options[:on_data] or raise "Option :on_data must be specified"
+
+      url, params = url_and_params_from_args(url, params)
+      content_type, body = serialize_params(params)
+
+      return do_request(url) { |connection|
+        connection.put(
+          :host => url.host,
+          :path => url.path,
+          :headers => {
+            'Accept' => 'application/json',
+            'Content-Type' => content_type
+          },
+          :body => body,
+          :persistent => false,
+          :response_block => streamer(on_data)
+        )
       }
     end
 
@@ -191,44 +234,72 @@ module Pebblebed
       response
     end
 
-    def self.do_easy(cache: true, &block)
-      with_easy(cache: cache) do |easy|
-        yield easy
-        response = Response.new(easy.url, easy.header_str, easy.body_str)
-        return handle_http_errors(response)
+    def self.do_request(url, idempotent: true, &block)
+      with_connection(url) { |connection|
+        begin
+          request = block.call(connection)
+          response = Response.new(url, request.status, request.body)
+          return handle_http_errors(response)
+        rescue Excon::Errors::Timeout => error
+          raise HttpTimeoutError.new(error)
+        rescue Excon::Errors::SocketError => error
+          raise HttpSocketError.new(error) unless idempotent
+          # Connection failed, close the connection and try again
+          connection.reset
+          begin
+            request = block.call(connection)
+            response = Response.new(url, request.status, request.body)
+            return handle_http_errors(response)
+          rescue Excon::Errors::SocketError => error
+            raise HttpSocketError.new(error)
+          end
+        end
+      }
+    end
+
+    def self.with_connection(url, &block)
+      connection = self.current_connection(url) || new_connection(url)
+      self.current_connection={:url => url, :connection => connection}
+      yield connection
+    end
+
+    def self.base_url(url)
+      if url.is_a?(URI)
+        uri = url
+      else
+        uri = URI.parse(url)
       end
+      "#{uri.scheme}://#{uri.host}:#{uri.port}"
     end
 
-    def self.with_easy(cache: true, &block)
-      if cache
-        easy = self.current_easy ||= new_easy
+    def self.cache_key(url)
+      if url.is_a?(URI)
+        uri = url
       else
-        easy = new_easy
+        uri = URI.parse(url)
       end
-      yield easy
+      ip = Resolv.getaddress(uri.host)
+      "#{uri.scheme}://#{ip}:#{uri.port}"
     end
 
-    def self.current_easy
-      Thread.current[:pebblebed_curb_easy]
+    def self.current_connection(url)
+      Thread.current[:pebblebed_excon] ||= {}
+      Thread.current[:pebblebed_excon][cache_key(url)]
     end
 
-    def self.current_easy=(value)
-      if (current = Thread.current[:pebblebed_curb_easy])
-        # Reset old instance
-        current.reset
-      end
-      Thread.current[:pebblebed_curb_easy] = value
+    def self.current_connection=(value)
+      Thread.current[:pebblebed_excon] ||= {}
+      Thread.current[:pebblebed_excon][cache_key(value[:url])] = value[:connection]
     end
 
-    # Returns new Easy instance from current configuration.
-    def self.new_easy
-      easy = Curl::Easy.new
-      easy.connect_timeout = connect_timeout || DEFAULT_CONNECT_TIMEOUT
-      easy.timeout = request_timeout || DEFAULT_REQUEST_TIMEOUT
-      easy.low_speed_time = read_timeout || DEFAULT_READ_TIMEOUT
-      easy.low_speed_limit = 1
-      easy.follow_location = true
-      easy
+    # Returns new Excon conection from current configuration.
+    def self.new_connection(url)
+      connection = Excon.new(base_url(url), {
+        :read_timeout => read_timeout || DEFAULT_READ_TIMEOUT,
+        :write_timeout => write_timeout || DEFAULT_WRITE_TIMEOUT,
+        :connect_timeout => connect_timeout || DEFAULT_CONNECT_TIMEOUT,
+        :thread_safe_sockets => false
+      })
     end
 
     def self.url_with_params(url, params)

data/lib/pebblebed/version.rb

@@ -1,3 +1,3 @@
 module Pebblebed
-  VERSION = "0.3.26"
+  VERSION = "0.4.0"
 end

data/pebblebed.gemspec

@@ -25,9 +25,10 @@ Gem::Specification.new do |s|
   s.add_development_dependency "sinatra" # for testing purposes
   s.add_development_dependency "rack-test" # for testing purposes
   s.add_development_dependency "memcache_mock"
+  s.add_development_dependency "webmock"
 
   s.add_runtime_dependency "deepstruct", ">= 0.0.4"
-  s.add_runtime_dependency "curb", ">= 0.8.8"
+  s.add_runtime_dependency "excon", ">= 0.52.0"
   s.add_runtime_dependency "yajl-ruby"
   s.add_runtime_dependency "queryparams"
   s.add_runtime_dependency "futurevalue"

data/spec/http_spec.rb

@@ -22,8 +22,8 @@ describe Pebblebed::Http do
 
   before :all do
     Pebblebed::Http.connect_timeout = nil
-    Pebblebed::Http.request_timeout = nil
     Pebblebed::Http.read_timeout = nil
+    Pebblebed::Http.write_timeout = nil
 
     # Starts the mock pebble at localhost:8666/api/mock/v1
     mock_pebble.start
@@ -101,7 +101,7 @@ describe Pebblebed::Http do
           })
         result = JSON.parse(buf)
         expect(result["QUERY_STRING"]).to eq "hello=world"
-        expect(response.body).to eq nil
+        expect(response.body).to eq ''
       end
 
       it "supports multiple sequential streaming request" do
@@ -113,31 +113,53 @@ describe Pebblebed::Http do
             })
           result = JSON.parse(buf)
           expect(result["QUERY_STRING"]).to eq "hello=world"
-          expect(response.body).to eq nil
+          expect(response.body).to eq ''
         end
       end
     end
   end
-
-  it "enforces request timeout" do
-    Pebblebed::Http.request_timeout = 1
-    expect {
-      Pebblebed::Http.get(pebble_url, {slow: '2'})
-    }.to raise_error(Curl::Err::TimeoutError)
-    expect {
-      Pebblebed::Http.get(pebble_url, {slow: '0.5'})
-    }.not_to raise_error
-  end
-
   it "enforces read timeout" do
-    Pebblebed::Http.request_timeout = 1000
     Pebblebed::Http.read_timeout = 1
     expect {
       Pebblebed::Http.get(pebble_url, {slow: '30'})
-    }.to raise_error(Curl::Err::TimeoutError)
+    }.to raise_error(Pebblebed::HttpTimeoutError)
     expect {
       Pebblebed::Http.get(pebble_url, {slow: '0.5'})
     }.not_to raise_error
   end
 
+  describe 'retrying' do
+    run_count = 0
+
+    before do
+      Excon.stub({:method => :post}) {
+        raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
+      }
+      Excon.stub({:method => :get}) { |params|
+        run_count += 1
+        if run_count <= 2
+          raise Excon::Errors::SocketError.new(Exception.new "Mock Error")
+        end
+        {:body => params[:body], :headers => params[:headers], :status => 200}
+      }
+    end
+
+    after do
+      Excon.stubs.clear
+    end
+
+    it "post with error doesn't try again" do
+      expect {
+        Pebblebed::Http.post(pebble_url, {hello: 'world'})
+      }.to raise_error(Pebblebed::HttpSocketError)
+    end
+
+    it "get request tries one more time" do
+      expect {
+        Pebblebed::Http.get(pebble_url, {hello: 'world'})
+      }.to raise_error(Pebblebed::HttpSocketError)
+      expect(run_count).to equal(2)
+    end
+
+  end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'simplecov'
 require 'rspec'
+require 'webmock/rspec'
 
 SimpleCov.add_filter 'spec'
 SimpleCov.add_filter 'config'
@@ -11,6 +12,7 @@ require './spec/mock_pebble'
 RSpec.configure do |c|
   c.mock_with :rspec
   c.before(:each) do
+    WebMock.allow_net_connect!
     ::Pebblebed.memcached = MemcacheMock.new
   end
   c.around(:each) do |example|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebblebed
 version: !ruby/object:Gem::Version
-  version: 0.3.26
+  version: 0.4.0
 platform: ruby
 authors:
 - Katrina Owen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-25 00:00:00.000000000 Z
+date: 2018-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -95,6 +95,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: deepstruct
   requirement: !ruby/object:Gem::Requirement
@@ -110,19 +124,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.0.4
 - !ruby/object:Gem::Dependency
-  name: curb
+  name: excon
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.8
+        version: 0.52.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.8
+        version: 0.52.0
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
   requirement: !ruby/object:Gem::Requirement