recurly 3.3.1 → 3.4.0

data/lib/recurly.rb

@@ -7,6 +7,7 @@ require "recurly/requests"
 require "recurly/resources"
 require "recurly/http"
 require "recurly/errors"
+require "recurly/connection_pool"
 require "recurly/client"
 
 module Recurly

data/lib/recurly/client.rb

@@ -1,18 +1,22 @@
-require "faraday"
 require "logger"
 require "erb"
+require "net/https"
+require "base64"
 require_relative "./schema/json_parser"
 require_relative "./schema/file_parser"
-require_relative "./client/adapter"
 
 module Recurly
   class Client
     require_relative "./client/operations"
 
-    BASE_URL = "https://v3.recurly.com/"
+    BASE_HOST = "v3.recurly.com"
+    BASE_PORT = 443
+    CA_FILE = File.join(File.dirname(__FILE__), "../data/ca-certificates.crt")
     BINARY_TYPES = [
       "application/pdf",
     ]
+    JSON_CONTENT_TYPE = "application/json"
+    MAX_RETRIES = 3
 
     # Initialize a client. It requires an API key.
     #
@@ -42,17 +46,19 @@ module Recurly
     # @param subdomain [String] Optional subdomain for the site you wish to be scoped to. Providing this makes all the `site_id` parameters optional.
     def initialize(api_key:, site_id: nil, subdomain: nil, **options)
       set_site_id(site_id, subdomain)
+      set_api_key(api_key)
       set_options(options)
-      set_faraday_connection(api_key)
 
       # execute block with this client if given
       yield(self) if block_given?
     end
 
     def next_page(pager)
-      req = HTTP::Request.new(:get, pager.next, nil)
-      faraday_resp = run_request(req, headers)
-      handle_response! req, faraday_resp
+      path = extract_path(pager.next)
+      request = Net::HTTP::Get.new path
+      set_headers(request)
+      http_response = run_request(request)
+      handle_response! request, http_response
     end
 
     protected
@@ -68,44 +74,44 @@ module Recurly
 
     def get(path, **options)
       path = scope_by_site(path, **options)
-      request = HTTP::Request.new(:get, path, nil)
-      faraday_resp = run_request(request, headers)
-      handle_response! request, faraday_resp
-    rescue Faraday::ClientError => ex
-      raise_network_error!(ex)
+      request = Net::HTTP::Get.new path
+      set_headers(request, options[:headers])
+      http_response = run_request(request, options)
+      handle_response! request, http_response
     end
 
     def post(path, request_data, request_class, **options)
       request_class.new(request_data).validate!
       path = scope_by_site(path, **options)
-      request = HTTP::Request.new(:post, path, JSON.dump(request_data))
-      faraday_resp = run_request(request, headers)
-      handle_response! request, faraday_resp
-    rescue Faraday::ClientError => ex
-      raise_network_error!(ex)
+      request = Net::HTTP::Post.new path
+      request.set_content_type(JSON_CONTENT_TYPE)
+      set_headers(request, options[:headers])
+      request.body = JSON.dump(request_data)
+      http_response = run_request(request, options)
+      handle_response! request, http_response
     end
 
     def put(path, request_data = nil, request_class = nil, **options)
       path = scope_by_site(path, **options)
-      request = HTTP::Request.new(:put, path)
+      request = Net::HTTP::Put.new path
+      request.set_content_type(JSON_CONTENT_TYPE)
+      set_headers(request, options[:headers])
       if request_data
         request_class.new(request_data).validate!
-        logger.info("PUT BODY #{JSON.dump(request_data)}")
-        request.body = JSON.dump(request_data)
+        json_body = JSON.dump(request_data)
+        logger.info("PUT BODY #{json_body}")
+        request.body = json_body
       end
-      faraday_resp = run_request(request, headers)
-      handle_response! request, faraday_resp
-    rescue Faraday::ClientError => ex
-      raise_network_error!(ex)
+      http_response = run_request(request, options)
+      handle_response! request, http_response
     end
 
     def delete(path, **options)
       path = scope_by_site(path, **options)
