restify 3.0.0.rc2 → 3.0.0.rc3

data/lib/restify/promise.rb

@@ -1,95 +1,229 @@
 # frozen_string_literal: true
 
 module Restify
-  class Promise < Concurrent::IVar
-    # A driver that can complete this promise in the waiting thread,
-    # e.g. an adapter running its event loop. See `#wait`.
-    #
+  class Promise
+    class AlreadyCompleteError < StandardError; end
+
     # @api private
     attr_writer :driver
 
+    # @api private
+    attr_reader :reason
+
     def initialize(*dependencies, &task)
-      @task         = task
-      @dependencies = dependencies.flatten
+      @mutex        = Mutex.new
+      @condition    = nil
+      @observers    = nil
       @driver       = nil
+      @state        = :pending
+      @value        = nil
+      @reason       = nil
+      @task         = task
+      @dependencies = dependencies.empty? ? nil : dependencies.flatten
+
+      # When dependencies were passed in, but none are left after
+      # flattening, then we don't have to wait for explicit dependencies
+      # or resolution through a writer.
+      fulfill([]) if !@task && @dependencies&.empty?
+    end
 
-      super(&nil)
+    def pending?
+      @state == :pending
+    end
+
+    def fulfilled?
+      @state == :fulfilled
+    end
+
+    def rejected?
+      @state == :rejected
+    end
+
+    def complete?
+      @state == :fulfilled || @state == :rejected
+    end
 
-      # When dependencies were passed in, but none are left after flattening,
-      # then we don't have to wait for explicit dependencies or resolution
-      # through a writer.
-      complete true, [], nil if !@task && @dependencies.empty? && dependencies.any?
+    def incomplete?
+      !complete?
     end
 
+    # Wait until the promise is complete.
+    #
+    # @param timeout [Numeric, Restify::Timeout, nil] Maximum seconds
+    #   to wait, or `Restify::Timeout.default_timeout` if nil.
+    #
+    # @raise [Restify::Timeout::Error] When the timeout expired first.
+    #
+    # @return [self]
+    #
     def wait(timeout = nil)
-      t = Timeout.new(timeout, self)
+      return self if complete?
 
-      execute(t) if pending?
+      timeout = Timeout.new(timeout, self)
 
       # Let the driver run on the current thread instead of sleeping and
-      # switching to another thread if possible. If unsupported, the
-      # driver returns false.
-      super unless incomplete? && @driver&.drive(self, t)
+      # switching to another thread if possible. The driver returns when
+      # the promise is complete, the timeout expired, or it cannot run
+      # here.
+      @driver&.drive(self, timeout)
+
+      until complete?
+        remaining = timeout.remaining
+        raise timeout unless remaining.positive?
 
-      raise t if incomplete?
+        run(timeout) if claim(remaining)
+      end
 
       self
     end
 
+    # Wait until the promise is complete, and return its value, or nil
+    # if it was rejected.
+    #
+    # @see #wait
+    #
+    def value(timeout = nil)
+      wait(timeout)
+      @value
+    end
+
+    # Wait until the promise is complete, and return its value, or raise
+    # the reason it was rejected with.
+    #
+    # @see #wait
+    #
+    def value!(timeout = nil)
+      wait(timeout)
+      raise @reason if rejected?
+
+      @value
+    end
+
+    # Return a new promise that will be fulfilled with the result of the
+    # given block once this promise is complete.
+    #
     def then(&)
-      Promise.new([self], &)
+      Promise.new(self, &)
     end
 
-    def execute(timeout = nil)
-      synchronize { ns_execute timeout }
+    # @api private
+    #
+    def add_observer(&block)
+      complete = @mutex.synchronize do
+        (@observers ||= []) << block unless complete?
+        complete?
+      end
+
+      yield(@value, @reason) if complete
+
+      self
+    end
+
+    private
+
+    def fulfill(value)
+      complete(:fulfilled, value, nil)
     end
 
-    protected
+    def reject(reason)
+      complete(:rejected, nil, reason)
+    end
+
+    def complete(state, value, reason)
+      observers = @mutex.synchronize do
+        raise AlreadyCompleteError.new("Promise already #{@state}") if complete?
+
+        # Set the state last, as it is read without holding the lock:
+        @value  = value
+        @reason = reason
+        @state  = state
+
+        # Release everything not needed anymore:
+        @task = @dependencies = nil
 
-    # @!visibility private
-    def ns_execute(timeout = nil)
-      return unless compare_and_set_state(:processing, :pending)
-      return unless @task || @dependencies.any?
+        @condition&.broadcast
 
-      executor = Concurrent::SafeTaskExecutor.new \
-        method(:ns_exec), rescue_exception: true
+        @observers.tap { @observers = nil }
+      end
 
-      success, value, reason = executor.execute(timeout)
+      observers&.each do |observer|
+        observer.call(value, reason)
+      rescue StandardError => e
+        Restify.logger&.error(self.class.name) { e }
+      end
 
-      complete success, value, reason
+      self
     end
 
