net-http2 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba9816c229aab7bb320437a77c3c91ed60752609
-  data.tar.gz: 63836c93155c8d717f68542519b145f87e5e6bd1
+  metadata.gz: 06fbac929ced0fe89503612541dd469842084882
+  data.tar.gz: b1a1119b920b3e2aaa2445b4f3810a9438ee32b2
 SHA512:
-  metadata.gz: bb589fa1c74d8fb02f79161660756667c3420baaa3810007a47506df85c5b996cfa46524d98bf6a11e2099dedc9fd2bba7922fd4ed171201dce5b59472e5012a
-  data.tar.gz: 749b07f13a864be5a935ee7fbeef1bc912e1a4e75170f9c1334de8799aeeb0f318e43a6cc209bcc8733b6687121bee756165a759e17273e47ddc50fbeaee63ba
+  metadata.gz: 7a49a1d2f16b33d0260464584880d74e55076d4b7c1f59545f9fabb6af2861c8c357596f1fd16ab30b4212450be0ea242f2bcf2ea76c6a966d8d9f38762f73f4
+  data.tar.gz: 1d7492113575170952373c2326c13bab44018f1ae941f71a1ff56eeb6e4426ef9721499c6b88a12febda67fb73c1b93d65eb76ec7bada382b0650fa7b2aa49d4

data/README.md

