restify 2.1.0 → 3.0.0.rc3

data/lib/restify/timeout.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'hitimes'
+require 'timeout'
 
 module Restify
   class Timeout
@@ -8,56 +8,44 @@ module Restify
       attr_accessor :default_timeout
     end
 
-    # Default wait timeout of 300 seconds.
     self.default_timeout = 300
 
+    # @return [Float] Seconds to wait in total.
+    attr_reader :duration
+
     def initialize(timeout, target = nil)
-      @timeout = parse_timeout(timeout)
       @target = target
-
-      @interval = ::Hitimes::Interval.new
-      @interval.start
+      @duration = parse_timeout(timeout)
+      @deadline = now + @duration
     end
 
-    def wait_on!(ivar)
-      ivar.value!(wait_interval).tap do
-        raise self unless ivar.complete?
-      end
-    rescue ::Timeout::Error
-      raise self
-    end
-
-    def timeout!
-      raise self if wait_interval <= 0
+    def remaining
+      @deadline - now
     end
 
     def exception
-      Error.new(@target)
+      Error.new(@target, @duration)
     end
 
     private
 
-    def wait_interval
-      @timeout - @interval.to_f
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
     def parse_timeout(value)
-      return self.class.default_timeout if value.nil?
-
-      begin
-        value = Float(value)
-      rescue ArgumentError
-        raise ArgumentError.new \
-          "Timeout must be an number but is #{value}"
-      end
+      value = self.class.default_timeout if value.nil?
+      timeout = Float(value, exception: false)
 
-      raise ArgumentError.new "Timeout must be > 0 but is #{value.inspect}." unless value.positive?
+      raise ArgumentError.new("Timeout must be a number but is #{value.inspect}") unless timeout
+      raise ArgumentError.new("Timeout must be > 0 but is #{value.inspect}.") unless timeout.positive?
+      raise ArgumentError.new("Timeout must be finite but is #{value.inspect}.") unless timeout.finite?
 
-      value
+      timeout
     end
 
     class << self
-      def new(timeout, *args)
+      def new(timeout, target = nil)
         return timeout if timeout.is_a?(self)
 
         super
@@ -65,15 +53,16 @@ module Restify
     end
 
     class Error < ::Timeout::Error
-      attr_reader :target
+      attr_reader :target, :duration
 
-      def initialize(target)
+      def initialize(target, duration)
         @target = target
+        @duration = duration
 
         if @target
-          super("Operation on #{@target} timed out")
+          super("Operation on #{@target} timed out after #{duration}s")
         else
-          super('Operation timed out')
+          super("Operation timed out after #{duration}s")
         end
       end
     end

data/lib/restify/version.rb

@@ -2,10 +2,10 @@
 
 module Restify
   module VERSION
-    MAJOR = 2
-    MINOR = 1
+    MAJOR = 3
+    MINOR = 0
     PATCH = 0
-    STAGE = nil
+    STAGE = :rc3
     STRING = [MAJOR, MINOR, PATCH, STAGE].compact.join('.').freeze
 
     def self.to_s

data/lib/restify/webmock.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'restify'
+require 'webmock'
+
+module WebMock
+  module HttpLibAdapters
+    #
+    # WebMock support for Restify (independent of the adapter)
+    #
+    # Requests are intercepted before they are handed over to an
+    # adapter. Stubbed responses are returned as they are, including
+    # redirects, like WebMock does for other libcurl-based libraries.
+    # Requests not stubbed are passed on to the adapter, if allowed.
+    #
+    # Must be loaded before WebMock is enabled, e.g. in
+    # `spec_helper.rb`:
+    #
+    #     require 'webmock/rspec'
+    #     require 'restify/webmock'
+    #
+    class RestifyAdapter < HttpLibAdapter
+      adapter_for :restify
+
+      class << self
+        def enable!
+          @enabled = true
+        end
+
+        def disable!
+          @enabled = false
+        end
+
+        def enabled?
+          @enabled == true
+        end
+
+        # Respond to a request with a stubbed response, or pass it on to
+        # the given block if allowed.
+        #
+        # @api private
+        def call(request, &)
+          signature = signature(request)
+          RequestRegistry.instance.requested_signatures.put(signature)
+
+          stub = StubRegistry.instance.response_for_request(signature)
+          return passthrough(signature, &) unless stub
+
+          CallbackRegistry.invoke_callbacks({lib: :restify}, signature, stub)
+
+          Restify::Promise.fulfilled(respond(request, stub))
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          # e.g. `NetConnectNotAllowedError`
+          Restify::Promise.rejected(e)
+        end
+
+        private
+
+        def signature(request)
+          RequestSignature.new(
+            request.method.to_sym,
+            request.uri.to_s,
+            body: request.body,
+            headers: request.headers,
+          )
+        end
+
+        def passthrough(signature)
+          unless ::WebMock.net_connect_allowed?(signature.uri)
+            raise NetConnectNotAllowedError.new(signature)
+          end
+
+          yield.tap do |promise|
+            # Observers run when the request is complete, even when
+            # nobody waits on the promise.
+            promise.add_observer do |response, _|
+              next unless response
+
+              CallbackRegistry.invoke_callbacks(
+                {lib: :restify, real_request: true},
+                signature,
+                webmock_response(response),
+              )
+            end
+          end
+        end
+
+        def respond(request, stub)
+          raise Restify::NetworkError.new(request, 'Timeout was reached') if stub.should_timeout
+
+          stub.raise_error_if_any
+
+          headers = (stub.headers || {}).to_h do |name, value|
+            [name.upcase.tr('-', '_'), value]
+          end
+
+          Restify::Response.new(request, request.uri, stub.status[0], headers, stub.body)
+        end
+
+        def webmock_response(response)
+          Response.new.tap do |webmock|
+            webmock.status = [response.code, response.message.to_s]
+            webmock.headers = response.headers.to_h do |name, value|
+              [name.split('_').map(&:capitalize).join('-'), value]
+            end
+            webmock.body = response.body.to_s
+          end
+        end
+      end
+
+      # Intercept requests after `Adapter::Telemetry` but before
+      # `Adapter::Base#call` so that telemetry is included.
+      #
+      # @api private
+      module Intercept
+        def call(request)
+          return super unless RestifyAdapter.enabled?
+
+          RestifyAdapter.call(request) { super }
+        end
+      end
+
+      ::Restify::Adapter::Telemetry.include(Intercept)
+    end
+  end
+end

