restify 2.0.2 → 3.0.0.rc2

data/lib/restify/adapter/loop_lock.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Restify
+  module Adapter
+    #
+    # Manages coordination for exclusive ownership of an event loop,
+    # shared between a background thread and threads waiting on results.
+    # This way, the event loop can run on waiting threads directly,
+    # avoiding costly context switches to the background thread.
+    #
+    # Waiting threads have priority: the background thread only acquires
+    # the loop while no thread is waiting for it, and is interrupted to
+    # release it as soon as one is.
+    #
+    # Waiting threads can give up waiting once their result is
+    # available, e.g. because another thread running the loop produced
+    # it. Whoever runs the loop must call `#notify` after producing a
+    # result.
+    #
+    class LoopLock
+      # @yield Called when a waiting thread needs the background thread to
+      #   release the loop, e.g. to wake it up from `select`.
+      #
+      def initialize(&interrupt)
+        @interrupt = interrupt
+
+        reset!
+      end
+
+      # Acquire the loop for a thread waiting on a result.
+      #
+      # @param timeout [Restify::Timeout, Numeric] Maximum time to wait,
+      #   derived from the promise timeout of the waiting thread.
+      #
+      # @yieldreturn [Boolean] Whether the result is available, and
+      #   the loop is not needed anymore.
+      #
+      # @return [Boolean] true when the calling thread holds the loop,
+      #   false when the result is available or the timeout expired
+      #   first.
+      #
+      def acquire(timeout, &done)
+        timeout = Timeout.new(timeout)
+
+        background = @mutex.synchronize do
+          @waiters += 1
+          @background
+        end
+
+        @interrupt&.call if background
+
+        @mutex.synchronize do
+          loop do
+            return false if done&.call
+
+            remaining = timeout.remaining
+            return false unless remaining.positive?
+
+            if free?
+              @owner = Thread.current
+              return true
+            end
+
+            @changed.wait(@mutex, remaining)
+          end
+        ensure
+          @waiters -= 1
+
+          # Let the background thread continue.
+          @changed.broadcast if @waiters.zero?
+        end
+      end
+
+      # Acquire the loop for the background thread. Blocks while any
+      # other thread holds the loop or waits for it.
+      def acquire_background
+        @mutex.synchronize do
+          @changed.wait(@mutex) until free? && @waiters.zero?
+
+          @owner = Thread.current
+          @background = true
+        end
+      end
+
+      def release
+        @mutex.synchronize do
+          @owner = nil
+          @background = false
+          @changed.broadcast
+        end
+      end
+
+      def owned?
+        @owner.equal?(Thread.current)
+      end
+
+      def notify
+        return unless @waiters.positive?
+
+        @mutex.synchronize { @changed.broadcast }
+      end
+
+      # Forget all threads holding or waiting for the loop, e.g. in a
+      # forked child process, where these threads do not exist.
+      #
+      # Must not be called while other threads use the lock.
+      def reset!
+        @mutex      = Mutex.new
+        @changed    = ConditionVariable.new
+        @owner      = nil
+        @background = false
+        @waiters    = 0
+      end
+
+      private
+
+      # A thread holding the loop can be gone without releasing it, e.g.
+      # when killed.
+      def free?
+        @owner.nil? || !@owner.alive?
+      end
+    end
+  end
+end

data/lib/restify/adapter/telemetry.rb

@@ -8,16 +8,18 @@ module Restify
     module Telemetry
       def call(request)
         method = request.method.to_s.upcase
-        uri = URI.parse(request.uri)
-        name = "#{method} #{uri.scheme}://#{uri.host}:#{uri.port}"
+        uri = request.uri
+        port = uri.inferred_port
+        name = "#{method} #{uri.scheme}://#{uri.host}:#{port}"
 
+        # Remove `nil` as OTEL spans must not contain any nil attributes
         attributes = {
           'http.request.method' => method,
           'server.address' => uri.host,
-          'server.port' => uri.port,
+          'server.port' => port,
           'url.full' => uri.to_s,
           'url.scheme' => uri.scheme,
-        }
+        }.compact
 
         span = tracer.start_span(name, attributes:, kind: :client)
         OpenTelemetry::Trace.with_span(span) do

