async-http 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 013fbd13a7bf3d427d1fa5b21caff2f818050103
-  data.tar.gz: 8d87d03698f68f4d7d69e639ca66726463c72f31
+SHA256:
+  metadata.gz: 5159abaa1252d9eb0885989ab212b178e8bc8c672904b570bd26df5d5b077245
+  data.tar.gz: 6713e0b620617916076956129bed3c3de4338b83dba8bfbffe9f8306c90f564a
 SHA512:
-  metadata.gz: 72444c8c1320f81dbedea9cf855ebc729a39989ee831d1e27633899242309ea4ab34645998c08f35b66cf41a75da58276622d4062ba3ef0f7c117e2ac4a8ccda
-  data.tar.gz: 4dfb58bd27fed7d8fa4d61d06049c6d4aeeeb7a930c62808f46e9aa72600a1c594602a730da5e5cef03a9779567db6cf24b98970e2c68e4ac3bea721df370834
+  metadata.gz: 2e814e75bddb4cd9fee74c78d45a2da90ab01e7f37454871b5b1ec7d5f42a88fea57b02b6f28dcbdda079803511f2da4b4d9ed2fbf9ecd18b6d0cae1213b07eb
+  data.tar.gz: b08a59a9a07811a5cf91cee4a4bc650eb3bbb753c1076f27fd41c5a237d4684542677b8ed1ce32f2474fe3347f80d05730b8141f1fcd1c8e6c571ac33653b95b

data/.travis.yml

@@ -1,20 +1,36 @@
 language: ruby
-sudo: false
+sudo: required
 dist: trusty
 cache: bundler
 
+addons:
+  apt:
+    packages:
+#    - wrk installed below from xenial
+    - apache2-utils
+
+before_install:
+  - echo "deb http://us.archive.ubuntu.com/ubuntu/ xenial main restricted universe" | sudo tee -a /etc/apt/sources.list
+  - sudo apt-get update -qq
+  - sudo apt-get install openssl libssl-dev wrk
+# Rebuild Ruby using the updated OpenSSL libraries which allows 2.5 to pass.
+#  - rvm reinstall --disable-binary `rvm current`
+# Fix a bug with Ruby 2.5: LoadError: cannot load such file -- bundler/dep_proxy
+  - gem update --system
+# This works for Ruby 2.3 and 2.4 but not 2.5 which doesn't seem to use the local gem.
+  - gem install openssl
+
 matrix:
   include:
-    - rvm: 2.0
-    - rvm: 2.1
-    - rvm: 2.2
     - rvm: 2.3
     - rvm: 2.4
+    - rvm: 2.5
     - rvm: jruby-head
       env: JRUBY_OPTS="--debug -X+O"
     - rvm: ruby-head
     - rvm: rbx-3
   allow_failures:
+    - rvm: 2.5
     - rvm: ruby-head
     - rvm: jruby-head
     - rvm: rbx-3

data/Gemfile

@@ -3,6 +3,12 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in async-io.gemspec
 gemspec
 
+group :development do
+	gem 'trenni-sanitize'
+	
+	gem 'async-await'
+end
+
 group :test do
 	gem 'simplecov'
 	gem 'coveralls', require: false

data/README.md

@@ -36,9 +36,7 @@ require 'async/http/server'
 require 'async/http/client'
 require 'async/reactor'
 
-endpoints = [
-	Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true)
-]
+endpoint = Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true)
 
 class Server < Async::HTTP::Server
 	def handle_request(request, peer, address)
@@ -46,8 +44,8 @@ class Server < Async::HTTP::Server
 	end
 end
 
-server = Server.new(endpoints)
-client = Async::HTTP::Client.new(endpoints)
+server = Server.new(endpoint)
+client = Async::HTTP::Client.new(endpoint)
 	
 Async::Reactor.run do |task|
 	server_task = task.async do

data/Rakefile

@@ -5,18 +5,21 @@ RSpec::Core::RakeTask.new(:test)
 
 task :default => :test
 