data/lib/restify.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 
 require 'restify/version'
 
-require 'concurrent'
 require 'addressable/uri'
 require 'addressable/template'
 
@@ -28,7 +27,11 @@ module Restify
 
   module Adapter
     require 'restify/adapter/base'
-    require 'restify/adapter/typhoeus'
+    require 'restify/adapter/loop_lock'
+    require 'restify/adapter/ethon'
+
+    # Optional, requires the `typhoeus` gem.
+    autoload :Typhoeus, 'restify/adapter/typhoeus'
   end
 
   module Processors

data/spec/restify/adapter/ethon/easy_spec.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Ethon::Easy do
+  let(:easy) { described_class.new }
+
+  describe '#response' do
+    subject(:response) { easy.response(request) }
+
+    let(:request) { Restify::Request.new(uri: 'http://example.org/base') }
+
+    # A transfer is handed back from libcurl with its return code and, for
+    # HTTP, the status code of the response.
+    let(:info) do
+      {
+        return_code: :ok,
+        response_code: 200,
+        effective_url: 'http://example.org/base',
+        response_headers: "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n",
+        response_body: '{}',
+      }
+    end
+
+    before { allow(easy).to receive_messages(info) }
+
+    it 'returns the response' do
+      expect(response).to be_a Restify::Response
+      expect(response).to have_attributes(code: 200, body: '{}', request:)
+    end
+
+    it 'reuses the request URI without redirects' do
+      expect(response.uri).to be request.uri
+    end
+
+    context 'when redirected' do
+      let(:info) { super().merge(effective_url: 'http://example.org/other/base') }
+
+      it 'uses the effective URL as the response URI' do
+        expect(response.uri.to_s).to eq 'http://example.org/other/base'
+      end
+    end
+
+    context 'when the transfer failed' do
+      let(:info) { super().merge(return_code: :couldnt_connect, response_code: 0) }
+
+      it { expect { response }.to raise_error Restify::NetworkError, /connect/i }
+    end
+
+    # Non-HTTP protocols are refused before a transfer is started, but
+    # libcurl still reports success with a zero status code whenever no
+    # HTTP status was received, and no status code at all when it cannot
+    # be read back. Neither has a response to process.
+    context 'without an HTTP status' do
+      let(:info) { super().merge(response_code: 0) }
+
+      it { expect { response }.to raise_error Restify::NetworkError, /without HTTP status/ }
+    end
+
+    context 'with an unavailable HTTP status' do
+      let(:info) { super().merge(response_code: nil) }
+
+      it { expect { response }.to raise_error Restify::NetworkError, /without HTTP status/ }
+    end
+
+    describe 'headers' do
+      subject(:headers) { response.headers }
+
+      context 'with multiple values' do
+        let(:info) { super().merge(response_headers: "HTTP/1.1 200 OK\r\nLink: <a>\r\nLink: <b>\r\n\r\n") }
+
+        it { is_expected.to eq('LINK' => ['<a>', '<b>']) }
+      end
+
+      context 'with a folded value' do
+        let(:info) { super().merge(response_headers: "HTTP/1.1 200 OK\r\nX-Long: first\r\n\tsecond\r\n\r\n") }
+
+        it { is_expected.to eq('X_LONG' => 'first second') }
+      end
+
+      context 'with multiple responses, e.g. after a redirect' do
+        let(:info) do
+          super().merge(
+            response_headers: "HTTP/1.1 302 Found\r\nLocation: /b\r\n\r\n" \
+                              "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\n",
+          )
+        end
+
+        it { is_expected.to eq('CONTENT_TYPE' => 'text/plain') }
+      end
+
+      context 'without headers' do
+        let(:info) { super().merge(response_headers: nil) }
+
+        it { is_expected.to eq({}) }
+      end
+    end
+  end
+
+  describe '#reset' do
+    it 'forgets the previous request' do
+      easy._otel_span = Object.new
+      easy._restify_request = Object.new
+      easy._restify_writer = Object.new
+
+      easy.reset
+
+      expect([easy._otel_span, easy._restify_request, easy._restify_writer]).to all be_nil
+    end
+  end
+end

