pax_global_header 0000666 0000000 0000000 00000000064 13731260101 0014504 g ustar 00root root 0000000 0000000 52 comment=9130422859db85f7603b482c6533984a8bb90131
ruby-async-http-0.52.5/ 0000775 0000000 0000000 00000000000 13731260101 0014646 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/.editorconfig 0000664 0000000 0000000 00000000064 13731260101 0017323 0 ustar 00root root 0000000 0000000 root = true
[*]
indent_style = tab
indent_size = 2
ruby-async-http-0.52.5/.github/ 0000775 0000000 0000000 00000000000 13731260101 0016206 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/.github/workflows/ 0000775 0000000 0000000 00000000000 13731260101 0020243 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/.github/workflows/development.yml 0000664 0000000 0000000 00000001754 13731260101 0023317 0 ustar 00root root 0000000 0000000 name: Development
on: [push, pull_request]
jobs:
test:
runs-on: ${{matrix.os}}-latest
continue-on-error: ${{matrix.experimental}}
strategy:
matrix:
os:
- ubuntu
- macos
ruby:
- 2.5
- 2.6
- 2.7
experimental: [false]
env: [""]
include:
- os: ubuntu
ruby: truffleruby
experimental: true
- os: ubuntu
ruby: jruby
experimental: true
- os: ubuntu
ruby: head
experimental: true
steps:
- uses: actions/checkout@v2
- uses: ioquatix/setup-ruby@master
with:
ruby-version: ${{matrix.ruby}}
bundler-cache: true
- name: Installing packages (ubuntu)
if: matrix.os == 'ubuntu'
run: sudo apt-get install apache2-utils
- name: Run tests
timeout-minutes: 5
run: ${{matrix.env}} bundle exec rspec
ruby-async-http-0.52.5/.gitignore 0000664 0000000 0000000 00000000200 13731260101 0016626 0 ustar 00root root 0000000 0000000 .tags
/.bundle/
/.yardoc
/gems.locked
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
.rspec_status
.covered.db
/h2spec
ruby-async-http-0.52.5/.rspec 0000664 0000000 0000000 00000000067 13731260101 0015766 0 ustar 00root root 0000000 0000000 --format documentation
--warnings
--require spec_helper ruby-async-http-0.52.5/README.md 0000664 0000000 0000000 00000024657 13731260101 0016143 0 ustar 00root root 0000000 0000000 # Async::HTTP
An asynchronous client and server implementation of HTTP/1.0, HTTP/1.1 and HTTP/2 including TLS. Support for streaming requests and responses. Built on top of [async](https://github.com/socketry/async) and [async-io](https://github.com/socketry/async-io). [falcon](https://github.com/socketry/falcon) provides a rack-compatible server.
[](https://github.com/socketry/async-http/actions?workflow=Development)
## Installation
Add this line to your application's Gemfile:
``` ruby
gem 'async-http'
```
And then execute:
$ bundle
Or install it yourself as:
$ gem install async-http
## Usage
### Post JSON data
Here is an example showing how to post a data structure as JSON to a remote resource:
``` ruby
#!/usr/bin/env ruby
require 'json'
require 'async'
require 'async/http/internet'
data = {'life' => 42}
Async do
# Make a new internet:
internet = Async::HTTP::Internet.new
# Prepare the request:
headers = [['accept', 'application/json']]
body = [JSON.dump(data)]
# Issues a POST request:
response = internet.post("https://httpbin.org/anything", headers, body)
# Save the response body to a local file:
pp JSON.parse(response.read)
ensure
# The internet is closed for business:
internet.close
end
```
Consider using [async-rest](https://github.com/socketry/async-rest) instead.
### Multiple Requests
To issue multiple requests concurrently, you should use a barrier, e.g.
``` ruby
#!/usr/bin/env ruby
require 'async'
require 'async/barrier'
require 'async/http/internet'
TOPICS = ["ruby", "python", "rust"]
Async do
internet = Async::HTTP::Internet.new
barrier = Async::Barrier.new
# Spawn an asynchronous task for each topic:
TOPICS.each do |topic|
barrier.async do
response = internet.get "https://www.google.com/search?q=#{topic}"
puts "Found #{topic}: #{response.read.scan(topic).size} times."
end
end
# Ensure we wait for all requests to complete before continuing:
barrier.wait
ensure
internet&.close
end
```
#### Limiting Requests
If you need to limit the number of simultaneous requests, use a semaphore.
``` ruby
#!/usr/bin/env ruby
require 'async'
require 'async/barrier'
require 'async/semaphore'
require 'async/http/internet'
TOPICS = ["ruby", "python", "rust"]
Async do
internet = Async::HTTP::Internet.new
barrier = Async::Barrier.new
semaphore = Async::Semaphore.new(2, parent: barrier)
# Spawn an asynchronous task for each topic:
TOPICS.each do |topic|
semaphore.async do
response = internet.get "https://www.google.com/search?q=#{topic}"
puts "Found #{topic}: #{response.read.scan(topic).size} times."
end
end
# Ensure we wait for all requests to complete before continuing:
barrier.wait
ensure
internet&.close
end
```
### Downloading a File
Here is an example showing how to download a file and save it to a local path:
``` ruby
#!/usr/bin/env ruby
require 'async'
require 'async/http/internet'
Async do
# Make a new internet:
internet = Async::HTTP::Internet.new
# Issues a GET request to Google:
response = internet.get("https://www.google.com/search?q=kittens")
# Save the response body to a local file:
response.save("/tmp/search.html")
ensure
# The internet is closed for business:
internet.close
end
```
### Basic Client/Server
Here is a basic example of a client/server running in the same reactor:
``` ruby
#!/usr/bin/env ruby
require 'async'
require 'async/http/server'
require 'async/http/client'
require 'async/http/endpoint'
require 'async/http/protocol/response'
endpoint = Async::HTTP::Endpoint.parse('http://127.0.0.1:9294')
app = lambda do |request|
Protocol::HTTP::Response[200, {}, ["Hello World"]]
end
server = Async::HTTP::Server.new(app, endpoint)
client = Async::HTTP::Client.new(endpoint)
Async do |task|
server_task = task.async do
server.run
end
response = client.get("/")
puts response.status
puts response.read
server_task.stop
end
```
### Advanced Verification
You can hook into SSL certificate verification to improve server verification.
``` ruby
require 'async'
require 'async/http'
# These are generated from the certificate chain that the server presented.
trusted_fingerprints = {
"dac9024f54d8f6df94935fb1732638ca6ad77c13" => true,
"e6a3b45b062d509b3382282d196efe97d5956ccb" => true,
"07d63f4c05a03f1c306f9941b8ebf57598719ea2" => true,
"e8d994f44ff20dc78dbff4e59d7da93900572bbf" => true,
}
Async do
endpoint = Async::HTTP::Endpoint.parse("https://www.codeotaku.com/index")
# This is a quick hack/POC:
ssl_context = endpoint.ssl_context
ssl_context.verify_callback = proc do |verified, store_context|
certificate = store_context.current_cert
fingerprint = OpenSSL::Digest::SHA1.new(certificate.to_der).to_s
if trusted_fingerprints.include? fingerprint
true
else
Async.logger.warn("Untrusted Certificate Fingerprint"){fingerprint}
false
end
end
endpoint = endpoint.with(ssl_context: ssl_context)
client = Async::HTTP::Client.new(endpoint)
response = client.get(endpoint.path)
pp response.status, response.headers.fields, response.read
end
```
### Timeouts
Here's a basic example with a timeout:
``` ruby
#!/usr/bin/env ruby
require 'async/http/internet'
Async do |task|
internet = Async::HTTP::Internet.new
# Request will timeout after 2 seconds
task.with_timeout(2) do
response = internet.get "https://httpbin.org/delay/10"
end
rescue Async::TimeoutError
puts "The request timed out"
ensure
internet&.close
end
```
## Performance
On a 4-core 8-thread i7, running `ab` which uses discrete (non-keep-alive) connections:
$ ab -c 8 -t 10 http://127.0.0.1:9294/
This is ApacheBench, Version 2.3 <$Revision: 1757674 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
Benchmarking 127.0.0.1 (be patient)
Completed 5000 requests
Completed 10000 requests
Completed 15000 requests
Completed 20000 requests
Completed 25000 requests
Completed 30000 requests
Completed 35000 requests
Completed 40000 requests
Completed 45000 requests
Completed 50000 requests
Finished 50000 requests
Server Software:
Server Hostname: 127.0.0.1
Server Port: 9294
Document Path: /
Document Length: 13 bytes
Concurrency Level: 8
Time taken for tests: 1.869 seconds
Complete requests: 50000
Failed requests: 0
Total transferred: 2450000 bytes
HTML transferred: 650000 bytes
Requests per second: 26755.55 [#/sec] (mean)
Time per request: 0.299 [ms] (mean)
Time per request: 0.037 [ms] (mean, across all concurrent requests)
Transfer rate: 1280.29 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.0 0 0
Processing: 0 0 0.2 0 6
Waiting: 0 0 0.2 0 6
Total: 0 0 0.2 0 6
Percentage of the requests served within a certain time (ms)
50% 0
66% 0
75% 0
80% 0
90% 0
95% 1
98% 1
99% 1
100% 6 (longest request)
On a 4-core 8-thread i7, running `wrk`, which uses 8 keep-alive connections:
$ wrk -c 8 -d 10 -t 8 http://127.0.0.1:9294/
Running 10s test @ http://127.0.0.1:9294/
8 threads and 8 connections
Thread Stats Avg Stdev Max +/- Stdev
Latency 217.69us 0.99ms 23.21ms 97.39%
Req/Sec 12.18k 1.58k 17.67k 83.21%
974480 requests in 10.10s, 60.41MB read
Requests/sec: 96485.00
Transfer/sec: 5.98MB
According to these results, the cost of handling connections is quite high, while general throughput seems pretty decent.
## Semantic Model
### Scheme
HTTP/1 has an implicit scheme determined by the kind of connection made to the server (either `http` or `https`), while HTTP/2 models this explicitly and the client indicates this in the request using the `:scheme` pseudo-header (typically `https`). To normalize this, `Async::HTTP::Client` and `Async::HTTP::Server` have a default scheme which is used if none is supplied.
### Version
HTTP/1 has an explicit version while HTTP/2 does not expose the version in any way.
### Reason
HTTP/1 responses contain a reason field which is largely irrelevant. HTTP/2 does not support this field.
## Contributing
1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request
## See Also
- [benchmark-http](https://github.com/socketry/benchmark-http) — A benchmarking tool to report on web server concurrency.
- [falcon](https://github.com/socketry/falcon) — A rack compatible server built on top of `async-http`.
- [async-websocket](https://github.com/socketry/async-websocket) — Asynchronous client and server websockets.
- [async-rest](https://github.com/socketry/async-rest) — A RESTful resource layer built on top of `async-http`.
- [async-http-faraday](https://github.com/socketry/async-http-faraday) — A faraday adapter to use `async-http`.
## License
Released under the MIT license.
Copyright, 2018, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
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.
ruby-async-http-0.52.5/async-http.gemspec 0000664 0000000 0000000 00000001651 13731260101 0020310 0 ustar 00root root 0000000 0000000
require_relative "lib/async/http/version"
Gem::Specification.new do |spec|
spec.name = "async-http"
spec.version = Async::HTTP::VERSION
spec.summary = "A HTTP client and server library."
spec.authors = ["Samuel Williams"]
spec.license = "MIT"
spec.homepage = "https://github.com/socketry/async-http"
spec.files = Dir.glob('{bake,lib}/**/*', File::FNM_DOTMATCH, base: __dir__)
spec.add_dependency "async", "~> 1.25"
spec.add_dependency "async-io", "~> 1.28"
spec.add_dependency "async-pool", "~> 0.2"
spec.add_dependency "protocol-http", "~> 0.20.0"
spec.add_dependency "protocol-http1", "~> 0.13.0"
spec.add_dependency "protocol-http2", "~> 0.14.0"
spec.add_development_dependency "async-container", "~> 0.14"
spec.add_development_dependency "async-rspec", "~> 1.10"
spec.add_development_dependency "covered"
spec.add_development_dependency "rack-test"
spec.add_development_dependency "rspec", "~> 3.6"
end
ruby-async-http-0.52.5/bake.rb 0000664 0000000 0000000 00000000000 13731260101 0016063 0 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/bake/ 0000775 0000000 0000000 00000000000 13731260101 0015550 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/bake/async/ 0000775 0000000 0000000 00000000000 13731260101 0016665 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/bake/async/http.rb 0000664 0000000 0000000 00000004110 13731260101 0020165 0 ustar 00root root 0000000 0000000
# Fetch the specified URL and print the response.
# @param url [String] the URL to parse and fetch.
# @param method [String] the HTTP method to use.
def fetch(url, method:)
require 'async/http/internet'
require 'kernel/sync'
terminal = Console::Terminal.for($stdout)
terminal[:request] = terminal.style(:blue, nil, :bold)
terminal[:response] = terminal.style(:green, nil, :bold)
terminal[:length] = terminal.style(nil, nil, :bold)
terminal[:key] = terminal.style(nil, nil, :bold)
terminal[:chunk_0] = terminal.style(:blue)
terminal[:chunk_1] = terminal.style(:cyan)
align = 20
format_body = proc do |body, terminal|
if body
if length = body.length
terminal.print(:body, "body with length ", :length, length, "B")
else
terminal.print(:body, "body without length")
end
else
terminal.print(:body, "no body")
end
end.curry
Sync do
internet = Async::HTTP::Internet.new
response = internet.send(method.downcase.to_sym, url)
terminal.print_line(
:request, method.rjust(align), :reset, ": ", url
)
terminal.print_line(
:response, "version".rjust(align), :reset, ": ", response.version
)
terminal.print_line(
:response, "status".rjust(align), :reset, ": ", response.status,
)
terminal.print_line(
:response, "body".rjust(align), :reset, ": ", format_body[response.body],
)
response.headers.each do |key, value|
terminal.print_line(
:key, key.rjust(align), :reset, ": ", :value, value.inspect
)
end
if body = response.body
index = 0
style = [:chunk_0, :chunk_1]
response.body.each do |chunk|
terminal.print(style[index % 2], chunk)
index += 1
end
end
response.finish
if trailers = response.headers.trailers
trailers.each do |key, value|
terminal.print_line(
:key, key.rjust(align), :reset, ": ", :value, value.inspect
)
end
end
internet.close
end
end
# GET the specified URL and print the response.
def get(url)
self.fetch(url, method: "GET")
end
# HEAD the specified URL and print the response.
def head(url)
self.fetch(url, method: "HEAD")
end
ruby-async-http-0.52.5/bake/async/http/ 0000775 0000000 0000000 00000000000 13731260101 0017644 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/bake/async/http/h2spec.rb 0000664 0000000 0000000 00000001577 13731260101 0021367 0 ustar 00root root 0000000 0000000
def build
# Fetch the code:
system "go get github.com/spf13/cobra"
system "go get github.com/summerwind/h2spec"
# This builds `h2spec` into the current directory
system "go build ~/go/src/github.com/summerwind/h2spec/cmd/h2spec/h2spec.go"
end
def test
server do
system("./h2spec", "-p", "7272")
end
end
private
def server
require 'async'
require 'async/container'
require 'async/http/server'
require 'async/io/host_endpoint'
endpoint = Async::IO::Endpoint.tcp('127.0.0.1', 7272)
container = Async::Container.new
Async.logger.info(self){"Starting server..."}
container.run(count: 1) do
server = Async::HTTP::Server.for(endpoint, Async::HTTP::Protocol::HTTP2, "https") do |request|
Protocol::HTTP::Response[200, {'content-type' => 'text/plain'}, ["Hello World"]]
end
Async do
server.run
end
end
yield if block_given?
ensure
container&.stop
end
ruby-async-http-0.52.5/examples/ 0000775 0000000 0000000 00000000000 13731260101 0016464 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/compare/ 0000775 0000000 0000000 00000000000 13731260101 0020112 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/compare/Gemfile 0000664 0000000 0000000 00000000137 13731260101 0021406 0 ustar 00root root 0000000 0000000
source "https://rubygems.org"
gem "benchmark-ips"
gem "async"
gem "async-http"
gem "httpx"
ruby-async-http-0.52.5/examples/compare/benchmark.rb 0000775 0000000 0000000 00000002330 13731260101 0022372 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require 'benchmark'
require 'httpx'
require 'async'
require 'async/barrier'
require 'async/semaphore'
require 'async/http/internet'
URL = "https://www.codeotaku.com/index"
REPEATS = 10
Benchmark.bmbm do |x|
x.report("async-http") do
Async do
internet = Async::HTTP::Internet.new
i = 0
while i < REPEATS
response = internet.get(URL)
response.read
i += 1
end
ensure
internet&.close
end
end
x.report("async-http (pipelined)") do
Async do |task|
internet = Async::HTTP::Internet.new
semaphore = Async::Semaphore.new(100, parent: task)
barrier = Async::Barrier.new(parent: semaphore)
# Warm up the connection pool...
response = internet.get(URL)
response.read
i = 0
while i < REPEATS
barrier.async do
response = internet.get(URL)
response.read
end
i += 1
end
barrier.wait
ensure
internet&.close
end
end
x.report("httpx") do
i = 0
while i < REPEATS
response = HTTPX.get(URL)
response.read
i += 1
end
end
x.report("httpx (pipelined)") do
urls = [URL] * REPEATS
responses = HTTPX.get(*urls)
responses.each do |response|
response.read
end
end
end
ruby-async-http-0.52.5/examples/download/ 0000775 0000000 0000000 00000000000 13731260101 0020273 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/download/chunked.rb 0000775 0000000 0000000 00000004141 13731260101 0022244 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require 'async'
require 'async/clock'
require 'async/barrier'
require 'async/semaphore'
require_relative '../../lib/async/http/endpoint'
require_relative '../../lib/async/http/client'
Async do
url = "https://static.openfoodfacts.org/data/en.openfoodfacts.org.products.csv"
endpoint = Async::HTTP::Endpoint.parse(url)
client = Async::HTTP::Client.new(endpoint)
headers = {'user-agent' => 'curl/7.69.1', 'accept' => '*/*'}
file = File.open("products.csv", "w")
Async.logger.info(self) {"Saving download to #{Dir.pwd}"}
begin
response = client.head(endpoint.path, headers)
content_length = nil
if response.success?
unless response.headers['accept-ranges'].include?('bytes')
raise "Does not advertise support for accept-ranges: bytes!"
end
unless content_length = response.body&.length
raise "Could not determine length of response!"
end
end
ensure
response&.close
end
Async.logger.info(self) {"Content length: #{content_length/(1024**2)}MiB"}
parts = []
offset = 0
chunk_size = 1024*1024
start_time = Async::Clock.now
amount = 0
while offset < content_length
byte_range_start = offset
byte_range_end = [offset + chunk_size, content_length].min
parts << (byte_range_start...byte_range_end)
offset += chunk_size
end
Async.logger.info(self) {"Breaking download into #{parts.size} parts..."}
semaphore = Async::Semaphore.new(8)
barrier = Async::Barrier.new(parent: semaphore)
while !parts.empty?
barrier.async do
part = parts.shift
Async.logger.info(self) {"Issuing range request range: bytes=#{part.min}-#{part.max}"}
response = client.get(endpoint.path, [
["range", "bytes=#{part.min}-#{part.max-1}"],
*headers
])
if response.success?
Async.logger.info(self) {"Got response: #{response}... writing data for #{part}."}
written = file.pwrite(response.read, part.min)
amount += written
duration = Async::Clock.now - start_time
Async.logger.info(self) {"Rate: #{((amount.to_f/(1024**2))/duration).round(2)}MiB/s"}
end
end
end
barrier.wait
ensure
client&.close
end
ruby-async-http-0.52.5/examples/fetch/ 0000775 0000000 0000000 00000000000 13731260101 0017555 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/fetch/Gemfile 0000664 0000000 0000000 00000000031 13731260101 0021042 0 ustar 00root root 0000000 0000000
gem 'rack'
gem 'falcon'
ruby-async-http-0.52.5/examples/fetch/Gemfile.lock 0000664 0000000 0000000 00000003110 13731260101 0021772 0 ustar 00root root 0000000 0000000 GEM
specs:
async (1.24.2)
console (~> 1.0)
nio4r (~> 2.3)
timers (~> 4.1)
async-container (0.16.2)
async (~> 1.0)
async-io (~> 1.26)
process-group
async-http (0.50.5)
async (~> 1.23)
async-io (~> 1.27.0)
async-pool (~> 0.2)
protocol-http (~> 0.14.1)
protocol-http1 (~> 0.10.0)
protocol-http2 (~> 0.11.0)
async-http-cache (0.1.2)
async-http
protocol-http (~> 0.14.4)
async-io (1.27.4)
async (~> 1.14)
async-pool (0.2.0)
async (~> 1.8)
build-environment (1.13.0)
coderay (1.1.2)
console (1.8.2)
falcon (0.35.6)
async (~> 1.13)
async-container (~> 0.16.0)
async-http (~> 0.50.4)
async-http-cache (~> 0.1.0)
async-io (~> 1.22)
build-environment (~> 1.13)
localhost (~> 1.1)
process-metrics (~> 0.1.0)
rack (>= 1.0)
samovar (~> 2.1)
ffi (1.12.2)
localhost (1.1.6)
mapping (1.1.1)
method_source (0.9.2)
nio4r (2.5.2)
process-group (1.2.1)
process-terminal (~> 0.2.0)
process-metrics (0.1.1)
process-terminal (0.2.0)
ffi
protocol-hpack (1.4.2)
protocol-http (0.14.4)
protocol-http1 (0.10.2)
protocol-http (~> 0.13)
protocol-http2 (0.11.1)
protocol-hpack (~> 1.4)
protocol-http (~> 0.2)
pry (0.12.2)
coderay (~> 1.1.0)
method_source (~> 0.9.0)
rack (2.2.2)
samovar (2.1.4)
console (~> 1.0)
mapping (~> 1.0)
timers (4.3.0)
PLATFORMS
ruby
DEPENDENCIES
falcon
pry
rack
BUNDLED WITH
1.17.3
ruby-async-http-0.52.5/examples/fetch/README.md 0000664 0000000 0000000 00000000125 13731260101 0021032 0 ustar 00root root 0000000 0000000 # Fetch
This was an experiment to see how browsers handle bi-directional streaming.
ruby-async-http-0.52.5/examples/fetch/config.ru 0000664 0000000 0000000 00000000666 13731260101 0021402 0 ustar 00root root 0000000 0000000
require 'rack'
class Echo
def initialize(app)
@app = app
end
def call(env)
request = Rack::Request.new(env)
if request.path_info == "/echo"
if output = request.body
return [200, {}, output.body]
else
return [200, {}, ["Hello World?"]]
end
else
return @app.call(env)
end
end
end
use Echo
use Rack::Static, :urls => [''], :root => 'public', :index => 'index.html'
run lambda{|env| [404, {}, []]}
ruby-async-http-0.52.5/examples/fetch/public/ 0000775 0000000 0000000 00000000000 13731260101 0021033 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/fetch/public/index.html 0000664 0000000 0000000 00000000455 13731260101 0023034 0 ustar 00root root 0000000 0000000
Streaming Fetch
Streams
Sent
Received
ruby-async-http-0.52.5/examples/fetch/public/stream.js 0000664 0000000 0000000 00000002403 13731260101 0022663 0 ustar 00root root 0000000 0000000 const inputStream = new ReadableStream({
start(controller) {
interval = setInterval(() => {
let string = "Hello World!";
// Add the string to the stream
controller.enqueue(string);
// show it on the screen
let listItem = document.createElement('li');
listItem.textContent = string;
sent.appendChild(listItem);
}, 10000);
stopButton.addEventListener('click', function() {
clearInterval(interval);
controller.close();
})
},
pull(controller) {
// We don't really need a pull in this example
},
cancel() {
// This is called if the reader cancels,
// so we should stop generating strings
clearInterval(interval);
}
});
fetch("/echo", {method: 'POST', body: inputStream})
.then(response => {
const reader = response.body.getReader();
const decoder = new TextDecoder("utf-8");
function push() {
reader.read().then(({done, value}) => {
console.log("done:", done, "value:", value);
const string = decoder.decode(value);
// show it on the screen
let listItem = document.createElement('li');
if (done)
listItem.textContent = ""
else
listItem.textContent = string;
received.appendChild(listItem);
if (done) return;
else push();
});
};
push();
});
ruby-async-http-0.52.5/examples/google/ 0000775 0000000 0000000 00000000000 13731260101 0017740 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/google/search.rb 0000775 0000000 0000000 00000003262 13731260101 0021540 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require "async"
require "async/clock"
require "protocol/http/middleware"
require_relative "../../lib/async/http"
URL = "https://www.google.com/search"
ENDPOINT = Async::HTTP::Endpoint.parse(URL)
# Console.logger.enable(Async::IO::Stream, Console::Logger::DEBUG)
class Google < Protocol::HTTP::Middleware
def search(term)
Async.logger.info(self) {"Searching for #{term}..."}
self.get("/search?q=#{term}", {"user-agent" => "Hi Google!"})
end
end
terms = %w{thoughtful fear size payment lethal modern recognise face morning sulky mountainous contain science snow uncle skirt truthful door travel snails closed rotten halting creator teeny-tiny beautiful cherries unruly level follow strip team things suggest pretty warm end cannon bad pig consider airport strengthen youthful fog three walk furry pickle moaning fax book ruddy sigh plate cakes shame stem faulty bushes dislike train sleet one colour behavior bitter suit count loutish squeak learn watery orange idiotic seat wholesale omniscient nostalgic arithmetic instruct committee puffy program cream cake whistle rely encourage war flagrant amusing fluffy prick utter wacky occur daily son check}
if count = ENV.fetch('COUNT', 20)&.to_i
terms = terms.first(count)
end
Async do |task|
client = Async::HTTP::Client.new(ENDPOINT)
google = Google.new(client)
google.search("null").finish
duration = Async::Clock.measure do
counts = terms.map do |term|
task.async do
response = google.search(term)
[term, response.read.scan(term).count]
end
end.map(&:wait).to_h
Async.logger.info(self, name: 'counts') {counts}
end
Async.logger.info(self, name: 'duration') {duration}
ensure
google.close
end
ruby-async-http-0.52.5/examples/licenses/ 0000775 0000000 0000000 00000000000 13731260101 0020271 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/licenses/gemspect.rb 0000775 0000000 0000000 00000003320 13731260101 0022426 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require 'csv'
require 'json'
require 'net/http'
require 'protocol/http/header/authorization'
class RateLimitingError < StandardError; end
@user = ENV['GITHUB_USER']
@token = ENV['GITHUB_TOKEN']
unless @user && @token
fail "export GITHUB_USER and GITHUB_TOKEN!"
end
def fetch_github_license(homepage_uri)
%r{github.com/(?.+?)/(?.+)} =~ homepage_uri
return nil unless repo
url = URI.parse("https://api.github.com/repos/#{owner}/#{repo}/license")
request = Net::HTTP::Get.new(url)
request['user-agent'] = 'fetch-github-licenses'
request['authorization'] = Protocol::HTTP::Header::Authorization.basic(@user, @token)
response = Net::HTTP.start(url.hostname) do |http|
http.request(request)
end
case response
when Net::HTTPOK
JSON.parse(response.body).dig('license', 'spdx_id')
when Net::HTTPNotFound, Net::HTTPMovedPermanently, Net::HTTPForbidden
nil
else
raise response.body
end
end
def fetch_rubygem_license(name, version)
url = URI.parse("https://rubygems.org/api/v2/rubygems/#{name}/versions/#{version}.json")
response = Net::HTTP.get_response(url)
case response
when Net::HTTPOK
body = JSON.parse(response.body)
[name, body.dig('licenses', 0) || fetch_github_license(body['homepage_uri'])]
when Net::HTTPNotFound
[name, nil] # from a non rubygems remote
when Net::HTTPTooManyRequests
raise RateLimitingError
else
raise response.body
end
rescue RateLimitingError
sleep 1
retry
end
threads = ARGF.map do |line|
if line == "GEM\n" .. line.chomp.empty?
/\A\s{4}(?[a-z].+?) \((?.+)\)\n\z/ =~ line
Thread.new { fetch_rubygem_license(name, version) } if name
end
end.compact
puts CSV.generate { |csv| threads.each { csv << _1.value } }
ruby-async-http-0.52.5/examples/licenses/list.rb 0000775 0000000 0000000 00000003574 13731260101 0021605 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require 'csv'
require 'json'
require 'async/http/internet'
class RateLimitingError < StandardError; end
@internet = Async::HTTP::Internet.new
@user = ENV['GITHUB_USER']
@token = ENV['GITHUB_TOKEN']
unless @user && @token
fail "export GITHUB_USER and GITHUB_TOKEN!"
end
GITHUB_HEADERS = {
'user-agent' => 'fetch-github-licenses',
'authorization' => Protocol::HTTP::Header::Authorization.basic(@user, @token)
}
RUBYGEMS_HEADERS = {
'user-agent' => 'fetch-github-licenses'
}
def fetch_github_license(homepage_uri)
%r{github.com/(?.+?)/(?.+)} =~ homepage_uri
return nil unless repo
response = @internet.get("https://api.github.com/repos/#{owner}/#{repo}/license", GITHUB_HEADERS)
case response.status
when 200
return JSON.parse(response.read).dig('license', 'spdx_id')
when 404
return nil
else
raise response.read
end
ensure
response.finish
end
def fetch_rubygem_license(name, version)
response = @internet.get("https://rubygems.org/api/v2/rubygems/#{name}/versions/#{version}.json", RUBYGEMS_HEADERS)
case response.status
when 200
body = JSON.parse(response.read)
[name, body.dig('licenses', 0) || fetch_github_license(body['homepage_uri'])]
when 404
[name, nil] # from a non rubygems remote
when 429
raise RateLimitingError
else
raise response.read
end
rescue RateLimitingError
response.finish
Async.logger.warn(name) {"Rate limited..."}
Async::Task.current.sleep(1.0)
retry
ensure
response.finish
end
Sync do |parent|
output = CSV.new($stdout)
tasks = ARGF.map do |line|
if line == "GEM\n" .. line.chomp.empty?
/\A\s{4}(?[a-z].+?) \((?.+)\)\n\z/ =~ line
parent.async do
fetch_rubygem_license(name, version)
end if name
end
end.compact
tasks.each do |task|
output << task.wait
end
@internet.instance_variable_get(:@clients).each do |name, client|
puts client.pool
end
end
ruby-async-http-0.52.5/examples/request.rb 0000664 0000000 0000000 00000001500 13731260101 0020475 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
#
# $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
# $LOAD_PATH.unshift(File.expand_path("../../http-protocol/lib", __dir__))
require 'async'
require 'async/logger'
require 'async/http/client'
require 'async/http/endpoint'
# Async.logger.level = Logger::DEBUG
Async do |task|
endpoint = Async::HTTP::Endpoint.parse("https://www.google.com")
client = Async::HTTP::Client.new(endpoint)
headers = {
'accept' => 'text/html',
}
request = Protocol::HTTP::Request.new(client.scheme, "www.google.com", "GET", "/search?q=cats", headers)
puts "Sending request..."
response = client.call(request)
puts "Reading response status=#{response.status}..."
if body = response.body
while chunk = body.read
puts chunk.size
end
end
response.close
puts "Finish reading response."
end
ruby-async-http-0.52.5/examples/stream/ 0000775 0000000 0000000 00000000000 13731260101 0017757 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/stream/stop.rb 0000664 0000000 0000000 00000001057 13731260101 0021274 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require 'async'
require 'async/http/internet'
Async do |parent|
internet = Async::HTTP::Internet.new
connection = nil
child = parent.async do
response = internet.get("https://utopia-falcon-heroku.herokuapp.com/beer/index")
connection = response.connection
response.each do |chunk|
Async.logger.info(response) {chunk}
end
ensure
Async.logger.info(response) {"Closing response..."}
response&.close
end
parent.sleep(5)
Async.logger.info(parent) {"Killing #{child}..."}
child.stop
ensure
internet&.close
end
ruby-async-http-0.52.5/examples/trenni/ 0000775 0000000 0000000 00000000000 13731260101 0017763 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/trenni/Gemfile 0000664 0000000 0000000 00000000076 13731260101 0021261 0 ustar 00root root 0000000 0000000
source 'https://rubygems.org'
gem "trenni"
gem "async-http"
ruby-async-http-0.52.5/examples/trenni/streaming.rb 0000664 0000000 0000000 00000001475 13731260101 0022310 0 ustar 00root root 0000000 0000000
require 'trenni/template'
require 'async'
require 'async/http/body/writable'
# The template, using inline text. The sleep could be anything - database query, HTTP request, redis, etc.
buffer = Trenni::Buffer.new(<<-EOF)
The "\#{self[:count]} bottles of \#{self[:drink]} on the wall" song!
\#{index} bottles of \#{self[:drink]} on the wall,
\#{index} bottles of \#{self[:drink]},
take one down, and pass it around,
\#{index - 1} bottles of \#{self[:drink]} on the wall.
EOF
template = Trenni::Template.new(buffer)
Async do
body = Async::HTTP::Body::Writable.new
generator = Async do
template.to_string({count: 100, drink: 'coffee'}, body)
end
while chunk = body.read
$stdout.write chunk
end
generator.wait
end.wait
ruby-async-http-0.52.5/examples/upload/ 0000775 0000000 0000000 00000000000 13731260101 0017750 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/examples/upload/client.rb 0000664 0000000 0000000 00000001615 13731260101 0021556 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
require 'async'
require 'protocol/http/body/file'
require 'async/http/body/delayed'
require 'async/http/client'
require 'async/http/endpoint'
Async do
endpoint = Async::HTTP::Endpoint.parse("http://localhost:9222")
client = Async::HTTP::Client.new(endpoint, Async::HTTP::Protocol::HTTP2)
headers = [
['accept', 'text/plain'],
]
body = Async::HTTP::Body::Delayed.new(Protocol::HTTP::Body::File.open(File.join(__dir__, "data.txt"), block_size: 32))
response = client.post(endpoint.path, headers, body)
puts response.status
# response.read -> string
# response.each {|chunk| ...}
# response.close (forcefully ignore data)
# body = response.finish (read and buffer response)
# response.save("echo.txt")
response.each do |chunk|
puts chunk.inspect
end
ensure
client.close if client
end
puts "Done."
ruby-async-http-0.52.5/examples/upload/data.txt 0000664 0000000 0000000 00000012674 13731260101 0021434 0 ustar 00root root 0000000 0000000 The Parable of the Two Programmers
Neil W. Rickert
Once upon a time, unbeknownst to each other, the "Automated Accounting Applications Association" and the "Consolidated Computerized Capital Corporation" decided that they needed the identical program to perform a certain service.
Automated hired a programmer-analyst, Alan, to solve their problem.
Meanwhile, Consolidated decided to ask a newly-hired entry-level programmer, Charles, to tackle the job, to see if he was as good as he pretended.
Alan, having had experience in difficult programming projects, decided to use the PQR structured design methodology. With this in mind he asked his department manager to assign another three programmers as a programming team. Then the team went to work, churning out preliminary reports and problem analyses.
Back at Consolidated, Charles spent some time thinking about the problem. His fellow employees noticed that Charles often sat with his feet on the desk, drinking coffee. He was occasionally seen at his computer terminal, but his office mate could tell from the rhythmic striking of keys that he was actually playing Space Invaders.
By now, the team at Automated was starting to write code. The programmers were spending about half their time writing and compiling code, and the rest of their time in conference, discussing the interfaces between the various modules.
His office mate noticed that Charles had finally given up on Space Invaders. Instead he now divided his time between drinking coffee with his feet on the table, and scribbling on little scraps of paper. His scribbling didn't seem to be Tic-Tac-Toe, but it didn't exactly make much sense, either.
Two months have gone by. The team at Automated finally releases an implementation timetable. In another two months they will have a test version of the program. Then a two month period of testing and enhancing should yield a completed version.
The manager of Charles has by now tired of seeing him goof off. He decides to confront him. But as he walks into Charles' office, he is surprised to see Charles busy entering code at his terminal. He decides to postpone the confrontation, so makes some small talk and then leaves. However, he begins to keep a closer watch on Charles, so that when the opportunity presents itself he can confront him. Not looking forward to an unpleasant conversation, he is pleased to notice that Charles seems to be busy most of the time. He has even been seen to delay his lunch, and to stay after work two or three days a week.
At the end of three months, Charles announces he has completed the project. He submits a 500-line program. The program appears to be clearly written, and when tested it does everything required in the specifications. In fact, it even has a few additional convenience features which might significantly improve the usability of the program. The program is put into test, and except for one quickly corrected oversight, performs well.
The team at Automated has by now completed two of the four major modules required for their program. These modules are now undergoing testing while the other modules are completed.
After another three weeks, Alan announces that the preliminary version is ready one week ahead of schedule. He supplies a list of the deficiencies that he expects to correct. The program is placed under test. The users find a number of bugs and deficiencies other than those listed. As Alan explains, this is no surprise. After all, this is a preliminary version in which bugs were expected.
After about two more months, the team has completed its production version of the program. It consists of about 2,500 lines of code. When tested, it seems to satisfy most of the original specifications. It has omitted one or two features, and is very fussy about the format of its input data. However, the company decides to install the program. They can always train their data-entry staff to enter data in the strict format required. The program is handed over to some maintenance programmers to eventually incorporate the missing features.
Sequel
At first Charles' supervisor was impressed. But as he read through the source code, he realized that the project was really much simpler than he had originally thought. It now seemed apparent that this was not much of a challenge even for a beginning programmer.
Charles did produce about five lines of code per day. This is perhaps a little above average. However, considering the simplicity of the program, it was nothing exceptional. Also, his supervisor remembered his two months of goofing off.
At his next salary review Charles was given a raise which was about half the inflation over the period. He was not given a promotion. After about a year he became discouraged and left Consolidated.
At Automated, Alan was complimented for completing his project on schedule. His supervisor looked over the program. Within a few minutes of thumbing through he saw that the company standards about structured programming were being observed. He quickly gave up attempting to read the program; however, it seemed quite incomprehensible. He realized by now that the project was really much more complex than he had originally assumed, and he congratulated Alan again on his achievement.
The team had produced over three lines of code per programmer per day. This was about average, but considering the complexity of the problem, could be considered to be exceptional. Alan was given a hefty pay raise, and promoted to Systems Analyst as a reward for his achievement. ruby-async-http-0.52.5/examples/upload/server.rb 0000664 0000000 0000000 00000000715 13731260101 0021606 0 ustar 00root root 0000000 0000000
$LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
require 'logger'
require 'async'
require 'async/http/server'
require 'async/http/endpoint'
protocol = Async::HTTP::Protocol::HTTP2
endpoint = Async::HTTP::Endpoint.parse('http://127.0.0.1:9222', reuse_port: true)
Async.logger.level = Logger::DEBUG
Async do
server = Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[200, {}, request.body]
end
server.run
end
ruby-async-http-0.52.5/examples/upload/upload.rb 0000664 0000000 0000000 00000001105 13731260101 0021556 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
require 'async'
require 'protocol/http/body/file'
require 'async/http/internet'
Async do
internet = Async::HTTP::Internet.new
headers = [
['accept', 'text/plain'],
]
body = Protocol::HTTP::Body::File.open(File.join(__dir__, "data.txt"))
response = internet.post("https://utopia-falcon-heroku.herokuapp.com/echo/index", headers, body)
# response.read -> string
# response.each {|chunk| ...}
# response.close (forcefully ignore data)
# body = response.finish (read and buffer response)
response.save("echo.txt")
ensure
internet.close
end
ruby-async-http-0.52.5/gems.rb 0000664 0000000 0000000 00000000612 13731260101 0016125 0 ustar 00root root 0000000 0000000 source 'https://rubygems.org'
gemspec
group :maintenance, optional: true do
gem "bake-modernize"
gem "bake-bundler"
end
# gem "async", path: "../async"
# gem "async-io", path: "../async-io"
# gem "protocol-http", path: "../protocol-http"
# gem "protocol-http1", path: "../protocol-http1"
# gem "protocol-http2", path: "../protocol-http2"
# gem "protocol-hpack", path: "../protocol-hpack"
ruby-async-http-0.52.5/lib/ 0000775 0000000 0000000 00000000000 13731260101 0015414 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/ 0000775 0000000 0000000 00000000000 13731260101 0016531 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/http.rb 0000664 0000000 0000000 00000002416 13731260101 0020040 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'http/version'
require_relative 'http/client'
require_relative 'http/server'
require_relative 'http/endpoint'
ruby-async-http-0.52.5/lib/async/http/ 0000775 0000000 0000000 00000000000 13731260101 0017510 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/http/body.rb 0000664 0000000 0000000 00000002456 13731260101 0021001 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/body/buffered'
require_relative 'body/writable'
module Async
module HTTP
module Body
include ::Protocol::HTTP::Body
end
end
end
ruby-async-http-0.52.5/lib/async/http/body/ 0000775 0000000 0000000 00000000000 13731260101 0020445 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/http/body/delayed.rb 0000664 0000000 0000000 00000002774 13731260101 0022413 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/body/wrapper'
module Async
module HTTP
module Body
class Delayed < Protocol::HTTP::Body::Wrapper
def initialize(body, delay = 0.01)
super(body)
@delay = delay
end
def ready?
false
end
def read
Async::Task.current.sleep(@delay)
return super
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/body/hijack.rb 0000664 0000000 0000000 00000005121 13731260101 0022222 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/body/readable'
require_relative 'stream'
module Async
module HTTP
module Body
# A body which is designed for hijacked server responses - a response which uses a block to read and write the request and response bodies respectively.
class Hijack < ::Protocol::HTTP::Body::Readable
def self.response(request, status, headers, &block)
::Protocol::HTTP::Response[status, headers, self.wrap(request, &block)]
end
def self.wrap(request, &block)
self.new(request.body, &block)
end
def initialize(input = nil, &block)
@input = input
@block = block
@task = nil
@stream = nil
end
def call(stream)
return @block.call(stream)
end
attr :input
# Has the producer called #finish and has the reader consumed the nil token?
def empty?
if @stream
@stream.empty?
else
false
end
end
def ready?
if @stream
@stream.output.ready?
end
end
# Read the next available chunk.
def read
unless @task
@stream = Stream.new(@input)
@task = Task.current.async do |task|
task.annotate "Streaming hijacked body."
@block.call(@stream)
end
end
return @stream.output.read
end
def inspect
"\#<#{self.class} #{@block.inspect}>"
end
def to_s
""
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/body/pipe.rb 0000664 0000000 0000000 00000005267 13731260101 0021741 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require_relative 'writable'
module Async
module HTTP
module Body
class Pipe
# If the input stream is closed first, it's likely the output stream will also be closed.
def initialize(input, output = Writable.new, task: Task.current)
@input = input
@output = output
head, tail = IO::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
@head = IO::Stream.new(head)
@tail = tail
@reader = nil
@writer = nil
task.async(&self.method(:reader))
task.async(&self.method(:writer))
end
def to_io
@tail
end
def close
@reader&.stop
@writer&.stop
@tail.close
end
private
# Read from the @input stream and write to the head of the pipe.
def reader(task)
@reader = task
task.annotate "#{self.class} reader."
while chunk = @input.read
@head.write(chunk)
@head.flush
end
@head.close_write
ensure
@reader = nil
@input.close($!)
@head.close if @writer.nil?
end
# Read from the head of the pipe and write to the @output stream.
# If the @tail is closed, this will cause chunk to be nil, which in turn will call `@output.close` and `@head.close`
def writer(task)
@writer = task
task.annotate "#{self.class} writer."
while chunk = @head.read_partial
@output.write(chunk)
end
ensure
@writer = nil
@output.close($!)
@head.close if @reader.nil?
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/body/slowloris.rb 0000664 0000000 0000000 00000005405 13731260101 0023033 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'writable'
require 'async/clock'
module Async
module HTTP
module Body
# A dynamic body which you can write to and read from.
class Slowloris < Writable
class ThroughputError < StandardError
def initialize(throughput, minimum_throughput, time_since_last_write)
super("Slow write: #{throughput.round(1)}bytes/s less than required #{minimum_throughput.round}bytes/s.")
end
end
# In order for this implementation to work correctly, you need to use a LimitedQueue.
# @param minimum_throughput [Integer] the minimum bytes per second otherwise this body will be forcefully closed.
def initialize(*arguments, minimum_throughput: 1024, **options)
super(*arguments, **options)
@minimum_throughput = minimum_throughput
@last_write_at = nil
@last_chunk_size = nil
end
attr :minimum_throughput
# If #read is called regularly to maintain throughput, that is good. If #read is not called, that is a problem. Throughput is dependent on data being available, from #write, so it doesn't seem particularly problimatic to do this check in #write.
def write(chunk)
if @last_chunk_size
time_since_last_write = Async::Clock.now - @last_write_at
throughput = @last_chunk_size / time_since_last_write
if throughput < @minimum_throughput
error = ThroughputError.new(throughput, @minimum_throughput, time_since_last_write)
self.close(error)
end
end
super.tap do
@last_write_at = Async::Clock.now
@last_chunk_size = chunk&.bytesize
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/body/stream.rb 0000664 0000000 0000000 00000011604 13731260101 0022267 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require_relative 'writable'
module Async
module HTTP
module Body
# The input stream is an IO-like object which contains the raw HTTP POST data. When applicable, its external encoding must be “ASCII-8BIT” and it must be opened in binary mode, for Ruby 1.9 compatibility. The input stream must respond to gets, each, read and rewind.
class Stream
def initialize(input, output = Writable.new)
@input = input
@output = output
raise ArgumentError, "Non-writable output!" unless output.respond_to?(:write)
# Will hold remaining data in `#read`.
@buffer = nil
@closed = false
end
attr :input
attr :output
# rack.hijack_io must respond to:
# read, write, read_nonblock, write_nonblock, flush, close, close_read, close_write, closed?
# read behaves like IO#read. Its signature is read([length, [buffer]]). If given, length must be a non-negative Integer (>= 0) or nil, and buffer must be a String and may not be nil. If length is given and not nil, then this method reads at most length bytes from the input stream. If length is not given or nil, then this method reads all data until EOF. When EOF is reached, this method returns nil if length is given and not nil, or “” if length is not given or is nil. If buffer is given, then the read data will be placed into buffer instead of a newly created String object.
# @param length [Integer] the amount of data to read
# @param buffer [String] the buffer which will receive the data
# @return a buffer containing the data
def read(size = nil, buffer = nil)
return '' if size == 0
buffer ||= Async::IO::Buffer.new
if @buffer
buffer.replace(@buffer)
@buffer = nil
end
if size
while buffer.bytesize < size and chunk = read_next
buffer << chunk
end
@buffer = buffer.byteslice(size, buffer.bytesize)
buffer = buffer.byteslice(0, size)
if buffer.empty?
return nil
else
return buffer
end
else
while chunk = read_next
buffer << chunk
end
return buffer
end
end
# Read at most `size` bytes from the stream. Will avoid reading from the underlying stream if possible.
def read_partial(size = nil)
if @buffer
buffer = @buffer
@buffer = nil
else
buffer = read_next
end
if buffer and size
if buffer.bytesize > size
@buffer = buffer.byteslice(size, buffer.bytesize)
buffer = buffer.byteslice(0, size)
end
end
return buffer
end
def read_nonblock(length, buffer = nil)
@buffer ||= read_next
chunk = nil
return nil if @buffer.nil?
if @buffer.bytesize > length
chunk = @buffer.byteslice(0, length)
@buffer = @buffer.byteslice(length, @buffer.bytesize)
else
chunk = @buffer
@buffer = nil
end
if buffer
buffer.replace(chunk)
else
buffer = chunk
end
return buffer
end
def write(buffer)
@output.write(buffer)
end
alias write_nonblock write
def flush
end
def close_read
@input&.close
end
def close_write
@output&.close
end
# Close the input and output bodies.
def close
self.close_read
self.close_write
ensure
@closed = true
end
# Whether the stream has been closed.
def closed?
@closed
end
# Whether there are any output chunks remaining?
def empty?
@output.empty?
end
private
def read_next
if chunk = @input&.read
return chunk
else
@input = nil
return nil
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/body/writable.rb 0000664 0000000 0000000 00000006126 13731260101 0022610 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/body/readable'
require 'async/queue'
module Async
module HTTP
module Body
include ::Protocol::HTTP::Body
# A dynamic body which you can write to and read from.
class Writable < Readable
class Closed < StandardError
end
# @param [Integer] length The length of the response body if known.
# @param [Async::Queue] queue Specify a different queue implementation, e.g. `Async::LimitedQueue.new(8)` to enable back-pressure streaming.
def initialize(length = nil, queue: Async::Queue.new)
@queue = queue
@length = length
@count = 0
@finished = false
@closed = false
@error = nil
end
def length
@length
end
# Stop generating output; cause the next call to write to fail with the given error.
def close(error = nil)
unless @closed
@queue.enqueue(nil)
@closed = true
@error = error
end
super
end
def closed?
@closed
end
def ready?
!@queue.empty?
end
# Has the producer called #finish and has the reader consumed the nil token?
def empty?
@finished
end
# Read the next available chunk.
def read
return if @finished
unless chunk = @queue.dequeue
@finished = true
end
return chunk
end
# Write a single chunk to the body. Signal completion by calling `#finish`.
def write(chunk)
# If the reader breaks, the writer will break.
# The inverse of this is less obvious (*)
if @closed
raise(@error || Closed)
end
@count += 1
@queue.enqueue(chunk)
end
alias << write
def inspect
"\#<#{self.class} #{@count} chunks written, #{status}>"
end
private
def status
if @finished
'finished'
elsif @closed
'closing'
else
'waiting'
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/client.rb 0000775 0000000 0000000 00000012100 13731260101 0021310 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'async/io/endpoint'
require 'async/io/stream'
require 'async/pool/controller'
require 'protocol/http/body/streamable'
require 'protocol/http/methods'
require_relative 'protocol'
module Async
module HTTP
DEFAULT_RETRIES = 3
DEFAULT_CONNECTION_LIMIT = nil
class Client < ::Protocol::HTTP::Methods
# 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, protocol = endpoint.protocol, scheme = endpoint.scheme, authority = endpoint.authority, retries: DEFAULT_RETRIES, connection_limit: DEFAULT_CONNECTION_LIMIT)
@endpoint = endpoint
@protocol = protocol
@retries = retries
@pool = make_pool(connection_limit)
@scheme = scheme
@authority = authority
end
attr :endpoint
attr :protocol
attr :retries
attr :pool
attr :scheme
attr :authority
def secure?
@endpoint.secure?
end
def self.open(*arguments, **options, &block)
client = self.new(*arguments, **options)
return client unless block_given?
begin
yield client
ensure
client.close
end
end
def close
while @pool.busy?
Async.logger.warn(self) {"Waiting for #{@protocol} pool to drain: #{@pool}"}
@pool.wait
end
@pool.close
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 = @pool.acquire
response = make_response(request, connection)
# This signals that the ensure block below should not try to release the connection, because it's bound into the response which will be returned:
connection = nil
return response
rescue Protocol::RequestFailed
# This is a specific case where the entire request wasn't sent before a failure occurred. So, we can even resend non-idempotent requests.
if connection
@pool.release(connection)
connection = nil
end
if attempt < @retries
retry
else
raise
end
rescue SocketError, IOError, EOFError, Errno::ECONNRESET, Errno::EPIPE
if connection
@pool.release(connection)
connection = nil
end
if request.idempotent? and attempt < @retries
retry
else
raise
end
ensure
@pool.release(connection) if connection
end
end
protected
def make_response(request, connection)
response = request.call(connection)
# The connection won't be released until the body is completely read/released.
::Protocol::HTTP::Body::Streamable.wrap(response) do
@pool.release(connection)
end
return response
end
def make_pool(connection_limit)
Async::Pool::Controller.wrap(limit: connection_limit) do
Async.logger.debug(self) {"Making connection to #{@endpoint.inspect}"}
@protocol.client(@endpoint.connect)
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/endpoint.rb 0000664 0000000 0000000 00000013464 13731260101 0021665 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/io/host_endpoint'
require 'async/io/ssl_endpoint'
require 'async/io/ssl_socket'
require_relative 'protocol/http1'
require_relative 'protocol/https'
module Async
module HTTP
# Represents a way to connect to a remote HTTP server.
class Endpoint < Async::IO::Endpoint
def self.parse(string, endpoint = nil, **options)
url = URI.parse(string).normalize
return self.new(url, endpoint, **options)
end
# Construct an endpoint with a specified scheme, hostname, and options.
def self.for(scheme, hostname, **options)
# TODO: Consider using URI.for once it becomes available:
uri_klass = URI.scheme_list[scheme.upcase] || URI::HTTP
self.new(
uri_klass.new(scheme, nil, hostname, nil, nil, nil, nil, nil, nil),
**options
)
end
# @option scheme [String] the scheme to use, overrides the URL scheme.
# @option hostname [String] the hostname to connect to (or bind to), overrides the URL hostname (used for SNI).
# @option port [Integer] the port to bind to, overrides the URL port.
# @option ssl_context [OpenSSL::SSL::SSLContext] the context to use for TLS.
# @option alpn_protocols [Array] the alpn protocols to negotiate.
def initialize(url, endpoint = nil, **options)
super(**options)
raise ArgumentError, "URL must be absolute (include scheme, host): #{url}" unless url.absolute?
@url = url
if endpoint
@endpoint = self.build_endpoint(endpoint)
else
@endpoint = nil
end
end
def to_url
url = @url.dup
unless default_port?
url.port = self.port
end
return url
end
def to_s
"\#<#{self.class} #{self.to_url} #{@options}>"
end
def inspect
"\#<#{self.class} #{self.to_url} #{@options.inspect}>"
end
attr :url
def address
endpoint.address
end
def secure?
['https', 'wss'].include?(self.scheme)
end
def protocol
@options.fetch(:protocol) do
if secure?
Protocol::HTTPS
else
Protocol::HTTP1
end
end
end
def default_port
secure? ? 443 : 80
end
def default_port?
port == default_port
end
def port
@options[:port] || @url.port || default_port
end
# The hostname is the server we are connecting to:
def hostname
@options[:hostname] || @url.hostname
end
def scheme
@options[:scheme] || @url.scheme
end
def authority(ignore_default_port = true)
if ignore_default_port and default_port?
@url.hostname
else
"#{@url.hostname}:#{port}"
end
end
# Return the path and query components of the given URL.
def path
buffer = @url.path || "/"
if query = @url.query
buffer = "#{buffer}?#{query}"
end
return buffer
end
def alpn_protocols
@options.fetch(:alpn_protocols) {self.protocol.names}
end
def localhost?
@url.hostname =~ /^(.*?\.)?localhost\.?$/
end
# We don't try to validate peer certificates when talking to localhost because they would always be self-signed.
def ssl_verify_mode
if self.localhost?
OpenSSL::SSL::VERIFY_NONE
else
OpenSSL::SSL::VERIFY_PEER
end
end
def ssl_context
@options[:ssl_context] || OpenSSL::SSL::SSLContext.new.tap do |context|
if alpn_protocols = self.alpn_protocols
context.alpn_protocols = alpn_protocols
end
context.set_params(
verify_mode: self.ssl_verify_mode
)
end
end
def build_endpoint(endpoint = nil)
endpoint ||= tcp_endpoint
if secure?
# Wrap it in SSL:
return Async::IO::SSLEndpoint.new(endpoint,
ssl_context: self.ssl_context,
hostname: @url.hostname,
timeout: self.timeout,
)
end
return endpoint
end
def endpoint
@endpoint ||= build_endpoint
end
def bind(*arguments, &block)
endpoint.bind(*arguments, &block)
end
def connect(&block)
endpoint.connect(&block)
end
def each
return to_enum unless block_given?
self.tcp_endpoint.each do |endpoint|
yield self.class.new(@url, endpoint, **@options)
end
end
def key
[@url, @options]
end
def eql? other
self.key.eql? other.key
end
def hash
self.key.hash
end
protected
def tcp_options
options = @options.dup
options.delete(:scheme)
options.delete(:port)
options.delete(:hostname)
options.delete(:ssl_context)
options.delete(:alpn_protocols)
options.delete(:protocol)
return options
end
def tcp_endpoint
Async::IO::Endpoint.tcp(self.hostname, port, **tcp_options)
end
end
end
end ruby-async-http-0.52.5/lib/async/http/internet.rb 0000664 0000000 0000000 00000005143 13731260101 0021670 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'client'
require_relative 'endpoint'
require 'protocol/http/middleware'
require 'protocol/http/body/buffered'
module Async
module HTTP
class Internet
def initialize(**options)
@clients = {}
@options = options
end
# A cache of clients.
# @attribute [Hash(URI, Client)]
attr :clients
def call(method, url, headers = nil, body = nil)
endpoint = Endpoint.parse(url)
key = host_key(endpoint)
client = @clients.fetch(key) do
@clients[key] = self.client_for(endpoint)
end
body = Body::Buffered.wrap(body)
headers = ::Protocol::HTTP::Headers[headers]
request = ::Protocol::HTTP::Request.new(client.scheme, endpoint.authority, method, endpoint.path, nil, headers, body)
return client.call(request)
end
def client_for(endpoint)
Client.new(endpoint, **@options)
end
def close
# The order of operations here is to avoid a race condition between iterating over clients (#close may yield) and creating new clients.
clients = @clients.values
@clients.clear
clients.each(&:close)
end
::Protocol::HTTP::Methods.each do |name, verb|
define_method(verb.downcase) do |url, headers = nil, body = nil|
self.call(verb, url.to_str, headers, body)
end
end
private
def host_key(endpoint)
url = endpoint.url.dup
url.path = ""
url.fragment = nil
url.query = nil
return url
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol.rb 0000664 0000000 0000000 00000003531 13731260101 0021700 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'protocol/http1'
require_relative 'protocol/https'
module Async
module HTTP
# A protocol specifies a way in which to communicate with a remote peer.
module Protocol
# A protocol must implement the following interface:
# class Protocol
# def client(stream) -> Connection
# def server(stream) -> Connection
# end
# A connection must implement the following interface:
# class Connection
# def concurrency -> can invoke call 1 or more times simultaneously.
# def reusable? -> can be used again/persistent connection.
# def viable? -> Boolean
# def call(request) -> Response
# def each -> (yield(request) -> Response)
# end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/ 0000775 0000000 0000000 00000000000 13731260101 0021351 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/http/protocol/http1.rb 0000664 0000000 0000000 00000003360 13731260101 0022740 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'http1/client'
require_relative 'http1/server'
module Async
module HTTP
module Protocol
module HTTP1
VERSION = "HTTP/1.1"
def self.bidirectional?
true
end
def self.trailers?
true
end
def self.client(peer)
stream = IO::Stream.new(peer, sync: false)
return HTTP1::Client.new(stream, VERSION)
end
def self.server(peer)
stream = IO::Stream.new(peer, sync: false)
return HTTP1::Server.new(stream, VERSION)
end
def self.names
["http/1.1", "http/1.0"]
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http1/ 0000775 0000000 0000000 00000000000 13731260101 0022411 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/http/protocol/http1/client.rb 0000664 0000000 0000000 00000006665 13731260101 0024231 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'connection'
module Async
module HTTP
module Protocol
module HTTP1
class Client < Connection
# Used by the client to send requests to the remote server.
def call(request, task: Task.current)
Async.logger.debug(self) {"#{request.method} #{request.path} #{request.headers.inspect}"}
trailers = request.headers.trailers!
# We carefully interpret https://tools.ietf.org/html/rfc7230#section-6.3.1 to implement this correctly.
begin
write_request(request.authority, request.method, request.path, @version, request.headers)
rescue
# If we fail to fully write the request and body, we can retry this request.
raise RequestFailed
end
if request.body?
body = request.body
if protocol = request.protocol
# This is a very tricky apect of handling HTTP/1 upgrade connections. In theory, this approach is a bit inefficient, because we spin up a task just to handle writing to the underlying stream when we could be writing to the stream directly. But we need to maintain some level of compatibility with HTTP/2. Additionally, we don't know if the upgrade request will be accepted, so starting to write the body at this point needs to be handled with care.
task.async do |subtask|
subtask.annotate("Upgrading request.")
# If this fails, this connection will be closed.
write_upgrade_body(protocol, body)
end
elsif request.connect?
task.async do |subtask|
subtask.annotate("Tunnelling body.")
write_tunnel_body(@version, body)
end
else
task.async do |subtask|
subtask.annotate("Streaming body.")
# Once we start writing the body, we can't recover if the request fails. That's because the body might be generated dynamically, streaming, etc.
write_body(@version, body, false, trailers)
end
end
elsif protocol = request.protocol
write_upgrade_body(protocol)
else
write_body(@version, body, false, trailers)
end
return Response.read(self, request)
rescue
# This will ensure that #reusable? returns false.
@stream.close
raise
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http1/connection.rb 0000775 0000000 0000000 00000004254 13731260101 0025105 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http1'
require_relative 'request'
require_relative 'response'
module Async
module HTTP
module Protocol
module HTTP1
class Connection < ::Protocol::HTTP1::Connection
def initialize(stream, version)
super(stream)
@version = version
end
attr :version
def http1?
true
end
def http2?
false
end
def read_line?
@stream.read_until(CRLF)
rescue Errno::ECONNRESET
return nil
end
def read_line
@stream.read_until(CRLF) or raise EOFError, "Could not read line!"
end
def peer
@stream.io
end
attr :count
def concurrency
1
end
# Can we use this connection to make requests?
def viable?
@stream&.connected?
end
def reusable?
@persistent && @stream && !@stream.closed?
end
def close
Async.logger.debug(self) {"Closing connection"}
super
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http1/request.rb 0000664 0000000 0000000 00000003514 13731260101 0024431 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../request'
module Async
module HTTP
module Protocol
module HTTP1
class Request < Protocol::Request
def self.read(connection)
if parts = connection.read_request
self.new(connection, *parts)
end
end
def initialize(connection, authority, method, path, version, headers, body)
@connection = connection
protocol = connection.upgrade?(headers)
super(nil, authority, method, path, version, headers, body, protocol)
end
def connection
@connection
end
def hijack?
true
end
def hijack!
@connection.hijack!
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http1/response.rb 0000664 0000000 0000000 00000003622 13731260101 0024577 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../response'
module Async
module HTTP
module Protocol
module HTTP1
class Response < Protocol::Response
def self.read(connection, request)
if parts = connection.read_response(request.method)
self.new(connection, *parts)
end
end
# @param reason [String] HTTP response line reason, ignored.
def initialize(connection, version, status, reason, headers, body)
@connection = connection
protocol = connection.upgrade?(headers)
super(version, status, headers, body, protocol)
end
def connection
@connection
end
def hijack?
@body.nil?
end
def hijack!
@connection.hijack!
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http1/server.rb 0000664 0000000 0000000 00000007300 13731260101 0024244 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'connection'
module Async
module HTTP
module Protocol
module HTTP1
class Server < Connection
def fail_request(status)
@persistent = false
write_response(@version, status, {}, nil)
end
def next_request
# The default is true.
return unless @persistent
# Read an incoming request:
return unless request = Request.read(self)
unless persistent?(request.version, request.method, request.headers)
@persistent = false
end
return request
rescue Async::TimeoutError
# For an interesting discussion about this behaviour, see https://trac.nginx.org/nginx/ticket/1005
# If you enable this, you will see some spec failures...
# fail_request(408)
raise
rescue
fail_request(400)
raise
end
# Server loop.
def each(task: Task.current)
task.annotate("Reading #{self.version} requests for #{self.class}.")
while request = next_request
response = yield(request, self)
return if @stream.nil? or @stream.closed?
if response
trailers = response.headers.trailers!
write_response(@version, response.status, response.headers)
body = response.body
if body and protocol = response.protocol
stream = write_upgrade_body(protocol)
# At this point, the request body is hijacked, so we don't want to call #finish below.
request = nil
# We also don't want to hold on to the response object:
response = nil
body.call(stream)
elsif body and request.connect?
stream = write_tunnel_body(request.version)
# Same as above:
request = nil
response = nil
body.call(stream)
else
head = request.head?
version = request.version
request = nil unless body
response = nil
write_body(version, body, head, trailers)
end
else
# If the request failed to generate a response, it was an internal server error:
write_response(@version, 500, {})
write_body(request.version, nil)
end
# Gracefully finish reading the request body if it was not already done so.
request&.finish
# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
task.yield
end
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http10.rb 0000775 0000000 0000000 00000003300 13731260101 0023015 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'http1'
module Async
module HTTP
module Protocol
module HTTP10
VERSION = "HTTP/1.0"
def self.bidirectional?
false
end
def self.trailers?
false
end
def self.client(peer)
stream = IO::Stream.new(peer, sync: false)
return HTTP1::Client.new(stream, VERSION)
end
def self.server(peer)
stream = IO::Stream.new(peer, sync: false)
return HTTP1::Server.new(stream, VERSION)
end
def self.names
["http/1.0"]
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http11.rb 0000664 0000000 0000000 00000003276 13731260101 0023027 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'http1'
module Async
module HTTP
module Protocol
module HTTP11
VERSION = "HTTP/1.1"
def self.bidirectional?
true
end
def self.trailers?
true
end
def self.client(peer)
stream = IO::Stream.new(peer, sync: false)
return HTTP1::Client.new(stream, VERSION)
end
def self.server(peer)
stream = IO::Stream.new(peer, sync: false)
return HTTP1::Server.new(stream, VERSION)
end
def self.names
["http/1.1"]
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2.rb 0000664 0000000 0000000 00000005715 13731260101 0022747 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'http2/client'
require_relative 'http2/server'
module Async
module HTTP
module Protocol
module HTTP2
VERSION = "h2"
def self.bidirectional?
true
end
def self.trailers?
true
end
CLIENT_SETTINGS = {
::Protocol::HTTP2::Settings::ENABLE_PUSH => 0,
::Protocol::HTTP2::Settings::MAXIMUM_FRAME_SIZE => 0x100000,
::Protocol::HTTP2::Settings::INITIAL_WINDOW_SIZE => 0x800000,
}
SERVER_SETTINGS = {
# We choose a lower maximum concurrent streams to avoid overloading a single connection/thread.
::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 128,
::Protocol::HTTP2::Settings::MAXIMUM_FRAME_SIZE => 0x100000,
::Protocol::HTTP2::Settings::INITIAL_WINDOW_SIZE => 0x800000,
::Protocol::HTTP2::Settings::ENABLE_CONNECT_PROTOCOL => 1,
}
def self.client(peer, settings = CLIENT_SETTINGS)
stream = IO::Stream.new(peer, sync: true)
client = Client.new(stream)
client.send_connection_preface(settings)
client.start_connection
return client
end
def self.server(peer, settings = SERVER_SETTINGS)
stream = IO::Stream.new(peer, sync: true)
server = Server.new(stream)
server.read_connection_preface(settings)
server.start_connection
return server
end
def self.names
["h2"]
end
module WithPush
CLIENT_SETTINGS = HTTP2::CLIENT_SETTINGS.merge(
::Protocol::HTTP2::Settings::ENABLE_PUSH => 1,
)
def self.client(peer, settings = CLIENT_SETTINGS)
HTTP2.client(peer, settings)
end
def self.server(peer, settings = SERVER_SETTINGS)
HTTP2.server(peer, settings)
end
def self.names
HTTP2.names
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/ 0000775 0000000 0000000 00000000000 13731260101 0022412 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/lib/async/http/protocol/http2/client.rb 0000664 0000000 0000000 00000003725 13731260101 0024224 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'connection'
require_relative 'response'
require 'protocol/http2/client'
module Async
module HTTP
module Protocol
module HTTP2
class Client < ::Protocol::HTTP2::Client
include Connection
def initialize(stream)
@stream = stream
framer = ::Protocol::HTTP2::Framer.new(@stream)
super(framer)
end
def create_response
Response::Stream.create(self, self.next_stream_id).response
end
# Used by the client to send requests to the remote server.
def call(request)
raise ::Protocol::HTTP2::Error, "Connection closed!" if self.closed?
@count += 1
response = create_response
response.send_request(request)
response.wait
return response
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/connection.rb 0000664 0000000 0000000 00000007155 13731260101 0025106 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'stream'
require 'async/semaphore'
module Async
module HTTP
module Protocol
module HTTP2
HTTPS = 'https'.freeze
SCHEME = ':scheme'.freeze
METHOD = ':method'.freeze
PATH = ':path'.freeze
AUTHORITY = ':authority'.freeze
STATUS = ':status'.freeze
PROTOCOL = ':protocol'.freeze
CONTENT_LENGTH = 'content-length'.freeze
CONNECTION = 'connection'.freeze
TRAILERS = 'trailers'.freeze
module Connection
def initialize(*)
super
@count = 0
@reader = nil
# Writing multiple frames at the same time can cause odd problems if frames are only partially written. So we use a semaphore to ensure frames are written in their entirety.
@write_frame_guard = Async::Semaphore.new(1)
end
def to_s
"\#<#{self.class} #{@streams.count} active streams>"
end
attr :stream
def http1?
false
end
def http2?
true
end
def start_connection
@reader || read_in_background
end
def close(error = nil)
@reader = nil
super
end
def write_frame(frame)
# We don't want to write multiple frames at the same time.
@write_frame_guard.acquire do
super
end
@stream.flush
end
def write_frames(&block)
@write_frame_guard.acquire do
super
end
@stream.flush
end
def read_in_background(parent: Task.current)
raise RuntimeError, "Connection is closed!" if closed?
parent.async(transient: true) do |task|
@reader = task
task.annotate("#{version} reading data for #{self.class}.")
begin
while !self.closed?
self.consume_window
self.read_frame
end
rescue SocketError, IOError, EOFError, Errno::ECONNRESET, Errno::EPIPE, Async::Wrapper::Cancelled
# Ignore.
ensure
# Don't call #close twice.
if @reader
self.close($!)
end
end
end
end
attr :promises
def peer
@stream.io
end
attr :count
def concurrency
self.maximum_concurrent_streams
end
# Can we use this connection to make requests?
def viable?
@stream.connected?
end
def reusable?
!self.closed?
end
def version
VERSION
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/input.rb 0000664 0000000 0000000 00000004174 13731260101 0024104 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../../body/writable'
module Async
module HTTP
module Protocol
module HTTP2
# A writable body which requests window updates when data is read from it.
class Input < Body::Writable
def initialize(stream, length)
super(length)
@stream = stream
@remaining = length
end
def read
if chunk = super
# If we read a chunk fron the stream, we want to extend the window if required so more data will be provided.
@stream.request_window_update
end
# We track the expected length and check we got what we were expecting.
if @remaining
if chunk
@remaining -= chunk.bytesize
elsif @remaining > 0
raise EOFError, "Expected #{self.length} bytes, #{@remaining} bytes short!"
elsif @remaining < 0
raise EOFError, "Expected #{self.length} bytes, #{@remaining} bytes over!"
end
end
return chunk
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/output.rb 0000664 0000000 0000000 00000010000 13731260101 0024266 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../../body/stream'
module Async
module HTTP
module Protocol
module HTTP2
class Output
def initialize(stream, body, trailers = nil)
@stream = stream
@body = body
@trailers = trailers
@task = nil
@window_updated = Async::Condition.new
end
attr :trailers
def start(parent: Task.current)
raise "Task already started!" if @task
if @body.respond_to?(:call)
@task = parent.async(&self.method(:stream))
else
@task = parent.async(&self.method(:passthrough))
end
end
def window_updated(size)
@window_updated.signal
end
def write(chunk)
until chunk.empty?
maximum_size = @stream.available_frame_size
while maximum_size <= 0
@window_updated.wait
maximum_size = @stream.available_frame_size
end
break unless chunk = send_data(chunk, maximum_size)
end
end
# This method should only be called from within the context of the output task.
def close(error = nil)
if @stream
@stream.finish_output(error)
@stream = nil
end
end
# This method should only be called from within the context of the HTTP/2 stream.
def stop(error)
@task&.stop
@task = nil
end
private
def stream(task)
task.annotate("Streaming #{@body} to #{@stream}.")
input = @stream.wait_for_input
@body.call(Body::Stream.new(input, self))
rescue Async::Stop
# Ignore.
end
# Reads chunks from the given body and writes them to the stream as fast as possible.
def passthrough(task)
task.annotate("Writing #{@body} to #{@stream}.")
while chunk = @body&.read
self.write(chunk)
# TODO this reduces memory usage?
# chunk.clear unless chunk.frozen?
# GC.start
end
self.close
ensure
@body&.close($!)
@body = nil
end
# Send `maximum_size` bytes of data using the specified `stream`. If the buffer has no more chunks, `END_STREAM` will be sent on the final chunk.
# @param maximum_size [Integer] send up to this many bytes of data.
# @param stream [Stream] the stream to use for sending data frames.
# @return [String, nil] any data that could not be written.
def send_data(chunk, maximum_size)
if chunk.bytesize <= maximum_size
@stream.send_data(chunk, maximum_size: maximum_size)
else
@stream.send_data(chunk.byteslice(0, maximum_size), maximum_size: maximum_size)
# The window was not big enough to send all the data, so we save it for next time:
return chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
end
return nil
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/request.rb 0000664 0000000 0000000 00000014531 13731260101 0024433 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../request'
require_relative 'stream'
module Async
module HTTP
module Protocol
module HTTP2
# Typically used on the server side to represent an incoming request, and write the response.
class Request < Protocol::Request
class Stream < HTTP2::Stream
def initialize(*)
super
@enqueued = false
@request = Request.new(self)
end
attr :request
# Create a fake request on the server, with the given headers.
def create_push_promise_stream(headers)
stream = @connection.create_push_promise_stream(&Stream.method(:create))
stream.headers = ::Protocol::HTTP::Headers.new
# This will ultimately enqueue the request to be processed by the server:
stream.receive_initial_headers(headers, false)
return stream
end
def receive_initial_headers(headers, end_stream)
headers.each do |key, value|
if key == SCHEME
raise ::Protocol::HTTP2::HeaderError, "Request scheme already specified!" if @request.scheme
@request.scheme = value
elsif key == AUTHORITY
raise ::Protocol::HTTP2::HeaderError, "Request authority already specified!" if @request.authority
@request.authority = value
elsif key == METHOD
raise ::Protocol::HTTP2::HeaderError, "Request method already specified!" if @request.method
@request.method = value
elsif key == PATH
raise ::Protocol::HTTP2::HeaderError, "Request path is empty!" if value.empty?
raise ::Protocol::HTTP2::HeaderError, "Request path already specified!" if @request.path
@request.path = value
elsif key == PROTOCOL
raise ::Protocol::HTTP2::HeaderError, "Request protocol already specified!" if @request.protocol
@request.protocol = value
elsif key == CONTENT_LENGTH
raise ::Protocol::HTTP2::HeaderError, "Request content length already specified!" if @length
@length = Integer(value)
elsif key == CONNECTION
raise ::Protocol::HTTP2::HeaderError, "Connection header is not allowed!"
elsif key.start_with? ':'
raise ::Protocol::HTTP2::HeaderError, "Invalid pseudo-header #{key}!"
elsif key =~ /[A-Z]/
raise ::Protocol::HTTP2::HeaderError, "Invalid characters in header #{key}!"
else
add_header(key, value)
end
end
@request.headers = @headers
unless @request.valid?
raise ::Protocol::HTTP2::HeaderError, "Request is missing required headers!"
else
# We only construct the input/body if data is coming.
unless end_stream
@request.body = prepare_input(@length)
end
# We are ready for processing:
@connection.requests.enqueue(@request)
end
return headers
end
def closed(error)
@request = nil
super
end
end
def initialize(stream)
super(nil, nil, nil, nil, VERSION, nil)
@stream = stream
end
attr :stream
def connection
@stream.connection
end
def valid?
@scheme and @method and @path
end
def hijack?
false
end
def push?
@stream.connection.enable_push?
end
# @return [Stream] the promised stream, on which to send data.
def push(path, headers = nil, scheme = @scheme, authority = @authority)
raise ArgumentError, "Missing scheme!" unless scheme
raise ArgumentError, "Missing authority!" unless authority
push_headers = [
[SCHEME, scheme],
[METHOD, ::Protocol::HTTP::Methods::GET],
[PATH, path],
[AUTHORITY, authority]
]
if headers
push_headers = Headers::Merged.new(
push_headers,
headers
)
end
@stream.send_push_promise(push_headers)
end
NO_RESPONSE = [
[STATUS, '500'],
]
def send_response(response)
if response.nil?
return @stream.send_headers(nil, NO_RESPONSE, ::Protocol::HTTP2::END_STREAM)
end
protocol_headers = [
[STATUS, response.status],
]
if protocol = response.protocol
protocol_headers << [PROTOCOL, protocol]
end
if length = response.body&.length
protocol_headers << [CONTENT_LENGTH, length]
end
headers = ::Protocol::HTTP::Headers::Merged.new(protocol_headers, response.headers)
if body = response.body and !self.head?
# This function informs the headers object that any subsequent headers are going to be trailers. Therefore, it must be called *before* sending the headers, to avoid any race conditions.
trailers = response.headers.trailers!
@stream.send_headers(nil, headers)
@stream.send_body(body, trailers)
else
# Ensure the response body is closed if we are ending the stream:
response.close
@stream.send_headers(nil, headers, ::Protocol::HTTP2::END_STREAM)
end
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/response.rb 0000664 0000000 0000000 00000016447 13731260101 0024611 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../response'
require_relative 'stream'
module Async
module HTTP
module Protocol
module HTTP2
# Typically used on the client side for writing a request and reading the incoming response.
class Response < Protocol::Response
class Stream < HTTP2::Stream
def initialize(*)
super
@response = Response.new(self)
@notification = Async::Notification.new
@exception = nil
end
attr :response
def wait_for_input
# The input isn't ready until the response headers have been received:
@response.wait
# There is a possible race condition if you try to access @input - it might already be closed and nil.
return @response.body
end
def accept_push_promise_stream(promised_stream_id, headers)
stream = @connection.accept_push_promise_stream(promised_stream_id, &Stream.method(:create))
stream.response.build_request(headers)
@response.promises.enqueue(stream.response)
return stream
end
# This should be invoked from the background reader, and notifies the task waiting for the headers that we are done.
def receive_initial_headers(headers, end_stream)
headers.each do |key, value|
if key == STATUS
@response.status = Integer(value)
elsif key == PROTOCOL
@response.protocol = value
elsif key == CONTENT_LENGTH
@length = Integer(value)
else
add_header(key, value)
end
end
@response.headers = @headers
if @response.valid?
if !end_stream
# We only construct the input/body if data is coming.
@response.body = prepare_input(@length)
elsif @response.head?
@response.body = ::Protocol::HTTP::Body::Head.new(@length)
end
else
send_reset_stream(::Protocol::HTTP2::Error::PROTOCOL_ERROR)
end
self.notify!
return headers
end
# Notify anyone waiting on the response headers to be received (or failure).
def notify!
if notification = @notification
@notification = nil
notification.signal
end
end
# Wait for the headers to be received or for stream reset.
def wait
# If you call wait after the headers were already received, it should return immediately:
@notification&.wait
if @exception
raise @exception
end
end
def closed(error)
super
if @response
@response.promises.enqueue nil
@response = nil
end
@exception = error
notify!
end
end
def initialize(stream)
super(stream.connection.version, nil, nil)
@stream = stream
@request = nil
@promises = nil
end
attr :stream
attr :request
def connection
@stream.connection
end
def wait
@stream.wait
end
def head?
@request&.head?
end
def valid?
!!@status
end
def promises
@promises ||= Async::Queue.new
end
def build_request(headers)
request = ::Protocol::HTTP::Request.new
request.headers = ::Protocol::HTTP::Headers.new
headers.each do |key, value|
if key == SCHEME
raise ::Protocol::HTTP2::HeaderError, "Request scheme already specified!" if request.scheme
request.scheme = value
elsif key == AUTHORITY
raise ::Protocol::HTTP2::HeaderError, "Request authority already specified!" if request.authority
request.authority = value
elsif key == METHOD
raise ::Protocol::HTTP2::HeaderError, "Request method already specified!" if request.method
request.method = value
elsif key == PATH
raise ::Protocol::HTTP2::HeaderError, "Request path is empty!" if value.empty?
raise ::Protocol::HTTP2::HeaderError, "Request path already specified!" if request.path
request.path = value
elsif key.start_with? ':'
raise ::Protocol::HTTP2::HeaderError, "Invalid pseudo-header #{key}!"
else
request.headers[key] = value
end
end
@request = request
end
# Send a request and read it into this response.
def send_request(request)
@request = request
# https://http2.github.io/http2-spec/#rfc.section.8.1.2.3
# All HTTP/2 requests MUST include exactly one valid value for the :method, :scheme, and :path pseudo-header fields, unless it is a CONNECT request (Section 8.3). An HTTP request that omits mandatory pseudo-header fields is malformed (Section 8.1.2.6).
pseudo_headers = [
[SCHEME, request.scheme],
[METHOD, request.method],
[PATH, request.path],
]
# To ensure that the HTTP/1.1 request line can be reproduced accurately, this pseudo-header field MUST be omitted when translating from an HTTP/1.1 request that has a request target in origin or asterisk form (see [RFC7230], Section 5.3). Clients that generate HTTP/2 requests directly SHOULD use the :authority pseudo-header field instead of the Host header field.
if authority = request.authority
pseudo_headers << [AUTHORITY, authority]
end
if protocol = request.protocol
pseudo_headers << [PROTOCOL, protocol]
end
headers = ::Protocol::HTTP::Headers::Merged.new(
pseudo_headers,
request.headers
)
if request.body.nil?
@stream.send_headers(nil, headers, ::Protocol::HTTP2::END_STREAM)
else
# This function informs the headers object that any subsequent headers are going to be trailers. Therefore, it must be called *before* sending the headers, to avoid any race conditions.
trailers = request.headers.trailers!
begin
@stream.send_headers(nil, headers)
rescue
raise RequestFailed
end
@stream.send_body(request.body, trailers)
end
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/server.rb 0000664 0000000 0000000 00000005330 13731260101 0024246 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'connection'
require_relative 'request'
require 'protocol/http2/server'
module Async
module HTTP
module Protocol
module HTTP2
class Server < ::Protocol::HTTP2::Server
include Connection
def initialize(stream)
# Used by some generic methods in Connetion:
@stream = stream
framer = ::Protocol::HTTP2::Framer.new(stream)
super(framer)
@requests = Async::Queue.new
end
attr :requests
def accept_stream(stream_id)
super do
Request::Stream.create(self, stream_id)
end
end
def close(error = nil)
if @requests
# Stop the request loop:
@requests.enqueue(nil)
@requests = nil
end
super
end
def each(task: Task.current)
task.annotate("Reading #{version} requests for #{self.class}.")
# It's possible the connection has died before we get here...
@requests&.async do |task, request|
task.annotate("Incoming request: #{request.method} #{request.path.inspect}.")
@count += 1
begin
response = yield(request)
rescue
# We need to close the stream if the user code blows up while generating a response:
request.stream.send_reset_stream(::Protocol::HTTP2::INTERNAL_ERROR)
raise
else
request.send_response(response)
end
end
# Maybe we should add some synchronisation here - i.e. only exit once all requests are finished.
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/http2/stream.rb 0000664 0000000 0000000 00000013052 13731260101 0024233 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http2/stream'
require_relative 'input'
require_relative 'output'
module Async
module HTTP
module Protocol
module HTTP2
class Stream < ::Protocol::HTTP2::Stream
def initialize(*)
super
@headers = nil
@trailers = nil
# Input buffer, reading request body, or response body (receive_data):
@length = nil
@input = nil
# Output buffer, writing request body or response body (window_updated):
@output = nil
end
attr_accessor :headers
attr :input
def add_header(key, value)
if key == CONNECTION
raise ::Protocol::HTTP2::HeaderError, "Connection header is not allowed!"
elsif key.start_with? ':'
raise ::Protocol::HTTP2::HeaderError, "Invalid pseudo-header #{key}!"
elsif key =~ /[A-Z]/
raise ::Protocol::HTTP2::HeaderError, "Invalid upper-case characters in header #{key}!"
else
@headers.add(key, value)
end
end
def receive_trailing_headers(headers, end_stream)
headers.each do |key, value|
if @trailers.include?(key)
add_header(key, value)
else
raise ::Protocol::HTTP2::HeaderError, "Cannot add trailer #{key} as it was not specified as a trailer!"
end
end
end
def process_headers(frame)
if @headers.nil?
@headers = ::Protocol::HTTP::Headers.new
self.receive_initial_headers(super, frame.end_stream?)
@trailers = @headers[TRAILERS]
elsif @trailers and frame.end_stream?
self.receive_trailing_headers(super, frame.end_stream?)
else
raise ::Protocol::HTTP2::HeaderError, "Unable to process headers!"
end
# TODO this might need to be in an ensure block:
if @input and frame.end_stream?
@input.close($!)
@input = nil
end
rescue ::Protocol::HTTP2::HeaderError => error
Async.logger.error(self, error)
send_reset_stream(error.code)
end
def wait_for_input
return @input
end
# Prepare the input stream which will be used for incoming data frames.
# @return [Input] the input body.
def prepare_input(length)
if @input.nil?
@input = Input.new(self, length)
else
raise ArgumentError, "Input body already prepared!"
end
end
def update_local_window(frame)
consume_local_window(frame)
# This is done on demand in `Input#read`:
# request_window_update
end
def process_data(frame)
data = frame.unpack
if @input
unless data.empty?
@input.write(data)
end
if frame.end_stream?
@input.close
@input = nil
end
end
return data
rescue ::Protocol::HTTP2::ProtocolError
raise
rescue # Anything else...
send_reset_stream(::Protocol::HTTP2::Error::INTERNAL_ERROR)
end
# Set the body and begin sending it.
def send_body(body, trailers = nil)
@output = Output.new(self, body, trailers)
@output.start
end
# Called when the output terminates normally.
def finish_output(error = nil)
trailers = @output&.trailers
@output = nil
if error
send_reset_stream(::Protocol::HTTP2::Error::INTERNAL_ERROR)
else
# Write trailers?
if trailers
send_headers(nil, trailers, ::Protocol::HTTP2::END_STREAM)
else
send_data(nil, ::Protocol::HTTP2::END_STREAM)
end
end
end
def window_updated(size)
super
@output&.window_updated(size)
end
# When the stream transitions to the closed state, this method is called. There are roughly two ways this can happen:
# - A frame is received which causes this stream to enter the closed state. This method will be invoked from the background reader task.
# - A frame is sent which causes this stream to enter the closed state. This method will be invoked from that task.
# While the input stream is relatively straight forward, the output stream can trigger the second case above
def closed(error)
super
if @input
@input.close(error)
@input = nil
end
if @output
@output.stop(error)
@output = nil
end
return self
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/https.rb 0000664 0000000 0000000 00000004736 13731260101 0023052 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'http10'
require_relative 'http11'
require_relative 'http2'
require 'openssl'
unless OpenSSL::SSL::SSLContext.instance_methods.include? :alpn_protocols=
warn "OpenSSL implementation doesn't support ALPN."
class OpenSSL::SSL::SSLContext
def alpn_protocols= names
return names
end
end
class OpenSSL::SSL::SSLSocket
def alpn_protocol
return nil
end
end
end
module Async
module HTTP
module Protocol
# A server that supports both HTTP1.0 and HTTP1.1 semantics by detecting the version of the request.
module HTTPS
HANDLERS = {
"h2" => HTTP2,
"http/1.1" => HTTP11,
"http/1.0" => HTTP10,
nil => HTTP11,
}
def self.protocol_for(peer)
# alpn_protocol is only available if openssl v1.0.2+
name = peer.alpn_protocol
Async.logger.debug(self) {"Negotiating protocol #{name.inspect}..."}
if protocol = HANDLERS[name]
return protocol
else
raise ArgumentError, "Could not determine protocol for connection (#{name.inspect})."
end
end
def self.client(peer)
protocol_for(peer).client(peer)
end
def self.server(peer)
protocol_for(peer).server(peer)
end
# Supported Application Layer Protocol Negotiation names:
def self.names
HANDLERS.keys.compact
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/request.rb 0000664 0000000 0000000 00000003640 13731260101 0023371 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/request'
require 'protocol/http/headers'
require_relative '../body/writable'
module Async
module HTTP
module Protocol
# Failed to send the request. The request body has NOT been consumed (i.e. #read) and you should retry the request.
class RequestFailed < StandardError
end
# This is generated by server protocols.
class Request < ::Protocol::HTTP::Request
def connection
nil
end
def hijack?
false
end
def push?
false
end
def peer
if connection = self.connection
connection.peer
end
end
def remote_address
@remote_address ||= peer.remote_address
end
def remote_address= value
@remote_address = value
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/protocol/response.rb 0000664 0000000 0000000 00000003264 13731260101 0023541 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/response'
require_relative '../body/writable'
module Async
module HTTP
module Protocol
# This is generated by client protocols.
class Response < ::Protocol::HTTP::Response
def connection
nil
end
def hijack?
false
end
def peer
if connection = self.connection
connection.peer
end
end
def remote_address
@remote_address ||= peer.remote_address
end
def remote_address= value
@remote_address = value
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/proxy.rb 0000664 0000000 0000000 00000010215 13731260101 0021215 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require_relative 'client'
require_relative 'endpoint'
require_relative 'body/pipe'
module Async
module HTTP
# Wraps a client, address and headers required to initiate a connectio to a remote host using the CONNECT verb.
# Behaves like a TCP endpoint for the purposes of connecting to a remote host.
class Proxy
module Client
def proxy(endpoint, headers = nil)
Proxy.new(self, endpoint.authority(false), headers)
end
# Create a client that will proxy requests through the current client.
def proxied_client(endpoint, headers = nil)
proxy = self.proxy(endpoint, headers)
return self.class.new(proxy.wrap_endpoint(endpoint))
end
def proxied_endpoint(endpoint, headers = nil)
proxy = self.proxy(endpoint, headers)
return proxy.wrap_endpoint(endpoint)
end
end
# Prepare and endpoint which can establish a TCP connection to the remote system.
# @param client [Async::HTTP::Client] the client which will be used as a proxy server.
# @param host [String] the hostname or address to connect to.
# @param port [String] the port number to connect to.
# @param headers [Array] an optional list of headers to use when establishing the connection.
# @see Async::IO::Endpoint#tcp
def self.tcp(client, host, port, headers = nil)
self.new(client, "#{host}:#{port}", headers)
end
# Construct a endpoint that will use the given client as a proxy for HTTP requests.
# @param client [Async::HTTP::Client] the client which will be used as a proxy server.
# @param endpoint [Async::HTTP::Endpoint] the endpoint to connect to.
# @param headers [Array] an optional list of headers to use when establishing the connection.
def self.endpoint(client, endpoint, headers = nil)
proxy = self.new(client, endpoint.authority(false), headers)
return proxy.endpoint(endpoint.url)
end
# @param client [Async::HTTP::Client] the client which will be used as a proxy server.
# @param address [String] the address to connect to.
# @param headers [Array] an optional list of headers to use when establishing the connection.
def initialize(client, address, headers = nil)
@client = client
@address = address
@headers = ::Protocol::HTTP::Headers[headers].freeze
end
attr :client
# Close the underlying client connection.
def close
@client.close
end
# Establish a TCP connection to the specified host.
# @return [Socket] a connected bi-directional socket.
def connect(&block)
input = Body::Writable.new
response = @client.connect(@address.to_s, @headers, input)
pipe = Body::Pipe.new(response.body, input)
return pipe.to_io unless block_given?
begin
yield pipe.to_io
ensure
pipe.close
end
end
# @return [Async::HTTP::Endpoint] an endpoint that connects via the specified proxy.
def wrap_endpoint(endpoint)
Endpoint.new(endpoint.url, self, **endpoint.options)
end
end
Client.prepend(Proxy::Client)
end
end
ruby-async-http-0.52.5/lib/async/http/reference.rb 0000664 0000000 0000000 00000002375 13731260101 0022002 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/reference'
module Async
module HTTP
Reference = ::Protocol::HTTP::Reference
end
end
ruby-async-http-0.52.5/lib/async/http/relative_location.rb 0000664 0000000 0000000 00000005031 13731260101 0023537 0 ustar 00root root 0000000 0000000 # Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'client'
require_relative 'endpoint'
require_relative 'reference'
require 'protocol/http/middleware'
module Async
module HTTP
class TooManyRedirects < StandardError
end
# A client wrapper which transparently handles both relative and absolute redirects to a given maximum number of hops.
class RelativeLocation < ::Protocol::HTTP::Middleware
DEFAULT_METHOD = GET
# maximum_hops is the max number of redirects. Set to 0 to allow 1 request with no redirects.
def initialize(app, maximum_hops = 3)
super(app)
@maximum_hops = maximum_hops
end
# The maximum number of hops which will limit the number of redirects until an error is thrown.
attr :maximum_hops
def call(request)
hops = 0
# We need to cache the body as it might be submitted multiple times.
request.finish
while hops <= @maximum_hops
response = super(request)
if response.redirection?
hops += 1
response.finish
location = response.headers['location']
uri = URI.parse(location)
if uri.absolute?
return response
else
request.path = Reference[request.path] + location
end
unless response.preserve_method?
request.method = DEFAULT_METHOD
end
else
return response
end
end
raise TooManyRedirects, "Redirected #{hops} times, exceeded maximum!"
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/server.rb 0000775 0000000 0000000 00000004771 13731260101 0021357 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'async/io/endpoint'
require 'async/io/stream'
require_relative 'protocol'
require 'protocol/http/middleware'
module Async
module HTTP
class Server < ::Protocol::HTTP::Middleware
def self.for(*arguments, &block)
self.new(block, *arguments)
end
def initialize(app, endpoint, protocol = endpoint.protocol, scheme = endpoint.scheme)
super(app)
@endpoint = endpoint
@protocol = protocol
@scheme = scheme
end
attr :endpoint
attr :protocol
attr :scheme
def accept(peer, address, task: Task.current)
connection = @protocol.server(peer)
Async.logger.debug(self) {"Incoming connnection from #{address.inspect} to #{@protocol}"}
connection.each do |request|
# We set the default scheme unless it was otherwise specified.
# https://tools.ietf.org/html/rfc7230#section-5.5
request.scheme ||= self.scheme
# This is a slight optimization to avoid having to get the address from the socket.
request.remote_address = address
# Async.logger.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
# If this returns nil, we assume that the connection has been hijacked.
self.call(request)
end
ensure
connection&.close
end
def run
@endpoint.accept(&self.method(:accept))
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/statistics.rb 0000664 0000000 0000000 00000006255 13731260101 0022237 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'protocol/http/body/wrapper'
require 'async/clock'
module Async
module HTTP
class Statistics
def self.start
self.new(Clock.now)
end
def initialize(start_time)
@start_time = start_time
end
def wrap(response, &block)
if response and response.body
response.body = Body::Statistics.new(@start_time, response.body, block)
end
return response
end
end
module Body
# Invokes a callback once the body has finished reading.
class Statistics < ::Protocol::HTTP::Body::Wrapper
def initialize(start_time, body, callback)
super(body)
@sent = 0
@start_time = start_time
@first_chunk_time = nil
@end_time = nil
@callback = callback
end
attr :start_time
attr :first_chunk_time
attr :end_time
attr :sent
def total_duration
if @end_time
@end_time - @start_time
end
end
def first_chunk_duration
if @first_chunk_time
@first_chunk_time - @start_time
end
end
def close(error = nil)
complete_statistics(error)
super
end
def read
chunk = super
@first_chunk_time ||= Clock.now
if chunk
@sent += chunk.bytesize
end
return chunk
end
def to_s
parts = ["sent #{@sent} bytes"]
if duration = self.total_duration
parts << "took #{format_duration(duration)} in total"
end
if duration = self.first_chunk_duration
parts << "took #{format_duration(duration)} until first chunk"
end
return parts.join('; ')
end
def inspect
"#{super} | \#<#{self.class} #{self.to_s}>"
end
private
def complete_statistics(error = nil)
@end_time = Clock.now
@callback.call(self, error) if @callback
end
def format_duration(seconds)
if seconds < 1.0
return "#{(seconds * 1000.0).round(2)}ms"
else
return "#{seconds.round(1)}s"
end
end
end
end
end
end
ruby-async-http-0.52.5/lib/async/http/version.rb 0000664 0000000 0000000 00000002305 13731260101 0021522 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
#
# Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
module Async
module HTTP
VERSION = "0.52.5"
end
end
ruby-async-http-0.52.5/spec/ 0000775 0000000 0000000 00000000000 13731260101 0015600 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/async/ 0000775 0000000 0000000 00000000000 13731260101 0016715 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/async/http/ 0000775 0000000 0000000 00000000000 13731260101 0017674 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/async/http/body/ 0000775 0000000 0000000 00000000000 13731260101 0020631 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/async/http/body/hijack_spec.rb 0000664 0000000 0000000 00000003563 13731260101 0023430 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/body/hijack'
RSpec.describe Async::HTTP::Body::Hijack do
include_context Async::RSpec::Reactor
let(:content) {"Hello World!"}
describe '#call' do
let(:stream) {Async::HTTP::Body::Writable.new}
subject do
described_class.new do |stream|
3.times do
stream.write(content)
end
stream.close
end
end
it "should generate body using direct invocation" do
subject.call(stream)
3.times do
expect(stream.read).to be == content
end
expect(stream.read).to be_nil
expect(stream).to be_empty
end
it "should generate body using stream" do
3.times do
expect(subject.read).to be == content
end
expect(subject.read).to be_nil
expect(subject).to be_empty
end
end
end
ruby-async-http-0.52.5/spec/async/http/body/slowloris_spec.rb 0000664 0000000 0000000 00000003333 13731260101 0024227 0 ustar 00root root 0000000 0000000 # Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require_relative 'writable_examples'
require 'async/http/body/slowloris'
RSpec.describe Async::HTTP::Body::Slowloris do
include_context Async::RSpec::Reactor
it_behaves_like Async::HTTP::Body::Writable
it "closes body with error if throughput is not maintained" do
subject.write("Hello World")
sleep 0.1
expect do
subject.write("Hello World")
end.to raise_error(Async::HTTP::Body::Slowloris::ThroughputError, /Slow write/)
end
it "doesn't close body if throughput is exceeded" do
subject.write("Hello World")
expect do
subject.write("Hello World")
end.to_not raise_error
end
end
ruby-async-http-0.52.5/spec/async/http/body/writable_examples.rb 0000664 0000000 0000000 00000006621 13731260101 0024672 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/server'
require 'async/http/client'
require 'async/reactor'
require 'async/http/body'
require 'protocol/http/body/deflate'
require 'async/http/body/writable'
require 'async/http/endpoint'
require 'async/io/ssl_socket'
require 'async/rspec/ssl'
RSpec.shared_examples_for Async::HTTP::Body::Writable do
it "can write and read data" do
3.times do |i|
subject.write("Hello World #{i}")
expect(subject.read).to be == "Hello World #{i}"
end
end
it "can buffer data in order" do
3.times do |i|
subject.write("Hello World #{i}")
end
3.times do |i|
expect(subject.read).to be == "Hello World #{i}"
end
end
context '#join' do
it "can join chunks" do
3.times do |i|
subject.write("#{i}")
end
subject.close
expect(subject.join).to be == "012"
end
end
context '#each' do
it "can read all data in order" do
3.times do |i|
subject.write("Hello World #{i}")
end
subject.close
3.times do |i|
chunk = subject.read
expect(chunk).to be == "Hello World #{i}"
end
end
it "can propagate failures" do
reactor.async do
expect do
subject.each do |chunk|
raise RuntimeError.new("It was too big!")
end
end.to raise_error(RuntimeError, /big/)
end
expect{
subject.write("Beep boop") # This will cause a failure.
Async::Task.current.yield
subject.write("Beep boop") # This will fail.
}.to raise_error(RuntimeError, /big/)
end
it "can propagate failures in nested bodies" do
nested = Protocol::HTTP::Body::Deflate.for(subject)
reactor.async do
expect do
nested.each do |chunk|
raise RuntimeError.new("It was too big!")
end
end.to raise_error(RuntimeError, /big/)
end
expect{
subject.write("Beep boop") # This will cause a failure.
Async::Task.current.yield
subject.write("Beep boop") # This will fail.
}.to raise_error(RuntimeError, /big/)
end
it "will stop after finishing" do
output_task = reactor.async do
subject.each do |chunk|
expect(chunk).to be == "Hello World!"
end
end
subject.write("Hello World!")
subject.close
expect(subject).to_not be_empty
Async::Task.current.yield
expect(output_task).to be_finished
expect(subject).to be_empty
end
end
end
ruby-async-http-0.52.5/spec/async/http/body/writable_spec.rb 0000664 0000000 0000000 00000002433 13731260101 0024003 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative 'writable_examples'
RSpec.describe Async::HTTP::Body::Writable do
include_context Async::RSpec::Reactor
it_behaves_like Async::HTTP::Body::Writable
end
ruby-async-http-0.52.5/spec/async/http/body_spec.rb 0000664 0000000 0000000 00000010013 13731260101 0022163 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/body'
require 'async/http/server'
require 'async/http/client'
require 'async/http/endpoint'
require 'async/io/ssl_socket'
require 'async/rspec/reactor'
require 'async/rspec/ssl'
RSpec.shared_examples Async::HTTP::Body do
let(:client) {Async::HTTP::Client.new(client_endpoint, described_class)}
it "can stream requests" do
server = Async::HTTP::Server.for(server_endpoint, described_class) do |request|
input = request.body
output = Async::HTTP::Body::Writable.new
Async::Task.current.async do |task|
input.each do |chunk|
output.write(chunk.reverse)
end
output.close
end
Protocol::HTTP::Response[200, [], output]
end
server_task = reactor.async do
server.run
end
output = Async::HTTP::Body::Writable.new
reactor.async do |task|
output.write("Hello World!")
output.close
end
response = client.post("/", {}, output)
expect(response).to be_success
expect(response.read).to be == "!dlroW olleH"
server_task.stop
client.close
end
it "can stream response" do
notification = Async::Notification.new
server = Async::HTTP::Server.for(server_endpoint, described_class) do |request|
body = Async::HTTP::Body::Writable.new
Async::Task.current.async do |task|
10.times do |i|
body.write("#{i}")
notification.wait
end
body.close
end
Protocol::HTTP::Response[200, {}, body]
end
server_task = reactor.async do
server.run
end
response = client.get("/")
expect(response).to be_success
j = 0
# This validates interleaving
response.body.each do |line|
expect(line.to_i).to be == j
j += 1
notification.signal
end
server_task.stop
client.close
end
end
RSpec.describe Async::HTTP::Protocol::HTTP1, timeout: 2 do
include_context Async::RSpec::Reactor
let(:endpoint) {Async::HTTP::Endpoint.parse('http://127.0.0.1:9296', reuse_port: true)}
let(:client_endpoint) {endpoint}
let(:server_endpoint) {endpoint}
it_should_behave_like Async::HTTP::Body
end
RSpec.describe Async::HTTP::Protocol::HTTPS, timeout: 2 do
include_context Async::RSpec::Reactor
include_context Async::RSpec::SSL::ValidCertificate
let(:server_context) do
OpenSSL::SSL::SSLContext.new.tap do |context|
context.cert = certificate
context.alpn_select_cb = lambda do |protocols|
protocols.first
end
context.key = key
end
end
let(:client_context) do
OpenSSL::SSL::SSLContext.new.tap do |context|
context.cert_store = certificate_store
context.alpn_protocols = ['h2']
context.verify_mode = OpenSSL::SSL::VERIFY_PEER
end
end
# Shared port for localhost network tests.
let(:server_endpoint) {Async::HTTP::Endpoint.parse("https://localhost:9296", ssl_context: server_context)}
let(:client_endpoint) {Async::HTTP::Endpoint.parse("https://localhost:9296", ssl_context: client_context)}
it_should_behave_like Async::HTTP::Body
end ruby-async-http-0.52.5/spec/async/http/client/ 0000775 0000000 0000000 00000000000 13731260101 0021152 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/async/http/client/google_spec.rb 0000664 0000000 0000000 00000003050 13731260101 0023763 0 ustar 00root root 0000000 0000000 # Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'async/http/client'
require 'async/http/endpoint'
RSpec.describe Async::HTTP::Client, timeout: 5 do
include_context Async::RSpec::Reactor
let(:endpoint) {Async::HTTP::Endpoint.parse('https://www.google.com')}
let(:client) {Async::HTTP::Client.new(endpoint)}
it 'can fetch remote resource' do
response = client.get('/', 'accept' => '*/*')
response.finish
expect(response).to_not be_failure
client.close
end
end
ruby-async-http-0.52.5/spec/async/http/client_spec.rb 0000664 0000000 0000000 00000005477 13731260101 0022526 0 ustar 00root root 0000000 0000000 # Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'server_context'
require 'async/http/server'
require 'async/http/client'
require 'async/reactor'
require 'async/io/ssl_socket'
require 'async/http/endpoint'
require 'protocol/http/accept_encoding'
RSpec.describe Async::HTTP::Client, timeout: 5 do
describe Async::HTTP::Protocol::HTTP1 do
include_context Async::HTTP::Server
it "client can get resource" do
response = client.get("/")
response.read
expect(response).to be_success
end
end
context 'non-existant host' do
include_context Async::RSpec::Reactor
let(:endpoint) {Async::HTTP::Endpoint.parse('http://the.future')}
let(:client) {Async::HTTP::Client.new(endpoint)}
it "should fail to connect" do
expect do
client.get("/")
end.to raise_error(SocketError, /not known/)
end
end
describe Async::HTTP::Protocol::HTTPS do
include_context Async::RSpec::Reactor
let(:endpoint) {Async::HTTP::Endpoint.parse('https://www.codeotaku.com')}
let(:client) {Async::HTTP::Client.new(endpoint)}
it "should specify hostname" do
expect(endpoint.hostname).to be == "www.codeotaku.com"
expect(client.authority).to be == "www.codeotaku.com"
end
it "can request remote resource" do
2.times do
response = client.get("/index")
expect(response).to be_success
response.finish
end
client.close
end
it "can request remote resource with compression" do
compressor = Protocol::HTTP::AcceptEncoding.new(client)
response = compressor.get("/index", {'accept-encoding' => 'gzip'})
expect(response).to be_success
expect(response.body).to be_kind_of Async::HTTP::Body::Inflate
expect(response.read).to be_start_with('')
client.close
end
end
end
ruby-async-http-0.52.5/spec/async/http/endpoint_spec.rb 0000664 0000000 0000000 00000011035 13731260101 0023053 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/endpoint'
RSpec.describe Async::HTTP::Endpoint do
it "should fail to parse relative url" do
expect{
described_class.parse("/foo/bar")
}.to raise_error(ArgumentError, /absolute/)
end
describe '#port' do
let(:url_string) {"https://localhost:9292"}
it "extracts port from URL" do
endpoint = Async::HTTP::Endpoint.parse(url_string)
expect(endpoint.port).to eq 9292
end
it "extracts port from options" do
endpoint = Async::HTTP::Endpoint.parse(url_string, port: 9000)
expect(endpoint.port).to eq 9000
end
end
describe '#hostname' do
describe Async::HTTP::Endpoint.parse("https://127.0.0.1:9292") do
it {is_expected.to have_attributes(hostname: '127.0.0.1')}
it "should be connecting to 127.0.0.1" do
expect(subject.endpoint).to be_a Async::IO::SSLEndpoint
expect(subject.endpoint).to have_attributes(hostname: '127.0.0.1')
expect(subject.endpoint.endpoint).to have_attributes(hostname: '127.0.0.1')
end
end
describe Async::HTTP::Endpoint.parse("https://127.0.0.1:9292", hostname: 'localhost') do
it {is_expected.to have_attributes(hostname: 'localhost')}
it {is_expected.to_not be_localhost}
it "should be connecting to localhost" do
expect(subject.endpoint).to be_a Async::IO::SSLEndpoint
expect(subject.endpoint).to have_attributes(hostname: '127.0.0.1')
expect(subject.endpoint.endpoint).to have_attributes(hostname: 'localhost')
end
end
end
describe '.for' do
context Async::HTTP::Endpoint.for("http", "localhost") do
it {is_expected.to have_attributes(scheme: "http", hostname: "localhost")}
it {is_expected.to_not be_secure}
end
end
describe '#secure?' do
subject {Async::HTTP::Endpoint.parse(description)}
context 'http://localhost' do
it { is_expected.to_not be_secure }
end
context 'https://localhost' do
it { is_expected.to be_secure }
end
context 'with scheme: https' do
subject {Async::HTTP::Endpoint.parse("http://localhost", scheme: 'https')}
it { is_expected.to be_secure }
end
end
describe '#localhost?' do
subject {Async::HTTP::Endpoint.parse(description)}
context 'http://localhost' do
it { is_expected.to be_localhost }
end
context 'http://hello.localhost' do
it { is_expected.to be_localhost }
end
context 'http://localhost.' do
it { is_expected.to be_localhost }
end
context 'http://hello.localhost.' do
it { is_expected.to be_localhost }
end
context 'http://localhost.com' do
it { is_expected.to_not be_localhost }
end
end
describe '#path' do
it "can normal urls" do
endpoint = Async::HTTP::Endpoint.parse("http://foo.com/bar?baz")
expect(endpoint.path).to be == "/bar?baz"
end
it "can handle websocket urls" do
endpoint = Async::HTTP::Endpoint.parse("wss://foo.com/bar?baz")
expect(endpoint.path).to be == "/bar?baz"
end
end
end
RSpec.describe "http://www.google.com/search" do
let(:endpoint) {Async::HTTP::Endpoint.parse(subject)}
it "should be valid endpoint" do
expect{endpoint}.to_not raise_error
end
it "should select the correct protocol" do
expect(endpoint.protocol).to be Async::HTTP::Protocol::HTTP1
end
it "should parse the correct hostname" do
expect(endpoint.hostname).to be == "www.google.com"
end
it "should not be equal if path is different" do
other = Async::HTTP::Endpoint.parse('http://www.google.com/search?q=ruby')
expect(endpoint).to_not be_eql other
end
end
ruby-async-http-0.52.5/spec/async/http/internet_spec.rb 0000664 0000000 0000000 00000003462 13731260101 0023070 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/internet'
require 'async/reactor'
require 'json'
RSpec.describe Async::HTTP::Internet, timeout: 5 do
include_context Async::RSpec::Reactor
let(:headers) {[['accept', '*/*'], ['user-agent', 'async-http']]}
after do
subject.close
end
it "can fetch remote website" do
response = subject.get("https://www.codeotaku.com/index", headers)
expect(response).to be_success
response.close
end
let(:sample) {{"hello" => "world"}}
let(:body) {[JSON.dump(sample)]}
it "can fetch remote json" do
response = subject.post("https://httpbin.org/anything", headers, body)
expect(response).to be_success
expect{JSON.parse(response.read)}.to_not raise_error
end
end
ruby-async-http-0.52.5/spec/async/http/performance_spec.rb 0000775 0000000 0000000 00000005634 13731260101 0023547 0 ustar 00root root 0000000 0000000 # Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require 'async/http/server'
require 'async/http/client'
require 'async/http/endpoint'
require 'async/io/shared_endpoint'
require 'async/reactor'
require 'async/container'
require 'etc'
require 'benchmark'
RSpec.shared_examples_for 'client benchmark' do
let(:endpoint) {Async::HTTP::Endpoint.parse("http://127.0.0.1:9294")}
let(:url) {endpoint.url.to_s}
let(:protocol) {Async::HTTP::Protocol::HTTP1}
let(:concurrency) {Etc.nprocessors rescue 2}
# TODO making this higher causes issues in connect - what's the issue?
let(:repeats) {200}
let(:client) {Async::HTTP::Client.new(endpoint, protocol)}
let(:bound_endpoint) do
Async::Reactor.run do
Async::IO::SharedEndpoint.bound(endpoint)
end.wait
end
before(:all) do
GC.disable
end
after(:all) do
GC.enable
end
it "runs benchmark" do
server
container = Async::Container.new
container.run(count: concurrency) do
server.run
end
bound_endpoint&.close
if ab = `which ab`.chomp!
# puts [ab, "-n", (concurrency*repeats).to_s, "-c", concurrency.to_s, url].join(' ')
system(ab, "-k", "-n", (concurrency*repeats).to_s, "-c", concurrency.to_s, url)
end
if wrk = `which wrk`.chomp!
system(wrk, "-c", concurrency.to_s, "-d", "2", "-t", concurrency.to_s, url)
end
container.stop(false)
end
end
RSpec.describe Async::HTTP::Server do
describe Protocol::HTTP::Middleware::Okay do
let(:server) do
Async::HTTP::Server.new(
Protocol::HTTP::Middleware::Okay,
bound_endpoint, protocol, endpoint.scheme
)
end
include_examples 'client benchmark'
end
describe 'multiple chunks' do
let(:server) do
Async::HTTP::Server.for(bound_endpoint, protocol, endpoint.scheme) do
Protocol::HTTP::Response[200, {}, "Hello World".chars]
end
end
include_examples 'client benchmark'
end
end
ruby-async-http-0.52.5/spec/async/http/protocol/ 0000775 0000000 0000000 00000000000 13731260101 0021535 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/async/http/protocol/http10_spec.rb 0000664 0000000 0000000 00000002435 13731260101 0024220 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/protocol/http10'
require_relative 'shared_examples'
RSpec.describe Async::HTTP::Protocol::HTTP10, timeout: 2 do
it_behaves_like Async::HTTP::Protocol
end
ruby-async-http-0.52.5/spec/async/http/protocol/http11_spec.rb 0000775 0000000 0000000 00000004324 13731260101 0024223 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/protocol/http11'
require_relative 'shared_examples'
RSpec.describe Async::HTTP::Protocol::HTTP11, timeout: 2 do
it_behaves_like Async::HTTP::Protocol
context 'head request' do
include_context Async::HTTP::Server
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[200, {}, ["Hello", "World"]]
end
end
it "doesn't reply with body" do
5.times do
response = client.head("/")
expect(response).to be_success
expect(response.version).to be == "HTTP/1.1"
expect(response.body).to be_empty
response.read
end
end
end
context 'raw response' do
include_context Async::HTTP::Server
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
peer = request.hijack!
peer.write(
"#{request.version} 200 It worked!\r\n" +
"connection: close\r\n" +
"\r\n" +
"Hello World!"
)
peer.close
nil
end
end
it "reads raw response" do
response = client.get("/")
expect(response.read).to be == "Hello World!"
end
end
end
ruby-async-http-0.52.5/spec/async/http/protocol/http2_spec.rb 0000664 0000000 0000000 00000010774 13731260101 0024146 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/protocol/http2'
require_relative 'shared_examples'
RSpec.describe Async::HTTP::Protocol::HTTP2, timeout: 2 do
it_behaves_like Async::HTTP::Protocol
context 'bad requests' do
include_context Async::HTTP::Server
it "should fail with explicit authority" do
expect do
client.post("/", [[':authority', 'foo']])
end.to raise_error(Protocol::HTTP2::StreamError)
end
end
context 'closed streams' do
include_context Async::HTTP::Server
it 'should delete stream after response stream is closed' do
response = client.get("/")
connection = response.connection
response.read
expect(connection.streams).to be_empty
end
end
context 'host header' do
include_context Async::HTTP::Server
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[200, request.headers, ["Authority: #{request.authority.inspect}"]]
end
end
# We specify nil for the authority - it won't be sent.
let!(:client) {Async::HTTP::Client.new(endpoint, protocol, endpoint.scheme, nil)}
it "should not send :authority header if host header is present" do
response = client.post("/", [['host', 'foo']])
expect(response.headers).to include('host')
expect(response.headers['host']).to be == 'foo'
# TODO Should HTTP/2 respect host header?
expect(response.read).to be == "Authority: nil"
end
end
context 'stopping requests' do
include_context Async::HTTP::Server
let(:notification) {Async::Notification.new}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
body = Async::HTTP::Body::Writable.new
reactor.async do |task|
begin
100.times do |i|
body.write("Chunk #{i}")
task.sleep (0.01)
end
rescue
# puts "Response generation failed: #{$!}"
ensure
body.close
notification.signal
end
end
Protocol::HTTP::Response[200, {}, body]
end
end
let(:pool) {client.pool}
it "should close stream without closing connection" do
expect(pool).to be_empty
response = client.get("/")
expect(pool).to_not be_empty
response.close
notification.wait
expect(response.stream.connection).to be_reusable
end
end
context 'push promises' do
include_context Async::HTTP::Server
let(:protocol) {described_class::WithPush}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
if request.path == "/index.html"
stream = request.push('/index.css')
expect(stream.headers).to_not be_nil
end
Protocol::HTTP::Response[200, {}, ["Path: #{request.path}"]]
end
end
it "can send push promises" do
response = client.get("/index.html")
expect(response).to be_success
expect(response.read).to be == "Path: /index.html"
promise = response.promises.dequeue
expect(promise.request.path).to be == '/index.css'
expect(promise.request.headers).to_not be_nil
expect(promise.headers).to_not be_nil
promise.wait # Wait for the promise to complete
expect(promise).to be_success
expect(promise.read).to be == "Path: /index.css"
end
it "doesn't sent push promises" do
response = client.get("/index.aspx")
expect(response).to be_success
expect(response.read).to be == "Path: /index.aspx"
promise = response.promises.dequeue
expect(promise).to be_nil
end
end
end
ruby-async-http-0.52.5/spec/async/http/protocol/shared_examples.rb 0000664 0000000 0000000 00000027533 13731260101 0025240 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require_relative '../server_context'
require 'async'
require 'async/clock'
require 'async/http/client'
require 'async/http/server'
require 'async/http/endpoint'
require 'async/http/body/hijack'
require 'tempfile'
require 'protocol/http/body/file'
require 'async/rspec/profile'
RSpec.shared_examples_for Async::HTTP::Protocol do
include_context Async::HTTP::Server
it "should have valid scheme" do
expect(client.scheme).to be == "http"
end
context "huge body", timeout: 600 do
let(:body) {Protocol::HTTP::Body::File.open("/dev/zero", size: 512*1024**2)}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[200, {}, body]
end
end
it "client can download data quickly" do |example|
response = client.get("/")
expect(response).to be_success
data_size = 0
duration = Async::Clock.measure do
while chunk = response.body.read
data_size += chunk.bytesize
chunk.clear
end
response.finish
end
size_mbytes = data_size / 1024**2
example.reporter.message "Data size: #{size_mbytes}MB Duration: #{duration.round(2)}s Throughput: #{(size_mbytes / duration).round(2)}MB/s"
end
end
context 'buffered body' do
let(:body) {Async::HTTP::Body::Buffered.new(["Hello World"])}
let(:response) {Protocol::HTTP::Response[200, {}, body]}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
response
end
end
it "response body should be closed" do
expect(body).to receive(:close).and_call_original
# expect(response).to receive(:close).and_call_original
expect(client.get("/", {}).read).to be == "Hello World"
end
end
context 'empty body' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[204]
end
end
it 'properly handles no content responses' do
expect(client.get("/", {}).read).to be_nil
end
end
context 'with trailers', if: described_class.bidirectional? do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
if trailers = request.headers['trailers']
expect(request.headers).to_not include('etag')
request.finish
expect(request.headers).to include('etag')
Protocol::HTTP::Response[200, [], "request trailers"]
else
headers = Protocol::HTTP::Headers.new
headers.add('trailers', 'etag')
body = Async::HTTP::Body::Writable.new
Async do |task|
body.write("response trailers")
task.sleep(0.01)
headers.add('etag', 'abcd')
body.close
end
Protocol::HTTP::Response[200, headers, body]
end
end
end
it "can send request trailers" do
headers = Protocol::HTTP::Headers.new
headers.add('trailers', 'etag')
body = Async::HTTP::Body::Writable.new
Async do |task|
body.write("Hello")
task.sleep(0.01)
headers.add('etag', 'abcd')
body.close
end
response = client.post("/", headers, body)
expect(response.read).to be == "request trailers"
expect(response).to be_success
end
it "can receive response trailers" do
response = client.get("/")
expect(response.headers).to include('trailers')
headers = response.headers
expect(headers).to_not include('etag')
expect(response.read).to be == "response trailers"
expect(response).to be_success
# It was sent as a trailer.
expect(headers).to include('etag')
end
end
context 'with working server' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
if request.method == 'POST'
# We stream the request body directly to the response.
Protocol::HTTP::Response[200, {}, request.body]
elsif request.method == 'GET'
expect(request.body).to be nil
Protocol::HTTP::Response[200, {
'remote-address' => request.remote_address.inspect
}, ["#{request.method} #{request.version}"]]
else
Protocol::HTTP::Response[200, {}, ["Hello World"]]
end
end
end
it "should have valid scheme" do
expect(server.scheme).to be == "http"
end
it "disconnects slow clients" do
response = client.get("/")
response.read
# We expect this connection to be closed:
connection = response.connection
reactor.sleep(1.0)
response = client.get("/")
response.read
expect(connection).to_not be_reusable
# client.close
# reactor.sleep(0.1)
# reactor.print_hierarchy
end
context 'using GET method' do
let(:expected) {"GET #{protocol::VERSION}"}
it "can handle many simultaneous requests", timeout: nil do |example|
duration = Async::Clock.measure do
10.times do
tasks = 100.times.collect do
Async do
client.get("/")
end
end
tasks.each do |task|
response = task.wait
expect(response).to be_success
expect(response.read).to eq expected
end
end
end
example.reporter.message "Pool: #{client.pool}"
example.reporter.message "Duration = #{duration.round(2)}"
end
context 'with response' do
let(:response) {client.get("/")}
after {response.finish}
it "can finish gracefully" do
expect(response).to be_success
end
it "is successful" do
expect(response).to be_success
expect(response.read).to eq expected
end
it "provides content length" do
expect(response.body.length).to_not be_nil
end
let(:tempfile) {Tempfile.new}
it "can save to disk" do
response.save(tempfile.path)
expect(tempfile.read).to eq expected
tempfile.close
end
it "has remote-address header" do
expect(response.headers['remote-address']).to_not be_nil
end
it "has protocol version" do
expect(response.version).to_not be_nil
end
end
end
context 'HEAD' do
let(:response) {client.head("/")}
after {response.finish}
it "is successful and without body" do
expect(response).to be_success
expect(response.body).to_not be_nil
expect(response.body).to be_empty
expect(response.body.length).to_not be_nil
expect(response.read).to be_nil
end
end
context 'POST' do
let(:response) {client.post("/", {}, ["Hello", " ", "World"])}
after {response.finish}
it "is successful" do
expect(response).to be_success
expect(response.read).to be == "Hello World"
expect(client.pool).to_not be_busy
end
it "can buffer response" do
buffer = response.finish
expect(buffer.join).to be == "Hello World"
expect(client.pool).to_not be_busy
end
it "should not contain content-length response header" do
expect(response.headers).to_not include('content-length')
end
it "fails gracefully when closing connection" do
client.pool.acquire do |connection|
connection.stream.close
end
end
end
end
context 'hijack with nil response' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
nil
end
end
it "fails with appropriate error" do
response = client.get("/")
expect(response).to be_server_failure
end
end
context 'partial hijack' do
let(:content) {"Hello World!"}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Async::HTTP::Body::Hijack.response(request, 200, {}) do |stream|
stream.write content
stream.write content
stream.close
end
end
end
it "reads hijacked body" do
response = client.get("/")
expect(response.read).to be == (content*2)
end
end
context 'body with incorrect length' do
let(:bad_body) {Async::HTTP::Body::Buffered.new(["Borked"], 10)}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[200, {}, bad_body]
end
end
it "fails with appropriate error" do
response = client.get("/")
expect do
response.read
end.to raise_error(EOFError)
end
end
context 'streaming server' do
let!(:sent_chunks) {[]}
let(:server) do
chunks = sent_chunks
Async::HTTP::Server.for(endpoint, protocol) do |request|
body = Async::HTTP::Body::Writable.new
Async::Reactor.run do |task|
10.times do |i|
chunk = "Chunk #{i}"
chunks << chunk
body.write chunk
task.sleep 0.25
end
body.finish
end
Protocol::HTTP::Response[200, {}, body]
end
end
it "can cancel response" do
response = client.get("/")
expect(response.body.read).to be == "Chunk 0"
response.close
expect(sent_chunks).to be == ["Chunk 0"]
end
end
context 'hijack server' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
if request.hijack?
io = request.hijack!
io.write "HTTP/1.1 200 Okay\r\nContent-Length: 16\r\n\r\nHijack Succeeded"
io.flush
io.close
else
Protocol::HTTP::Response[200, {}, ["Hijack Failed"]]
end
end
end
it "will hijack response if possible" do
response = client.get("/")
expect(response.read).to include("Hijack")
end
end
context 'broken server' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
raise RuntimeError.new('simulated failure')
end
end
it "can't get /" do
expect do
response = client.get("/")
end.to raise_error(Exception)
end
end
context 'slow server' do
let(:endpoint) {Async::HTTP::Endpoint.parse('http://127.0.0.1:9294', reuse_port: true, timeout: 0.1)}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Async::Task.current.sleep(endpoint.timeout * 2)
Protocol::HTTP::Response[200, {}, []]
end
end
it "can't get /" do
expect do
client.get("/")
end.to raise_error(Async::TimeoutError)
end
end
context 'bi-directional streaming', if: described_class.bidirectional? do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
# Echo the request body back to the client.
Protocol::HTTP::Response[200, {}, request.body]
end
end
it "can read from request body and write response body simultaneously" do
body = Async::HTTP::Body::Writable.new
# Ideally, the flow here is as follows:
# 1/ Client writes headers to server.
# 2/ Client starts writing data to server (in async task).
# 3/ Client reads headers from server.
# 4a/ Client reads data from server.
# 4b/ Client finishes sending data to server.
response = client.post(endpoint.path, [], body)
expect(response).to be_success
body.write "."
count = 0
response.each do |chunk|
if chunk.bytesize > 32
body.close
else
count += 1
body.write chunk*2
Async::Task.current.sleep(0.1)
end
end
expect(count).to be == 6
end
end
end
ruby-async-http-0.52.5/spec/async/http/proxy_spec.rb 0000664 0000000 0000000 00000013720 13731260101 0022417 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async'
require 'async/http/proxy'
require 'async/http/protocol'
require 'async/http/body/hijack'
require_relative 'server_context'
RSpec.shared_examples_for Async::HTTP::Proxy do
include_context Async::HTTP::Server
describe '.proxied_endpoint' do
it "can construct valid endpoint" do
endpoint = Async::HTTP::Endpoint.parse("http://www.codeotaku.com")
proxied_endpoint = client.proxied_endpoint(endpoint)
expect(proxied_endpoint).to be_kind_of(Async::HTTP::Endpoint)
end
end
describe '.proxied_client' do
it "can construct valid client" do
endpoint = Async::HTTP::Endpoint.parse("http://www.codeotaku.com")
proxied_client = client.proxied_client(endpoint)
expect(proxied_client).to be_kind_of(Async::HTTP::Client)
end
end
context 'CONNECT' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Async::HTTP::Body::Hijack.response(request, 200, {}) do |stream|
chunk = stream.read
stream.close_read
stream.write(chunk)
stream.close
end
end
end
let(:data) {"Hello World!"}
it "can connect and hijack connection" do
input = Async::HTTP::Body::Writable.new
response = client.connect("127.0.0.1:1234", [], input)
expect(response).to be_success
input.write(data)
input.close
expect(response.read).to be == data
end
end
context 'echo server' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
expect(request.path).to be == "localhost:1"
Async::HTTP::Body::Hijack.response(request, 200, {}) do |stream|
while chunk = stream.read_partial(1024)
stream.write(chunk)
stream.flush
end
stream.close
end
end
end
let(:data) {"Hello World!"}
it "can connect to remote system using block" do
proxy = Async::HTTP::Proxy.tcp(client, "localhost", 1)
expect(proxy.client.pool).to be_empty
proxy.connect do |peer|
stream = Async::IO::Stream.new(peer)
stream.write(data)
stream.close_write
expect(stream.read).to be == data
end
proxy.close
expect(proxy.client.pool).to be_empty
end
it "can connect to remote system" do
proxy = Async::HTTP::Proxy.tcp(client, "localhost", 1)
expect(proxy.client.pool).to be_empty
stream = Async::IO::Stream.new(proxy.connect)
stream.write(data)
stream.close_write
expect(stream.read).to be == data
stream.close
proxy.close
expect(proxy.client.pool).to be_empty
end
end
context 'proxied client' do
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
expect(request.method).to be == "CONNECT"
host, port = request.path.split(":", 2)
endpoint = Async::IO::Endpoint.tcp(host, port)
Async.logger.debug(self) {"Making connection to #{endpoint}..."}
Async::HTTP::Body::Hijack.response(request, 200, {}) do |stream|
upstream = Async::IO::Stream.new(endpoint.connect)
Async.logger.debug(self) {"Connected to #{upstream}..."}
reader = Async do |task|
task.annotate "Upstream reader."
while chunk = upstream.read_partial
stream.write(chunk)
stream.flush
end
ensure
Async.logger.debug(self) {"Finished reading from upstream..."}
stream.close_write
end
writer = Async do |task|
task.annotate "Upstream writer."
while chunk = stream.read_partial
upstream.write(chunk)
upstream.flush
end
rescue Async::Wrapper::Cancelled
#ignore
ensure
Async.logger.debug(self) {"Finished writing to upstream..."}
upstream.close_write
end
reader.wait
writer.wait
ensure
upstream.close
stream.close
end
end
end
it 'can get insecure website' do
endpoint = Async::HTTP::Endpoint.parse("http://www.google.com")
proxy_client = client.proxied_client(endpoint)
response = proxy_client.get("/search")
expect(response).to_not be_failure
# The response would be a redirect:
expect(response).to be_redirection
response.finish
# The proxy.connnect response is not being released correctly - after pipe is done:
expect(proxy_client.pool).to_not be_empty
proxy_client.close
expect(proxy_client.pool).to be_empty
end
it 'can get secure website' do
endpoint = Async::HTTP::Endpoint.parse("https://www.google.com")
proxy_client = client.proxied_client(endpoint)
response = proxy_client.get("/search")
expect(response).to_not be_failure
expect(response.read).to_not be_empty
proxy_client.close
end
end
end
RSpec.describe Async::HTTP::Protocol::HTTP10 do
it_behaves_like Async::HTTP::Proxy
end
RSpec.describe Async::HTTP::Protocol::HTTP11 do
it_behaves_like Async::HTTP::Proxy
end
RSpec.describe Async::HTTP::Protocol::HTTP2 do
it_behaves_like Async::HTTP::Proxy
end
ruby-async-http-0.52.5/spec/async/http/relative_location_spec.rb 0000664 0000000 0000000 00000007740 13731260101 0024746 0 ustar 00root root 0000000 0000000 # Copyright, 2018, by Samuel G. D. Williams.
#
# 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.
require 'async/http/relative_location'
require 'async/http/server'
RSpec.describe Async::HTTP::RelativeLocation do
let(:endpoint) {Async::HTTP::Endpoint.parse('http://127.0.0.1:9294', reuse_port: true)}
let(:client) {Async::HTTP::Client.new(endpoint)}
subject {described_class.new(client)}
context 'server redirections' do
include_context Async::RSpec::Reactor
let!(:server_task) do
reactor.async do
server.run
end
end
after(:each) do
server_task.stop
subject.close
end
context '301' do
let(:server) do
Async::HTTP::Server.for(endpoint) do |request|
case request.path
when '/home'
Protocol::HTTP::Response[301, {'location' => '/'}, []]
when '/'
Protocol::HTTP::Response[301, {'location' => '/index.html'}, []]
when '/index.html'
Protocol::HTTP::Response[200, {}, [request.method]]
end
end
end
it 'should redirect POST to GET' do
response = subject.post('/')
expect(response).to be_success
expect(response.read).to be == "GET"
end
context 'limiting redirects' do
subject {described_class.new(client, 1)}
it 'should allow the maximum number of redirects' do
response = subject.get('/')
response.finish
expect(response).to be_success
end
it 'should fail with maximum redirects' do
expect{
response = subject.get('/home')
}.to raise_error(Async::HTTP::TooManyRedirects, /maximum/)
end
end
end
context '302' do
let(:server) do
Async::HTTP::Server.for(endpoint) do |request|
case request.path
when '/'
Protocol::HTTP::Response[302, {'location' => '/index.html'}, []]
when '/index.html'
Protocol::HTTP::Response[200, {}, [request.method]]
end
end
end
it 'should redirect POST to GET' do
response = subject.post('/')
expect(response).to be_success
expect(response.read).to be == "GET"
end
end
context '307' do
let(:server) do
Async::HTTP::Server.for(endpoint) do |request|
case request.path
when '/'
Protocol::HTTP::Response[307, {'location' => '/index.html'}, []]
when '/index.html'
Protocol::HTTP::Response[200, {}, [request.method]]
end
end
end
it 'should redirect with same method' do
response = subject.post('/')
expect(response).to be_success
expect(response.read).to be == "POST"
end
end
context '308' do
let(:server) do
Async::HTTP::Server.for(endpoint) do |request|
case request.path
when '/'
Protocol::HTTP::Response[308, {'location' => '/index.html'}, []]
when '/index.html'
Protocol::HTTP::Response[200, {}, [request.method]]
end
end
end
it 'should redirect with same method' do
response = subject.post('/')
expect(response).to be_success
expect(response.read).to be == "POST"
end
end
end
end
ruby-async-http-0.52.5/spec/async/http/server_context.rb 0000664 0000000 0000000 00000003405 13731260101 0023275 0 ustar 00root root 0000000 0000000 # Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require 'async/http/server'
# Async.logger.level = Logger::DEBUG
RSpec.shared_context Async::HTTP::Server do
include_context Async::RSpec::Reactor
let(:protocol) {described_class}
let(:endpoint) {Async::HTTP::Endpoint.parse('http://127.0.0.1:9294', timeout: 0.8, reuse_port: true)}
let(:retries) {1}
let!(:client) {Async::HTTP::Client.new(endpoint, protocol, retries: retries)}
let!(:server_task) do
server_task = reactor.async do
server.run
end
end
after(:each) do
client.close
server_task.stop
end
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
Protocol::HTTP::Response[200, {}, []]
end
end
end
ruby-async-http-0.52.5/spec/async/http/ssl_spec.rb 0000664 0000000 0000000 00000005331 13731260101 0022036 0 ustar 00root root 0000000 0000000 # Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require 'async/http/server'
require 'async/http/client'
require 'async/http/endpoint'
require 'async/io/ssl_socket'
require 'async/rspec/reactor'
require 'async/rspec/ssl'
RSpec.describe Async::HTTP::Server, timeout: 5 do
include_context Async::RSpec::Reactor
include_context Async::RSpec::SSL::ValidCertificate
describe "application layer protocol negotiation" do
let(:server_context) do
OpenSSL::SSL::SSLContext.new.tap do |context|
context.cert = certificate
context.alpn_select_cb = lambda do |protocols|
protocols.last
end
context.key = key
end
end
let(:client_context) do
OpenSSL::SSL::SSLContext.new.tap do |context|
context.cert_store = certificate_store
context.alpn_protocols = ["h2", "http/1.1"]
context.verify_mode = OpenSSL::SSL::VERIFY_PEER
end
end
# Shared port for localhost network tests.
let(:server_endpoint) {Async::HTTP::Endpoint.parse("https://localhost:6779", ssl_context: server_context)}
let(:client_endpoint) {Async::HTTP::Endpoint.parse("https://localhost:6779", ssl_context: client_context)}
it "client can get a resource via https" do
server = Async::HTTP::Server.for(server_endpoint, Async::HTTP::Protocol::HTTP1) do |request|
Protocol::HTTP::Response[200, {}, ['Hello World']]
end
client = Async::HTTP::Client.new(client_endpoint)
Async do |task|
server_task = task.async do
server.run
end
response = client.get("/")
expect(response).to be_success
expect(response.read).to be == "Hello World"
client.close
server_task.stop
end
end
end
end ruby-async-http-0.52.5/spec/async/http/statistics_spec.rb 0000664 0000000 0000000 00000003612 13731260101 0023427 0 ustar 00root root 0000000 0000000 # Copyright, 2017, by Samuel G. D. Williams.
#
# 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.
require_relative 'server_context'
require 'async/http/statistics'
RSpec.describe Async::HTTP::Statistics, timeout: 5 do
include_context Async::HTTP::Server
let(:protocol) {Async::HTTP::Protocol::HTTP1}
let(:server) do
Async::HTTP::Server.for(endpoint, protocol) do |request|
statistics = described_class.start
response = Protocol::HTTP::Response[200, {}, ["Hello ", "World!"]]
statistics.wrap(response) do |statistics, error|
expect(statistics.sent).to be == 12
expect(error).to be_nil
end.tap do |response|
expect(response.body).to receive(:complete_statistics).and_call_original
end
end
end
it "client can get resource" do
response = client.get("/")
expect(response.read).to be == "Hello World!"
expect(response).to be_success
end
end
ruby-async-http-0.52.5/spec/rack/ 0000775 0000000 0000000 00000000000 13731260101 0016520 5 ustar 00root root 0000000 0000000 ruby-async-http-0.52.5/spec/rack/test_spec.rb 0000664 0000000 0000000 00000003365 13731260101 0021045 0 ustar 00root root 0000000 0000000 # Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require 'rack/test'
require 'async'
require 'async/http'
RSpec.describe Rack::Test do
include_context Async::RSpec::Reactor
include Rack::Test::Methods
let(:app) do
Rack::Builder.new do
def body(*chunks)
body = Async::HTTP::Body::Writable.new
Async do |task|
chunks.each do |chunk|
body.write(chunk)
task.sleep(0.1)
end
body.close
end
return body
end
# This echos the body back.
run lambda { |env| [200, {}, body("Hello", " ", "World", "!")] }
end
end
it "can read response body" do
get "/"
expect(last_response.body).to be == "Hello World!"
end
end
ruby-async-http-0.52.5/spec/spec_helper.rb 0000664 0000000 0000000 00000003075 13731260101 0020423 0 ustar 00root root 0000000 0000000 # Copyright, 2019, by Samuel G. D. Williams.
#
# 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.
require 'bundler/setup'
require 'covered/rspec'
require 'async/rspec'
RSpec.shared_context 'docstring as description' do
let(:description) {self.class.metadata.fetch(:description_args).first}
end
RSpec.configure do |config|
# Enable flags like --only-failures and --next-failure
config.example_status_persistence_file_path = ".rspec_status"
config.include_context 'docstring as description'
config.expect_with :rspec do |c|
c.syntax = :expect
end
end