routemaster-drain 2.3.0 → 2.4.0

data/lib/routemaster/null_logger.rb

@@ -0,0 +1,16 @@
+module Routemaster
+  class NullLogger
+    def false
+      false
+    end
+
+    def noop
+
+    end
+
+    [:debug, :info, :warn, :error, :fatal].each do |method|
+      alias method :noop
+      alias :"#{method}?" :false
+    end
+  end
+end

data/lib/routemaster/redis_broker.rb

@@ -1,4 +1,5 @@
 require 'redis-namespace'
+require 'redis/distributed'
 require 'uri'
 require 'singleton'
 
@@ -11,13 +12,13 @@ module Routemaster
       _cleanup
     end
 
-    def get(url)
+    def get(name, urls: [])
       _check_for_fork
-      @_connections[url] ||= begin
-        parsed_url = URI.parse(url)
-        namespace = parsed_url.path.split('/')[2] || 'rm'
-        Redis::Namespace.new(namespace, redis: Redis.new(url: url))
-      end
+      @_connections[name] ||= begin
+                                parsed_url = URI.parse(urls.first)
+                                namespace = parsed_url.path.split('/')[2] || 'rm'
+                                Redis::Namespace.new(namespace, redis: Redis::Distributed.new(urls))
+                              end
     end
 
     def cleanup
@@ -32,7 +33,7 @@ module Routemaster
 
     def _cleanup
       @_pid = Process.pid
-      @_connections.each_value(&:quit)
+      @_connections.each_value.map(&:redis).each(&:quit)
       @_connections = {}
     end
 

data/lib/routemaster/resources/rest_resource.rb

@@ -1,4 +1,6 @@
 require 'routemaster/api_client'
+require 'routemaster/responses/hateoas_enumerable_response'
+require 'routemaster/responses/hateoas_response'
 
 module Routemaster
   module Resources
@@ -7,26 +9,35 @@ module Routemaster
 
       def initialize(url, client: nil)
         @url = url
-        @client = client || Routemaster::APIClient.new(response_class: Responses::HateoasResponse)
+        @client = client || Routemaster::APIClient.new
       end
 
       def create(params)
-        @client.post(@url, body: params)
+        @client.with_response(Responses::HateoasResponse) do
+          @client.post(@url, body: params)
+        end
       end
 
-      def show(id=nil)
-        @client.get(@url.gsub('{id}', id.to_s))
+      def show(id=nil, enable_caching: true)
+        @client.with_response(Responses::HateoasResponse) do
+          @client.get(@url.gsub('{id}', id.to_s), options: { enable_caching: enable_caching })
+        end
       end
 
-      def index
-        @client.get(@url)
+      def index(params: {}, filters: {}, enable_caching: false)
+        @client.with_response(Responses::HateoasEnumerableResponse) do
+          @client.get(@url, params: params.merge(filters), options: { enable_caching: enable_caching })
+        end
       end
 
       def update(id=nil, params)
-        @client.patch(@url.gsub('{id}', id.to_s), body: params)
+        @client.with_response(Responses::HateoasResponse) do
+          @client.patch(@url.gsub('{id}', id.to_s), body: params)
+        end
       end
 
       def destroy(id=nil)
+        # no response wrapping as DELETE is supposed to 204.
         @client.delete(@url.gsub('{id}', id.to_s))
       end
     end

data/lib/routemaster/responses/future_response.rb

@@ -1,30 +1,16 @@
-require 'thread/pool'
-require 'thread/future'
+require 'concurrent/future'
+require 'concurrent/executor/cached_thread_pool'
 require 'singleton'
 require 'delegate'
 
 module Routemaster
   module Responses
-    # A pool of threads, used for parallel/future request processing.
-    class Pool < SimpleDelegator
-      include Singleton
-
-      def initialize
-        Thread.pool(5, 20).tap do |p|
-          # TODO: configurable pool size and trim timeout?
-          p.auto_trim!
-          p.idle_trim! 10 # 10 seconds
-          super p
-        end
-      end
-    end
-
     class FutureResponse
       extend Forwardable
 
       # The `block` is expected to return a {Response}
       def initialize(&block)
-        @future = Pool.instance.future(&block)
+        @future = Concurrent::Future.execute(executor: Pool.current, &block)
       end
 
       # @!attribute status
@@ -41,6 +27,40 @@ module Routemaster
 
       delegate :value => :@future
       delegate %i(status headers body) => :value
+      delegate :respond_to_missing? => :value
+      
+      def method_missing(m, *args, &block)
+        value.public_send(m, *args, &block)
+      end
+
+      def value
+        @future.value.tap do
+          raise @future.reason if @future.rejected?
+        end
+      end
+
+      module Pool
+        LOCK = Mutex.new
+
+        def self.current
+          LOCK.synchronize do
+            @pool ||= _build_pool
+          end
+        end
+
+        def self.reset
+          LOCK.synchronize do
+            return unless @pool
+            @pool.tap(&:shutdown).wait_for_termination
+            @pool = nil
+          end
+          self
+        end
+
+        def self._build_pool
+          Concurrent::CachedThreadPool.new(min_length: 5, max_length: 20, max_queue: 0, fallback_policy: :caller_runs)
+        end
+      end
     end
   end
 end

