falcon 0.18.14 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00d78cf28ce29545aadf35ae46f9c74d9a17d735104a0ae14e89e65d4971b9cf
-  data.tar.gz: bb8ebf365e2c1b509e02d59e5f3777f2afd7dc93ba36766093115a12276f73f7
+  metadata.gz: 16eb6bd0bff8f6177b4f110a0d7fc07da2a1b190a4c0e0aa77bbe86978bf9331
+  data.tar.gz: b3520e014ed9f70fe6f87ba9d5cefbe69d27b173bc79c1d3cf4cc36e9960c967
 SHA512:
-  metadata.gz: 5815df38ef80aec5070a315513e90507c1e6e012d8f4ae72b3346fe04f2370f3bcc54d9b58f33d5159c5360abb2a4768561593a153477cf3cc93874a947e0c28
-  data.tar.gz: 1ebfc78ee21151b7e7f4c119b910bac160e2c33e178a4d706bb8367c73964b1d6247cc3bf54304ebdc7b520f4775f269f70f6791c4c66fc3506b58a4e1bed792
+  metadata.gz: 14f8a9402e0f4080d9cb1aa4cd2ea545a62b1b986c1e23306f3a56fc64a3125883f50225abc14029c13370ef628b1c7fecf06f525a5868d70fa34e7224d6cbd4
+  data.tar.gz: ab8782501460ae14988977be03af1209e6d45a37eadaa42d3f67b3a4196bfd1499fac05efd7360f84ca65d77cad522db83ae6cf7ddedd1a3d43c4bad3161e19d

data/README.md