+require 'async/http/protocol'
+PROTOCOL = Async::HTTP::Protocol::HTTP2
+
+task :debug do
+	require 'async/logger'
+	
+	Async.logger.level = Logger::DEBUG
+end
+
 task :server do
 	require 'async/reactor'
 	require 'async/http/server'
 	
-	app = lambda do |env|
-		[200, {}, ["Hello World"]]
-	end
-
-	server = Async::HTTP::Server.new([
-		Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true)
-	], app)
-
+	server = Async::HTTP::Server.new(Async::IO::Endpoint.tcp('0.0.0.0', 9294, reuse_port: true), PROTOCOL)
+	
 	Async::Reactor.run do
 		server.run
 	end
@@ -26,9 +29,7 @@ task :client do
 	require 'async/reactor'
 	require 'async/http/client'
 	
-	client = Async::HTTP::Client.new([
-		Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true)
-	])
+	client = Async::HTTP::Client.new(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), PROTOCOL)
 	
 	Async::Reactor.run do
 		response = client.get("/")
@@ -44,13 +45,11 @@ task :wrk do
 	app = lambda do |env|
 		[200, {}, ["Hello World"]]
 	end
-
-	server = Async::HTTP::Server.new([
-		Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true)
-	], app)
-
+	
+	server = Async::HTTP::Server.new(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), app)
+	
 	process_count = Etc.nprocessors
-
+	
 	pids = process_count.times.collect do
 		fork do
 			Async::Reactor.run do

data/async-http.gemspec

@@ -16,8 +16,11 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 	
-	spec.add_dependency("async", "~> 1.1")
-	spec.add_dependency("async-io", "~> 1.0")
+	spec.add_dependency("async", "~> 1.4")
+	spec.add_dependency("async-io", "~> 1.5")
+	
+	spec.add_dependency("http-2", "~> 0.8")
+	spec.add_dependency("openssl")
 	
 	spec.add_development_dependency "async-rspec", "~> 1.1"
 	

data/examples/spider.rb

@@ -0,0 +1,129 @@
+#!/usr/bin/env ruby
+
+require 'async/await'
+
+require 'pry'
+
+require_relative '../lib/async/http/client'
+require '../lib/async/http/url_endpoint'
+require '../lib/async/http/protocol/https'
+
+require 'trenni/sanitize'
+require 'set'
+
+Async.logger.level = Logger::DEBUG
+
+class HTML < Trenni::Sanitize::Filter
+	def initialize(*)
+		super
+		
+		@base = nil
+		@links = []
+	end
+	
+	attr :base
+	attr :links
+	
+	def filter(node)
+		if node.name == 'base'
+			@base = node['href']
+		elsif node.name == 'a'
+			@links << node['href']
+		end
+		
+		node.skip!(TAG)
+	end
+end
+
+class Cache
+	def initialize
+		@clients = {}
+	end
+	
+	def close
+		@clients.each(&:close)
+		@clients.clear
+	end
+	
+	def [] endpoint
+		url = endpoint.specification
+		key = "#{url.scheme}://#{url.userinfo}@#{url.hostname}"
+		
+		@clients[key] ||= Async::HTTP::Client.new(endpoint, endpoint.secure? ? Async::HTTP::Protocol::HTTPS : Async::HTTP::Protocol::HTTP1)
+	end
+end
+
+class << self
+	include Async::Await
+	
+	async def fetch(url, depth = 4, fetched = Set.new, clients = Cache.new)
+		return if fetched.include?(url) or depth == 0 or url.host != "www.codeotaku.com"
+		fetched << url
+		
+		endpoint = Async::HTTP::URLEndpoint.new(url)
+		client = clients[endpoint]
+		
+		request_uri = endpoint.specification.request_uri
+		puts "GET #{url} (depth = #{depth})"
+		
+		response = timeout(10) do
+			client.get(request_uri, {
+				':authority' => endpoint.specification.hostname,
+				'accept' => '*/*',
+				'user-agent' => 'spider',
+			})
+		end
+		
+		if response.status >= 300 && response.status < 400
+			location = url + response.headers['location']
+			# puts "Following redirect to #{location}"
+			return fetch(location, depth-1, fetched)
+		end
+		
+		content_type = response.headers['content-type']
+		unless content_type&.start_with? 'text/html'
+			# puts "Unsupported content type: #{response.headers['content-type']}"
+			return
+		end
+		
+		base = endpoint.specification
+		
+		begin
+			html = HTML.parse(response.body)
+		rescue
+			# Async.logger.error($!)
+			return
+		end
+		
+		if html.base
+			base = base + html.base
+		end
+		
+		html.links.each do |href|
+			begin
+				full_url = base + href
+				
+				fetch(full_url, depth - 1, fetched) if full_url.kind_of? URI::HTTP
+			rescue ArgumentError, URI::InvalidURIError
+				# puts "Could not fetch #{href}, relative to #{base}."
+			end
+		end
+	rescue Async::TimeoutError
+		Async.logger.error("Timeout while fetching #{url}")
+	rescue StandardError
+		Async.logger.error($!)
+	ensure
+		puts "Closing client from spider..."
+		client.close if client
+	end
+	
+	async def fetch_one(url)
+		endpoint = Async::HTTP::URLEndpoint.new(url)
+		client = Async::HTTP::Client.new(endpoint, endpoint.secure? ? Async::HTTP::Protocol::HTTPS : Async::HTTP::Protocol::HTTP1)
+		
+		binding.pry
+	end
+end
+
+fetch_one(URI.parse("https://www.codeotaku.com"))
+#puts "Finished."