-      request = HTTP::Request.new(:delete, path, nil)
-      faraday_resp = run_request(request, headers)
-      handle_response! request, faraday_resp
-    rescue Faraday::ClientError => ex
-      raise_network_error!(ex)
+      request = Net::HTTP::Delete.new path
+      set_headers(request, options[:headers])
+      http_response = run_request(request, options)
+      handle_response! request, http_response
     end
 
     protected
@@ -118,18 +124,70 @@ module Recurly
     # @return [Logger]
     attr_reader :logger
 
-    def run_request(request, headers)
-      read_headers @conn.run_request(request.method, request.path, request.body, headers)
+    @connection_pool = Recurly::ConnectionPool.new
+
+    class << self
+      # @return [Recurly::ConnectionPool]
+      attr_accessor :connection_pool
+    end
+
+    def run_request(request, options = {})
+      self.class.connection_pool.with_connection do |http|
+        set_http_options(http, options)
+
+        retries = 0
+
+        begin
+          http.start unless http.started?
+          http.request(request)
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH, Errno::ECONNABORTED,
+               Errno::EPIPE, Errno::ETIMEDOUT, Net::OpenTimeout, EOFError, SocketError => ex
+          retries += 1
+          if retries < MAX_RETRIES
+            retry
+          end
+
+          if ex.kind_of?(Net::OpenTimeout) || ex.kind_of?(Errno::ETIMEDOUT)
+            raise Recurly::Errors::TimeoutError, "Request timed out"
+          end
+
+          raise Recurly::Errors::ConnectionFailedError, "Failed to connect to Recurly: #{ex.message}"
+        rescue Net::ReadTimeout, Timeout::Error
+          raise Recurly::Errors::TimeoutError, "Request timed out"
+        rescue OpenSSL::SSL::SSLError => ex
+          raise Recurly::Errors::SSLError, ex.message
+        rescue StandardError => ex
+          raise Recurly::Errors::NetworkError, ex.message
+        end
+      end
+    end
+
+    def set_headers(request, additional_headers = {})
+      request["Accept"] = "application/vnd.recurly.#{api_version}".chomp # got this method from operations.rb
+      request["Authorization"] = "Basic #{Base64.encode64(@api_key)}".chomp
+      request["User-Agent"] = "Recurly/#{VERSION}; #{RUBY_DESCRIPTION}"
+
+      # TODO this is undocumented until we finalize it
+      additional_headers.each { |header, v| request[header] = v } if additional_headers
+    end
+
+    def set_http_options(http, options)
+      http.open_timeout = options[:open_timeout] || 20
+      http.read_timeout = options[:read_timeout] || 60
+
+      http.set_debug_output(logger) if @log_level <= Logger::INFO && !http.started?
     end
 
-    def handle_response!(request, faraday_resp)
-      response = HTTP::Response.new(faraday_resp, request)
-      raise_api_error!(response) unless (200...300).include?(response.status)
+    def handle_response!(request, http_response)
+      response = HTTP::Response.new(http_response, request)
+      raise_api_error!(http_response, response) unless http_response.kind_of?(Net::HTTPSuccess)
       resource = if response.body
-          if BINARY_TYPES.include?(response.content_type)
+          if http_response.content_type.include?(JSON_CONTENT_TYPE)
+            JSONParser.parse(self, response.body)
+          elsif BINARY_TYPES.include?(http_response.content_type)
             FileParser.parse(response.body)
           else
-            JSONParser.parse(self, response.body)
+            raise Recurly::Errors::InvalidResponseError, "Unexpected content type: #{http_response.content_type}"
           end
         else
           Resources::Empty.new
@@ -139,25 +197,21 @@ module Recurly
       resource
     end
 
-    def raise_network_error!(ex)
-      error_class = case ex
-        when Faraday::TimeoutError
-          Errors::TimeoutError
-        when Faraday::ConnectionFailed
-          Errors::ConnectionFailedError
-        when Faraday::SSLError
-          Errors::SSLError
-        else
-          Errors::NetworkError
-        end
+    def raise_api_error!(http_response, response)
+      if response.content_type.include?(JSON_CONTENT_TYPE)
+        error = JSONParser.parse(self, response.body)
+        error_class = Errors::APIError.error_class(error.type)
+        raise error_class.new(response, error)
+      end
 