@@ -5,6 +5,7 @@ Falcon is a multi-process, multi-fiber rack-compatible HTTP server built on top
 [![Build Status](https://secure.travis-ci.org/socketry/falcon.svg)](http://travis-ci.org/socketry/falcon)
 [![Code Climate](https://codeclimate.com/github/socketry/falcon.svg)](https://codeclimate.com/github/socketry/falcon)
 [![Coverage Status](https://coveralls.io/repos/socketry/falcon/badge.svg)](https://coveralls.io/r/socketry/falcon)
+[![Gitter](https://badges.gitter.im/join.svg)](https://gitter.im/socketry/falcon)
 
 [async]: https://github.com/socketry/async
 [async-io]: https://github.com/socketry/async-io
@@ -51,9 +52,13 @@ Falcon works perfectly with `rails` apps.
 
 Alternatively run `RACK_HANDLER=falcon rails server` to start the server (at least, until [rack#181](https://github.com/rack/rack/pull/1181) is merged).
 
-#### Thread Safety (Rails < 5.x)
+#### Thread Safety
 
-With older versons of Rails, the `Rack::Lock` middleware is inserted into your app unless you explicitly add `config.threadsafe!`. `Rack::Lock` will cause both poor performance and deadlocks due to the highly concurrent nature of `falcon`. Therefore, please ensure you specify `config.threadsafe!` in your `config/application.rb`:
+With older versions of Rails, the `Rack::Lock` middleware can be inserted into your app by Rails. `Rack::Lock` will cause both poor performance and deadlocks due to the highly concurrent nature of `falcon`. Other web frameworks are generally unaffected.
+
+##### Rails 3.x (and older)
+
+Please ensure you specify `config.threadsafe!` in your `config/application.rb`:
 
 ```ruby
 module MySite
@@ -65,8 +70,13 @@ module MySite
 	end
 end
 ```
+##### Rails 4.x
+
+Please ensure you have `config.allow_concurrency = true` in your configuration.
+
+##### Rails 5.x+
 
-This became the default in Rails 5 so no change is necessary in this version. Other web frameworks are generally unaffected.
+This became the default in Rails 5 so no change is necessary unless you explicitly disabled concurrency, in which case you should remove that configuration.
 
 ### WebSockets
 

data/falcon.gemspec

@@ -16,10 +16,10 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 
-	spec.add_dependency("http-protocol", "~> 0.6.0")
+	spec.add_dependency("http-protocol", "~> 0.8.0")
 
 	spec.add_dependency("async-io", "~> 1.9")
-	spec.add_dependency("async-http", "~> 0.34.0")
+	spec.add_dependency("async-http", "~> 0.36.0")
 	spec.add_dependency("async-container", "~> 0.6.0")
 	
 	spec.add_dependency("rack", ">= 1.0")

data/lib/falcon/adapters/rack.rb

@@ -26,6 +26,12 @@ require 'async/logger'
 module Falcon
 	module Adapters
 		class Rack
+			HTTP_X_FORWARDED_PROTO = 'HTTP_X_FORWARDED_PROTO'.freeze
+			REMOTE_ADDR = 'REMOTE_ADDR'.freeze
+			
+			CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+			CONTENT_LENGTH = 'CONTENT_LENGTH'.freeze
+			
 			def initialize(app, logger = Async.logger)
 				@app = app
 				
@@ -45,76 +51,98 @@ module Falcon
 				end
 			end
 			
+			# Process the incoming request into a valid rack env.
+			def unwrap_request(request, env)
+				if content_type = request.headers.delete('content-type')
+					env[CONTENT_TYPE] = content_type
+				end
+				
+				# In some situations we don't know the content length, e.g. when using chunked encoding, or when decompressing the body.
+				if body = request.body and length = body.length
+					env[CONTENT_LENGTH] = length.to_s
+				end
+				
+				self.unwrap_headers(request.headers, env)
+				
+				# HTTP/2 prefers `:authority` over `host`, so we do this for backwards compatibility.
+				env[::Rack::HTTP_HOST] ||= request.authority
+				
+				# This is the HTTP/1 header for the scheme of the request and is used by Rack.
+				# Technically it should use the Forwarded header but this is not common yet.
+				# https://tools.ietf.org/html/rfc7239#section-5.4
+				# https://github.com/rack/rack/issues/1310
+				env[HTTP_X_FORWARDED_PROTO] ||= request.scheme
+				
+				if remote_address = request.remote_address
+					env[REMOTE_ADDR] = remote_address.ip_address if remote_address.ip?
+				end
+			end
+			
+			def make_response(request, status, headers, body)
+				@logger.debug(request) {"Rack response: #{status} #{headers.inspect} #{body.class}"}
+				
+				return Response.wrap(status, headers, body)
+			end
+			
 			def call(request)
 				request_path, query_string = request.path.split('?', 2)
 				server_name, server_port = (request.authority || '').split(':', 2)
 				
 				env = {
-					'rack.version' => [2, 0, 0],
+					::Rack::RACK_VERSION => [2, 0, 0],
 					
-					'rack.input' => Input.new(request.body),
-					'rack.errors' => $stderr,
+					::Rack::RACK_INPUT => Input.new(request.body),
+					::Rack::RACK_ERRORS => $stderr,
 					
-					'rack.multithread' => true,
-					'rack.multiprocess' => true,
-					'rack.run_once' => false,
+					::Rack::RACK_MULTITHREAD => true,
+					::Rack::RACK_MULTIPROCESS => true,
+					::Rack::RACK_RUNONCE => false,
 					
 					# The HTTP request method, such as “GET” or “POST”. This cannot ever be an empty string, and so is always required.
-					'REQUEST_METHOD' => request.method,
+					::Rack::REQUEST_METHOD => request.method,
 					
 					# The initial portion of the request URL's “path” that corresponds to the application object, so that the application knows its virtual “location”. This may be an empty string, if the application corresponds to the “root” of the server.
-					'SCRIPT_NAME' => '',
+					::Rack::SCRIPT_NAME => '',
 					
 					# The remainder of the request URL's “path”, designating the virtual “location” of the request's target within the application. This may be an empty string, if the request URL targets the application root and does not have a trailing slash. This value may be percent-encoded when originating from a URL.
-					'PATH_INFO' => request_path,
+					::Rack::PATH_INFO => request_path,
 					
 					# The portion of the request URL that follows the ?, if any. May be empty, but is always required!
-					'QUERY_STRING' => query_string || '',
+					::Rack::QUERY_STRING => query_string || '',
 					
-					# The server protocol, e.g. HTTP/1.1
-					'SERVER_PROTOCOL' => request.version,
-					'rack.url_scheme' => 'http',
+					# The server protocol (e.g. HTTP/1.1):
+					::Rack::SERVER_PROTOCOL => request.version,
+					
+					# The request scheme:
+					::Rack::RACK_URL_SCHEME => request.scheme,
 					
 					# I'm not sure what sane defaults should be here:
-					'SERVER_NAME' => server_name || '',
-					'SERVER_PORT' => server_port || '',
+					::Rack::SERVER_NAME => server_name || '',
+					::Rack::SERVER_PORT => server_port || '',
 				}
 				
-				if content_type = request.headers.delete('content-type')
-					env['CONTENT_TYPE'] = content_type
-				end
-				
-				if content_length = request.headers.delete('content-length')
-					env['CONTENT_LENGTH'] = content_length
-				end
-				
-				self.unwrap_headers(request.headers, env)
-				
-				# HTTP/2 prefers `:authority` over `host`, so we do this for backwards compatibility.
-				env['HTTP_HOST'] ||= request.authority
-				
-				if remote_address = request.remote_address
-					env['REMOTE_ADDR'] = remote_address.ip_address if remote_address.ip?
-				end
+				self.unwrap_request(request, env)
 				
 				if request.hijack?
-					env['rack.hijack?'] = true
+					env[::Rack::RACK_IS_HIJACK] = true
 					
-					env['rack.hijack'] = lambda do
+					env[::Rack::RACK_HIJACK] = lambda do
 						wrapper = request.hijack
 						
 						# We dup this as it might be taken out of the normal control flow, and the io will be closed shortly after returning from this method.
 						io = wrapper.io.dup
 						wrapper.close
 						
-						env['rack.hijack_io'] = io
+						# This is implicitly returned:
+						env[::Rack::RACK_HIJACK_IO] = io
 					end
 				else
-					env['rack.hijack?'] = false
+					env[::Rack::RACK_IS_HIJACK] = false
 				end
 				
 				status, headers, body = @app.call(env)
 				
+				# Partial hijack is not supported/tested.
 				# if hijack = headers.delete('rack.hijack')
 				# 	body = Async::HTTP::Body::Writable.new
 				# 
@@ -128,8 +156,7 @@ module Falcon
 				# 	return nil
 				# end
 				
-				@logger.debug(request) {"Rack response: #{status} #{headers.inspect} #{body.class}"}
-				return Response.wrap(status, headers, body)
+				return make_response(request, status, headers, body)
 			rescue => exception
 				@logger.error "#{exception.class}: #{exception.message}\n\t#{$!.backtrace.join("\n\t")}"
 				

data/lib/falcon/adapters/rewindable.rb

@@ -51,12 +51,14 @@ module Falcon
 				return false
 			end
 			
+			# Wrap the request body in a rewindable buffer.
+			# @return [Async::HTTP::Response] the response.
 			def call(request)
 				if body = request.body and needs_rewind?(request)
 					request.body = Async::HTTP::Body::Rewindable.new(body)
 				end
 				
-				response = super
+				return super
 			end
 		end
 	end

data/lib/falcon/command.rb

@@ -19,6 +19,7 @@
 # THE SOFTWARE.
 
 require_relative 'command/serve'
+require_relative 'command/virtual'
 
 require_relative 'version'
 
@@ -39,9 +40,10 @@ module Falcon
 				option '-v/--version', "Print out the application version."
 			end
 			
-			nested '<command>',
+			nested '<command>', {
 				'serve' => Serve,
-				default: 'serve'
+				'virtual' => Virtual
+			}, default: 'serve'
 			
 			def verbose?
 				@options[:logging] == :verbose

data/lib/falcon/command/serve.rb

@@ -90,7 +90,7 @@ module Falcon
 			end
 			
 			def run(verbose = false)
-				app, options = load_app(verbose)
+				app, _ = load_app(verbose)
 				
 				endpoint = Endpoint.parse(@options[:bind], **endpoint_options)
 				
@@ -112,7 +112,7 @@ module Falcon
 						end
 					end
 					
-					server = Falcon::Server.new(app, bound_endpoint, endpoint.protocol)
+					server = Falcon::Server.new(app, bound_endpoint, endpoint.protocol, endpoint.scheme)
 					
 					server.run
 					

data/lib/falcon/command/virtual.rb

@@ -0,0 +1,126 @@
+# 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 '../server'
+require_relative '../endpoint'
+require_relative '../hosts'
+
+require 'async/container'
+require 'async/container/controller'
+
+require 'async/io/host_endpoint'
+require 'async/io/shared_endpoint'
+require 'async/io/ssl_endpoint'
+
+require 'samovar'
+
+require 'rack/builder'
+require 'rack/server'
+
+module Falcon
+	module Command
+		class Virtual < Samovar::Command
+			self.description = "Run an HTTP server with one or more virtual hosts."
+			
+			options do
+				option '--bind-insecure <address>', "Bind redirection to the given hostname/address", default: "http://localhost"
+				option '--bind-secure <address>', "Bind proxy to the given hostname/address", default: "https://localhost"
+				
+				option '--self-signed', "Use self-signed SSL", default: false
+			end
+			
+			many :sites
+			
+			CONFIG_RU = "config.ru"
+			
+			def load_app(path, verbose)
+				config = File.join(path, CONFIG_RU)
+				
+				rack_app, options = Rack::Builder.parse_file(config)
+				
+				return Server.middleware(rack_app, verbose: verbose), options
+			end
+			
+			def client
+				Async::HTTP::Client.new(client_endpoint)
+			end
+			
+			def run(verbose = false)
+				hosts = Falcon::Hosts.new
+				root = Dir.pwd
+				
+				sites.each do |path|
+					name = File.basename(path)
+					
+					hosts.add(name) do |host|
+						host.app_root = File.expand_path(path, root)
+						
+						if @options[:self_signed]
+							host.self_signed!(name)
+						else
+							host.ssl_certificate_path = File.join(path, "ssl", "fullchain.pem")
+							host.ssl_key_path = File.join(path, "ssl", "privkey.pem")
+						end
+					end
+				end
+				
+				controller = Async::Container::Controller.new
+				
+				hosts.each do |name, host|
+					if container = host.start
+						controller << container
+					end
+				end
+				
+				controller << Async::Container::Forked.new do |task|
+					proxy = hosts.proxy
+					secure_endpoint = Async::HTTP::URLEndpoint.parse(@options[:bind_secure], ssl_context: hosts.ssl_context)
+					
+					Process.setproctitle("Falcon Proxy")
+					
+					proxy_server = Falcon::Server.new(proxy, secure_endpoint)
+					
+					proxy_server.run
+				end
+				
+				controller << Async::Container::Forked.new do |task|
+					redirection = hosts.redirection
+					insecure_endpoint = Async::HTTP::URLEndpoint.parse(@options[:bind_insecure])
+					
+					Process.setproctitle("Falcon Redirector")
+					
+					redirection_server = Falcon::Server.new(redirection, insecure_endpoint)
+					
+					redirection_server.run
+				end
+				
+				Process.setproctitle("Falcon Controller")
+				
+				return controller
+			end
+			
+			def invoke(parent)
+				container = run(parent.verbose?)
+				
+				container.wait
+			end
+		end
+	end
+end

data/lib/falcon/hosts.rb

@@ -20,10 +20,18 @@
 
 require 'async/io/endpoint'
 
+require_relative 'proxy'
+require_relative 'redirection'
+
+require 'async/container/forked'
+
 module Falcon
 	class Host
 		def initialize
 			@app = nil
+			@app_root = nil
+			@config_path = "config.ru"
+			
 			@endpoint = nil
 			
 			@ssl_certificate = nil
@@ -33,6 +41,8 @@ module Falcon
 		end
 		
 		attr_accessor :app
+		attr_accessor :app_root
+		attr_accessor :config_path
 		
 		attr_accessor :endpoint
 		
@@ -49,6 +59,40 @@ module Falcon
 			super
 		end
 		
+		def app?
+			@app || @config_path
+		end
+		
+		def load_app(verbose = false)
+			return @app if @app
+			
+			if @config_path
+				rack_app, options = Rack::Builder.parse_file(@config_path)
+				
+				return Server.middleware(rack_app, verbose: verbose)
+			end
+		end
+		
+		def self_signed!(hostname)
+			authority = Localhost::Authority.fetch(hostname)
+			
+			@ssl_context = authority.server_context.tap do |context|
+				context.alpn_select_cb = lambda do |protocols|
+					if protocols.include? "h2"
+						return "h2"
+					elsif protocols.include? "http/1.1"
+						return "http/1.1"
+					elsif protocols.include? "http/1.0"
+						return "http/1.0"
+					else
+						return nil
+					end
+				end
+				
+				context.session_id_context = "falcon"
+			end
+		end
+		
 		def ssl_certificate_path= path
 			@ssl_certificate = OpenSSL::X509::Certificate.new(File.read(path))
 		end
@@ -70,9 +114,13 @@ module Falcon
 			end
 		end
 		
-		def start
-			if app = self.app
+		def start(*args)
+			if self.app?
 				Async::Container::Forked.new do
+					Dir.chdir(@app_root) if @app_root
+					
+					app = self.load_app(*args)
+					
 					server = Falcon::Server.new(app, self.server_endpoint)
 					
 					server.run
@@ -143,5 +191,60 @@ module Falcon
 		def proxy
 			Proxy.new(Falcon::BadRequest, self.client_endpoints)
 		end
+		
+		def redirection
+			Redirection.new(Falcon::BadRequest, self.client_endpoints)
+		end
+		
+		def call(controller)
+			self.each do |name, host|
+				if container = host.start
+					controller << container
+				end
+			end
+
+			proxy = hosts.proxy
+			debug_trap = Async::IO::Trap.new(:USR1)
+
+			profile = RubyProf::Profile.new(merge_fibers: true)
+
+			controller << Async::Container::Forked.new do |task|
+				Process.setproctitle("Falcon Proxy")
+				
+				server = Falcon::Server.new(
+					proxy,
+					Async::HTTP::URLEndpoint.parse(
+						'https://0.0.0.0',
+						reuse_address: true,
+						ssl_context: hosts.ssl_context
+					)
+				)
+				
+				Async::Reactor.run do |task|
+					task.async do
+						debug_trap.install!
+						$stderr.puts "Send `kill -USR1 #{Process.pid}` for detailed status :)"
+						
+						debug_trap.trap do
+							task.reactor.print_hierarchy($stderr)
+							# Async.logger.level = Logger::DEBUG
+						end
+					end
+					
+					task.async do |task|
+						start_time = Async::Clock.now
+						
+						while true
+							task.sleep(600)
+							duration = Async::Clock.now - start_time
+							puts "Handled #{proxy.count} requests; #{(proxy.count.to_f / duration.to_f).round(1)} requests per second."
+						end
+					end
+					
+					$stderr.puts "Starting server"
+					server.run
+				end
+			end
+		end
 	end
 end

data/lib/falcon/proxy.rb

@@ -32,7 +32,10 @@ module Falcon
 	end
 	
 	class Proxy < Async::HTTP::Middleware
+		FORWARDED = 'forwarded'.freeze
 		X_FORWARDED_FOR = 'x-forwarded-for'.freeze
+		X_FORWARDED_PROTO = 'x-forwarded-proto'.freeze
+		
 		VIA = 'via'.freeze
 		CONNECTION = ::HTTP::Protocol::CONNECTION
 		
@@ -83,19 +86,38 @@ module Falcon
 			headers.slice!(HOP_HEADERS)
 		end
 		
+		def prepare_request(request)
+			forwarded = []
+			
+			if address = request.remote_address
+				request.headers.add(X_FORWARDED_FOR, address.ip_address)
+				forwarded << "for=#{address.ip_address}"
+			end
+			
+			if scheme = request.scheme
+				request.headers.add(X_FORWARDED_PROTO, scheme)
+				forwarded << "proto=#{scheme}"
+			end
+			
+			unless forwarded.empty?
+				request.headers.add(FORWARDED, forwarded.join(';'))
+			end
+			
+			request.headers.add(VIA, "#{request.version} #{self.class}")
+			
+			self.prepare_headers(request.headers)
+			
+			return request
+		end
+		
 		def call(request)
 			if endpoint = lookup(request)
 				@count += 1
 				
-				if address = request.remote_address
-					request.headers.add(X_FORWARDED_FOR, address.ip_address)
-				end
-				
-				request.headers.add(VIA, "#{request.version} #{self.class}")
+				request = self.prepare_request(request)
 				
 				client = connect(endpoint)
 				
-				prepare_headers(request.headers)
 				client.call(request)
 			else
 				super

data/lib/falcon/redirection.rb

@@ -0,0 +1,58 @@
+# 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 'async/http/client'
+require 'http/protocol/headers'
+
+module Falcon
+	module NotFound
+		def self.call(request)
+			return Async::HTTP::Response[404, {}, []]
+		end
+		
+		def self.close
+		end
+	end
+	
+	class Redirection < Async::HTTP::Middleware
+		def initialize(app, hosts)
+			super(app)
+			
+			@hosts = hosts
+		end
+		
+		def lookup(request)
+			# Trailing dot and port is ignored/normalized.
+			if authority = request.authority.sub(/(\.)?(:\d+)?$/, '')
+				return @hosts[authority]
+			end
+		end
+		
+		def call(request)
+			if endpoint = lookup(request)
+				location = "https://#{request.authority}#{request.path}"
+				
+				return Async::HTTP::Response[301, {'location' => location}, []]
+			else
+				super
+			end
+		end
+	end
+end

data/lib/falcon/version.rb

@@ -19,5 +19,5 @@
 # THE SOFTWARE.
 
 module Falcon
-	VERSION = "0.18.14"
+	VERSION = "0.19.0"
 end

data/lib/rack/handler/falcon.rb

@@ -8,6 +8,8 @@ require 'async/io/host_endpoint'
 module Rack
 	module Handler
 		module Falcon
+			SCHEME = "http".freeze
+			
 			def self.endpoint_for(**options)
 				host = options[:Host] || 'localhost'
 				port = Integer(options[:Port] || 9292)
@@ -21,7 +23,7 @@ module Rack
 				app = ::Falcon::Adapters::Rack.new(app)
 				app = ::Falcon::Adapters::Rewindable.new(app)
 				
-				server = ::Falcon::Server.new(app, endpoint)
+				server = ::Falcon::Server.new(app, endpoint, Async::HTTP::Protocol::HTTP1, SCHEME)
 				
 				Async::Reactor.run do
 					server.run

data/server.rb

@@ -30,66 +30,7 @@ end
 
 controller = Async::Container::Controller.new
 
-hosts.each do |name, host|
-	if container = host.start
-		controller << container
-	end
-end
-
-proxy = hosts.proxy
-debug_trap = Async::IO::Trap.new(:USR1)
-
-profile = RubyProf::Profile.new(merge_fibers: true)
-
-#controller << Async::Container::Forked.new do |task|
-	Process.setproctitle("Falcon Proxy")
-	
-	server = Falcon::Server.new(
-		proxy,
-		Async::HTTP::URLEndpoint.parse(
-			'https://0.0.0.0',
-			reuse_address: true,
-			ssl_context: hosts.ssl_context
-		)
-	)
-
-begin
-	#profile.start
-	
-	Async::Reactor.run do |task|
-		task.async do
-			debug_trap.install!
-			$stderr.puts "Send `kill -USR1 #{Process.pid}` for detailed status :)"
-			
-			debug_trap.trap do
-				task.reactor.print_hierarchy($stderr)
-				# Async.logger.level = Logger::DEBUG
-			end
-		end
-		
-		task.async do |task|
-			start_time = Async::Clock.now
-			
-			while true
-				task.sleep(600)
-				duration = Async::Clock.now - start_time
-				puts "Handled #{proxy.count} requests; #{(proxy.count.to_f / duration.to_f).round(1)} requests per second."
-			end
-		end
-		
-		$stderr.puts "Starting server"
-		server.run
-	end
-ensure
-	if profile.running?
-		profile.stop
-		
-		# print a flat profile to text
-		printer = RubyProf::FlatPrinter.new(profile)
-		printer.print($stdout)
-	end
-end
-
-#Process.setproctitle("Falcon Controller")
-#controller.wait
+hosts.call(controller)
 
+Process.setproctitle("Falcon Controller")
+controller.wait

data/tasks/benchmark.rake

@@ -42,7 +42,7 @@ namespace :benchmark do
 						
 						socket = endpoint.connect
 						
-						request = Async::HTTP::Request.new("localhost", "GET", "/small")
+						request = Async::HTTP::Request.new("http", "localhost", "GET", "/small")
 						stream = Async::IO::Stream.new(socket)
 						protocol = Async::HTTP::Protocol::HTTP1.client(stream)
 						

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: falcon
 version: !ruby/object:Gem::Version
-  version: 0.18.14
+  version: 0.19.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-17 00:00:00.000000000 Z
+date: 2018-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-protocol
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: async-io
   requirement: !ruby/object:Gem::Requirement
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.34.0
+        version: 0.36.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.34.0
+        version: 0.36.0
 - !ruby/object:Gem::Dependency
   name: async-container
   requirement: !ruby/object:Gem::Requirement
@@ -208,9 +208,11 @@ files:
 - lib/falcon/adapters/rewindable.rb
 - lib/falcon/command.rb
 - lib/falcon/command/serve.rb
+- lib/falcon/command/virtual.rb
 - lib/falcon/endpoint.rb
 - lib/falcon/hosts.rb
 - lib/falcon/proxy.rb
+- lib/falcon/redirection.rb
 - lib/falcon/server.rb
 - lib/falcon/verbose.rb
 - lib/falcon/version.rb