data/lib/routemaster/responses/hateoas_enumerable_response.rb

@@ -0,0 +1,47 @@
+require 'forwardable'
+require 'routemaster/responses/hateoas_response'
+
+module Routemaster
+  module Responses
+    # Yields all resources listed in a collection endpoint in a non-greedy,
+    # non-recursive manner.
+    #
+    # Each yielded resource is a future; synchronous requests are performed for
+    # each page.
+    #
+    # NB: the first named collection in the _links section of the payload will
+    # be enumerated. Any other named collections will simply be ignored.
+    class HateoasEnumerableResponse < HateoasResponse
+      include Enumerable
+
+      def each(&block)
+        each_page do |items|
+          items.each(&block)
+        end
+      end
+
+      def each_page
+        current_page = self
+        loop do
+          yield _page_items(current_page)
+          break unless current_page.has?(:next)
+          current_page = current_page.next.index
+        end
+      end
+
+      private
+
+      def _resource_name
+        _links.find { |k,v|
+          !%w[curies self].include?(k) && v.kind_of?(Array)
+        }.first
+      end
+
+      def _page_items(page)
+        page.body._links.fetch(_resource_name).map do |link|
+          @client.fget(link.href)
+        end
+      end
+    end
+  end
+end

data/lib/routemaster/responses/hateoas_response.rb

@@ -1,9 +1,10 @@
-require 'faraday_middleware'
-require 'routemaster/api_client'
-require 'routemaster/responses/hateoas_response'
-require 'routemaster/resources/rest_resource'
+require 'core_ext/forwardable'
 require 'forwardable'
-require 'json'
+require 'routemaster/api_client'
+
+# While this depends on `RestResource`, we can't laod it as there is a circular
+# dependency.
+# require 'routemaster/resources/rest_resource'
 
 module Routemaster
   module Responses
@@ -15,7 +16,7 @@ module Routemaster
 
       def initialize(response, client: nil)
         @response = response
-        @client = client || Routemaster::APIClient.new(response_class: Routemaster::Responses::HateoasResponse)
+        @client = client || Routemaster::APIClient.new(response_class: self.class)
       end
 
       def method_missing(m, *args, &block)
@@ -25,12 +26,8 @@ module Routemaster
         if _links.keys.include?(normalized_method_name)
           unless respond_to?(method_name)
             resource = Resources::RestResource.new(_links[normalized_method_name]['href'], client: @client)
-
-            define_singleton_method(method_name) do |*m_args|
-              resource
-            end
-
-            resource
+            define_singleton_method(method_name) { resource }
+            public_send method_name
           end
         else
           super

data/routemaster-drain.gemspec

@@ -18,10 +18,10 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency     'faraday', '>= 0.9.0'
   spec.add_runtime_dependency     'faraday_middleware'
-  spec.add_runtime_dependency     'net-http-persistent', '< 3' # 3.x is currently incompatible with faraday
+  spec.add_runtime_dependency     'typhoeus', '~> 1.1'
   spec.add_runtime_dependency     'rack', '>= 1.4.5'
   spec.add_runtime_dependency     'wisper', '~> 1.6.1'
   spec.add_runtime_dependency     'hashie'
   spec.add_runtime_dependency     'redis-namespace'
-  spec.add_runtime_dependency     'thread'
+  spec.add_runtime_dependency     'concurrent-ruby'
 end

data/spec/routemaster/api_client_spec.rb

@@ -10,12 +10,11 @@ describe Routemaster::APIClient do
   uses_redis
   uses_webmock
 
-  describe '.get' do
-    let(:url) { 'https://example.com/widgets/132' }
-    let(:headers) {{}}
-    let(:fetcher) { described_class.new }
-    subject { fetcher.get(url, headers: headers) }
+  let(:url) { 'https://example.com/widgets/132' }
+  let(:headers) {{}}
+  let(:fetcher) { described_class.new }
 
+  shared_examples 'a GET requester' do
     before do
       @req = stub_request(:get, /example\.com/).to_return(
         status:   200,
@@ -24,47 +23,13 @@ describe Routemaster::APIClient do
           'content-type' => 'application/json;v=1'
         }
       )
-
-      @post_req = stub_request(:post, /example\.com/).to_return(
-        status:   200,
-        body:     { id: 132, type: 'widget' }.to_json,
-        headers:  {
-          'content-type' => 'application/json;v=1'
-        }
-      )
-
-      @patch_req = stub_request(:patch, /example\.com/).to_return(
-        status:   200,
-        body:     { id: 132, type: 'widget' }.to_json,
-        headers:  {
-          'content-type' => 'application/json;v=1'
-        }
-      )
     end
 
     it 'GETs from the URL' do
