async-aws 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 015565e72854159af66339152c90b413caa5fc32b419f3ee14b38d19c345a3ae
-  data.tar.gz: 26f6079d3e6d1de58bd670ae306af9fa4bbfa7f8523253d984bbab6d91c7db6d
+  metadata.gz: d4b4634f5e07b319d4e20f927f524e59fea4236693fc38a57d914cba8e616fc8
+  data.tar.gz: 57868e373bbe1137a4f5a0fd38f6727f72eb895ce1a732910e3d5debec1e18b0
 SHA512:
-  metadata.gz: 6b5bac239f67be456b553f298b1d7f35ec1701e3a4bc511110bbb71a9af0534b846f0bcdf8f66aefa6361263cc9bdb009d5eb4f9ef8faf88c75b5d7e6f03ad77
-  data.tar.gz: 47cedb33f2cb7d5ea04759b9601e5fd95c76c697f19d96f08b9c0dc8db82773a66cc95540255b91e5c0a96d1859f43a4418ccba143cc406368ee26ea259a49f5
+  metadata.gz: 9acbd7be0847428db25bdc766c184d2c10eb9bd5c6facb72b266389bdcc7d276bf07e99da04cfd959d6522ce1aecf247707061d3b8b1b8f537aacd38b093f01e
+  data.tar.gz: 72f1485b45e5d2b8cd8be02f5ad96dc7161fd8b94e0e4989a95fcd8786e7fc63dd460533ebb1cc88dc2923ca52320dac6ae5030c643b28cb845b3aababecd5dd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    async-aws (0.1.0)
+    async-aws (0.3.0)
       async-http (~> 0.48)
 
 GEM
@@ -11,14 +11,17 @@ GEM
       console (~> 1.0)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-http (0.48.2)
-      async (~> 1.19)
-      async-io (~> 1.25)
-      protocol-http (~> 0.12.0)
-      protocol-http1 (~> 0.9.0)
-      protocol-http2 (~> 0.9.0)
-    async-io (1.27.0)
+    async-http (0.50.0)
+      async (~> 1.23)
+      async-io (~> 1.27.0)
+      async-pool (~> 0.2)
+      protocol-http (~> 0.13.0)
+      protocol-http1 (~> 0.10.0)
+      protocol-http2 (~> 0.10.0)
+    async-io (1.27.1)
       async (~> 1.14)
+    async-pool (0.2.0)
+      async (~> 1.8)
     aws-eventstream (1.0.3)
     aws-partitions (1.223.0)
     aws-sdk-core (3.68.1)
@@ -43,10 +46,10 @@ GEM
     jmespath (1.4.0)
     nio4r (2.5.2)
     protocol-hpack (1.4.1)
-    protocol-http (0.12.3)
-    protocol-http1 (0.9.0)
-      protocol-http (~> 0.5)
-    protocol-http2 (0.9.7)
+    protocol-http (0.13.0)
+    protocol-http1 (0.10.0)
+      protocol-http (~> 0.13)
+    protocol-http2 (0.10.4)
       protocol-hpack (~> 1.4)
       protocol-http (~> 0.2)
     rake (10.5.0)
@@ -78,4 +81,4 @@ DEPENDENCIES
   rspec (~> 3.0)
 
 BUNDLED WITH
-   2.0.2
+   2.1.2

data/lib/async/aws.rb

@@ -1,6 +1,6 @@
 require 'async/http'
 require 'async/http/internet'
-require 'async/aws/connection_pool'
+require 'async/aws/http_client'
 require 'async/aws/http_handler'
 require 'async/aws/http_plugin'
 
@@ -8,12 +8,24 @@ module Async
   module Aws
     module_function
 
-    def connection_pool=(arg)
-      @connection_pool = arg
+    def keep_alive_timeout=(arg)
+      @keep_alive_timeout = arg.to_i
     end
 
