http-2 0.6.1 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb3959b06060d626b9065b6b267fc1e4f3906742
-  data.tar.gz: c7da3c39b1829b0458d6d550df7db911bcd69d29
+  metadata.gz: debc6f11031e879547dd45605849500e45fd1142
+  data.tar.gz: 61e60a0b2b831553a9ecca42b069c032afe12e30
 SHA512:
-  metadata.gz: 293393327feb7f5aafd7017fb63ddb1a332957c8c5221c26050cb5045edf7067b8c2094ee8587227262c3be427838bab46ebd16c33ae8c0e05f8e08482d222ee
-  data.tar.gz: d619c4939dfe5daa0d861d190d9f83368cfd352e46e22b897eaca17318e12550612b855a0a1bf7f860d5443776d3ca9d1fe5e873bdde452c6e2b29c21b568292
+  metadata.gz: b7c36dec0419a45e75f8664e6ac4ede157c49057d51bd7f25f795139313048978e4c053e49d90f0140731ec36b2a7df68fd075c50bb1f9cf98169b3192571ddd
+  data.tar.gz: 9ab31eb78ec61a37139efeba7185a87cd742588f30a456b35bbeb8935e50487cd948be09e9fed68ba1510ef91db88916815cc30ab41941634b567be59b56099c

data/.autotest