-      raise error_class, ex.message
-    end
+      error_class = Errors::APIError.from_response(http_response)
 
-    def raise_api_error!(response)
-      error = JSONParser.parse(self, response.body)
-      error_class = Errors::APIError.error_class(error.type)
-      raise error_class.new(response, error)
+      if error_class <= Recurly::Errors::APIError
+        error = Recurly::Resources::Error.new(message: "#{http_response.code}: #{http_response.message}")
+        raise error_class.new(response, error)
+      else
+        raise error_class, "#{http_response.code}: #{http_response.message}"
+      end
     end
 
     def read_headers(response)
@@ -167,14 +221,6 @@ module Recurly
       response
     end
 
-    def headers
-      {
-        "Accept" => "application/vnd.recurly.#{api_version}", # got this method from operations.rb
-        "Content-Type" => "application/json",
-        "User-Agent" => "Recurly/#{VERSION}; #{RUBY_DESCRIPTION}",
-      }.merge(@extra_headers)
-    end
-
     def interpolate_path(path, **options)
       options.each do |k, v|
         # Check to see that we are passing the correct data types
@@ -201,6 +247,10 @@ module Recurly
       end
     end
 
+    def set_api_key(api_key)
+      @api_key = api_key
+    end
+
     def scope_by_site(path, **options)
       if site = site_id || options[:site_id]
         "/sites/#{site}#{path}"
@@ -209,34 +259,16 @@ module Recurly
       end
     end
 
-    def set_faraday_connection(api_key)
-      options = {
-        url: BASE_URL,
-        request: { timeout: 60, open_timeout: 50 },
-        ssl: { verify: true },
-      }
-      # Let's not use the bundled cert in production yet
-      # but we will use these certs for any other staging or dev environment
-      unless BASE_URL.end_with?(".recurly.com")
-        options[:ssl][:ca_file] = File.join(File.dirname(__FILE__), "../data/ca-certificates.crt")
-      end
-
-      @conn = Faraday.new(options) do |faraday|
-        if [Logger::DEBUG, Logger::INFO].include?(@log_level)
-          faraday.response :logger
-        end
-        faraday.basic_auth(api_key, "")
-        configure_net_adapter(faraday)
-      end
+    # Returns just the path and parameters so we can safely reuse the connection
+    def extract_path(uri_or_path)
+      uri = URI(uri_or_path)
+      uri.kind_of?(URI::HTTP) ? uri.request_uri : uri_or_path
     end
 
     def set_options(options)
       @log_level = options[:log_level] || Logger::WARN
       @logger = Logger.new(STDOUT)
       @logger.level = @log_level
-
-      # TODO this is undocumented until we finalize it
-      @extra_headers = options[:headers] || {}
     end
   end
 end

data/lib/recurly/connection_pool.rb

@@ -0,0 +1,40 @@
+require "net/https"
+
+module Recurly
+  class ConnectionPool
+    def initialize
+      @mutex = Mutex.new
+      @pool = []
+    end
+
+    def with_connection
+      http = nil
+      @mutex.synchronize do
+        http = @pool.pop
+      end
+
+      # create connection if the pool was empty
+      http ||= init_http_connection
+
+      response = yield http
+
+      if http.started?
+        @mutex.synchronize do
+          @pool.push(http)
+        end
+      end
+
+      response
+    end
+
+    def init_http_connection
+      http = Net::HTTP.new(Client::BASE_HOST, Client::BASE_PORT)
+      http.use_ssl = true
+      http.ca_file = Client::CA_FILE
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      http.keep_alive_timeout = 600
+
+      http
+    end
+  end
+end

data/lib/recurly/errors.rb

@@ -17,6 +17,36 @@ module Recurly
         Errors.const_get(class_name)
       end
 