-      subject
+      subject.status
       expect(@req).to have_been_requested
     end
 
-    context 'POST request' do
-      subject { fetcher.post(url, body: {}, headers: headers) }
-
-      it 'POSTs from the URL' do
-        subject
-        expect(@post_req).to have_been_requested
-      end
-    end
-
-    context 'PATCH request' do
-      subject { fetcher.patch(url, body: {}, headers: headers) }
-
-      it 'PATCH from the URL' do
-        subject
-        expect(@patch_req).to have_been_requested
-      end
-    end
-
     it 'has :status, :headers, :body' do
       expect(subject.status).to eq(200)
       expect(subject.headers).to have_key('content-type')
@@ -76,7 +41,7 @@ describe Routemaster::APIClient do
     end
 
     it 'uses auth' do
-      subject
+      subject.status
       assert_requested(:get, /example/) do |req|
         credentials = Base64.strict_encode64('username:s3cr3t')
         expect(req.headers['Authorization']).to eq("Basic #{credentials}")
@@ -85,7 +50,7 @@ describe Routemaster::APIClient do
 
     it 'passes headers' do
       headers['x-custom-header'] = 'why do you even'
-      subject
+      subject.status
       assert_requested(:get, /example/) do |req|
         expect(req.headers).to include('X-Custom-Header')
       end
@@ -95,14 +60,123 @@ describe Routemaster::APIClient do
       before do
         class DummyResponse
           def initialize(res, client: nil); end
+          def dummy; true; end
         end
       end
 
       let(:fetcher) { described_class.new(response_class: DummyResponse) }
 
-      it 'returns a response_class instance as a response' do
-        expect(subject).to be_an_instance_of(DummyResponse)
+      it 'wraps the response in the response class' do
+        expect(subject.dummy).to be_truthy
       end
     end
   end
+
+  describe '#get' do
+    subject { fetcher.get(url, headers: headers) }
+    it_behaves_like 'a GET requester'
+  end
+
+  describe '#fget' do
+    subject { fetcher.fget(url, headers: headers) }
+    it_behaves_like 'a GET requester'
+  end
+
+  describe '#post' do
+    subject { fetcher.post(url, body: {}, headers: headers) }
+
+    before do
+      @post_req = stub_request(:post, /example\.com/).to_return(
+        status:   200,
+        body:     { id: 132, type: 'widget' }.to_json,
+        headers:  {
+          'content-type' => 'application/json;v=1'
+        }
+      )
+    end
+
+    it 'POSTs from the URL' do
+      subject
+      expect(@post_req).to have_been_requested
+    end
+  end
+
+  describe '#patch' do
+    subject { fetcher.patch(url, body: {}, headers: headers) }
+
+    before do
+      @patch_req = stub_request(:patch, /example\.com/).to_return(
+        status:   200,
+        body:     { id: 132, type: 'widget' }.to_json,
+        headers:  {
+          'content-type' => 'application/json;v=1'
+        }
+      )
+    end
+
+    it 'PATCH from the URL' do
+      subject
+      expect(@patch_req).to have_been_requested
+    end
+  end
+
+  describe '#delete' do
+    subject { fetcher.delete(url, headers: headers) }
+
+    before do
+      @delete_req = stub_request(:delete, /example\.com/).to_return(
+        status:   204,
+      )
+    end
+
+    it 'DELETES from the URL' do
+      subject
+      expect(@delete_req).to have_been_requested
+    end
+  end
+
+  describe '#discover' do
+    before do
+      @req = stub_request(:get, /example\.com/).to_return(
+        status:   200,
+        body:     { id: 132, type: 'widget' }.to_json,
+        headers:  {
+          'content-type' => 'application/json;v=1'
+        }
+      )
+    end
+
+    it 'GETs from the URL' do
+      subject.discover('https://example.com')
+      expect(@req).to have_been_requested
+    end
+  end
+
+  describe '#with_response' do
+    before { stub_request(:any, //).to_return(status: 200) }
+
+    class DummyResponseA
+      def initialize(res, client: nil); end
+      def dummy_a; true; end
+    end
+
+    class DummyResponseB
+      def initialize(res, client: nil); end
+      def dummy_b; true; end
+    end
+
+    subject { described_class.new(response_class: DummyResponseA) }
+    let(:response) { subject.get('https://example.com') }
+
+    it 'changes the response wrapper during the block' do
+      subject.with_response(DummyResponseB) do
+        expect(response).to respond_to(:dummy_b)
+      end
+    end
+
+    it 'restores the original response wrapper after the block' do
+      subject.with_response(DummyResponseB) {}
+      expect(response).to respond_to(:dummy_a)
+    end
+  end
 end