data/spec/restify/adapter/ethon/event_loop_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Ethon::EventLoop do
+  subject(:events) { described_class.new }
+
+  let(:threads) { [] }
+
+  let(:options) do
+    Restify::Adapter::Ethon::Options.new(Restify::Adapter::Ethon::ENFORCED_OPTIONS)
+  end
+
+  before do
+    stub_request(:get, 'http://stubserver/base').to_return(status: 200, body: '{}')
+  end
+
+  after { threads.each(&:kill).each(&:join) }
+
+  # A prepared easy handle with its promise, and a queue recording the
+  # thread completing it.
+  def transfer
+    request = Restify::Request.new(uri: 'http://localhost:9292/base')
+    writer = nil
+    promise = Restify::Promise.create {|w| writer = w }
+    completed_by = Queue.new
+
+    easy = Restify::Adapter::Ethon::Easy.new
+    easy._restify_request = request
+    easy._restify_writer = writer
+    easy.prepare(request, options)
+    easy.on_complete do |completed|
+      completed_by << Thread.current
+      writer.set { completed.response(request) }
+      events.notify
+    end
+
+    [easy, promise, completed_by]
+  end
+
+  describe '#drive' do
+    it 'runs transfers in the calling thread' do
+      easy, promise, completed_by = transfer
+      events.enqueue(easy)
+
+      expect(events.drive(promise, Restify::Timeout.new(1))).to be true
+      expect(promise.value.code).to eq 200
+      expect(completed_by.pop(timeout: 1)).to eq Thread.current
+    end
+
+    it 'gives up when the timeout expires' do
+      expect(events.drive(Restify::Promise.new, Restify::Timeout.new(0.1))).to be true
+    end
+
+    it 'does not run the loop again from within the loop' do
+      events.instance_variable_get(:@lock).acquire(0.1)
+
+      expect(events.drive(Restify::Promise.new, Restify::Timeout.new(0.1))).to be false
+    end
+  end
+
+  describe '#run' do
+    it 'completes transfers enqueued from other threads' do
+      background = Thread.new { events.run }
+      threads << background
+
+      easy, promise, completed_by = transfer
+      events.enqueue(easy)
+
+      expect(completed_by.pop(timeout: 1)).to eq background
+      expect(promise).to be_fulfilled
+    end
+  end
+
+  describe '#forked!' do
+    it 'rejects pending transfers' do
+      easy, promise, = transfer
+      events.enqueue(easy)
+
+      events.forked!
+
+      expect(promise).to be_rejected
+      expect(promise.reason).to be_a Restify::NetworkError
+      expect(promise.reason.message).to include 'Request started before fork'
+    end
+
+    it 'does not release pending handles' do
+      easy, = transfer
+      events.enqueue(easy)
+
+      events.forked!
+
+      expect(easy.handle.autorelease?).to be false
+    end
+  end
+end

