restify 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3acb2cc3581b8c3c47ad27c6ab1ea34406d7fa39
-  data.tar.gz: 91e4eb0b80116b6e13d8aca4cf8942de6ef064bc
+  metadata.gz: 6cb4e54249171cc430b42e94584d53a8d855dc27
+  data.tar.gz: 021d1ef66172c7a992f7f447ffbe0ac2770421d9
 SHA512:
-  metadata.gz: e314678c3419674b6a709db0ba224bd46b704ba24455db084dba0f7e9dfccaf4c633243e384411d1fd7046a0c34480f19353a2313190c70ed62599eb50d04a3a
-  data.tar.gz: 8378f0c684c143cab5c92b4799a1424370f3b0db6395296d7b4bf38b3b8c48e08274035dfcd770f8ecc52308e9b80d74247628e125635f477f2fcec7436ba670
+  metadata.gz: d32a9c6b8978674f26a021f5e29618fe3c75012144697431f79033db6f4a503c0d7de39803dedb20c691c0d3feaa0965a9382de598cf9741d7c9bcb33e63292e
+  data.tar.gz: 8b699331f7a597f3b99ead0a5fe9da59bdec2648244a802798c952cdac430d729a1297e91807657723ed43fd35a04c3b52d95ec8abf93a1364fd2a2f99140af8

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.2.1
+
+* Fix issue with Ruby 2.2 compatibility
+
+## 1.2.0
+
+* Add experimental PooledEM adapter (#10)
+* Improve marshalling of resources
+
 ## 1.1.0
 
 * Return response body if no processor matches (#7)

data/README.md

@@ -26,12 +26,9 @@ Included processors can handle:
 
 Restify requires Ruby 2.0+.
 
-## Restify is still under development
-
-* It is build on experimental obligation library.
-
-Planned features:
+### Planned features
 
+* HTTP cache
 * API versions via header
 * Content-Type and Language negotiation
 * Processors for MessagePack, JSON-HAL, etc.

data/lib/restify.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 require 'restify/version'
 
 require 'hashie'
@@ -32,6 +34,8 @@ module Restify
     require 'restify/processors/json'
   end
 
+  require 'restify/railtie' if defined?(Rails::Railtie)
+
   PROCESSORS = [Processors::Json].freeze
 
   extend Global

data/lib/restify/adapter/pooled_em.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'eventmachine'
+require 'em-http-request'
+
+module Restify
+  module Adapter
+    class PooledEM < Base
+      # rubocop:disable RedundantFreeze
+      LOG_PROGNAME = 'restify.adapter.pooled-em'.freeze
+
+      # This class maintains a pool of connection objects, grouped by origin,
+      # and ensures limits for total parallel requests and per-origin requests.
+      #
+      # It does so by maintaining a list of already open, reusable connections.
+      # When any of them are checked out for usage, it counts the usages to
+      # prevent constraints being broken.
+      class Pool
+        def initialize(size: 32, per_host: 6, connect_timeout: 2, inactivity_timeout: 10)
+          @size = size
+          @per_host = per_host
+          @connect_timeout = connect_timeout
+          @inactivity_timeout = inactivity_timeout
+
+          @host = Hash.new {|h, k| h[k] = 0 }
+          @available = []
+          @queue = []
+          @used = 0
+        end
+
+        # Request a connection from the pool.
+        #
+        # Attempts to checkout a reusable connection from the pool (or create a
+        # new one). If any of the limits have been reached, the request will be
+        # put onto a queue until other connections are released.
+        #
+        # Returns a Deferrable that succeeds with a connection instance once a
+        # connection has been checked out (usually immediately).
+        #
+        # @return [Deferrable<Request>]
+        #
+        def get(request, timeout: 2)
+          defer = Deferrable.new(request)
+          defer.timeout(timeout, :timeout)
+          defer.errback { @queue.delete(defer) }
+
+          checkout(defer)
+
+          defer
+        end
+
+        # Return a connection to the pool.
+        #
+        # If there are requests in the queue (due to one of the limits having
+        # been reached), they will be given an attempt to use the released
+        # connection.
+        #
+        # If no requests are queued, the connection will be held for reuse by a
+        # subsequent request.
+        #
+        # @return [void]
+        #
+        def release(conn)
+          @available.unshift(conn) if @available.size < @size
+          @used -= 1 if @used > 0
+
+          Restify.logger.debug(LOG_PROGNAME) do
+            "[#{conn.uri}] Released to pool (#{@available.size}/#{@used}/#{size})"
+          end
+
+          checkout(@queue.shift) if @queue.any? # checkout next waiting defer
+        end
+
+        alias << release
+
+        def remove(conn)
+          close(conn)
+
+          Restify.logger.debug(LOG_PROGNAME) do
+            "[#{conn.uri}] Removed from pool (#{@available.size}/#{@used}/#{size})"
+          end
+
+          checkout(@queue.shift) if @queue.any? # checkout next waiting defer
+        end
+
+        # Determine the number of connections in the pool.
+        #
+        # This takes into account both reusable (idle) and used connections.
+        #
+        # @return [Integer]
+        #
+        def size
+          @available.size + @used
+        end
+
+        private
+
+        def close(conn)
+          @used -= 1 if @used > 0
+          @host[conn.uri.to_s] -= 1
+
+          conn.close
+        end
+
+        def checkout(defer)
+          origin = defer.request.uri.origin
+
+          if (index = find_reusable_connection(origin))
+            defer.succeed reuse_connection(index, origin)
+          elsif can_build_new_connection?(origin)
+            defer.succeed new_connection(origin)
+          else
+            queue defer
+          end
+        end
+
+        def find_reusable_connection(origin)
+          @available.find_index {|conn| conn.uri == origin }
+        end
+
+        def reuse_connection(index, origin)
+          @used += 1
+          @available.delete_at(index).tap do
+            Restify.logger.debug(LOG_PROGNAME) do
+              "[#{origin}] Take connection from pool " \
+                "(#{@available.size}/#{@used}/#{size})"
+            end
+          end
+        end
+
+        def new_connection(origin)
+          # If we have reached the limit, we have to throw away the oldest
+          # reusable connection in order to open a new one
+          close_oldest if size >= @size
+
+          @used += 1
+          new(origin).tap do
+            Restify.logger.debug(LOG_PROGNAME) do
+              "[#{origin}] Add new connection to pool " \
+                "(#{@available.size}/#{@used}/#{size})"
+            end
+          end
+        end
+
+        def close_oldest
+          close(@available.pop)
+
+          Restify.logger.debug(LOG_PROGNAME) do
+            "[#{origin}] Closed oldest connection in pool " \
+              "(#{@available.size}/#{@used}/#{size})"
+          end
+        end
+
+        def queue(defer)
+          Restify.logger.debug(LOG_PROGNAME) do
+            "[#{origin}] Wait for free slot " \
+              "(#{@available.size}/#{@used}/#{size})"
+          end
+
+          @queue << defer
+        end
+
+        def new(origin)
+          Restify.logger.debug(LOG_PROGNAME) do
+            "Connect to '#{origin}' " \
+            "(#{@connect_timeout}/#{@inactivity_timeout})..."
+          end
+
+          @host[origin] += 1
+
+          EventMachine::HttpRequest.new origin,
+            connect_timeout: @connect_timeout,
+            inactivity_timeout: @inactivity_timeout
+        end
+
+        def can_build_new_connection?(origin)
+          return false if @host[origin] >= @per_host
+
+          size < @size || @available.any?
+        end
+
+        class Deferrable
+          include ::EventMachine::Deferrable
+
+          attr_reader :request
+
+          def initialize(request)
+            @request = request
+          end
+
+          def succeed(connection)
+            @connection = connection
+            super
+          end
+        end
+      end
+
+      def initialize(**kwargs)
+        @pool = Pool.new(**kwargs)
+      end
+
+      # rubocop:disable MethodLength
+      # rubocop:disable AbcSize
+      # rubocop:disable BlockLength
+      def call_native(request, writer)
+        next_tick do
+          defer = @pool.get(request)
+
+          defer.errback do |error|
+            writer.reject(error)
+          end
+
+          defer.callback do |conn|
+            begin
+              req = conn.send request.method.downcase,
+                keepalive: true,
+                redirects: 3,
+                path: request.uri.normalized_path,
+                query: request.uri.normalized_query,
+                body: request.body,
+                head: request.headers
+
+              req.callback do
+                writer.fulfill Response.new(
+                  request,
+                  req.last_effective_url,
+                  req.response_header.status,
+                  req.response_header,
+                  req.response
+                )
+
+                if req.response_header['CONNECTION'] == 'close'
+                  @pool.remove(conn)
+                else
+                  @pool << conn
+                end
+              end
+
+              req.errback do
+                @pool.remove(conn)
+                writer.reject(req.error)
+              end
+            rescue Exception => ex # rubocop:disable RescueException
+              @pool.remove(conn)
+              writer.reject(ex)
+            end
+          end
+        end
+      end
+      # rubocop:enable all
+
+      private
+
+      def next_tick(&block)
+        ensure_running
+        EventMachine.next_tick(&block)
+      end
+
+      def ensure_running
+        return if EventMachine.reactor_running?
+
+        Thread.new do
+          begin
+            EventMachine.run {}
+          rescue => e
+            puts "#{self.class} -> #{e}\n#{e.backtrace.join("\n")}"
+            raise e
+          end
+        end
+      end
+    end
+  end
+end

data/lib/restify/context.rb

@@ -53,7 +53,7 @@ module Restify
         method: method,
         uri: join(uri),
         data: data,
-        headers: options.fetch(:headers, {})
+        headers: headers
 
       ret = cache.call(request) {|req| adapter.call(req) }
       ret.then do |response|
@@ -65,6 +65,26 @@ module Restify
       end
     end
 
+    def encode_with(coder)
+      coder.map = marshal_dump
+    end
+
+    def init_with(coder)
+      marshal_load(coder.map)
+    end
+
+    def marshal_dump
+      {
+        uri: uri.to_s,
+        headers: headers
+      }
+    end
+
+    def marshal_load(dump)
+      initialize dump.delete(:uri), \
+        headers: dump.fetch(:headers)
+    end
+
     private
 
     def adapter
@@ -75,6 +95,10 @@ module Restify
       options[:cache] || Restify.cache
     end
 
+    def headers
+      options.fetch(:headers, {})
+    end
+
     class << self
       def raise_response_error(response)
         case response.code

data/lib/restify/global.rb

@@ -30,6 +30,16 @@ module Restify
       @cache = cache
     end
 
+    def logger
+      @logger ||= ::Logger.new(STDOUT).tap do |logger|
+        logger.level = :info
+      end
+    end
+
+    def logger=(logger)
+      @logger = logger
+    end
+
     private
 
     def resolve_context(uri, **opts)

data/lib/restify/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Restify
+  class Railtie < Rails::Railtie
+    initializer 'restify.logger' do
+      config.after_initialize do
+        Restify.logger = Rails.logger
+      end
+    end
+  end
+end

data/lib/restify/response.rb

@@ -134,7 +134,7 @@ module Restify
 
     # @api private
     def follow_location
-      headers['LOCATION'] || headers['CONENT_LOCATION']
+      headers['LOCATION'] || headers['CONTENT_LOCATION']
     end
 
     private

data/lib/restify/version.rb

@@ -3,8 +3,8 @@
 module Restify
   module VERSION
     MAJOR = 1
-    MINOR = 1
-    PATCH = 0
+    MINOR = 2
+    PATCH = 1
     STAGE = nil
     STRING = [MAJOR, MINOR, PATCH, STAGE].reject(&:nil?).join('.').freeze
 

data/spec/restify/context_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'yaml'
+
+describe Restify::Context do
+  let(:uri) { 'http://localhost' }
+  let(:kwargs) { {} }
+  let(:context) { Restify::Context.new(uri, **kwargs) }
+
+  describe '<serialization>' do
+    shared_examples 'serialization' do
+      describe '#uri' do
+        subject { super().uri }
+
+        it { expect(subject).to be_a Addressable::URI }
+        it { expect(subject).to eq context.uri }
+      end
+
+      describe '#adapter' do
+        let(:kwargs) { {adapter: double('adapter')} }
+        subject { super().options[:adapter] }
+
+        it 'adapter is not serialized' do
+          expect(subject).to equal nil
+        end
+      end
+
+      describe '#cache' do
+        let(:kwargs) { {adapter: double('cache')} }
+        subject { super().options[:cache] }
+
+        it 'cache is not serialized' do
+          expect(subject).to equal nil
+        end
+      end
+
+      describe '#headers' do
+        let(:kwargs) { {headers: {'Accept': 'application/json'}} }
+        subject { super().options[:headers] }
+
+        it do
+          expect(subject).to eq context.send :headers
+        end
+      end
+    end
+
+    context 'YAML' do
+      let(:dump) { YAML.dump(context) }
+      let(:load) { YAML.load(dump) } # rubocop:disable YAMLLoad
+
+      subject { load }
+
+      include_examples 'serialization'
+    end
+
+    context 'Marshall' do
+      let(:dump) { Marshal.dump(context) }
+      let(:load) { Marshal.load(dump) } # rubocop:disable MarshalLoad
+
+      subject { load }
+
+      include_examples 'serialization'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -14,9 +14,12 @@ require 'restify'
 
 if ENV['ADAPTER']
   case ENV['ADAPTER'].to_s.downcase
-    when 'em-http-request'
+    when 'em'
       require 'restify/adapter/em'
       Restify.adapter = Restify::Adapter::EM.new
+    when 'em-pooled'
+      require 'restify/adapter/pooled_em'
+      Restify.adapter = Restify::Adapter::PooledEM.new
     when 'typhoeus'
       require 'restify/adapter/typhoeus'
       Restify.adapter = Restify::Adapter::Typhoeus.new
@@ -37,6 +40,10 @@ Dir[File.expand_path('spec/support/**/*.rb')].each {|f| require f }
 RSpec.configure do |config|
   config.order = 'random'
 
+  config.before(:each) do
+    Restify.logger.level = Logger::DEBUG
+  end
+
   config.after(:each) do
     EventMachine.stop if defined?(EventMachine) && EventMachine.reactor_running?
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restify
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.1
 platform: ruby
 authors:
 - Jan Graichen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-12 00:00:00.000000000 Z
+date: 2017-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -136,6 +136,7 @@ files:
 - lib/restify.rb
 - lib/restify/adapter/base.rb
 - lib/restify/adapter/em.rb
+- lib/restify/adapter/pooled_em.rb
 - lib/restify/adapter/typhoeus.rb
 - lib/restify/cache.rb
 - lib/restify/context.rb
@@ -145,6 +146,7 @@ files:
 - lib/restify/processors/base.rb
 - lib/restify/processors/json.rb
 - lib/restify/promise.rb
+- lib/restify/railtie.rb
 - lib/restify/registry.rb
 - lib/restify/relation.rb
 - lib/restify/request.rb
@@ -152,6 +154,7 @@ files:
 - lib/restify/response.rb
 - lib/restify/version.rb
 - spec/restify/cache_spec.rb
+- spec/restify/context_spec.rb
 - spec/restify/global_spec.rb
 - spec/restify/link_spec.rb
 - spec/restify/processors/base_spec.rb
@@ -164,7 +167,7 @@ files:
 - spec/spec_helper.rb
 homepage: https://github.com/jgraichen/restify
 licenses:
-- LGPLv3
+- LGPL-3.0+
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -182,12 +185,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: An experimental hypermedia REST client.
 test_files:
 - spec/restify/cache_spec.rb
+- spec/restify/context_spec.rb
 - spec/restify/global_spec.rb
 - spec/restify/link_spec.rb
 - spec/restify/processors/base_spec.rb