-    # @!visibility private
-    def ns_exec(timeout = nil)
-      t = Timeout.new(timeout, self)
+    # Claim running the task for the current thread, or sleep until the
+    # promise is complete, or can be claimed, e.g. because another
+    # thread gave up running it.
+    #
+    # The mutex is only held to claim, not while running the task. Other
+    # threads sleep on the condition variable with their own remaining
+    # time, whereas blocking on the mutex could not time out.
+    #
+    def claim(remaining)
+      @mutex.synchronize do
+        next false if complete?
+
+        if @state == :pending && (@task || @dependencies)
+          @state = :processing
+          next true
+        end
 
-      args = @dependencies.map do |d|
-        t.wait_on!(d)
+        (@condition ||= ConditionVariable.new).wait(@mutex, remaining)
+        false
       end
+    end
 
-      value = @task ? @task.call(*args) : args
-      value = t.wait_on!(value) while value.is_a?(Promise)
-      value
+    def run(timeout)
+      until complete?
+        if (rejected = @dependencies&.find {|d| d.wait(timeout).rejected? })
+          return reject(rejected.reason)
+        end
+
+        args = @dependencies&.map(&:value)
+
+        begin
+          value = @task ? @task.call(*args) : args
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          return reject(e)
+        end
+
+        if value.is_a?(Promise)
+          @dependencies = [value]
+          @task = ->(v) { v }
+        else
+          fulfill(value)
+        end
+      end
+    ensure
+      # Give up the claim when the timeout expired, or the thread was
+      # killed. Another waiting thread can take over, and continue with
+      # the dependencies completed so far.
+      if @state == :processing
+        @mutex.synchronize do
+          @state = :pending
+          @condition&.broadcast
+        end
+      end
     end
 
     class << self
       def create(driver: nil)
-        promise = Promise.new
+        promise = new
         promise.driver = driver
         yield Writer.new(promise)
         promise
       end
 
       def fulfilled(value)
-        create do |writer|
-          writer.fulfill value
-        end
+        new.send(:fulfill, value)
       end
 
-      def rejected(value)
-        create do |writer|
-          writer.reject value
-        end
+      def rejected(reason)
+        new.send(:reject, reason)
       end
     end
 
@@ -99,11 +233,11 @@ module Restify
       end
 
       def fulfill(value)
-        @promise.send :complete, true, value, nil
+        @promise.send(:fulfill, value)
       end
 
       def reject(reason)
-        @promise.send :complete, false, nil, reason
+        @promise.send(:reject, reason)
       end
 
       def set

data/lib/restify/relation.rb

@@ -55,13 +55,15 @@ module Restify
     end
 
     def expand(params)
-      params    = convert params
-      variables = extract! params
+      params    = convert(params)
+      variables = extract!(params)
 
-      uri = template.expand variables
-      uri.query_values = (uri.query_values || {}).merge params if params.any?
+      return expand_static(params) if template.variables.empty?
 
-      context.join uri
+      uri = template.expand(variables)
+      uri.query_values = (uri.query_values || {}).merge(params) if params.any?
+
+      context.join(uri)
     end
 
     def pattern
@@ -74,6 +76,18 @@ module Restify
 
     private
 
+    # A template without variables always expands to the same URI. It
+    # can be parsed and joined only once. The URI is frozen, as all
+    # requests share it.
+    def expand_static(params)
+      @static_uri ||= context.join(template.pattern).freeze
+      return @static_uri if params.empty?
+
+      @static_uri.dup.tap do |uri|
+        uri.query_values = (uri.query_values || {}).merge(params)
+      end
+    end
+
     def convert(params)
       params.each_pair.with_object({}) do |param, hash|
         hash[param[0]] = convert_param param[1]

data/lib/restify/timeout.rb

@@ -8,62 +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
-      @deadline = now + @timeout
-    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
+      @duration = parse_timeout(timeout)
+      @deadline = now + @duration
     end
 
     def remaining
-      wait_interval
+      @deadline - now
     end
 
     def exception
-      Error.new(@target)
+      Error.new(@target, @duration)
     end
 
     private
 
-    def wait_interval
-      @deadline - now
-    end
-
     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
@@ -71,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

@@ -5,7 +5,7 @@ module Restify
     MAJOR = 3
     MINOR = 0
     PATCH = 0
-    STAGE = :rc2
+    STAGE = :rc3
     STRING = [MAJOR, MINOR, PATCH, STAGE].compact.join('.').freeze
 
     def self.to_s

data/lib/restify/webmock.rb

@@ -73,7 +73,7 @@ module WebMock
           yield.tap do |promise|
             # Observers run when the request is complete, even when
             # nobody waits on the promise.
-            promise.add_observer do |_, response, _|
+            promise.add_observer do |response, _|
               next unless response
 
               CallbackRegistry.invoke_callbacks(

data/lib/restify.rb

@@ -4,7 +4,6 @@ require 'forwardable'
 
 require 'restify/version'
 
-require 'concurrent'
 require 'addressable/uri'
 require 'addressable/template'
 

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