data/lib/restify/adapter/typhoeus.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
-require 'typhoeus'
-
-Ethon.logger = Logging.logger[Ethon]
+begin
+  require 'typhoeus'
+rescue LoadError => e
+  raise LoadError.new(
+    "Restify::Adapter::Typhoeus requires the `typhoeus` gem, add it to your Gemfile (#{e.message})",
+  )
+end
 
 module Restify
   module Adapter
@@ -23,6 +27,14 @@ module Restify
         tcp_keepintvl: 5,
       }.freeze
 
+      # Restify follows relations from URLs in server responses, and
+      # libcurl supports far more than HTTP, e.g. `file://` or `scp://`.
+      # Therefore only HTTP-like protocols must ever be used, both for
+      # the request itself and when following redirects.
+      #
+      # This is intentionally not configurable.
+      PROTOCOLS = %i[http https].freeze
+
       # Patch Hydra to restore the correct OpenTelemetry span when
       # adding the request, so that the Ethon instrumentation can
       # properly pick up the context where the Restify request
@@ -41,8 +53,8 @@ module Restify
         end
       end
 
-      def initialize(sync: false, options: {}, **kwargs)
-        @hydra = ::Typhoeus::Hydra.new(**kwargs)
+      def initialize(sync: false, options: {}, **)
+        @hydra = ::Typhoeus::Hydra.new(**)
         @hydra.extend(EasyOverride)
 
         @mutex   = Mutex.new
@@ -62,8 +74,11 @@ module Restify
         req = convert(request, writer)
 
         if sync?
-          @hydra.queue(req)
-          @hydra.run
+          begin
+            req.run
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            writer.reject(e)
+          end
         else
           debug 'request:add',
             tag: request.object_id,
@@ -71,7 +86,7 @@ module Restify
             url: request.uri,
             timeout: request.timeout
 
-          @queue << convert(request, writer)
+          @queue << req
 
           thread.run unless thread.status
         end
@@ -88,33 +103,38 @@ module Restify
           body: request.body,
           timeout: request.timeout,
           connecttimeout: request.timeout,
+
+          # Block accessing and redirecting to non-HTTP protocols:
+          protocols: PROTOCOLS,
+          redir_protocols: PROTOCOLS,
         ).tap do |req|
           req._otel_span = OpenTelemetry::Trace.current_span
           req._restify_writer = writer
 
           req.on_complete do |response|
-            debug 'request:complete',
-              tag: request.object_id,
-              status: response.code,
-              message: response.return_message,
-              timeout: response.timed_out?
-
-            if response.timed_out? || response.code.zero?
-              writer.reject \
-                Restify::NetworkError.new(request, response.return_message)
-            else
-              writer.fulfill convert_back(response, request)
+            writer.set do
+              debug 'request:complete',
+                tag: request.object_id,
+                status: response.code,
+                message: response.return_message,
+                timeout: response.timed_out?
+
+              if response.timed_out? || response.code.zero?
+                raise Restify::NetworkError.new(request, response.return_message)
+              end
+
+              convert_back(response, request)
             end
 
-            # Add all newly queued requests to active hydra, e.g. requests
-            # queued in a completion callback.
+            # Add all newly queued requests to active hydra, e.g.
+            # requests queued in a completion callback.
             dequeue_all
           end
         end
       end
 
       def convert_back(response, request)
-        uri     = request.uri
+        uri     = effective_uri(response, request)
         status  = response.code
         body    = response.body
         headers = convert_headers(response.headers)
@@ -122,6 +142,11 @@ module Restify
         ::Restify::Response.new(request, uri, status, headers, body)
       end
 
+      def effective_uri(response, request)
+        url = response.effective_url
+        url ? Addressable::URI.parse(url) : request.uri
+      end
+
       def convert_headers(headers)
         return {} unless headers.respond_to?(:each_pair)
 
@@ -165,7 +190,7 @@ module Restify
           runs += 1
           debug 'hydra:completed'
         rescue StandardError => e
-          logger.error(e)
+          error(e)
         end
       ensure
         debug 'hydra:exit'

data/lib/restify/cache.rb

@@ -19,7 +19,7 @@ module Restify
 
     private
 
-    def match(_request)
+    def match(_request) # rubocop:disable Naming/PredicateMethod
       false
     end
 

data/lib/restify/context.rb

@@ -34,9 +34,9 @@ module Restify
       self.uri.join uri
     end
 
-    def inherit(uri, **kwargs)
+    def inherit(uri, **)
       uri ||= self.uri
