net-http2 0.14.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dfc359f7833ccb7f0f42ae71bdf7b870e2c7b2f1
-  data.tar.gz: 3b8fa8c3f7721edd104b271c7f85f3b090935543
+  metadata.gz: 7ca19f3b01ed565929287e4db629d7c5a3c1522e
+  data.tar.gz: d31dc0fc2f7cf652dcc8bdac6fcc8b31b6721797
 SHA512:
-  metadata.gz: 61752118de4cc018356527584ab1eb27b8e7270b531e01db85d05d78a93dca4d8c4f21161a22d1e2a56730aaeabb11754bbe78c7168f66777e0c97ee08e08db2
-  data.tar.gz: 922f803b411e0ae38b07247cf69062f46c50f9a8ece19b8960df32bb468672375cb8cefa4948d0948c03f19fdde070f8a65cdf73cef46a3ef0606c9590674bb0
+  metadata.gz: b0b94a8d7e38e0fed916585ff63b8f1686e0cf0ae0107dced66a7de8199155ac62484366fd1808ba2bfeb5e6fc02fb2bcd4cabab061ecfa2833a6bf1621ef22b
+  data.tar.gz: f88d758b5174c933832c003ce996f0a97277bf0b24da7ba517825bcb2eb4a898b8773f56b008fe256eb247ca0a659117a8cc04be0f22f463145e60fb414ab117

data/README.md

@@ -75,9 +75,10 @@ client.close
 
  Returns a new client. `url` is a `string` such as `http://nghttp2.org`.
  The current options are:
- 
+
   * `:connect_timeout`, specifies the max connect timeout in seconds (defaults to 60).
   * `:ssl_context`, in case the url has an https scheme and you want your SSL client to use a custom context.
+  * `:proxy_addr`, `:proxy_port`, `:proxy_user`, `:proxy_pass`, specify Proxy connection parameters.
 
  To create a new client:
  ```ruby
@@ -105,12 +106,13 @@ These behave similarly to HTTP/1 calls.
 
  Sends a request. Returns `nil` in case a timeout occurs.
 
- `method` is a symbol that specifies the `:method` header (`:get`, `:post`, `:put`, `:patch`, `:delete`, `:options`). The body and the headers of the request can be specified in the options, together with the timeout.
+ `method` is a symbol that specifies the `:method` header (`:get`, `:post`, `:put`, `:patch`, `:delete`, `:options`). The body, headers and query-string params of the request can be specified in the options, together with the timeout.
 
  ```ruby
  response_1 = client.call(:get, '/path1')
  response_2 = client.call(:get, '/path2', headers: { 'x-custom' => 'custom' })
  response_3 = client.call(:post, '/path3', body: "the request body", timeout: 1)