-    def connection_pool
-      @connection_pool ||= ConnectionPool.new
+    def keep_alive_timeout
+      @keep_alive_timeout || 2
+    end
+
+    def connection_pool_size=(arg)
+      @connection_pool_size = arg.to_i
+    end
+
+    def connection_pool_size
+      @connection_pool_size || 1
+    end
+
+    def configure(&block)
+      instance_exec(&block)
     end
   end
 end

data/lib/async/aws/http_client.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'async/io/endpoint'
+require 'async/io/stream'
+require 'protocol/http/body/streamable'
+require 'protocol/http/methods'
+
+module Async
+  module Aws
+    class HttpClient < ::Protocol::HTTP::Methods
+      attr_accessor :keep_alive_timeout
+      attr_reader   :scheme
+
+      ConnectionSpec = Struct.new(:connection, :used_at)
+
+      # Provides a robust interface to a server.
+      # * If there are no connections, it will create one.
+      # * If there are already connections, it will reuse it.
+      # * If a request fails, it will retry it up to N times if it was idempotent.
+      # The client object will never become unusable. It internally manages persistent connections (or non-persistent connections if that's required).
+      # @param endpoint [Endpoint] the endpoint to connnect to.
+      # @param protocol [Protocol::HTTP1 | Protocol::HTTP2 | Protocol::HTTPS] the protocol to use.
+      # @param scheme [String] The default scheme to set to requests.
+      # @param authority [String] The default authority to set to requests.
+      def initialize(endpoint, pool_size: 2, keep_alive_timeout: 5)
+        @endpoint = endpoint
+        @protocol = endpoint.protocol
+        @scheme = endpoint.scheme
+        @authority = endpoint.authority
+        @keep_alive_timeout = keep_alive_timeout
+        @clock_gettime_constant = \
+          if defined?(Process::CLOCK_MONOTONIC)
+            Process::CLOCK_MONOTONIC
+          else
+            Process::CLOCK_REALTIME
+          end
+        @pool = make_pool(pool_size)
+      end
+
+      def close
+        until @pool.empty?
+          connection_spec = @pool.dequeue
+          connection_spec.connection.close
+        end
+      end
+
+      def call(request)
+        request.scheme ||= self.scheme
+        request.authority ||= self.authority
+
+        attempt = 0
+
+        # We may retry the request if it is possible to do so. https://tools.ietf.org/html/draft-nottingham-httpbis-retry-01 is a good guide for how retrying requests should work.
+        begin
+          attempt += 1
+
+          # As we cache pool, it's possible these pool go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this. If this is the last attempt, we force a new connection.
+          connection_spec = @pool.dequeue
+          if connection_spec.used_at + keep_alive_timeout <= current_time
+            connection_spec.connection.close
+            connection_spec = create_connection_spec
+          end
+
+          # send request
+          response = request.call(connection_spec.connection)
+
+          # The connection won't be released until the body is completely read/released.
+          ::Protocol::HTTP::Body::Streamable.wrap(response) do
+            connection_spec.used_at = current_time
+            @pool << connection_spec
+          end
+
+          return response
+        rescue => e
+          @pool << connection_spec if connection_spec
+          raise e
+        end
+      end
+
+      private
+
+      def current_time
+        Process.clock_gettime(@clock_gettime_constant)
+      end
+
+      def create_connection_spec
+        ConnectionSpec.new(
+          @protocol.client(@endpoint.connect),
+          current_time
+        )
+      end
+
+      def make_pool(size)
+        Async::Queue.new.tap do |queue|
+          size.times do
+            queue << create_connection_spec
+          end
+        end
+      end
+    end
+  end
+end

data/lib/async/aws/http_handler.rb

@@ -1,17 +1,53 @@
 module Async
   module Aws
     class HttpHandler < ::Seahorse::Client::Handler