-      Context.new(uri, **kwargs, **options)
+      Context.new(uri, **, **options)
     end
 
     def process(response)
@@ -47,16 +47,16 @@ module Restify
       processor.new(context, response).resource
     end
 
-    def request(method, uri, data: nil, headers: {}, **kwargs)
+    def request(method, uri, data: nil, headers: {}, **)
       request = Request.new(
         headers: default_headers.merge(headers),
-        **kwargs,
+        **,
         method:,
         uri: join(uri),
         data:,
       )
 
-      ret = cache.call(request) {|req| adapter.call(req) }
+      ret = cache ? cache.call(request) {|req| adapter.call(req) } : adapter.call(request)
       ret.then do |response|
         raise ResponseError.from_code(response) if response.errored?
 

data/lib/restify/error.rb

@@ -13,6 +13,19 @@ module Restify
     end
   end
 
+  # A {ParseError} is raised when accessing the data of a resource,
+  # whose response body could not be parsed, e.g. invalid JSON. The
+  # original error is available as {#cause}.
+  #
+  class ParseError < StandardError
+    attr_reader :response
+
+    def initialize(response, message)
+      @response = response
+      super("Could not parse response body for `#{response&.uri}': #{message}")
+    end
+  end
+
   # A {ResponseError} is returned on a non-successful
   # response from server. Usually it will either be a
   # {ClientError} or a {ServerError}.

data/lib/restify/global.rb

@@ -2,47 +2,26 @@
 
 module Restify
   module Global
-    def new(uri, **opts)
-      context = resolve_context uri, **opts
+    def new(uri, **)
+      context = resolve_context(uri, **)
 
       Relation.new context, context.uri
     end
 
-    def adapter
-      @adapter ||= begin
-        Restify::Adapter::Typhoeus.new
-      end
-    end
-
-    def adapter=(adapter)
-      @adapter = adapter
-    end
-
-    def cache
-      @cache ||= begin
-        require 'active_support'
-        require 'active_support/cache'
-        Restify::Cache.new store: ActiveSupport::Cache::MemoryStore.new
-      end
-    end
-
-    def cache=(cache)
-      @cache = cache
-    end
+    attr_writer :adapter
+    attr_accessor :cache, :logger
 
-    def logger
-      ::Logging.logger[Restify]
+    def adapter
+      @adapter ||= Restify::Adapter::Ethon.new
     end
 
-    def logger=(logger); end
-
     private
 
-    def resolve_context(uri, **opts)
+    def resolve_context(uri, **)
       if uri.is_a? Symbol
-        Restify::Registry.fetch(uri).inherit(nil, **opts)
+        Restify::Registry.fetch(uri).inherit(nil, **)
       else
-        Context.new(uri, **opts)
+        Context.new(uri, **)
       end
     end
   end

data/lib/restify/logging.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-require 'logging'
-
 module Restify
   module Logging
     def logger
-      @logger ||= ::Logging.logger[self]
+      Restify.logger
     end
 
     def debug(message = nil, tag: nil, **kwargs)