data/lib/async/http/client.rb

@@ -25,52 +25,56 @@ require_relative 'protocol'
 module Async
 	module HTTP
 		class Client
-			def initialize(endpoints, protocol_class = Protocol::HTTP11)
-				@endpoints = endpoints
+			def initialize(endpoint, protocol = Protocol::HTTPS, **options)
+				@endpoint = endpoint
 				
-				@protocol_class = protocol_class
+				@protocol = protocol
+				
+				@connections = connect(**options)
 			end
 			
-			GET = 'GET'.freeze
-			HEAD = 'HEAD'.freeze
-			POST = 'POST'.freeze
-			
-			def get(path, *args)
-				connect do |protocol|
-					protocol.send_request(GET, path, *args)
+			def self.open(*args, &block)
+				client = self.new(*args)
+				
+				return client unless block_given?
+				
+				begin
+					yield client
+				ensure
+					client.close
 				end
 			end
 			
-			def head(path, *args)
-				connect do |protocol|
-					protocol.send_request(HEAD, path, *args)
-				end
+			def close
+				@connections.close
 			end
 			
-			def post(path, *args)
-				connect do |protocol|
-					protocol.send_request(POST, path, *args)
+			VERBS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE']
+			
+			VERBS.each do |verb|
+				define_method(verb.downcase) do |*args|
+					self.request(verb, *args)
 				end
 			end
 			
-			def send_request(*args)
-				connect do |protocol|
-					protocol.send_request(*args)
+			def request(*args)
+				@connections.acquire do |connection|
+					connection.send_request(*args)
 				end
 			end
 			
-			private
+			protected
 			
-			def connect
-				Async::IO::Endpoint.each(@endpoints) do |endpoint|
-					# puts "Connecting to #{address} on process #{Process.pid}"
+			def connect(connection_limit: nil)
+				Pool.new(connection_limit) do
+					Async.logger.debug(self) {"Making connection to #{@endpoint.inspect}"}
 					
-					endpoint.connect do |peer|
-						stream = Async::IO::Stream.new(peer)
+					@endpoint.each do |endpoint|
+						peer = endpoint.connect
 						
-						# We only yield for first successful connection.
+						stream = IO::Stream.new(peer)
 						
-						return yield @protocol_class.new(stream)
+						break @protocol.client(stream)
 					end
 				end
 			end

data/lib/async/http/pool.rb