data/spec/restify/adapter/ethon/options_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Ethon::Options do
+  subject(:options) { described_class.new(values) }
+
+  def number(name)
+    described_class.number(name)
+  end
+
+  describe '#to_a' do
+    subject(:compiled) { options.to_a }
+
+    context 'with bool options' do
+      let(:values) { {followlocation: true, verbose: false, tcp_keepalive: 0} }
+
+      it 'converts to 1 or 0' do
+        expect(compiled).to eq [
+          [number(:followlocation), :long, 1],
+          [number(:verbose), :long, 0],
+          [number(:tcp_keepalive), :long, 0],
+        ]
+      end
+    end
+
+    context 'with int options' do
+      let(:values) { {timeout_ms: 1500, maxredirs: '5'} }
+
+      it { expect(compiled).to eq [[number(:timeout_ms), :long, 1500], [number(:maxredirs), :long, 5]] }
+    end
+
+    context 'with enum options' do
+      let(:values) { {sslversion: :tlsv1, proxytype: 'https', timecondition: 1} }
+
+      it 'converts symbols, strings, and numbers' do
+        expect(compiled).to eq [
+          [number(:sslversion), :long, 1],
+          [number(:proxytype), :long, 2],
+          [number(:timecondition), :long, 1],
+        ]
+      end
+    end
+
+    context 'with bitmask options' do
+      let(:values) { {protocols: %i[http https], redir_protocols: :https} }
+
+      it { expect(compiled).to eq [[number(:protocols), :long, 3], [number(:redir_protocols), :long, 2]] }
+    end
+
+    context 'with string options' do
+      let(:values) { {useragent: :restify} }
+
+      it { expect(compiled).to eq [[number(:useragent), :string, 'restify']] }
+    end
+
+    context 'with nil values' do
+      let(:values) { {useragent: nil, timeout_ms: 5} }
+
+      it { expect(compiled).to eq [[number(:timeout_ms), :long, 5]] }
+    end
+
+    context 'with other option types' do
+      let(:values) { {postquote: []} }
+
+      it 'uses the generic handling' do
+        expect(compiled).to eq [[:postquote, nil, []]]
+      end
+    end
+  end
+
+  describe '#initialize' do
+    it 'raises on unknown options' do
+      expect { described_class.new(unknown: 1) }.to raise_error ArgumentError, /Unknown libcurl option: unknown/
+    end
+
+    it 'raises on unknown values' do
+      expect { described_class.new(sslversion: :tlsv9) }.to raise_error ArgumentError, /sslversion: :tlsv9/
+    end
+  end
+
+  describe '#apply' do
+    let(:values) { {followlocation: true, useragent: 'restify', postquote: []} }
+    let(:easy) { instance_double(Restify::Adapter::Ethon::Easy, handle: FFI::Pointer.new(1)) }
+
+    it 'sets converted options directly, and others with the generic handling' do
+      expect(Ethon::Curl).to receive(:easy_setopt).with(easy.handle, number(:followlocation), :long, 1)
+      expect(Ethon::Curl).to receive(:easy_setopt).with(easy.handle, number(:useragent), :string, 'restify')
+      expect(Ethon::Curl).to receive(:set_option).with(:postquote, [], easy.handle)
+
+      options.apply(easy)
+    end
+  end
+
+  describe '.number' do
+    it 'returns the number of the libcurl option' do
+      expect(number(:timeout_ms)).to eq 155
+    end
+
+    it 'raises on unknown options' do
+      expect { number(:unknown) }.to raise_error ArgumentError, /Unknown libcurl option/
+    end
+  end
+end

data/spec/restify/adapter/ethon/pool_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Restify::Adapter::Ethon::Pool do
+  subject(:pool) do
+    described_class.new(size: 2) do
+      created << Handle.new(0, Pointer.new(true))
+      created.last
+    end
+  end
+
+  let(:created) { [] }
+
+  before do
+    stub_const('Pointer', Struct.new(:autorelease))
+    stub_const('Handle', Struct.new(:resets, :handle) do
+      def reset
+        self.resets += 1
+      end
+    end,)
+  end
+
+  def release(*handles)
+    handles.each {|handle| pool.release(handle) }
+  end
+
+  describe '#checkout' do
+    it 'creates a handle when none is idle' do
+      expect(pool.checkout).to be created.first
+    end
+
+    it 'reuses released handles' do
+      handle = pool.checkout
+      release(handle)
+
+      expect(pool.checkout).to be handle
+      expect(created.size).to eq 1
+    end
+
+    it 'returns distinct handles to concurrent threads' do
+      release(*Array.new(2) { pool.checkout })
+
+      handles = Array.new(4) { Thread.new { pool.checkout } }.map(&:value)
+
+      expect(handles.map(&:object_id).uniq.size).to eq 4
+    end
+  end
+
+  describe '#release' do
+    it 'resets handles' do
+      handle = pool.checkout
+      release(handle)
+
+      expect(handle.resets).to eq 1
+    end
+
+    it 'keeps a limited number of idle handles' do
+      released = Array.new(3) { pool.checkout }
+      release(*released)
+
+      # Two of them are reused, the third one is created anew.
+      reused = Array.new(3) { pool.checkout }
+
+      expect(reused.count {|handle| released.any? {|r| r.equal?(handle) } }).to eq 2
+      expect(created.size).to eq 4
+    end
+  end
+
+  describe '#forked!' do
+    it 'does not release idle handles' do
+      idle = pool.checkout
+      release(idle)
+
+      pool.forked!
+
+      expect(idle.handle.autorelease).to be false
+      expect(pool.checkout).not_to be idle
+    end
+  end
+end