-      logger.debug do
+      logger&.debug(_log_name) do
         [
           _log_prefix,
           *Array(tag),
@@ -19,6 +17,14 @@ module Restify
       end
     end
 
+    def error(exception)
+      logger&.error(_log_name) { exception }
+    end
+
+    def _log_name
+      is_a?(Module) ? name : self.class.name
+    end
+
     def _log_prefix
       nil
     end

data/lib/restify/processors/base/parsing.rb

@@ -10,7 +10,19 @@ module Restify
       #
       module Parsing
         def load
-          parse deserialized_body, root: true
+          # No data, e.g. when a server sets a content type but sends an
+          # empty body.
+          return if body.nil? || body.empty?
+
+          begin
+            data = deserialized_body
+          rescue StandardError => e
+            # Keep the resource, e.g. with relations from headers, but
+            # raise on accessing its data.
+            return Resource.new(context, response:, error: e)
+          end
+
+          parse(data, root: true)
         end
 
         def parse(object, root: false)

data/lib/restify/promise.rb

@@ -2,9 +2,16 @@
 
 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`.
+    #
+    # @api private
+    attr_writer :driver
+
     def initialize(*dependencies, &task)
       @task         = task
       @dependencies = dependencies.flatten
+      @driver       = nil
 
       super(&nil)
 
@@ -19,7 +26,11 @@ module Restify
 
       execute(t) if pending?
 
-      super
+      # 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)
+
       raise t if incomplete?
 
       self
@@ -62,8 +73,9 @@ module Restify
     end
 
     class << self
-      def create
+      def create(driver: nil)
         promise = Promise.new
+        promise.driver = driver
         yield Writer.new(promise)
         promise
       end
@@ -93,6 +105,12 @@ module Restify
       def reject(reason)
         @promise.send :complete, false, nil, reason
       end
+
+      def set
+        fulfill(yield)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        reject(e)
+      end
     end
   end
 end

data/lib/restify/registry.rb

@@ -6,8 +6,8 @@ module Restify
       @registry = {}
     end
 
-    def store(name, uri, **opts)
-      @registry[name] = Context.new(uri, **opts)
+    def store(name, uri, **)
+      @registry[name] = Context.new(uri, **)
     end
 
     def fetch(name)

data/lib/restify/relation.rb

@@ -16,23 +16,23 @@ module Restify
 
     def initialize(context, template)
       @context  = context
-      @template = Addressable::Template.new template
+      @template = Addressable::Template.new(template)
     end
 
-    def request(method:, params: {}, **opts)
-      context.request(method, expand(params), **opts)
+    def request(method:, params: {}, **)
+      context.request(method, expand(params), **)
     end
 
-    def get(data = {}, params: {}, **opts)
-      request(**opts, method: :get, params: data.merge(params))
+    def get(data = {}, params: {}, **)
+      request(**, method: :get, params: data.merge(params))
     end
 
-    def head(data = {}, params: {}, **opts)
-      request(**opts, method: :head, params: data.merge(params))
+    def head(data = {}, params: {}, **)
+      request(**, method: :head, params: data.merge(params))
     end
 
-    def delete(data = {}, params: {}, **opts)
-      request(**opts, method: :delete, params: data.merge(params))
+    def delete(data = {}, params: {}, **)
+      request(**, method: :delete, params: data.merge(params))
     end
 
     def post(data = nil, **opts)
@@ -122,13 +122,5 @@ module Restify
         end
       end
     end
-
-    def to_template(pattern)
-      if pattern.is_a?(Addressable::Template)
-        pattern
-      else
-        Addressable::Template.new pattern
-      end
-    end
   end
 end

data/lib/restify/request.rb

@@ -11,7 +11,7 @@ module Restify
 
     # Request URI.
     #
-    # @return [String] Request URI.
+    # @return [Addressable::URI] Request URI.
     #
     attr_reader :uri
 
@@ -30,7 +30,7 @@ module Restify
     attr_reader :timeout
 
     def initialize(uri:, method: :get, data: nil, timeout: 300, headers: {})
-      @uri     = uri
+      @uri     = uri.is_a?(Addressable::URI) ? uri : Addressable::URI.parse(uri)
       @method  = method.to_s.downcase
       @data    = data
       @timeout = timeout

data/lib/restify/resource.rb

@@ -6,12 +6,13 @@ module Restify
   class Resource < SimpleDelegator
     # @api private
     #
-    def initialize(context, response: nil, data: nil, relations: {})
+    def initialize(context, response: nil, data: nil, relations: {}, error: nil)
       super(data)
 
       @context   = context
       @response  = response
       @relations = relations
+      @error     = error
     end
 
     # Check if resource has a relation with given name.
@@ -42,14 +43,31 @@ module Restify
 
     alias rel relation
 
+    # @api private
+    def __getobj__
+      # `Delegator` removes `Kernel#raise`, and the cause can only be
+      # set when raising.
+      ::Kernel.raise ParseError.new(@response, @error.message), cause: @error if @error
+
+      super
+    end
+
     # @!method data
     #
     #   Return response data. Usually a hash or array.
     #
     #   @return [Object] Response data.
+    #   @raise [ParseError] If the response body could not be parsed.
     #
     alias data __getobj__
 
+    # @api private
+    def respond_to_missing?(name, include_private = false)
+      return false if @error
+
+      super
+    end
+
     # @!method response
     #
     #   Return response if available.
@@ -95,7 +113,7 @@ module Restify
     # @api private
     def inspect
       text = {
-        '@data' => data,
+        (@error ? '@error' : '@data') => @error || data,
         '@relations' => @relations,
       }.map {|k, v| "#{k}=#{v.inspect}" }.join(' ')