@@ -0,0 +1,120 @@
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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
+		# Pool behaviours
+		# 
+		# - Single request per connection (HTTP/1 without keep-alive)
+		# - Multiple sequential requests per connection (HTTP1 with keep-alive)
+		# - Multiplex requests per connection (HTTP2)
+		# 
+		# In general we don't know the policy until connection is established.
+		#
+		# This pool doesn't impose a maximum number of open resources, but it WILL block if there are no available resources and trying to allocate another one fails.
+		#
+		# Resources must respond to
+		# 	#multiplex -> 1 or more.
+		# 	#reusable? -> can be used again.
+		#
+		class Pool
+			def initialize(limit = nil, &block)
+				@available = {} # resource => count
+				@waiting = []
+				
+				@limit = limit
+				
+				@constructor = block
+			end
+			
+			def acquire
+				resource = wait_for_next_available
+				
+				return resource unless block_given?
+				
+				begin
+					yield resource
+				ensure
+					release(resource)
+				end
+			end
+			
+			# Make the resource available and let waiting tasks know that there is something available.
+			def release(resource)
+				if resource.reusable?
+					Async.logger.debug(self) {"Reusing resource #{resource}"}
+					
+					@available[resource] -= 1
+					
+					if task = @waiting.pop
+						task.resume
+					end
+				else
+					Async.logger.debug(self) {"Closing resource: #{resource}"}
+					resource.close
+				end
+			end
+			
+			def close
+				@available.each_key(&:close)
+				@available.clear
+			end
+			
+			protected
+			
+			def wait_for_next_available
+				until resource = next_available
+					@waiting << Fiber.current
+					Task.yield
+				end
+				
+				return resource
+			end
+			
+			def create_resource
+				begin
+					# This might fail, which is okay :)
+					resource = @constructor.call
+				rescue StandardError
+					Async.logger.error "#{$!}: #{$!.backtrace}"
+					return nil
+				end
+				
+				@available[resource] = 1
+				
+				return resource
+			end
+			
+			# TODO this does not take into account resources that start off good but can fail.
+			def next_available
+				@available.each do |resource, count|
+					if count < resource.multiplex
+						@available[resource] += 1
+						
+						return resource
+					end
+				end
+				
+				Async.logger.debug(self) {"No available resources, allocating new one..."}
+				return create_resource
+			end
+		end
+	end
+end

data/lib/async/http/protocol.rb

@@ -18,4 +18,5 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'protocol/http1x'
+require_relative 'protocol/http1'
+require_relative 'protocol/https'

data/lib/async/http/protocol/{http1x.rb → http1.rb}

@@ -21,27 +21,33 @@
 require_relative 'http10'
 require_relative 'http11'
 
+require_relative '../pool'
+
 module Async
 	module HTTP
 		module Protocol
 			# A server that supports both HTTP1.0 and HTTP1.1 semantics by detecting the version of the request.
-			class HTTP1x < Async::IO::Protocol::Line
+			class HTTP1 < Async::IO::Protocol::Line
 				HANDLERS = {
 					"HTTP/1.0" => HTTP10,
 					"HTTP/1.1" => HTTP11,
 				}
 				
-				def initialize(stream, handlers: HANDLERS)
+				def initialize(stream)
 					super(stream, HTTP11::CRLF)
+				end
+				
+				class << self
+					def client(*args)
+						HTTP11.new(*args)
+					end
 					
-					@handlers = handlers
-					
-					@handler = nil
+					alias server new
 				end
 				
 				def create_handler(version)
-					if klass = @handlers[version]
-						klass.new(@stream)
+					if klass = HANDLERS[version]
+						klass.server(@stream)
 					else
 						raise RuntimeError, "Unsupported protocol version #{version}"
 					end
@@ -52,10 +58,6 @@ module Async
 					
 					create_handler(version).receive_requests(&block)
 				end
-				
-				def send_request(request, &block)
-					create_handler(request.version).send_request(request, &block)
-				end
 			end
 		end
 	end

data/lib/async/http/protocol/http10.rb

@@ -45,8 +45,14 @@ module Async
 						
 						write_response(request.version, status, headers, body)
 						
-						break unless keep_alive?(request.headers) && keep_alive?(headers)
+						unless keep_alive?(request.headers) && keep_alive?(headers)
+							@keep_alive = false
+							
+							break
+						end
 					end
+					
+					return false
 				end
 				
 				def write_body(body, chunked = true)

