restify 2.1.0 → 3.0.0.rc3

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

@@ -9,47 +9,64 @@ module Restify
       # Parses generic data structures into resources
       #
       module Parsing
+        RELATION_NAME = /\A\w+_url\z/i
+
         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)
           case object
-            when Hash
-              data      = object.each_with_object({}) {|each, obj| parse_data(each, obj) }
-              relations = object.each_with_object({}) {|each, obj| parse_rels(each, obj) }
-
-              Resource.new context,
-                data:,
-                response: root ? response : nil,
-                relations:
-
-            when Array
-              object.map {|each| parse(each) }
-            else
-              object
+            when Hash then build_resource(object, root)
+            when Array then object.map {|each| parse(each) }
+            else object
           end
         end
 
         private
 
-        def parse_data(pair, data)
-          data[pair[0].to_s] = parse pair[1]
+        # Build data and relations of a resource in one pass.
+        def build_resource(object, root)
+          data = {}
+          relations = {}
+
+          object.each_pair do |key, value|
+            key = key.to_s
+            data[key] = parse(value)
+            parse_relation(relations, key, value) if value.is_a?(String)
+          end
+
+          Resource.new(
+            context,
+            data:,
+            response: root ? response : nil,
+            relations:,
+          )
         end
 
-        def parse_rels(pair, relations)
-          name = case pair[0].to_s.downcase
-                   when /\A(\w+)_url\z/
-                     Regexp.last_match[1]
-                   when 'url'
-                     'self'
-                   else
-                     return
+        def parse_relation(relations, key, value)
+          name = if key.match?(RELATION_NAME)
+                   key[0, key.length - 4].downcase
+                 elsif key.casecmp?('url')
+                   'self'
                  end
 
-          return if relations.key?(name) || pair[1].nil? || pair[1].to_s =~ /\A\w*\z/
+          return if name.nil? || relations.key?(name)
+          return if value.empty?
 
-          relations[name] = pair[1].to_s
+          relations[name] = value
         end
       end
     end

data/lib/restify/promise.rb

@@ -1,83 +1,229 @@
 # frozen_string_literal: true
 
 module Restify
-  class Promise < Concurrent::IVar
+  class Promise
+    class AlreadyCompleteError < StandardError; end
+
+    # @api private
+    attr_writer :driver
+
+    # @api private
+    attr_reader :reason
+
     def initialize(*dependencies, &task)
+      @mutex        = Mutex.new
+      @condition    = nil
+      @observers    = nil
+      @driver       = nil
+      @state        = :pending
+      @value        = nil
+      @reason       = nil
       @task         = task
-      @dependencies = dependencies.flatten
+      @dependencies = dependencies.empty? ? nil : dependencies.flatten
 
-      super(&nil)
+      # 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
 
-      # 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 pending?
+      @state == :pending
     end
 
+    def fulfilled?
+      @state == :fulfilled
+    end
+
+    def rejected?
+      @state == :rejected
+    end
+
+    def complete?
+      @state == :fulfilled || @state == :rejected
+    end
+
+    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?
+
+      timeout = Timeout.new(timeout, self)
 
-      execute(t) if pending?
+      # Let the driver run on the current thread instead of sleeping and
+      # 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)
 
-      super
-      raise t if incomplete?
+      until complete?
+        remaining = timeout.remaining
+        raise timeout unless remaining.positive?
+
+        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
 
-    protected
+    private
 
-    # @!visibility private
-    def ns_execute(timeout = nil)
-      return unless compare_and_set_state(:processing, :pending)
-      return unless @task || @dependencies.any?
+    def fulfill(value)
+      complete(:fulfilled, value, nil)
+    end
 
-      executor = Concurrent::SafeTaskExecutor.new \
-        method(:ns_exec), rescue_exception: true
+    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
+
+        @condition&.broadcast
+
+        @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
+
+    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
 
-      value = @task ? @task.call(*args) : args
-      value = t.wait_on!(value) while value.is_a?(Promise)
-      value
+        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
-        promise = Promise.new
+      def create(driver: nil)
+        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
 
@@ -87,11 +233,17 @@ 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
+        fulfill(yield)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        reject(e)
       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

@@ -19,20 +19,20 @@ module Restify
       @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)
@@ -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/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(' ')
 

data/lib/restify/response.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'rack/media_type'
 require 'rack/utils'
 require 'json'
 
@@ -30,6 +31,10 @@ module Restify
 
     # Response body as string.
     #
+    # The body is encoded according to the charset from the response's
+    # `Content-Type` header. Without a charset, or with one unknown to
+    # Ruby, the body is returned as binary.
+    #
     # @return [String] Response body.
     #
     attr_reader :body
@@ -81,7 +86,7 @@ module Restify
       @code    = code
       @status  = STATUS_CODE_TO_SYMBOL[code]
       @headers = convert_headers(headers)
-      @body    = body
+      @body    = encode_body(body)
       @message = Rack::Utils::HTTP_STATUS_CODES[code]
     end
 
@@ -112,6 +117,24 @@ module Restify
       headers['CONTENT_TYPE']
     end
 
+    # Return the encoding from the response's content type, if any.
+    #
+    # @return [Encoding, nil] Encoding, or nil if the content type
+    #   carries no charset or an encoding unknown to Ruby.
+    #
+    def charset
+      return @charset if defined?(@charset)
+
+      charset = Rack::MediaType.params(content_type.to_s)['charset']
+
+      @charset = begin
+        Encoding.find(charset) if charset
+      rescue ArgumentError
+        # Unknown: keep the body as binary rather than guessing.
+        nil
+      end
+    end
+
     # Check if response is successful e.g. the status code
     # is on of 2XX.
     #
@@ -130,13 +153,20 @@ module Restify
       (400...600).cover? code
     end
 
+    # Decoded body for error messages, or nil if the body is empty or
+    # could not be parsed.
+    #
     # @api private
     def decoded_body
-      @decoded_body ||= begin
+      return @decoded_body if defined?(@decoded_body)
+
+      @decoded_body = begin
         case content_type
           when %r{\Aapplication/json($|;)}
-            ::JSON.parse(body)
+            ::JSON.parse(body) unless body.nil? || body.empty?
         end
+      rescue ::JSON::ParserError
+        nil
       end
     end
 
@@ -147,6 +177,12 @@ module Restify
 
     private
 
+    def encode_body(body)
+      return body unless body && charset
+
+      (+body).force_encoding(charset)
+    end
+
     def convert_headers(headers)
       headers.each.to_h do |pair|
         [pair[0].upcase, pair[1]]