+      # When the response does not have a JSON body, this determines the appropriate
+      # Error class based on the response code. This may occur when a load balancer
+      # returns an error before it reaches Recurly's API.
+      # @param response [Net::Response]
+      # @return [Errors::APIError,Errors::NetworkError]
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def self.from_response(response)
+        case response
+        when Net::HTTPBadRequest # 400
+          Recurly::Errors::BadRequestError
+        when Net::HTTPUnauthorized, Net::HTTPForbidden # 401, 403
+          Recurly::Errors::UnauthorizedError
+        when Net::HTTPRequestTimeOut # 408
+          Recurly::Errors::TimeoutError
+        when Net::HTTPTooManyRequests # 429
+          Recurly::Errors::RateLimitedError
+        when Net::HTTPInternalServerError # 500
+          Recurly::Errors::InternalServerError
+        when Net::HTTPServiceUnavailable # 503
+          Recurly::Errors::UnavailableError
+        when Net::HTTPGatewayTimeOut # 504
+          Recurly::Errors::TimeoutError
+        when Net::HTTPServerError # 5xx
+          Recurly::Errors::UnavailableError
+        else
+          Recurly::Errors::APIError
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
       def initialize(response, error)
         super(error.message)
         @response = response

data/lib/recurly/errors/network_errors.rb

@@ -1,8 +1,10 @@
 module Recurly
   module Errors
     class NetworkError < StandardError; end
+    class InvalidResponseError < NetworkError; end
     class TimeoutError < NetworkError; end
     class ConnectionFailedError < NetworkError; end
     class SSLError < NetworkError; end
+    class UnavailableError < NetworkError; end
   end
 end

data/lib/recurly/http.rb

@@ -8,12 +8,16 @@ module Recurly
 
       def initialize(resp, request)
         @request = request
-        @status = resp.status
-        @request_id = resp.headers["x-request-id"]
-        @rate_limit = resp.headers["x-ratelimit-limit"].to_i
-        @rate_limit_remaining = resp.headers["x-ratelimit-remaining"].to_i
-        @rate_limit_reset = Time.at(resp.headers["x-ratelimit-reset"].to_i).to_datetime
-        @content_type = resp.headers["content-type"].split(";").first if resp.headers["content-type"]
+        @status = resp.code.to_i
+        @request_id = resp["x-request-id"]
+        @rate_limit = resp["x-ratelimit-limit"].to_i
+        @rate_limit_remaining = resp["x-ratelimit-remaining"].to_i
+        @rate_limit_reset = Time.at(resp["x-ratelimit-reset"].to_i).to_datetime
+        if resp["content-type"]
+          @content_type = resp["content-type"].split(";").first
+        else
+          @content_type = resp.content_type
+        end
         if resp.body && !resp.body.empty?
           @body = resp.body
         else

data/lib/recurly/version.rb

@@ -1,3 +1,3 @@
 module Recurly
-  VERSION = "3.3.1"
+  VERSION = "3.4.0"
 end

data/recurly.gemspec

@@ -21,9 +21,6 @@ Gem::Specification.new do |spec|
   # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "faraday", ">= 0.8.11", "< 1.0.0"
-
-  spec.add_development_dependency "net-http-persistent", "~> 2.9.4"
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake", "~> 12.3.3"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,49 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: recurly
 version: !ruby/object:Gem::Version
-  version: 3.3.1
+  version: 3.4.0
 platform: ruby
 authors:
 - Recurly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-20 00:00:00.000000000 Z
+date: 2020-03-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.8.11
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.8.11
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: net-http-persistent
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.9.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.9.4
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -168,8 +134,8 @@ files:
 - lib/data/ca-certificates.crt
 - lib/recurly.rb
 - lib/recurly/client.rb
-- lib/recurly/client/adapter.rb
 - lib/recurly/client/operations.rb
+- lib/recurly/connection_pool.rb
 - lib/recurly/errors.rb
 - lib/recurly/errors/api_errors.rb
 - lib/recurly/errors/network_errors.rb
@@ -320,7 +286,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: The ruby client for Recurly's V3 API