data/lib/async/http/protocol/http11.rb

@@ -35,6 +35,22 @@ module Async
 				
 				def initialize(stream)
 					super(stream, CRLF)
+					
+					@keep_alive = true
+				end
+				
+				# Only one simultaneous connection at a time.
+				def multiplex
+					1
+				end
+				
+				def reusable?
+					@keep_alive
+				end
+				
+				class << self
+					alias server new
+					alias client new
 				end
 				
 				HTTP_CONNECTION = 'HTTP_CONNECTION'.freeze
@@ -60,7 +76,11 @@ module Async
 						
 						write_response(request.version, status, headers, body)
 						
-						break unless keep_alive?(request.headers) && keep_alive?(headers)
+						unless keep_alive?(request.headers) and keep_alive?(headers)
+							@keep_alive = false
+							
+							break
+						end
 						
 						# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
 						task.yield
@@ -72,7 +92,6 @@ module Async
 					write_request(method, path, version, headers, body)
 					
 					return Response.new(*read_response)
-				
 				rescue EOFError
 					return nil
 				end
@@ -92,6 +111,8 @@ module Async
 					headers = read_headers
 					body = read_body(headers)
 					
+					@keep_alive = keep_alive?(headers)
+					
 					return version, Integer(status), reason, headers, body
 				end
 				

data/lib/async/http/protocol/http2.rb

@@ -0,0 +1,205 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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 'response'
+
+require 'async/notification'
+
+require 'http/2'
+
+module Async
+	module HTTP
+		module Protocol
+			# A server that supports both HTTP1.0 and HTTP1.1 semantics by detecting the version of the request.
+			class HTTP2
+				def self.client(stream)
+					self.new(::HTTP2::Client.new, stream)
+				end
+				
+				def self.server(stream)
+					self.new(::HTTP2::Server.new, stream)
+				end
+				
+				def initialize(controller, stream)
+					@controller = controller
+					@stream = stream
+					
+					@controller.on(:frame) do |data|
+						@stream.write(data)
+						@stream.flush
+					end
+					
+					# @controller.on(:frame_sent) do |frame|
+					# 	Async.logger.debug(self) {"Sent frame: #{frame.inspect}"}
+					# end
+					# 
+					# @controller.on(:frame_received) do |frame|
+					# 	Async.logger.debug(self) {"Received frame: #{frame.inspect}"}
+					# end
+					
+					if @controller.is_a? ::HTTP2::Client
+						@controller.send_connection_preface
+						@reader = read_in_background
+					end
+				end
+				
+				# Multiple requests can be processed at the same time.
+				def multiplex
+					@controller.remote_settings[:settings_max_concurrent_streams]
+				end
+				
+				def reusable?
+					@reader.alive?
+				end
+				
+				def read_in_background(task: Task.current)
+					task.async do |nested_task|
+						while true
+							if data = @stream.io.read(10)
+								# Async.logger.debug(self) {"Reading data: #{data.size} bytes"}
+								@controller << data
+							else
+								Async.logger.debug(self) {"Connection reset by peer!"}
+								break
+							end
+						end
+					end
+				end
+				
+				def close
+					Async.logger.debug(self) {"Closing connection"}
+					@reader.stop
+					@stream.close
+				end
+				
+				def receive_requests(&block)
+					# emits new streams opened by the client
+					@controller.on(:stream) do |stream|
+						request = Request.new
+						request.version = "HTTP/2.0"
+						request.headers = {}
+						
+						# stream.on(:active) { } # fires when stream transitions to open state
+						# stream.on(:close) { } # stream is closed by client and server
+						
+						stream.on(:headers) do |headers|
+							headers.each do |key, value|
+								if key == ':method'
+									request.method = value
+								elsif key == ':path'
+									request.path = value
+								else
+									request.headers[key] = value
+								end
+							end
+						end
+						
+						stream.on(:data) do |body|
+							request.body = body
+						end
+						
+						stream.on(:half_close) do
+							response = yield request
+							
+							# send response
+							stream.headers(':status' => response[0].to_s)
+							
+							stream.headers(response[1]) unless response[1].empty?
+							
+							response[2].each do |chunk|
+								stream.data(chunk, end_stream: false)
+							end
+							
+							stream.data("", end_stream: true)
+						end
+					end
+					
+					while data = @stream.io.read(1024)
+						@controller << data
+					end
+				end
+				
+				def send_request(method, path, headers = {}, body = nil)
+					stream = @controller.new_stream
+					
+					internal_headers = {
+						':scheme' => 'https',
+						':method' => method,
+						':path' => path,
+					}.merge(headers)
+					
+					stream.headers(internal_headers, end_stream: true)
+					
+					# if body
+					# 	body.each do |chunk|
+					# 		stream.data(chunk, end_stream: false)
+					# 	end
+					# 
+					# 	stream.data("", end_stream: true)
+					# end
+					
+					response = Response.new
+					response.version = "HTTP/2"
+					response.headers = {}
+					response.body = Async::IO::BinaryString.new
+					
+					stream.on(:headers) do |headers|
+						# Async.logger.debug(self) {"Stream headers: #{headers.inspect}"}
+						
+						headers.each do |key, value|
+							if key == ':status'
+								response.status = value.to_i
+							elsif key == ':reason'
+								response.reason = value
+							else
+								response.headers[key] = value
+							end
+						end
+					end
+					
+					stream.on(:data) do |body|
+						# Async.logger.debug(self) {"Stream data: #{body.size} bytes"}
+						response.body << body
+					end
+					
+					finished = Async::Notification.new
+					
+					stream.on(:half_close) do
+						# Async.logger.debug(self) {"Stream half-closed."}
+					end
+					
+					stream.on(:close) do
+						# Async.logger.debug(self) {"Stream closed, sending signal."}
+						finished.signal
+					end
+					
+					@stream.flush
+					
+					# Async.logger.debug(self) {"Stream flushed, waiting for signal."}
+					finished.wait
+					
+					# Async.logger.debug(self) {"Stream finished: #{response.inspect}"}
+					return response
+				end
+			end
+		end
+	end
+end

