156 |
157 | | :reserved |
158 | fires exactly once when a push stream is initialized |
159 |
160 |
161 | | :active |
162 | fires exactly once when the stream become active and is counted towards the open stream limit |
163 |
164 |
165 | | :headers |
166 | fires once for each received header block (multi-frame blocks are reassembled before emitting this event) |
167 |
168 |
169 | | :data |
170 | fires once for every DATA frame (no buffering) |
171 |
172 |
173 | | :half_close |
174 | fires exactly once when the opposing peer closes its end of connection (e.g. client indicating that request is finished, or server indicating that response is finished) |
175 |
176 |
177 | | :close |
178 | fires exactly once when both peers close the stream, or if the stream is reset |
179 |
180 |
181 | | :priority |
182 | fires once for each received priority update (server only) |
183 |
184 |
185 |
186 |
187 | ### Prioritization
188 |
189 | Each HTTP/2 [stream has a priority value](https://hpbn.co/http2/#stream-prioritization) that can be sent when the new stream is initialized, and optionally reprioritized later:
190 |
191 | ```ruby
192 | client = HTTP2::Client.new
193 |
194 | default_priority_stream = client.new_stream
195 | custom_priority_stream = client.new_stream(priority: 42)
196 |
197 | # sometime later: change priority value
198 | custom_priority_stream.reprioritize(32000) # emits PRIORITY frame
199 | ```
200 |
201 | On the opposite side, the server can optimize its stream processing order or resource allocation by accessing the stream priority value (`stream.priority`).
202 |
203 |
204 | ### Flow control
205 |
206 | Multiplexing multiple streams over the same TCP connection introduces contention for shared bandwidth resources. Stream priorities can help determine the relative order of delivery, but priorities alone are insufficient to control how the resource allocation is performed between multiple streams. To address this, HTTP/2 provides a simple mechanism for [stream and connection flow control](https://hpbn.co/http2/#flow-control).
207 |
208 | Connection and stream flow control is handled by the library: all streams are initialized with the default window size (64KB), and send/receive window updates are automatically processed - i.e. window is decremented on outgoing data transfers, and incremented on receipt of window frames. Similarly, if the window is exceeded, then data frames are automatically buffered until window is updated.
209 |
210 | The only thing left is for your application to specify the logic as to when to emit window updates:
211 |
212 | ```ruby
213 | conn.buffered_amount # check amount of buffered data
214 | conn.window # check current window size
215 | conn.window_update(1024) # increment connection window by 1024 bytes
216 |
217 | stream.buffered_amount # check amount of buffered data
218 | stream.window # check current window size
219 | stream.window_update(2048) # increment stream window by 2048 bytes
220 | ```
221 |
222 |
223 | ### Server push
224 |
225 | An HTTP/2 server can [send multiple replies](https://hpbn.co/http2/#server-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:
226 |
227 | ```ruby
228 | conn = HTTP2::Server.new
229 |
230 | conn.on(:stream) do |stream|
231 | stream.on(:headers) { |head| ... }
232 | stream.on(:data) { |chunk| ... }
233 |
234 | # fires when client terminates its request (i.e. request finished)
235 | stream.on(:half_close) do
236 | promise_header = { ':method' => 'GET',
237 | ':authority' => 'localhost',
238 | ':scheme' => 'https',
239 | ':path' => "/other_resource" }
240 |
241 | # initiate server push stream
242 | push_stream = nil
243 | stream.promise(promise_header) do |push|
244 | push.headers({...})
245 | push_stream = push
246 | end
247 |
248 | # send response
249 | stream.headers({
250 | ":status" => 200,
251 | "content-type" => "text/plain"
252 | })
253 |
254 | # split response between multiple DATA frames
255 | stream.data(response_chunk, end_stream: false)
256 | stream.data(last_chunk)
257 |
258 | # now send the previously promised data
259 | push_stream.data(push_data)
260 | end
261 | end
262 | ```
263 |
264 | When a new push promise stream is sent by the server, the client is notified via the `:promise` event:
265 |
266 | ```ruby
267 | conn = HTTP2::Client.new
268 | conn.on(:promise) do |push|
269 | # process push stream
270 | end
271 | ```
272 |
273 | The client can cancel any given push stream (via `.close`), or disable server push entirely by sending the appropriate settings frame:
274 |
275 | ```ruby
276 | client.settings(settings_enable_push: 0)
277 | ```
278 | ### Specs
279 |
280 | To run specs:
281 |
282 | ```ruby
283 | rake
284 | ```
285 |
286 | ### License
287 |
288 | (MIT License) - Copyright (c) 2013-2019 Ilya Grigorik 
289 | (MIT License) - Copyright (c) 2019 Tiago Cardoso 
290 |
--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require "English"
4 | require "bundler/gem_tasks"
5 | require "open3"
6 |
7 | require_relative "tasks/generate_huffman_table"
8 |
9 | RUBY_MAJOR_MINOR = RUBY_VERSION.split(".").first(2).join(".")
10 |
11 | begin
12 | require "rspec/core/rake_task"
13 | RSpec::Core::RakeTask.new(:spec) do |t|
14 | t.exclude_pattern = "./spec/hpack_test_spec.rb"
15 | end
16 |
17 | RSpec::Core::RakeTask.new(:hpack) do |t|
18 | t.pattern = "./spec/hpack_test_spec.rb"
19 | end
20 | rescue LoadError
21 | end
22 |
23 | begin
24 | require "rubocop/rake_task"
25 | desc "Run rubocop"
26 | RuboCop::RakeTask.new
27 | rescue LoadError
28 | end
29 |
30 | begin
31 | require "yard"
32 | YARD::Rake::YardocTask.new
33 | rescue LoadError
34 | end
35 |
36 | namespace :coverage do
37 | desc "Aggregates coverage reports"
38 | task :report do
39 | return unless ENV.key?("CI")
40 |
41 | require "simplecov"
42 |
43 | puts Dir["coverage/**/.resultset.json"].inspect
44 | SimpleCov.collate Dir["coverage/**/.resultset.json"]
45 | end
46 | end
47 |
48 | desc "install h2spec"
49 | task :h2spec_install do
50 | platform = case RUBY_PLATFORM
51 | when /darwin/
52 | "h2spec_darwin_amd64.tar.gz"
53 | when /cygwin|mswin|mingw|bccwin|wince|emx/
54 | "h2spec_windows_amd64.zip"
55 | else
56 | "h2spec_linux_amd64.tar.gz"
57 | end
58 | # uri = "https://github.com/summerwind/h2spec/releases/download/v2.3.0/#{platform}"
59 |
60 | tar_location = File.join(__dir__, "h2spec-releases", platform)
61 | # require "net/http"
62 | # File.open(tar_location, "wb") do |file|
63 | # response = nil
64 | # loop do
65 | # uri = URI(uri)
66 | # http = Net::HTTP.new(uri.host, uri.port)
67 | # http.use_ssl = true
68 | # # http.set_debug_output($stderr)
69 | # response = http.get(uri.request_uri)
70 | # break unless response.is_a?(Net::HTTPRedirection)
71 |
72 | # uri = response["location"]
73 | # end
74 | # file.write(response.body)
75 | # end
76 |
77 | case RUBY_PLATFORM
78 | when /cygwin|mswin|mingw|bccwin|wince|emx/
79 | puts "Hi, you're on Windows, please unzip this file: #{tar_location}"
80 | when /darwin/
81 | system("gunzip -c #{tar_location} | tar -xvzf -")
82 | else
83 | system("tar -xvzf #{tar_location} h2spec")
84 | end
85 | # FileUtils.rm(tar_location)
86 | end
87 |
88 | desc "run h2spec"
89 | task :h2spec do
90 | h2spec = File.join(__dir__, "h2spec")
91 | unless File.exist?(h2spec)
92 | abort 'Please install h2spec first.\n' \
93 | 'Run "rake h2spec_install",\n' \
94 | "Or Download the binary from https://github.com/summerwind/h2spec/releases"
95 | end
96 |
97 | server_pid = Process.spawn("ruby example/server.rb -p 9000", out: File::NULL)
98 | sleep RUBY_ENGINE == "ruby" ? 5 : 20
99 | system("#{h2spec} -p 9000 -o 2 --strict")
100 | Process.kill("TERM", server_pid)
101 | exit($CHILD_STATUS.exitstatus)
102 | end
103 |
104 | default_tasks = %i[spec]
105 | default_tasks << :rubocop if defined?(RuboCop) && RUBY_ENGINE == "ruby"
106 | default_tasks += %i[h2spec_install h2spec] if ENV.key?("CI")
107 | task default: default_tasks
108 | task all: %i[default hpack]
109 |
--------------------------------------------------------------------------------
/benchmarks/client_server.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require "uri"
4 | require "http/2"
5 |
6 | DEBUG = ENV.key?("DEBUG")
7 | BENCHMARK = ENV.fetch("BENCH", "profile")
8 | ITERATIONS = 5000
9 |
10 | METHOD = "GET"
11 | BODY = "bang"
12 | URL = URI.parse(ARGV[0] || "http://localhost:8080/")
13 | CLIENT = HTTP2::Client.new
14 | SERVER = HTTP2::Server.new
15 |
16 | CLIENT_BUFFER = "".b
17 | SERVER_BUFFER = "".b
18 |
19 | def log
20 | return unless DEBUG
21 |
22 | puts yield
23 | end
24 |
25 | log { "build client..." }
26 | CLIENT.on(:frame) do |bytes|
27 | log { "(client) sending bytes: #{bytes.size}" }
28 | CLIENT_BUFFER << bytes
29 | end
30 | CLIENT.on(:frame_sent) do |frame|
31 | log { "(client) Sent frame: #{frame.inspect}" }
32 | end
33 | CLIENT.on(:frame_received) do |frame|
34 | log { "(client) Received frame: #{frame.inspect}" }
35 | end
36 |
37 | CLIENT.on(:altsvc) do |f|
38 | log { "(client) received ALTSVC #{f}" }
39 | end
40 |
41 | log { "build server..." }
42 | SERVER.on(:frame) do |bytes|
43 | log { "(server) sending bytes: #{bytes.bytesize}" }
44 | SERVER_BUFFER << bytes
45 | end
46 | SERVER.on(:frame_sent) do |frame|
47 | log { "(server) Sent frame: #{frame.inspect}" }
48 | end
49 | SERVER.on(:frame_received) do |frame|
50 | log { "(server) Received frame: #{frame.inspect}" }
51 | end
52 |
53 | SERVER.on(:goaway) do
54 | log { "(server) goaway received" }
55 | end
56 |
57 | SERVER.on(:stream) do |stream|
58 | req = {}
59 | buffer = "".b
60 |
61 | stream.on(:active) { log { "(server stream:#{stream.id}) client opened new stream" } }
62 | stream.on(:close) { log { "(server stream:#{stream.id}) stream closed" } }
63 |
64 | stream.on(:headers) do |h|
65 | log { "(server stream:#{stream.id}) request headers: #{Hash[*h.flatten]}" }
66 | end
67 |
68 | stream.on(:data) do |d|
69 | log { "(server stream:#{stream.id}) payload chunk: <<#{d}>>" }
70 | buffer << d
71 | end
72 |
73 | stream.on(:half_close) do
74 | log { "(server stream:#{stream.id}) client closed its end of the stream" }
75 |
76 | response = nil
77 | if req[":method"] == "POST"
78 | log { "(server stream:#{stream.id}) Received POST request, payload: #{buffer}" }
79 | response = "(server stream:#{stream.id}) Hello HTTP 2.0! POST payload: #{buffer}"
80 | else
81 | log { "Received GET request" }
82 | response = "(server stream:#{stream.id}) Hello HTTP 2.0! GET request"
83 | end
84 |
85 | stream.headers(
86 | {
87 | ":status" => "200",
88 | "content-length" => response.bytesize.to_s,
89 | "content-type" => "text/plain",
90 | "x-stream-id" => "stream-#{stream.id}"
91 | }, end_stream: false
92 | )
93 |
94 | # split response into multiple DATA frames
95 | stream.data(response[0, 5], end_stream: false)
96 | stream.data(response[5, -1] || "")
97 | end
98 | end
99 |
100 | def send_request
101 | stream = CLIENT.new_stream
102 |
103 | stream.on(:close) do
104 | log { "(client stream:#{stream.id}) stream closed" }
105 | end
106 |
107 | stream.on(:half_close) do
108 | log { "(client stream:#{stream.id}) closing client-end of the stream" }
109 | end
110 |
111 | stream.on(:headers) do |h|
112 | log { "(client stream:#{stream.id}) response headers: #{h}" }
113 | end
114 |
115 | stream.on(:data) do |d|
116 | log { "(client stream:#{stream.id}) response data chunk: <<#{d}>>" }
117 | end
118 |
119 | stream.on(:altsvc) do |f|
120 | log { "(client stream:#{stream.id}) received ALTSVC #{f}" }
121 | end
122 |
123 | head = {
124 | ":scheme" => URL.scheme,
125 | ":method" => METHOD,
126 | ":authority" => [URL.host, URL.port].join(":"),
127 | ":path" => URL.path,
128 | "accept" => "*/*"
129 | }
130 |
131 | log { "Sending HTTP 2.0 request" }
132 |
133 | if head[":method"] == "GET"
134 | stream.headers(head, end_stream: true)
135 | else
136 | stream.headers(head, end_stream: false)
137 | stream.data(BODY)
138 | end
139 |
140 | until CLIENT_BUFFER.empty? && SERVER_BUFFER.empty?
141 | unless CLIENT_BUFFER.empty?
142 | SERVER << CLIENT_BUFFER
143 | CLIENT_BUFFER.clear
144 | end
145 |
146 | unless SERVER_BUFFER.empty?
147 | CLIENT << SERVER_BUFFER
148 | SERVER_BUFFER.clear
149 | end
150 | end
151 | end
152 |
153 | def benchmark(bench_type, &block)
154 | return yield if DEBUG
155 |
156 | case bench_type
157 | when "profile"
158 | require "singed"
159 | Singed.output_directory = "tmp/"
160 |
161 | flamegraph(&block)
162 | when "memory"
163 | require "memory_profiler"
164 | MemoryProfiler.report(allow_files: ["lib/http/2"], &block).pretty_print
165 |
166 | when "benchmark"
167 | require "benchmark"
168 | puts Benchmark.measure(&block)
169 | end
170 | end
171 |
172 | GC.start
173 | GC.disable
174 |
175 | puts "warmup..."
176 | ITERATIONS.times do
177 | # start client stream
178 | send_request
179 | end
180 |
181 | puts "bench!"
182 | # Benchmark.bmbm do |x|
183 | benchmark(BENCHMARK) do
184 | ITERATIONS.times do
185 | # start client stream
186 | send_request
187 | end
188 |
189 | CLIENT.goaway
190 | end
191 |
--------------------------------------------------------------------------------
/example/Gemfile:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | source "https://rubygems.org"
4 |
5 | gem "http_parser.rb"
6 |
--------------------------------------------------------------------------------
/example/README.md:
--------------------------------------------------------------------------------
1 | ## Interop
2 |
3 | First, a quick test to ensure that we can talk to ourselves:
4 |
5 | ```bash
6 | # Direct connection
7 | $> ruby server.rb
8 | $> ruby client.rb http://localhost:8080/ # GET
9 | $> ruby client.rb http://localhost:8080/ -d 'some data' # POST
10 |
11 | # Server push
12 | $> ruby server.rb --push
13 | $> ruby client.rb http://localhost:8080/ # GET
14 |
15 | # TLS + NPN negotiation
16 | $> ruby server.rb --secure
17 | $> ruby client.rb https://localhost:8080/ # GET
18 | $> ...
19 | ```
20 |
21 | ### [nghttp2](https://github.com/tatsuhiro-t/nghttp2) (HTTP/2.0 C Library)
22 |
23 | Public test server: http://106.186.112.116 (Upgrade + Direct)
24 |
25 | ```bash
26 | # Direct request (http-2 > nghttp2)
27 | $> ruby client.rb http://106.186.112.116/
28 |
29 | # TLS + NPN request (http-2 > nghttp2)
30 | $> ruby client.rb https://106.186.112.116/
31 |
32 | # Direct request (nghttp2 > http-2)
33 | $> ruby server.rb
34 | $> nghttp -vnu http://localhost:8080 # Direct request to Ruby server
35 | ```
36 |
37 | ### Twitter (Java server)
38 |
39 | ```bash
40 | # NPN + GET request (http-2 > twitter)
41 | $> ruby client.rb https://twitter.com/
42 | ```
43 |
44 | For a complete list of current implementations, see [http2 wiki](https://github.com/http2/http2-spec/wiki/Implementations).
45 |
--------------------------------------------------------------------------------
/example/client.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require_relative "helper"
4 |
5 | options = {}
6 | OptionParser.new do |opts|
7 | opts.banner = "Usage: client.rb [options]"
8 |
9 | opts.on("-d", "--data [String]", "HTTP payload") do |v|
10 | options[:payload] = v
11 | end
12 | end.parse!
13 |
14 | uri = URI.parse(ARGV[0] || "http://localhost:8080/")
15 | tcp = TCPSocket.new(uri.host, uri.port)
16 | sock = nil
17 |
18 | if uri.scheme == "https"
19 | ctx = OpenSSL::SSL::SSLContext.new
20 | ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
21 |
22 | # For ALPN support, Ruby >= 2.3 and OpenSSL >= 1.0.2 are required
23 |
24 | ctx.alpn_protocols = [DRAFT]
25 | ctx.alpn_select_cb = lambda do |protocols|
26 | puts "ALPN protocols supported by server: #{protocols}"
27 | DRAFT if protocols.include? DRAFT
28 | end
29 |
30 | sock = OpenSSL::SSL::SSLSocket.new(tcp, ctx)
31 | sock.sync_close = true
32 | sock.hostname = uri.hostname
33 | sock.connect
34 |
35 | if sock.alpn_protocol != DRAFT
36 | puts "Failed to negotiate #{DRAFT} via ALPN"
37 | exit
38 | end
39 | else
40 | sock = tcp
41 | end
42 |
43 | conn = HTTP2::Client.new
44 | stream = conn.new_stream
45 | log = Logger.new(stream.id)
46 |
47 | conn.on(:frame) do |bytes|
48 | # puts "Sending bytes: #{bytes.unpack("H*").first}"
49 | sock.print bytes
50 | sock.flush
51 | end
52 | conn.on(:frame_sent) do |frame|
53 | puts "Sent frame: #{frame.inspect}"
54 | end
55 | conn.on(:frame_received) do |frame|
56 | puts "Received frame: #{frame.inspect}"
57 | end
58 |
59 | conn.on(:promise) do |promise|
60 | promise.on(:promise_headers) do |h|
61 | log.info "promise request headers: #{h}"
62 | end
63 |
64 | promise.on(:headers) do |h|
65 | log.info "promise headers: #{h}"
66 | end
67 |
68 | promise.on(:data) do |d|
69 | log.info "promise data chunk: <<#{d.size}>>"
70 | end
71 | end
72 |
73 | conn.on(:altsvc) do |f|
74 | log.info "received ALTSVC #{f}"
75 | end
76 |
77 | stream.on(:close) do
78 | log.info "stream closed"
79 | conn.goaway
80 | end
81 |
82 | stream.on(:half_close) do
83 | log.info "closing client-end of the stream"
84 | end
85 |
86 | stream.on(:headers) do |h|
87 | log.info "response headers: #{h}"
88 | end
89 |
90 | stream.on(:data) do |d|
91 | log.info "response data chunk: <<#{d}>>"
92 | end
93 |
94 | stream.on(:altsvc) do |f|
95 | log.info "received ALTSVC #{f}"
96 | end
97 |
98 | head = {
99 | ":scheme" => uri.scheme,
100 | ":method" => (options[:payload].nil? ? "GET" : "POST"),
101 | ":authority" => [uri.host, uri.port].join(":"),
102 | ":path" => uri.path,
103 | "accept" => "*/*"
104 | }
105 |
106 | puts "Sending HTTP 2.0 request"
107 | if head[":method"] == "GET"
108 | stream.headers(head, end_stream: true)
109 | else
110 | stream.headers(head, end_stream: false)
111 | stream.data(options[:payload])
112 | end
113 |
114 | require "memory_profiler"
115 | report = MemoryProfiler.report(allow_files: "http-2") do
116 | while !sock.closed? && !sock.eof?
117 | data = sock.read_nonblock(1024)
118 | # puts "Received bytes: #{data.unpack("H*").first}"
119 |
120 | begin
121 | conn << data
122 | rescue StandardError => e
123 | puts "#{e.class} exception: #{e.message} - closing socket."
124 | e.backtrace.each { |l| puts "\t#{l}" }
125 | sock.close
126 | end
127 | end
128 | end
129 |
130 | report.pretty_print
131 |
--------------------------------------------------------------------------------
/example/helper.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | $LOAD_PATH << "lib" << "../lib"
4 |
5 | require "optparse"
6 | require "socket"
7 | require "openssl"
8 | require "uri"
9 |
10 | # This will enable coverage within the CI environment
11 | if ENV.key?("CI")
12 | require "simplecov"
13 | SimpleCov.command_name "#{RUBY_ENGINE}-#{RUBY_VERSION}-h2spec"
14 | SimpleCov.coverage_dir "coverage/#{RUBY_ENGINE}-#{RUBY_VERSION}-h2spec"
15 | end
16 |
17 | require "http/2"
18 |
19 | DRAFT = "h2"
20 |
21 | class Logger
22 | def initialize(id)
23 | @id = id
24 | end
25 |
26 | def info(msg)
27 | puts "[Stream #{@id}]: #{msg}"
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/example/keys/server.crt:
--------------------------------------------------------------------------------
1 | -----BEGIN CERTIFICATE-----
2 | MIIDLjCCAhYCCQDIZ/9hq/2pXjANBgkqhkiG9w0BAQUFADBZMQswCQYDVQQGEwJB
3 | VTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0
4 | cyBQdHkgTHRkMRIwEAYDVQQDEwlsb2NhbGhvc3QwHhcNMTYwNjA2MTk0MzI1WhcN
5 | MTcwNjA2MTk0MzI1WjBZMQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0
6 | ZTEhMB8GA1UEChMYSW50ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMRIwEAYDVQQDEwls
7 | b2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCjFXrWqtRZ
8 | EMOO/o6AxGbgDYMgg/7uxCFQJM5Z6C4II6D8V94FDyCd+J0LOK2hB+QUdFqpA1S9
9 | 6RW2MvIwdvRt03RJMgbfcUF0+w4ZItv2xrW9waCfCmLSRDZgcSATacEF6u9p2Vs+
10 | o4J/cHacirSwjy4+m94CgkxtUFGtGcJaFqAZ6Cdj5WvQdJSiAI3x3gNC/UGA+5dL
11 | sp8+vwWx+/TMc6nDBmoRW3GHeG/NApQSh01w3wDv0FmUaFQlA5WPya/Js+CyuYh1
12 | miXbQJEjDnGGaJjnoyRAQpPrk72Jj+bnfOu9kxpzkuLJOsbaofRFkM+/Ar5U+bQz
13 | uU0ErQ8Ih8MPAgMBAAEwDQYJKoZIhvcNAQEFBQADggEBACL8HkKjW8kWLlW4TE5K
14 | EcfsBad2Ah5ugTocJ/pLnr/YEo8uD91gECDtsuFTXul9n2M7U5jJmzbHZ63cjyC3
15 | lb1BxJxUL7aIyaL61IMMcIJMWhC9VGnFUshMDNVBhuRkKs/QvaMD5KefKN1E9I2M
16 | mZ72Yww0VihYwNOu3MTn8gUuy9eU6k/gTYPY7PJVh18QmR+Fs2MaaPp+bDwxiqML
17 | 0o2I6+0ZsqM3vFtcUjxjRASV5s+JkM34pTWFwUOl7TZv1YsxCKSz4f0BXDImZEvU
18 | rwqFdlELp5WOG9LJsrszDRbf1wbFUsG1XXZpIBiWo3d6pOiIyRKrak1vKViNfYvI
19 | W30=
20 | -----END CERTIFICATE-----
21 |
--------------------------------------------------------------------------------
/example/keys/server.key:
--------------------------------------------------------------------------------
1 | -----BEGIN RSA PRIVATE KEY-----
2 | MIIEpAIBAAKCAQEAoxV61qrUWRDDjv6OgMRm4A2DIIP+7sQhUCTOWeguCCOg/Ffe
3 | BQ8gnfidCzitoQfkFHRaqQNUvekVtjLyMHb0bdN0STIG33FBdPsOGSLb9sa1vcGg
4 | nwpi0kQ2YHEgE2nBBervadlbPqOCf3B2nIq0sI8uPpveAoJMbVBRrRnCWhagGegn
5 | Y+Vr0HSUogCN8d4DQv1BgPuXS7KfPr8Fsfv0zHOpwwZqEVtxh3hvzQKUEodNcN8A
6 | 79BZlGhUJQOVj8mvybPgsrmIdZol20CRIw5xhmiY56MkQEKT65O9iY/m53zrvZMa
7 | c5LiyTrG2qH0RZDPvwK+VPm0M7lNBK0PCIfDDwIDAQABAoIBAQCZShphZsccRJ6c
8 | bPdDX9iW5vyG9qsMgPwTGdWAOrXx3pN2PZ0pwjNVaRcsMgU6JHGlLEz/Kmtf6pQG
9 | 41I0bcuI48Yc+tHs+sadD1IMHHEHP3Yau8KfWyLSI129Pvf4Z2IQjuik5LJYaVbD
10 | NNG4iMQYZS0Bmn6Oey0dXu62t0ywYa0qvbIDse/RmjTQSTipuvGg8/QEAeRGABv8
11 | Nd4Esya0zuxk6hGaNp3hkjyRkeoC7RsBVJbFSnp6gSubPdXwrJyHfySKe9jvrDG3
12 | Q/AzyHUh/6EODd5n66x0p6rq7oo9/PnLvZJY8jIGWG+aEp68RJyEgimrwll0rAWw
13 | /buqijGRAoGBANimL8407fFirmct7BceavaeJfXPK5yWiOhVX0XlJ0phAFuaAxK3
14 | 5HVT7DD+KKV66g1jtS9FUVZGDiYFHlsdsYuHVYcRmr0h5rZr941obrDwNrM9Nf9C
15 | 0uehN5+n/FaeGoQLR3V4THoP3rlkYTlLpQnI5mKA19JukXnIiJM9ARUZAoGBAMC0
16 | mcVsVuSKSFwURtQHHIufxL6SqC2kLTwIQ7exqejNYPCqCiif+ZWOmsTqbVGAGbMK
17 | Ohak4oLwN5IGCl4jNQG+vWagREkx6OXSk5NYcfoNBrOm+0UoFRzoEA85s7Dy6PuD
18 | tBucNZpt1sGauzkCSx7C8jj4ZlSwkv0XhBFfbTZnAoGBAK2wBjF+U6iq4YFM2rLq
19 | KvzOa0Z3MdKXCOmiz//cKDTEMaI+heoyzZCWmIvqpzGLqirT3gUowH23Kk6m2eBY
20 | nOdst0/S+Eha7nkfc9bFe8CUxHXMRAcCTs1ufYadCXtzw3RLCp4NtNpC8N+Wry9d
21 | CtIeYz1jaCOHi0+kSoIobT65AoGAc6hxWkJp7ITqZQlucTdLdKmRheeztKEC3TMA
22 | obGqDqWldww3SKarP431ahZhQjcmNYT/1DNmF7xhPe0OL+3llISMXJn4Ig4ogDdg
23 | h2DgF3nV+eFQkfM6qLzHVrwFE0DXgI1NffzFV0hxSoW5tL+honbStkqv8EiCEBEb
24 | HOovPCUCgYBpXuPARd2ycInAulVHijJmj2rmK7f41ZhVCWovYjcCWyeJyLIO7j+b
25 | MBJZbmwpStJhEjW64nE2zZGWg2HCBbvZz5/SXIr3fp7qVXwpn1TvB/TJDf43t0oF
26 | 3caLgyQYoQCsVHKT3cU4s3wuog/DyHKh9FtRkcJrEy7h9Rrc+ModbA==
27 | -----END RSA PRIVATE KEY-----
28 |
--------------------------------------------------------------------------------
/example/raw.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require "socket"
4 |
5 | puts "Starting server on port 9000"
6 | server = TCPServer.new(9000)
7 |
8 | loop do
9 | sock = server.accept
10 |
11 | puts sock.readpartial(1024).inspect while !sock.closed? && !(begin
12 | sock.eof?
13 | rescue StandardError
14 | true
15 | end)
16 | end
17 |
--------------------------------------------------------------------------------
/example/server.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require_relative "helper"
4 |
5 | options = { port: 8080 }
6 | OptionParser.new do |opts|
7 | opts.banner = "Usage: server.rb [options]"
8 |
9 | opts.on("-s", "--secure", "HTTPS mode") do |v|
10 | options[:secure] = v
11 | end
12 |
13 | opts.on("-p", "--port [Integer]", "listen port") do |v|
14 | options[:port] = v
15 | end
16 |
17 | opts.on("-u", "--push", "Push message") do |_v|
18 | options[:push] = true
19 | end
20 | end.parse!
21 |
22 | puts "Starting server on port #{options[:port]}"
23 | server = TCPServer.new(options[:port])
24 |
25 | if options[:secure]
26 | ctx = OpenSSL::SSL::SSLContext.new
27 | ctx.cert = OpenSSL::X509::Certificate.new(File.open("keys/server.crt"))
28 | ctx.key = OpenSSL::PKey::RSA.new(File.open("keys/server.key"))
29 |
30 | ctx.ssl_version = :TLSv1_2
31 | ctx.options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
32 | ctx.ciphers = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ciphers]
33 |
34 | ctx.alpn_protocols = ["h2"]
35 |
36 | ctx.alpn_select_cb = lambda do |protocols|
37 | raise "Protocol #{DRAFT} is required" if protocols.index(DRAFT).nil?
38 |
39 | DRAFT
40 | end
41 |
42 | ctx.ecdh_curves = "P-256"
43 |
44 | server = OpenSSL::SSL::SSLServer.new(server, ctx)
45 | end
46 |
47 | loop do
48 | sock = server.accept
49 | sock.setsockopt(:SOCKET, :RCVBUF, 2048)
50 | puts "New TCP connection!"
51 |
52 | conn = HTTP2::Server.new
53 | conn.on(:frame) do |bytes|
54 | # puts "Writing bytes: #{bytes.unpack("H*").first}"
55 | sock.write(bytes) unless sock.closed?
56 | end
57 | conn.on(:frame_sent) do |frame|
58 | puts "Sent frame: #{frame.inspect}"
59 | end
60 | conn.on(:frame_received) do |frame|
61 | puts "Received frame: #{frame.inspect}"
62 | end
63 |
64 | conn.on(:goaway) do
65 | Thread.start do
66 | sleep(1)
67 | sock.close
68 | end
69 | end
70 |
71 | conn.on(:stream) do |stream|
72 | log = Logger.new(stream.id)
73 | req = {}
74 | buffer = "".b
75 |
76 | stream.on(:active) { log.info "client opened new stream" }
77 | stream.on(:close) { log.info "stream closed" }
78 |
79 | stream.on(:headers) do |h|
80 | req = Hash[*h.flatten]
81 | log.info "request headers: #{h}"
82 | end
83 |
84 | stream.on(:data) do |d|
85 | log.info "payload chunk: <<#{d}>>"
86 | buffer << d
87 | end
88 |
89 | stream.on(:half_close) do
90 | log.info "client closed its end of the stream"
91 |
92 | response = nil
93 | if req[":method"] == "POST"
94 | log.info "Received POST request, payload: #{buffer}"
95 | response = "Hello HTTP 2.0! POST payload: #{buffer}"
96 | else
97 | log.info "Received GET request"
98 | response = "Hello HTTP 2.0! GET request"
99 | end
100 |
101 | stream.headers({
102 | ":status" => "200",
103 | "content-length" => response.bytesize.to_s,
104 | "content-type" => "text/plain"
105 | }, end_stream: false)
106 |
107 | if options[:push]
108 | push_streams = []
109 |
110 | # send 10 promises
111 | 10.times do |i|
112 | puts "sending push"
113 |
114 | head = { ":method" => "GET",
115 | ":authority" => "localhost",
116 | ":scheme" => "https",
117 | ":path" => "/other_resource/#{i}" }
118 |
119 | stream.promise(head) do |push|
120 | push.headers({ ":status" => "200", "content-type" => "text/plain", "content-length" => "11" })
121 | push_streams << push
122 | end
123 | end
124 | end
125 |
126 | # split response into multiple DATA frames
127 | stream.data(response[0, 5], end_stream: false)
128 | stream.data(response[5, -1] || "")
129 |
130 | if options[:push]
131 | push_streams.each_with_index do |push, i|
132 | sleep 1
133 | push.data("push_data #{i}")
134 | end
135 | end
136 | end
137 | end
138 |
139 | while !sock.closed? && !(sock.eof? rescue true) # rubocop:disable Style/RescueModifier
140 | # puts "Received bytes: #{data.unpack("H*").first}"
141 | data = sock.readpartial(16_384)
142 |
143 | begin
144 | conn << data
145 | rescue StandardError => e
146 | puts "#{e.class} exception: #{e.message} - closing socket."
147 | puts e.backtrace
148 | sock.close
149 | end
150 | end
151 | end
152 |
--------------------------------------------------------------------------------
/example/upgrade_client.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require_relative "helper"
4 | require "http_parser"
5 |
6 | OptionParser.new do |opts|
7 | opts.banner = "Usage: upgrade_client.rb [options]"
8 | end.parse!
9 |
10 | uri = URI.parse(ARGV[0] || "http://localhost:8080/")
11 | sock = TCPSocket.new(uri.host, uri.port)
12 |
13 | conn = HTTP2::Client.new
14 |
15 | def request_header_hash
16 | Hash.new do |hash, key|
17 | k = key.to_s.downcase
18 | k.tr! "_", "-"
19 | _, value = hash.find { |header_key, _| header_key.downcase == k }
20 | hash[key] = value if value
21 | end
22 | end
23 |
24 | conn.on(:frame) do |bytes|
25 | sock.print bytes
26 | sock.flush
27 | end
28 | conn.on(:frame_sent) do |frame|
29 | puts "Sent frame: #{frame.inspect}"
30 | end
31 | conn.on(:frame_received) do |frame|
32 | puts "Received frame: #{frame.inspect}"
33 | end
34 |
35 | # upgrader module
36 | class UpgradeHandler
37 | UPGRADE_REQUEST = <