+      def self.clients
+        @clients ||= {}
+      end
+
+      def self.with_configuration(**kwargs)
+        Class.new(self).tap do |klass|
+          klass.connection_pool_size = kwargs.fetch(
+            :connection_pool_size, Async::Aws.connection_pool_size
+          )
+          klass.keep_alive_timeout = kwargs.fetch(
+            :keep_alive_timeout, Async::Aws.keep_alive_timeout
+          )
+        end
+      end
+
+      def self.connection_pool_size
+        @connection_pool_size ||= Async::Aws.connection_pool_size
+      end
+
+      def self.connection_pool_size=(value)
+        @connection_pool_size = value.to_i
+      end
+
+      def self.keep_alive_timeout
+        @keep_alive_timeout ||= Async::Aws.keep_alive_timeout
+      end
+
+      def self.keep_alive_timeout=(value)
+        @keep_alive_timeout = value.to_i
+      end
+
       def call(context)
         req = context.http_request
         resp = context.http_response
+        endpoint = Async::HTTP::Endpoint.parse(req.endpoint.to_s)
 
         begin
+          client = client_for(endpoint)
           headers_arr = req.headers.reject do |k, v|
             k == 'host' || k == 'content-length'
           end
-          response = Async::Aws.connection_pool.call(
-            req.http_method, req.endpoint.to_s, headers_arr, req.body
+          buffered_body = Async::HTTP::Body::Buffered.wrap(req.body)
+          request = ::Protocol::HTTP::Request.new(
+            client.scheme, endpoint.authority, req.http_method, endpoint.path,
+            nil, headers_arr, buffered_body
           )
+          response = client.call(request)
           body = response.read
           resp.signal_headers(response.status.to_i, response.headers.to_h)
           resp.signal_data(body)
@@ -23,6 +59,14 @@ module Async
 
         Seahorse::Client::Response.new(context: context)
       end
+
+      def client_for(endpoint)
+        self.class.clients[endpoint.hostname] ||= ::Async::Aws::HttpClient.new(
+          endpoint,
+          pool_size: self.class.connection_pool_size,
+          keep_alive_timeout: self.class.keep_alive_timeout
+        )
+      end
     end
   end
 end

data/lib/async/aws/version.rb

@@ -1,5 +1,5 @@
 module Async
   module Aws
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-aws
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Julien D.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-11 00:00:00.000000000 Z
+date: 2020-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-http
@@ -130,7 +130,7 @@ files:
 - lib/async-aws.rb
 - lib/async/aws.rb
 - lib/async/aws/all.rb
-- lib/async/aws/connection_pool.rb
+- lib/async/aws/http_client.rb
 - lib/async/aws/http_handler.rb
 - lib/async/aws/http_plugin.rb
 - lib/async/aws/version.rb
@@ -157,7 +157,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Async AWS SDK adapter for `socketry/async` framework

data/lib/async/aws/connection_pool.rb

@@ -1,41 +0,0 @@
-module Async
-  module Aws
-    class ConnectionPool
-      def initialize(connection_limit: nil)
-        @clients = {}
-        @connection_limit = connection_limit
-      end
-
-      def call(method, url, headers = [], body = nil)
-        endpoint = ::Async::HTTP::Endpoint.parse(url)
-        client = client_for(endpoint)
-
-        request_body = \
-          case body
-          when ::Aws::Query::ParamList::IoWrapper
-            ::Async::HTTP::Body::Buffered.wrap(body.instance_variable_get(:@io))
-          else
-            ::Async::HTTP::Body::Buffered.wrap(body)
-          end
-        request = ::Protocol::HTTP::Request.new(
-          endpoint.scheme, endpoint.authority, method, endpoint.path, nil, headers,
-          request_body
-        )
-
-        client.call(request)
-      end
-
-      def client_for(endpoint)
-        @clients[endpoint] ||= ::Async::HTTP::Client.new(
-          endpoint, endpoint.protocol, endpoint.scheme, endpoint.authority,
-          retries: 3, connection_limit: @connection_limit
-        )
-      end
-
-      def close
-        @clients.each_value(&:close)
-        @clients.clear
-      end
-    end
-  end
-end