data/lib/async/http/protocol/https.rb

@@ -0,0 +1,67 @@
+# Copyright, 2017, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# 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'
+require_relative 'http2'
+
+require_relative '../pool'
+
+require 'openssl'
+
+unless OpenSSL::SSL::SSLContext.instance_methods.include? :alpn_protocols=
+	abort "OpenSSL implementation doesn't support ALPN."
+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 = {
+					"http/1.0" => HTTP10,
+					"http/1.1" => HTTP11,
+					"h2" => HTTP2,
+					nil => HTTP11,
+				}
+				
+				def self.protocol_for(stream)
+					# alpn_protocol is only available if openssl v1.0.2+
+					name = stream.io.alpn_protocol
+					
+					Async.logger.debug(self) {"Negotiating protocol #{name.inspect}..."}
+					
+					if protocol = HANDLERS[name]
+						return protocol
+					else
+						throw ArgumentError.new("Could not determine protocol for connection (#{name.inspect}).")
+					end
+				end
+				
+				def self.client(stream)
+					protocol_for(stream).client(stream)
+				end
+				
+				def self.server(stream)
+					protocol_for(stream).server(stream)
+				end
+			end
+		end
+	end
+end

data/lib/async/http/server.rb

@@ -25,45 +25,40 @@ require_relative 'protocol'
 module Async
 	module HTTP
 		class Server
-			def initialize(endpoints, protocol_class = Protocol::HTTP1x)
-				@endpoints = endpoints
+			def initialize(endpoint, protocol_class = Protocol::HTTP1)
+				@endpoint = endpoint
 				@protocol_class = protocol_class
 			end
 			
 			def handle_request(request, peer, address)
-				[200, {}, []]
+				[200, {"Content-Type" => "text/plain"}, ["Hello World"]]
 			end
 			
 			def accept(peer, address)
 				stream = Async::IO::Stream.new(peer)
+				protocol = @protocol_class.server(stream)
 				