@@ -1,10 +1,10 @@
 [![Build Status](https://travis-ci.org/ostinelli/net-http2.svg?branch=master)](https://travis-ci.org/ostinelli/net-http2)
+[![Code Climate](https://codeclimate.com/github/ostinelli/net-http2/badges/gpa.svg)](https://codeclimate.com/github/ostinelli/net-http2)
 
 # NetHttp2
 
 NetHttp2 is an HTTP/2 client for Ruby.
 
-
 ## Installation
 Just install the gem:
 
@@ -19,7 +19,9 @@ gem 'net-http2'
 ```
 
 ## Usage
+NetHttp2 can perform sync and async calls. Sync calls are very similar to the HTTP/1 calls, while async calls take advantage of the streaming properties of HTTP/2.
 
+To perform a sync call:
 ```ruby
 require 'net-http2'
 
@@ -27,7 +29,7 @@ require 'net-http2'
 client = NetHttp2::Client.new("http://106.186.112.116")
 
 # send request
-response = client.get('/')
+response = client.call(:get, '/')
 
 # read the response
 response.ok?      # => true
@@ -39,16 +41,34 @@ response.body     # => "A body"
 client.close
 ```
 
+To perform an async call:
+```ruby
+require 'net-http2'
 
-## Objects
+# create a client
+client = NetHttp2::Client.new("http://106.186.112.116")
 
-### `NetHttp2::Client`
-To create a new client:
+# prepare request
+request = client.prepare_request(:get, '/')
+request.on(:headers) { |headers| p headers }
+request.on(:body_chunk) { |chunk| p chunk }
+request.on(:close) { puts "request completed!" }
 
-```ruby
-NetHttp2::Client.new(url)
+# send
+client.call_async(request)
+
+# We need to wait for the callbacks to be triggered, so here's a quick and dirty fix for this example.
+# In real life, if you are using async requests so you probably have a running loop that keeps your program alive.
+sleep 5
+
+# close the connection
+client.close
 ```
 
+## Objects
+
+### `NetHttp2::Client`
+
 #### Methods
 
  * **new(url, options={})** → **`NetHttp2::Client`**
@@ -56,16 +76,20 @@ NetHttp2::Client.new(url)
  Returns a new client. `url` is a `string` such as https://localhost:443.
  The only current option is `:ssl_context`, in case the url has an https scheme and you want your SSL client to use a custom context.
 
- For instance:
+ To create a new client:
+ ```ruby
+ NetHttp2::Client.new("http://106.186.112.116")
+ ```
 
-  ```ruby
-  certificate = File.read("cert.pem")
-  ctx         = OpenSSL::SSL::SSLContext.new
-  ctx.key     = OpenSSL::PKey::RSA.new(certificate, "cert_password")
-  ctx.cert    = OpenSSL::X509::Certificate.new(certificate)
+ To create a new client with a custom SSL context:
+ ```ruby
+ certificate = File.read("cert.pem")
+ ctx         = OpenSSL::SSL::SSLContext.new
+ ctx.key     = OpenSSL::PKey::RSA.new(certificate, "cert_password")
+ ctx.cert    = OpenSSL::X509::Certificate.new(certificate)
 
-  NetHttp2::Client.new(url, ssl_context: ctx)
-  ```
+ NetHttp2::Client.new("http://106.186.112.116", ssl_context: ctx)
+ ```
 
  * **uri** → **`URI`**
 
@@ -80,18 +104,68 @@ These behave similarly to HTTP/1 calls.
 
  `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.
 
-  For example:
-
-  ```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)
-  ```
+ ```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)
+ ```
 
 
 ##### Non-blocking calls
+The real benefit of HTTP/2 is being able to receive body and header streams. Instead of buffering the whole response, you might want to react immediately upon receiving those streams. This is what non-blocking calls are for.
+
+ * **prepare_request(method, path, options={})** → **`NetHttp2::Request`**
+
+ Prepares an async request. Arguments are the same as the `call` method, with the difference that the `:timeout` option will be ignored. In an async call, you will need to write your own logic for timeouts.
 
-> The real benefit of HTTP/2 is being able to receive body and header streams. The non-blocking API calls are currently being developed.
+ ```ruby
+ request = client.prepare_request(:get, '/path', headers: { 'x-custom-header' => 'custom' })
+ ```
+
+ * **on(event, &block)** 
+
+ Allows to set a callback for the request. Available events are:
+ 
+  * `:headers`: triggered when headers are received (called once).
+  * `:body_chunk`: triggered when body chunks are received (may be called multiple times).
+  * `:close`: triggered when the request has been completed (called once).
+
+ Even if NetHttp2 is thread-safe, the async callbacks will be executed in a different thread, so ensure that your code in the callbacks is thread-safe.
+
+ ```ruby
+ request.on(:headers) { |headers| p headers }
+ request.on(:body_chunk) { |chunk| p chunk }
+ request.on(:close) { puts "request completed!" }
+ ```
+
+ * **call_async(request)**
+
+ Calls the server with the async request.
+
+
+### `NetHttp2::Request`
+
+#### Methods
+
+ * **method** → **`symbol`**
+ 
+ The request's method.
+
+ * **uri** → **`URI`**
+ 
+ The request's URI.
+
+ * **path** → **`string`**
+ 
+ The request's path.
+
+ * **body** → **`string`**
+ 
+ The request's body.
+
+ * **timeout** → **`integer`**
+ 
+ The request's timeout.
 
 
 ### `NetHttp2::Response`
@@ -115,6 +189,9 @@ These behave similarly to HTTP/1 calls.
  Returns the RAW body of the response.
 
 
+## Thread-Safety
+NetHttp2 is thread-safe.
+
 ## Contributing
 So you want to contribute? That's great! Please follow the guidelines below. It will make it easier to get merged in.
 

data/lib/net-http2/client.rb

@@ -22,11 +22,20 @@ module NetHttp2
     end
 
     def call(method, path, options={})
-      request = NetHttp2::Request.new(method, @uri, path, options)
+      request = prepare_request(method, path, options)
       ensure_open
       new_stream.call_with request
     end
 
+    def call_async(request)
+      ensure_open
+      new_stream.async_call_with request
+    end
+
+    def prepare_request(method, path, options={})
+      NetHttp2::Request.new(method, @uri, path, options)
+    end
+
     def ssl?
       @is_ssl
     end
@@ -42,27 +51,25 @@ module NetHttp2
 
     private
 
-    def async_call_with(request, &block)
-      ensure_open
-      new_stream.async_call_with request, &block
-    end
-
     def new_stream
       NetHttp2::Stream.new(uri: @uri, h2_stream: h2.new_stream)
     end
 
     def ensure_open
-      return if @socket_thread
+      @mutex.synchronize do
 
-      socket = new_socket
+        return if @socket_thread
 
-      @socket_thread = Thread.new do
+        socket = new_socket
 
-        begin
-          thread_loop(socket)
-        ensure
-          socket.close unless socket.closed?
-          @socket_thread = nil
+        @socket_thread = Thread.new do
+
+          begin
+            thread_loop(socket)
+          ensure
+            socket.close unless socket.closed?
+            @socket_thread = nil
+          end
         end
       end
     end
@@ -83,7 +90,7 @@ module NetHttp2
         end
 
         if ready[0].include?(@pipe_r)
-          data_to_send = @pipe_r.read_nonblock(1024)
+          data_to_send = @pipe_r.readpartial(1024)
           socket.write(data_to_send)
         end
       end
@@ -146,7 +153,7 @@ module NetHttp2
     end
 
     def exit_thread(thread)
-      return unless thread && thread.alive?
+      return unless thread
       thread.exit
       thread.join
     end

data/lib/net-http2/request.rb

@@ -13,6 +13,8 @@ module NetHttp2
       @body    = options[:body]
       @headers = options[:headers] || {}
       @timeout = options[:timeout] || DEFAULT_TIMEOUT
+
+      @events = {}
     end
 
     def headers
@@ -30,8 +32,19 @@ module NetHttp2
         @headers.delete('content-length')
       end
 
-
       @headers
     end
+
+    def on(event, &block)
+      raise ArgumentError, 'on event must provide a block' unless block_given?
+
+      @events[event] ||= []
+      @events[event] << block
+    end
+
+    def emit(event, arg)
+      return unless @events[event]
+      @events[event].each { |b| b.call(arg) }
+    end
   end
 end

data/lib/net-http2/stream.rb

@@ -4,30 +4,72 @@ module NetHttp2
 
     def initialize(options={})
       @h2_stream = options[:h2_stream]
-      @uri       = options[:uri]
       @headers   = {}
       @data      = ''
+      @request   = nil
       @completed = false
-      @block     = nil
+      @async     = false
 
-      @h2_stream.on(:headers) do |hs|
-        hs.each { |k, v| @headers[k] = v }
-      end
-
-      @h2_stream.on(:data) { |d| @data << d }
-      @h2_stream.on(:close) { @completed = true }
+      listen_for_headers
+      listen_for_data
+      listen_for_close
     end
 
     def call_with(request)
-      send_data_of request
-      sync_respond(request.timeout)
+      @request = request
+      send_request_data
+      sync_respond
+    end
+
+    def async_call_with(request)
+      @request = request
+      @async   = true
+      send_request_data
+    end
+
+    def completed?
+      @completed
+    end
+
+    def async?
+      @async
     end
 
     private
 
-    def send_data_of(request)
-      headers = request.headers
-      body    = request.body
+    def listen_for_headers
+      @h2_stream.on(:headers) do |hs_array|
+        hs = Hash[*hs_array.flatten]
+
+        if async?
+          @request.emit(:headers, hs)
+        else
+          @headers.merge!(hs)
+        end
+      end
+    end
+
+    def listen_for_data
+      @h2_stream.on(:data) do |data|
+        if async?
+          @request.emit(:body_chunk, data)
+        else
+          @data << data
+        end
+      end
+    end
+
+    def listen_for_close
+      @h2_stream.on(:close) do |data|
+        @completed = true
+
+        @request.emit(:close, data) if async?
+      end
+    end
+
+    def send_request_data
+      headers = @request.headers
+      body    = @request.body
 
       if body
         @h2_stream.headers(headers, end_stream: false)
@@ -37,24 +79,18 @@ module NetHttp2
       end
     end
 
-    def sync_respond(timeout)
-      wait(timeout)
-      response if @completed
+    def sync_respond
+      wait_for_completed
+
+      NetHttp2::Response.new(headers: @headers, body: @data) if @completed
     end
 
-    def wait(timeout)
-      cutoff_time = Time.now + timeout
+    def wait_for_completed
+      cutoff_time = Time.now + @request.timeout
 
       while !@completed && Time.now < cutoff_time
         sleep 0.1
       end
     end
-
-    def response
-      NetHttp2::Response.new(
-        headers: @headers,
-        body:    @data
-      )
-    end
   end
 end

data/lib/net-http2/version.rb

@@ -1,3 +1,3 @@
 module NetHttp2
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

metadata

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