+ response_3 = client.call(:post, '/path4', params: { page: 4 })
  ```
 
 ##### Non-blocking calls
@@ -149,6 +151,10 @@ The real benefit of HTTP/2 is being able to receive body and header streams. Ins
 
  The request's path.
 
+ * **params** → **`hash`**
+
+ The query string params in hash format, for example `{one: 1, two: 2}`. These will be encoded and appended to `path`.
+
  * **body** → **`string`**
 
  The request's body.

data/lib/net-http2/client.rb

@@ -5,7 +5,8 @@ require 'http/2'
 
 module NetHttp2
 
-  DRAFT = 'h2'
+  DRAFT               = 'h2'
+  PROXY_SETTINGS_KEYS = [:proxy_addr, :proxy_port, :proxy_user, :proxy_pass]
 
   class Client
     attr_reader :uri
@@ -15,6 +16,10 @@ module NetHttp2
       @connect_timeout = options[:connect_timeout] || 60
       @ssl_context     = add_npn_to_context(options[:ssl_context] || OpenSSL::SSL::SSLContext.new)
 
+      PROXY_SETTINGS_KEYS.each do |key|
+        instance_variable_set("@#{key}", options[key]) if options[key]
+      end
+
       @is_ssl = (@uri.scheme == 'https')
 
       @mutex = Mutex.new
@@ -55,13 +60,15 @@ module NetHttp2
     private
 
     def init_vars
-      @socket.close if @socket && !@socket.closed?
+      @mutex.synchronize do
+        @socket.close if @socket && !@socket.closed?
 
-      @h2              = nil
-      @socket          = nil
-      @socket_thread   = nil
-      @first_data_sent = false
-      @streams         = {}
+        @h2              = nil
+        @socket          = nil
+        @socket_thread   = nil
+        @first_data_sent = false
+        @streams         = {}
+      end
     end
 
     def new_stream
@@ -85,8 +92,7 @@ module NetHttp2
 
         return if @socket_thread
 
-        main_thread = Thread.current
-        @socket     = new_socket
+        @socket = new_socket
 
         @socket_thread = Thread.new do
           begin
@@ -95,14 +101,14 @@ module NetHttp2
           rescue EOFError
             # socket closed
             init_vars
-            main_thread.raise SocketError.new 'Socket was remotely closed'
+            raise SocketError.new 'Socket was remotely closed'
 
           rescue Exception => e
             # error on socket
             init_vars
-            main_thread.raise e
+            raise e
           end
-        end
+        end.tap { |t| t.abort_on_exception = true }
       end
     end
 
@@ -126,7 +132,11 @@ module NetHttp2
     end
 
     def new_socket
-      NetHttp2::Socket.create(@uri, ssl: ssl?, ssl_context: @ssl_context, connect_timeout: @connect_timeout)
+      options = {
+        ssl: ssl?, ssl_context: @ssl_context, connect_timeout: @connect_timeout
+      }
+      PROXY_SETTINGS_KEYS.each { |k| options[k] = instance_variable_get("@#{k}") }
+      NetHttp2::Socket.create(@uri, options)
     end
 
     def ensure_sent_before_receiving

data/lib/net-http2/request.rb

@@ -1,15 +1,18 @@
+require 'cgi'
+
 module NetHttp2
 
   class Request
 
     DEFAULT_TIMEOUT = 60
 
-    attr_reader :method, :uri, :path, :body, :timeout
+    attr_reader :method, :uri, :path, :params, :body, :timeout
 
     def initialize(method, uri, path, options={})
       @method  = method
       @uri     = uri
       @path    = path
+      @params  = options[:params] || {}
       @body    = options[:body]
       @headers = options[:headers] || {}
       @timeout = options[:timeout] || DEFAULT_TIMEOUT
@@ -21,7 +24,7 @@ module NetHttp2
       @headers.merge!({
         ':scheme' => @uri.scheme,
         ':method' => @method.to_s.upcase,
-        ':path'   => @path,
+        ':path'   => full_path,
       })
 
       @headers.merge!(':authority' => "#{@uri.host}:#{@uri.port}") unless @headers[':authority']
@@ -35,6 +38,12 @@ module NetHttp2
       @headers
     end
 
+    def full_path
+      path = @path
+      path += "?#{to_query(@params)}" unless @params.empty?
+      path
+    end
+
     def on(event, &block)
       raise ArgumentError, 'on event must provide a block' unless block_given?
 
@@ -46,5 +55,62 @@ module NetHttp2
       return unless @events[event]
       @events[event].each { |b| b.call(arg) }
     end
+
+    private
+
+    # The to_param and to_query code here below is a free adaptation from the original code in:
+    # <https://github.com/rails/rails/blob/v5.0.0.1/activesupport/lib/active_support/core_ext/object/to_query.rb>
+    # released under the following MIT license:
+    #
+    # Copyright (c) 2005-2016 David Heinemeier Hansson
+    #
+    # Permission is hereby granted, free of charge, to any person obtaining
+    # a copy of this software and associated documentation files (the
+    # "Software"), to deal in the Software without restriction, including
+    # without limitation the rights to use, copy, modify, merge, publish,
+    # distribute, sublicense, and/or sell copies of the Software, and to
+    # permit persons to whom the Software is furnished to do so, subject to
+    # the following conditions:
+    #
+    # The above copyright notice and this permission notice shall be
+    # included in all copies or substantial portions of the Software.
+    #
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+    def to_param(element)
+      if element.is_a?(TrueClass) || element.is_a?(FalseClass) || element.is_a?(NilClass)
+        element
+      elsif element.is_a?(Array)
+        element.collect(&:to_param).join '/'
+      else
+        element.to_s.strip
+      end
+    end
+
+    def to_query(element, namespace_or_key = nil)
+      if element.is_a?(Hash)
+        element.collect do |key, value|
+          unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+            to_query(value, namespace_or_key ? "#{namespace_or_key}[#{key}]" : key)
+          end
+        end.compact.sort! * '&'
+      elsif element.is_a?(Array)
+        prefix = "#{namespace_or_key}[]"
+
+        if element.empty?
+          to_query(nil, prefix)
+        else
+          element.collect { |value| to_query(value, prefix) }.join '&'
+        end
+      else
+        "#{CGI.escape(to_param(namespace_or_key))}=#{CGI.escape(to_param(element).to_s)}"
+      end
+    end
   end
 end

data/lib/net-http2/socket.rb

@@ -3,15 +3,22 @@ module NetHttp2
   module Socket
 
     def self.create(uri, options)
-      options[:ssl] ? ssl_socket(uri, options) : tcp_socket(uri, options)
+      return ssl_socket(uri, options) if options[:ssl]
+      return proxy_tcp_socket(uri, options) if options[:proxy_addr]
+
+      tcp_socket(uri, options)
     end
 
     def self.ssl_socket(uri, options)
-      tcp = tcp_socket(uri, options)
+      tcp = if options[:proxy_addr]
+        proxy_tcp_socket(uri, options)
+      else
+        tcp_socket(uri, options)
+      end
 
       socket            = OpenSSL::SSL::SSLSocket.new(tcp, options[:ssl_context])
       socket.sync_close = true
-      socket.hostname   = uri.hostname
+      socket.hostname   = options[:proxy_addr] || uri.host
 
       socket.connect
 
@@ -46,5 +53,49 @@ module NetHttp2
 
       socket
     end
+
+    def self.proxy_tcp_socket(uri, options)
+      proxy_addr = options[:proxy_addr]
+      proxy_port = options[:proxy_port]
+      proxy_user = options[:proxy_user]
+      proxy_pass = options[:proxy_pass]
+
+      proxy_uri = URI.parse("#{proxy_addr}:#{proxy_port}")
+      proxy_socket = tcp_socket(proxy_uri, options)
+
+      # The majority of proxies do not explicitly support HTTP/2 protocol,
+      # while they successfully create a TCP tunnel
+      # which can pass through binary data of HTTP/2 connection.
+      # So we’ll keep HTTP/1.1
+      http_version = '1.1'
+
+      buf = "CONNECT #{uri.host}:#{uri.port} HTTP/#{http_version}\r\n"
+      buf << "Host: #{uri.host}:#{uri.port}\r\n"
+      if proxy_user
+        credential = ["#{proxy_user}:#{proxy_pass}"].pack('m')
+        credential.delete!("\r\n")
+        buf << "Proxy-Authorization: Basic #{credential}\r\n"
+      end
+      buf << "\r\n"
+      proxy_socket.write(buf)
+      validate_proxy_response!(proxy_socket)
+
+      proxy_socket
+    end
+
+    private
+
+    def self.validate_proxy_response!(socket)
+      result = ''
+      loop do
+        line = socket.gets
+        break if !line || line.strip.empty?
+
+        result << line
+      end
+      return if result =~ /HTTP\/\d(?:\.\d)?\s+2\d\d\s/
+
+      raise(StandardError, "Proxy connection failure:\n#{result}")
+    end
   end
 end

data/lib/net-http2/version.rb

@@ -1,3 +1,3 @@
 module NetHttp2
-  VERSION = "0.14.0"
+  VERSION = "0.14.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: net-http2
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Roberto Ostinelli
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-30 00:00:00.000000000 Z
+date: 2016-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2