-				protocol = @protocol_class.new(stream)
-				
-				# puts "Opening session on child pid #{Process.pid}"
+				# Async.logger.debug(self) {"Incoming connnection from #{address.inspect}"}
 				
 				hijack = catch(:hijack) do
 					protocol.receive_requests do |request|
+						# Async.logger.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
 						handle_request(request, peer, address)
 					end
 				end
-
+				
 				if hijack
 					hijack.call
 				end
-
-				# puts "Closing session"
-				
 			rescue EOFError, Errno::ECONNRESET, Errno::EPIPE
 				# Sometimes client will disconnect without completing a result or reading the entire buffer.
 				return nil
+			ensure
+				peer.close
 			end
 			
 			def run
-				Async::IO::Endpoint.each(@endpoints) do |endpoint|
-					# puts "Binding to #{endpoint} on process #{Process.pid}"
-					
-					endpoint.accept(&self.method(:accept))
-				end
+				@endpoint.accept(&self.method(:accept))
 			end
 		end
 	end

data/lib/async/http/url_endpoint.rb

@@ -24,16 +24,32 @@ require 'async/io/ssl_socket'
 module Async
 	module HTTP
 		class URLEndpoint < Async::IO::Endpoint
+			DEFAULT_ALPH_PROTOCOLS = ['h2', 'http/1.1'].freeze
+			
 			def self.parse(string, **options)
 				self.new(URI.parse(string), **options)
 			end
 			
+			def initialize(url, endpoint = nil, **options)
+				@url = url
+				@endpoint = endpoint
+				@options = options
+			end
+			
 			def address
 				endpoint.address
 			end
 			
 			def secure?
-				['https', 'wss'].include?(specification.scheme)
+				['https', 'wss'].include?(@url.scheme)
+			end
+			
+			def protocol
+				if secure?
+					Protocol::HTTPS
+				else
+					Protocol::HTTP1
+				end
 			end
 			
 			def default_port
@@ -41,24 +57,27 @@ module Async
 			end
 			
 			def port
-				specification.port || default_port
+				@url.port || default_port
 			end
 			
 			def hostname
-				specification.hostname
+				@url.hostname
 			end
 			
 			def ssl_context
-				options[:ssl_context] || ::OpenSSL::SSL::SSLContext.new.tap do |context|
+				@options[:ssl_context] || ::OpenSSL::SSL::SSLContext.new.tap do |context|
+					context.alpn_protocols = @options.fetch(:alpn_protocols, DEFAULT_ALPH_PROTOCOLS)
 					context.set_params
 				end
 			end
 			
 			def endpoint
-				unless defined? @endpoint
+				unless @endpoint
 					@endpoint = Async::IO::Endpoint.tcp(hostname, port)
 					
 					if secure?
+						Async.logger.debug(self) {"Setting hostname: #{self.hostname}"}
+						
 						# Wrap it in SSL:
 						@endpoint = Async::IO::SecureEndpoint.new(@endpoint,
 							ssl_context: ssl_context,
@@ -77,6 +96,14 @@ module Async
 			def connect(*args, &block)
 				endpoint.connect(*args, &block)
 			end
+			
+			def each
+				return to_enum unless block_given?
+				
+				self.endpoint.each do |endpoint|
+					yield self.class.new(@url, endpoint, @options)
+				end
+			end
 		end
 	end
 end

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.6.0"
+		VERSION = "0.8.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-02 00:00:00.000000000 Z
+date: 2018-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,28 +16,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: async-io
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: http-2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -109,12 +137,16 @@ files:
 - README.md
 - Rakefile
 - async-http.gemspec
+- examples/spider.rb
 - lib/async/http.rb
 - lib/async/http/client.rb
+- lib/async/http/pool.rb
 - lib/async/http/protocol.rb
+- lib/async/http/protocol/http1.rb
 - lib/async/http/protocol/http10.rb
 - lib/async/http/protocol/http11.rb
-- lib/async/http/protocol/http1x.rb
+- lib/async/http/protocol/http2.rb
+- lib/async/http/protocol/https.rb
 - lib/async/http/protocol/request.rb
 - lib/async/http/protocol/response.rb
 - lib/async/http/server.rb
@@ -139,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: ''