@@ -1,8 +1,9 @@
 require 'autotest/growl'
 
 Autotest.add_hook(:initialize) {|at|
-  at.add_exception %r{^\.git}
+  at.add_exception %r{^\.git|\.yardoc}
   at.add_exception %r{^./tmp}
+  at.add_exception %r{coverage}
 
   at.clear_mappings
 

data/Gemfile

@@ -1,4 +1,11 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in http2-parser.gemspec
+gem 'rake'
+gem 'yard'
+
+group :test do
+  gem 'coveralls', :require => false
+  gem 'rspec'
+end
+
 gemspec

data/README.md

@@ -1,31 +1,41 @@
 # HTTP-2
 
+[![Gem Version](https://badge.fury.io/rb/http-2.png)](http://rubygems.org/gems/http-2)
+[![Build Status](https://travis-ci.org/igrigorik/http-2.png?branch=master)](https://travis-ci.org/igrigorik/http-2)
+[![Coverage Status](https://coveralls.io/repos/igrigorik/http-2/badge.png)](https://coveralls.io/r/igrigorik/http-2)
+
 Pure ruby, framework and transport agnostic implementation of [HTTP 2.0 protocol](http://tools.ietf.org/html/draft-ietf-httpbis-http2) with support for:
 
 * [Binary framing](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_binary_framing_layer) parsing and encoding
 * [Stream multiplexing](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_STREAMS_MESSAGES_FRAMES) and [prioritization](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PRIORITIZATION)
 * Connection and stream [flow control](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#_flow_control)
 * [Header compression](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_HEADER_COMPRESSION) and [server push](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PUSH)
-* Connection and stream management, and other HTTP 2.0 goodies...
+* Connection and stream management
+* And more... see [API docs](http://www.rubydoc.info/github/igrigorik/http-2/frames)
 
 Current implementation (see [HPBN chapter for HTTP 2.0 overview](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html)), is based on:
 
 * [draft-ietf-httpbis-http2-06](http://tools.ietf.org/html/draft-ietf-httpbis-http2-06)
-* [draft-ietf-httpbis-header-compression-01](http://tools.ietf.org/html/draft-ietf-httpbis-header-compression)
+* [draft-ietf-httpbis-header-compression-03](http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-03)
 
 _Note: the underlying specifications are still evolving, expect APIs to change and evolve also..._
 
 
 ## Getting started
 
+```bash
+$> gem install http-2
+```
+
 This implementation makes no assumptions as how the data is delivered: it could be a regular Ruby TCP socket, your custom eventloop, or whatever other transport you wish to use - e.g. ZeroMQ, [avian carriers](http://www.ietf.org/rfc/rfc1149.txt), etc.
 
 Your code is responsible for feeding data into the parser, which performs all of the necessary HTTP 2.0 decoding, state management and the rest, and vice versa, the parser will emit bytes (encoded HTTP 2.0 frames) that you can then route to the destination. Roughly, this works as follows:
 
 ```ruby
+require 'http/2'
 socket = YourTransport.new
 
-conn = HTTP2::Connection.new(:client)
+conn = HTTP2::Client.new
 conn.on(:frame) {|bytes| socket << bytes }
 
 while bytes = socket.read
@@ -38,11 +48,11 @@ Checkout provided [client](https://github.com/igrigorik/http-2/blob/master/examp
 
 ### Connection lifecycle management
 
-When the connection object is instantiated you must specify its role (`:client` or `:server`) to initialize appropriate header compression / decompression algorithms and stream management logic. From there, you can subscribe to connection level events, or invoke appropriate APIs to allocate new streams and manage the lifecycle. For example:
+Depending on the role of the endpoint you must initialize either a [Client](http://www.rubydoc.info/github/igrigorik/http-2/HTTP2/Client) or a [Server](http://www.rubydoc.info/github/igrigorik/http-2/HTTP2/Server) object. Doing so picks the appropriate header compression / decompression algorithms and stream management logic. From there, you can subscribe to connection level events, or invoke appropriate APIs to allocate new streams and manage the lifecycle. For example:
 
 ```ruby
 # - Server ---------------
-server = HTTP2::Connection.new(:server)
+server = HTTP2::Server.new
 
 server.on(:stream) { |stream| ... } # process inbound stream
 server.on(:frame)  { |bytes| ... }  # encoded HTTP 2.0 frames
@@ -51,7 +61,7 @@ server.ping { ... } # run liveness check, process pong response
 server.goaway # send goaway frame to the client
 
 # - Client ---------------
-client = HTTP2::Connection.new(:client)
+client = HTTP2::Client.new
 client.on(:promise) { |stream| ... } # process push promise
 
 stream = client.new_stream # allocate new stream
@@ -113,7 +123,7 @@ The good news is, all of the stream management, and state transitions, and error
 For sake of example, let's take a look at a simple server implementation:
 
 ```ruby
-conn = HTTP2::Connection.new(:server)
+conn = HTTP2::Server.new
 
 # emits new streams opened by the client
 conn.on(:stream) do |stream|
@@ -141,7 +151,7 @@ conn.on(:stream) do |stream|
 end
 ```
 
-Events emitted by the stream object:
+Events emitted by the [Stream object](http://www.rubydoc.info/github/igrigorik/http-2/HTTP2/Stream):
 
 <table>
   <tr>
@@ -180,13 +190,13 @@ Events emitted by the stream object:
 Each HTTP 2.0 [stream has a priority value](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PRIORITIZATION) that can be sent when the new stream is initialized, and optionally reprioritized later:
 
 ```ruby
-client = HTTP2::Connection.new(:client)
+client = HTTP2::Client.new
 
 default_priority_stream = client.new_stream
-custom_priority_stream = client.new_stream(42) # priority: 42
+custom_priority_stream = client.new_stream(priority: 42)
 
 # sometime later: change priority value
-custom_priority_stream.priority = 32000 # emits PRIORITY frame
+custom_priority_stream.reprioritize(32000) # emits PRIORITY frame
 ```
 
 On the opposite side, the server can optimize its stream processing order or resource allocation by accessing the stream priority value (`stream.priority`).
@@ -213,10 +223,8 @@ stream.window_update(2048) # increment stream window by 2048 bytes
 Alternatively, flow control can be disabled by emitting an appropriate settings frame on the connection:
 
 ```ruby
-conn.settings({
-  settings_max_concurrent_streams: 100, # limit number of concurrent streams
-  settings_flow_control_options: 1      # disable flow control
-})
+# limit number of concurrent streams to 100 and disable flow control
+conn.settings(streams: 100, window: Float::INFINITY)
 ```
 
 ### Server push
@@ -224,7 +232,7 @@ conn.settings({
 An HTTP 2.0 server can [send multiple replies](http://chimera.labs.oreilly.com/books/1230000000545/ch12.html#HTTP2_PUSH) to a single client request. To do so, first it emits a "push promise" frame which contains the headers of the promised resource, followed by the response to the original request, as well as promised resource payloads (which may be interleaved). A simple example is in order:
 
 ```ruby
-conn = HTTP2::Connection.new(:server)
+conn = HTTP2::Server.new
 
 conn.on(:stream) do |stream|
   stream.on(:headers) { |head| ... }
@@ -258,10 +266,10 @@ conn.on(:stream) do |stream|
 end
 ```
 
-When a new push promise stream is sent by the server, the client is notifed via the `:promise` event:
+When a new push promise stream is sent by the server, the client is notified via the `:promise` event:
 
 ```ruby
-conn = HTTP2::Connection.new(:client)
+conn = HTTP2::Client.new
 conn.on(:promise) do |push|
   # process push stream
 end
@@ -270,9 +278,7 @@ end
 The client can cancel any given push stream (via `.close`), or disable server push entirely by sending the appropriate settings frame (note that below setting only impacts server > client direction):
 
 ```ruby
-client.settings({
-  settings_max_concurrent_streams: 0 # set number of server initiated streams to 0 (aka, disable push)
-})
+client.settings(streams: 0) # setting max limit to 0 disables server push
 ```
 
 ### License

data/example/README.md

@@ -0,0 +1,53 @@
+## Interop
+
+First, a quick test to ensure that we can talk to ourselves:
+
+```bash
+# Direct connection
+$> ruby server.rb
+$> ruby client.rb http://localhost:8080/                 # GET
+$> ruby client.rb http://localhost:8080/ -d 'some data'  # POST
+
+# TLS + NPN negotiation
+$> ruby server.rb --secure
+$> ruby client.rb https://localhost:8080/                # GET
+$> ...
+```
+
+### [nghttp2](https://github.com/tatsuhiro-t/nghttp2) (HTTP/2.0 C Library)
+
+Public test server: http://106.186.112.116 (Upgrade + Direct)
+
+```bash
+# Direct request (http-2 > nghttp2)
+$> ruby client.rb http://106.186.112.116/
+
+# TLS + NPN request (http-2 > nghttp2)
+$> ruby client.rb https://106.186.112.116/
+
+# Direct request (nghttp2 > http-2)
+$> ruby server.rb
+$> nghttp -vnu http://localhost:8080       # Direct request to Ruby server
+```
+
+### [node-http2](https://github.com/molnarg/node-http2) (node.js client/server)
+
+```bash
+# NPN + GET request (http-2 > node-http2)
+$> ruby client.rb https://gabor.molnar.es:8080/
+
+# NPN + GET request with server push (http-2 > node-http2)
+$> ruby client.rb https://gabor.molnar.es:8080/test/push.html
+
+# NPN + POST request (http-2 > node-http2)
+$> ruby client.rb https://gabor.molnar.es:8080/post -d'some data'
+```
+
+### Twitter (Java server)
+
+```bash
+# NPN + GET request (http-2 > twitter)
+$> ruby client.rb https://twitter.com/
+```
+
+For a complete list of current implementations, see [http2 wiki](https://github.com/http2/http2-spec/wiki/Implementations).

data/example/client.rb

@@ -1,46 +1,104 @@
 require_relative 'helper'
 
-Addrinfo.tcp("localhost", 8080).connect do |sock|
-  conn = HTTP2::Connection.new(:client)
-  conn.on(:frame) do |bytes|
-    puts "Sending bytes: #{bytes.inspect}"
-    sock.print bytes
-    sock.flush
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: client.rb [options]"
+
+  opts.on("-d", "--data [String]", "HTTP payload") do |v|
+    options[:payload] = v
   end
+end.parse!
 
-  stream = conn.new_stream
-  log = Logger.new(stream.id)
 
-  stream.on(:close) do
-   log.info "stream closed"
-   sock.close
- end
+uri = URI.parse(ARGV[0] || 'http://localhost:8080/')
+tcp = TCPSocket.new(uri.host, uri.port)
+sock = nil
 
- stream.on(:half_close) do
-  log.info "closing client-end of the stream"
- end
+if uri.scheme == 'https'
+  ctx = OpenSSL::SSL::SSLContext.new
+  ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+  ctx.npn_protocols = [DRAFT]
+  ctx.npn_select_cb = lambda do |protocols|
+    puts "NPN protocols supported by server: #{protocols}"
+    DRAFT if protocols.include? DRAFT
+  end
+
+  sock = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
+  sock.sync_close = true
+  sock.hostname = uri.hostname
+  sock.connect
+
+  if sock.npn_protocol != DRAFT
+    puts "Failed to negotiate #{DRAFT} via NPN"
+    exit
+  end
+else
+  sock = tcp
+end
+
+conn = HTTP2::Client.new
+conn.on(:frame) do |bytes|
+  puts "Sending bytes: #{bytes.inspect}"
+  sock.print bytes
+  sock.flush
+end
+
+stream = conn.new_stream
+log = Logger.new(stream.id)
 
-  stream.on(:headers) do |h|
-    log.info "response headers: #{h}"
+conn.on(:promise) do |promise|
+  promise.on(:headers) do |h|
+    log.info "promise headers: #{h}"
   end
 
-  stream.on(:data) do |d|
-    log.info "response data chunk: <<#{d}>>"
+  promise.on(:data) do |d|
+    log.info "promise data chunk: <<#{d.size}>>"
   end
+end
 
-  puts "Sending POST request"
-  stream.headers({
-    ":method" => "post",
-    ":host" => "localhost",
-    ":path" => "/resource",
-    "accept" => "*/*"
-  })
+stream.on(:close) do
+  log.info "stream closed"
+  sock.close
+end
+
+stream.on(:half_close) do
+  log.info "closing client-end of the stream"
+end
+
+stream.on(:headers) do |h|
+  log.info "response headers: #{h}"
+end
+
+
+stream.on(:data) do |d|
+  log.info "response data chunk: <<#{d}>>"
+end
+
+head = {
+  ":scheme" => uri.scheme,
+  ":method" => (options[:payload].nil? ? "get" : "post"),
+  ":host" => [uri.host, uri.port].join(':'),
+  ":path" => uri.path,
+  "accept" => "*/*"
+}
+
+puts "Sending HTTP 2.0 request"
+if head[":method"] == "get"
+  stream.headers(head, end_stream: true)
+else
+  stream.headers(head, end_stream: false)
+  stream.data(options[:payload])
+end
 
-  stream.data("woot!")
+while !sock.closed? && !sock.eof?
+  data = sock.read_nonblock(1024)
+  # puts "Received bytes: #{data.inspect}"
 
-  while !sock.closed? && !sock.eof?
-    data = sock.readpartial(1024)
-    puts "Received bytes: #{data.inspect}"
+  begin
     conn << data
+  rescue Exception => e
+    puts "Exception: #{e}, #{e.message} - closing socket."
+    sock.close
   end
 end

data/example/helper.rb

@@ -1,7 +1,12 @@
 $: << 'lib' << '../lib'
 
+require 'optparse'
 require 'socket'
+require 'openssl'
 require 'http/2'
+require 'uri'
+
+DRAFT = 'HTTP-draft-06/2.0'
 
 class Logger
   def initialize(id)

data/example/keys/mycert.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIID9DCCAtygAwIBAgIJAKIwkCCNJr2mMA0GCSqGSIb3DQEBBQUAMFkxCzAJBgNV
+BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX
+aWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxvY2FsaG9zdDAeFw0xMjA2MjQxODE4
+MTZaFw0xMzA2MjQxODE4MTZaMFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21l
+LVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNV
+BAMTCWxvY2FsaG9zdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOTQ
+eHgUpZnggH2RwBeghuf86/7wNeO4DIJacLrmCynA871ioOvxzPx5jPTV6dkkitMT
+lNroneNa/BbRHHOVUvCtuJyKXEiFyWs/jCYAZ335uMYtDK2FAHRvNgXMM1YZTpbM
+CSIteVsWIAuNFAWwQS8Bd9oACUS1P69eNbA1BBOqnaYoZT1D+JD4bp9kpBYqXJtf
+wOgHGzPOVatqzJDgOqSwYVz1ZETVopv+TMBght938iVoow2cHnJ2Zj/n/jBkG8E9
+FNlmc67WqQkJsS16E9sEntJOSNldBRsjMFux4E+g7wzyn9tFJ0nYJ/rklWa24BN7
+Vg9diYljQNLLSMv8/tcCAwEAAaOBvjCBuzAdBgNVHQ4EFgQUqBtvGKKXRaXzFV16
+W1uMzroa8SkwgYsGA1UdIwSBgzCBgIAUqBtvGKKXRaXzFV16W1uMzroa8SmhXaRb
+MFkxCzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJ
+bnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxEjAQBgNVBAMTCWxvY2FsaG9zdIIJAKIw
+kCCNJr2mMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBALji7DAGBRU9
+x6/zw7EcEDlutGv6qp1VasJzSexVCZAr5c7vSDbdM+wlAxvwBguoFNLvrIvBxUMN
+pf/lvig2Q++lGTiqu5VodnmJXnqze7PO2Rdq9Yqgkva7qVFuGrYwGTXfiuz5LqGV
+BWz/i1i8EwJmO+p0yLk+r1hjBaeAqfbZtt1ACeZgu/8zaI9ypb2vpwOyW5TUJ8hk
+S+ZAX1Pd5OMqerD6DTfD/McHkWnC3ilcW4ZQIIJABKGxPc7k9Gyod9PZIPJS/ER7
+7koJ84u8esvnaP3DGHIuWngMpQcgMzJbD5bNX+C0DoaxkWre8u7afCW68a58RP19
+LTlr/GlI51c=
+-----END CERTIFICATE-----

data/example/keys/mykey.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEA5NB4eBSlmeCAfZHAF6CG5/zr/vA147gMglpwuuYLKcDzvWKg
+6/HM/HmM9NXp2SSK0xOU2uid41r8FtEcc5VS8K24nIpcSIXJaz+MJgBnffm4xi0M
+rYUAdG82BcwzVhlOlswJIi15WxYgC40UBbBBLwF32gAJRLU/r141sDUEE6qdpihl
+PUP4kPhun2SkFipcm1/A6AcbM85Vq2rMkOA6pLBhXPVkRNWim/5MwGCG33fyJWij
+DZwecnZmP+f+MGQbwT0U2WZzrtapCQmxLXoT2wSe0k5I2V0FGyMwW7HgT6DvDPKf
+20UnSdgn+uSVZrbgE3tWD12JiWNA0stIy/z+1wIDAQABAoIBABSU5/EtMkQoHIav
+AI9fgiMF7hhtdPt5x65GAlPdc22bDJGheIYgpuai7Fntj+5XSiF4ZnBWcjVMLtbC
+koOXD/HUPoHeNDTVy+tYuPuGF8kOGF/DF5vYFdVjV4Gn/4okFpyb18p6OqtFzzYa
+x41HcGWRBT3XuP20K/lTSRMDgc1e5N9bmoOONJqT+K1ak0Dv2Ifl5RTBWbmYymgR
+30cgDkiazCNjhRCCCBX8cctB4ULiOvqdksn5Ln05jvezd1Wog/ryr4SI+HMmAroZ
+dB+F8kODO792/ahR8DusQUVpwVbHqAXOVHmtplMZ4DlIgw+qY5pRawkvdetq/Ghy
+fHAInsECgYEA/U4uNsghZJiWnpZ999esCbHwM6orgX561Nx/WsmKGv0pjslZNDrx
+5Awd0EQo/NW59CUW5RcHnK+ayAsQ1xgN4HB97xYAj5v0xEzhQw8fg39fc/4gja+j
+F89wK3nfX1F4PpisN6eir+z2UcUJLT4rIsFa57R7TbLV6eV/nhxoauECgYEA5z+Y
+ITSdgwsS8FR+8ZL/UvdmkDW34gQUZ3QEAkJZfkCaHXq90tgIHDBm8dZBKEuDHJSN
+yJQ4VeHzBD9q7pdz/qDXAw5Jqgz01ToWWuGvCbcqvH6u1UrVvUhgr0JbyUZgrL4r
+/c5buWHS+IKwtBqWG1oo4kclfz3TIjtLXiVDmLcCgYB+/K2wav5KpzCDSqDWGjo2
+Fg18aSgsYBMGGZCDHBxvUVF/MrPUumQ/1k8v9KuzrRXvLpTevn/jbimjdeC4ZGe4
+h8yqipY3aJD5xCz96Fv9GWLqDJGXVmDl8+mg8hUofPhSMUnNEO4/UgVeku/5zXvk
+jZicJl/WYPxaqOIkistSIQKBgQCoLuhFvi6QkA1GHS32JCLuBGDjoS4Lg0wTsZz4
+x6iu2e08Y3iLT/MWDV3RpTHeTI0ezCwSJTqTu7Ey9ayfuibymafG4S1SL/og2g5I
+KrtTJZQ/YyNknPi2oV0wGeMHj9ffyq/T97FeMndtph893dguLHRvna73y88ypk06
+O3/eIQKBgH10X3RoSDr04vVLFPjJ4beRj4SQA7BVUCio5MSrqkh2aTW0nFv+DiVm
+M5nqfiH5QjO1NkKXrqUYAFVdAxcLRPXSAMHK0G61HyWDKyUEwAqWQ4sZGgFrzFUb
+tihmVFKrXyzeMLumwn6TNCGVPYGAWw4FgHq59Hr+bAMp2g80Nmyj
+-----END RSA PRIVATE KEY-----

data/example/server.rb

@@ -1,10 +1,35 @@
 require_relative 'helper'
 
-puts "Starting server on port 8080"
-Socket.tcp_server_loop(8080) do |sock|
+options = {port: 8080}
+OptionParser.new do |opts|
+  opts.banner = "Usage: server.rb [options]"
+
+  opts.on("-s", "--secure", "HTTPS mode") do |v|
+    options[:secure] = v
+  end
+
+  opts.on("-p", "--port [Integer]", "listen port") do |v|
+    options[:port] = v
+  end
+end.parse!
+
+puts "Starting server on port #{options[:port]}"
+server = TCPServer.new(options[:port])
+
+if options[:secure]
+  ctx = OpenSSL::SSL::SSLContext.new
+  ctx.cert = OpenSSL::X509::Certificate.new(File.open("keys/mycert.pem"))
+  ctx.key = OpenSSL::PKey::RSA.new(File.open("keys/mykey.pem"))
+  ctx.npn_protocols = [DRAFT]
+
+  server = OpenSSL::SSL::SSLServer.new(server, ctx)
+end
+
+loop do
+  sock = server.accept
   puts "New TCP connection!"
 
-  conn = HTTP2::Connection.new(:server)
+  conn = HTTP2::Server.new
   conn.on(:frame) do |bytes|
     puts "Writing bytes: #{bytes.inspect}"
     sock.write bytes
@@ -12,12 +37,13 @@ Socket.tcp_server_loop(8080) do |sock|
 
   conn.on(:stream) do |stream|
     log = Logger.new(stream.id)
-    buffer = ""
+    req, buffer = {}, ''
 
     stream.on(:active) { log.info "cliend opened new stream" }
     stream.on(:close)  { log.info "stream closed" }
 
     stream.on(:headers) do |h|
+      req = h
       log.info "request headers: #{h}"
     end
 
@@ -27,10 +53,17 @@ Socket.tcp_server_loop(8080) do |sock|
     end
 
     stream.on(:half_close) do
-      log.info "client closed its end of the stream, " +
-               "payload size: #{buffer.size}"
+      log.info "client closed its end of the stream"
+
+      response = nil
+      if req[":method"] == "post"
+        log.info "Received POST request, payload: #{buffer}"
+        response = "Hello HTTP 2.0! POST payload: #{buffer}"
+      else
+        log.info "Received GET request"
+        response = "Hello HTTP 2.0! GET request"
+      end
 
-      response = "Hello HTTP 2.0! echo: #{buffer}"
       stream.headers({
         ":status" => "200",
         "content-length" => response.bytesize.to_s,
@@ -45,6 +78,12 @@ Socket.tcp_server_loop(8080) do |sock|
 
   while !sock.closed? && !sock.eof?
     data = sock.readpartial(1024)
-    conn << data
+
+    begin
+      conn << data
+    rescue Exception => e
+      puts "Exception: #{e}, #{e.message} - closing socket."
+      sock.close
+    end
   end
 end