falcon 0.25.0 → 0.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96425fc2402b25445c421f2d8dec1739c0f2b04701c6d47de48db140f0a55123
-  data.tar.gz: 3c6b31df8560bbf133873e9c37d9600204e2bd893b139c23a0587678c5cbe22e
+  metadata.gz: fab1eafce5a511075f7339beabec2ef2364693ffeb050b84e90a8223e3faf614
+  data.tar.gz: 6f2512f83e06c16ab5600c66ceefc0d2ea910e6f8a53df3d8d919600c75671af
 SHA512:
-  metadata.gz: c3ce086375cceb639ba87947f286b66c1d53c2693717233bedb1f1fa2222b0b31b1747e3f39566592e508ad1f97545a5334bd5ff051c397fd7a93591a9c28dd5
-  data.tar.gz: 8bbf6a1e2717969ad54dadef79faa2566a3299069d97f675b697f1b0b5f8283419150f2430141bc6bdae09ea6272fb7a284aac44d131874c79aab3a5a24df5f2
+  metadata.gz: 0ce28b54426aa8ccbba9801e18c548a284ffbc8c64b54a9cf03b6d3af75ed11b029b999de1e923509b8e16ff525c465ac82695e6a37c9a207f002447333d5c83
+  data.tar.gz: 916bf5e17a59d440c633471a809fad988693f050d8912dd236150983bbb81a4fd2235406418f5a740072aec8e21ed8844593c123d47533d6b6255ddaa7221d14

data/examples/beer/config.ru

@@ -1,6 +1,7 @@
 #!/usr/bin/env falcon --verbose serve -c
 
 require 'rack'
+require 'trenni'
 
 def bottles(n)
 	n == 1 ? "#{n} bottle" : "#{n} bottles"
@@ -27,7 +28,7 @@ run lambda {|env|
 		count.downto(1) do |i|
 			task.annotate "bottles of beer #{i}"
 			
-			puts "#{bottles(i)} of beer on the wall..."
+			Async.logger.info(body) {"#{bottles(i)} of beer on the wall..."}
 			body.write("<p>#{bottles(i)} of beer on the wall, ")
 			task.sleep(0.1)
 			body.write("#{bottles(i)} of beer, ")
@@ -39,6 +40,9 @@ run lambda {|env|
 			body.write("<script>var child; while (child = document.body.firstChild) child.remove();</script>")
 		end
 		
+		code = File.read(__FILE__)
+		body.write("<h1>Source Code</h1>")
+		body.write("<pre><code>#{Trenni::Markup.escape_string code}</code></pre>")
 		body.write("</body></html>")
 	rescue
 		puts "Remote end closed connection: #{$!}"

data/examples/push/client.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require 'async'
+require 'async/http/url_endpoint'
+require 'async/http/client'
+
+Async do
+	endpoint = Async::HTTP::URLEndpoint.parse("https://localhost:9292")
+	client = Async::HTTP::Client.new(endpoint, Async::HTTP::Protocol::HTTP2::WithPush)
+	
+	response = client.get("/index.html")
+	
+	puts response.status
+	puts response.read
+	puts
+	
+	while promise = response.promises.dequeue
+		promise.wait
+		
+		puts "** Promise: #{promise.request.path} **"
+		puts promise.read
+		puts
+	end
+ensure
+	client.close
+end
+
+puts "Done"

data/examples/push/config.ru

@@ -1,3 +1,4 @@
+#!/usr/bin/env falcon --verbose serve --concurrency 1 --config
 
 class EarlyHints
 	def initialize(app)
@@ -5,7 +6,12 @@ class EarlyHints
 	end
 	
 	def call(env)
-		if env['PATH_INFO'] == "/index.html" and early_hints = env['rack.early_hints']
+		path = env['PATH_INFO']
+		early_hints = early_hints = env['rack.early_hints']
+		
+		Async.logger.debug("path: #{path} #{early_hints}")
+		
+		if path == "/index.html" and early_hints
 			early_hints.push("/style.css")
 			early_hints.push("/script.js")
 		end
@@ -15,5 +21,7 @@ class EarlyHints
 end
 
 use EarlyHints
+
 use Rack::Static, :urls => [""], :root => __dir__, :index => 'index.html'
+
 run lambda{|env| [404, [], ["Not Found"]]}

data/examples/push/script.js

@@ -0,0 +1,2 @@
+
+console.log("Hello World")

data/falcon.gemspec

@@ -16,21 +16,22 @@ 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.15")
+	spec.add_dependency "http-protocol", "~> 0.15"
 	
-	spec.add_dependency("async", "~> 1.13")
-	spec.add_dependency("async-io", "~> 1.18")
-	spec.add_dependency("async-http", "~> 0.38.0")
-	spec.add_dependency("async-container", "~> 0.10.0")
+	spec.add_dependency "async", "~> 1.13"
+	spec.add_dependency "async-io", "~> 1.20"
+	spec.add_dependency "async-http", "~> 0.38.0"
+	spec.add_dependency "async-container", "~> 0.10.0"
 	
-	spec.add_dependency("rack", ">= 1.0")
+	spec.add_dependency "rack", ">= 1.0"
 	
-	spec.add_dependency('samovar', "~> 1.3")
-	spec.add_dependency('localhost', "~> 1.1")
+	spec.add_dependency 'samovar', "~> 1.3"
+	spec.add_dependency 'localhost', "~> 1.1"
+	spec.add_dependency 'build-environment', '~> 1.6'
 	
+	spec.add_development_dependency "trenni"
 	spec.add_development_dependency "async-rspec", "~> 1.7"
 	spec.add_development_dependency "async-websocket", "~> 0.6.0"
-	
 	spec.add_development_dependency "async-process", "~> 1.1"
 	
 	spec.add_development_dependency "covered", "~> 0.10"

data/lib/falcon/command/virtual.rb

@@ -21,6 +21,7 @@
 require_relative '../server'
 require_relative '../endpoint'
 require_relative '../hosts'
+require_relative '../configuration'
 
 require 'async/container'
 require 'async/container/controller'
@@ -40,80 +41,22 @@ module Falcon
 			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
+				option '--bind-insecure <address>', "Bind redirection to the given hostname/address", default: "http://[::]"
+				option '--bind-secure <address>', "Bind proxy to the given hostname/address", default: "https://[::]"
 			end
 			
-			def client
-				Async::HTTP::Client.new(client_endpoint)
-			end
+			many :paths
 			
 			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
+				configuration = Configuration.new(verbose)
 				
-				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
+				@paths.each do |path|
+					configuration.load_file(path)
 				end
 				
-				Process.setproctitle("Falcon Controller")
+				hosts = Hosts.new(configuration)
 				
-				return controller
+				return hosts.run(@options)
 			end
 			
 			def invoke(parent)

data/lib/falcon/configuration.rb

@@ -0,0 +1,195 @@
+# 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 'build/environment'
+require 'async/io/unix_endpoint'
+
+module Falcon
+	class ProxyEndpoint < Async::IO::Endpoint
+		def initialize(endpoint, **options)
+			super(**options)
+			
+			@endpoint = endpoint
+		end
+		
+		attr :endpoint
+		
+		def protocol
+			@options[:protocol]
+		end
+		
+		def scheme
+			@options[:scheme]
+		end
+		
+		def authority
+			@options[:authority]
+		end
+		
+		def connect(&block)
+			@endpoint.connect(&block)
+		end
+		
+		def bind(&block)
+			@endpoint.bind(&block)
+		end
+		
+		def each
+			return to_enum unless block_given?
+			
+			@endpoint.each do |endpoint|
+				yield self.class.new(endpoint, @options)
+			end
+		end
+		
+		def self.unix(path, **options)
+			self.new(::Async::IO::Endpoint.unix(path), **options)
+		end
+	end
+	
+	class Configuration
+		def initialize(verbose = false)
+			@environments = {}
+			@verbose = verbose
+			
+			add(:ssl) do
+				ssl_session_id {"falcon"}
+			end
+			
+			add(:host, :ssl) do
+				ssl_certificate_path {File.expand_path("ssl/certificate.pem", root)}
+				ssl_certificate {OpenSSL::X509::Certificate.new(File.read(ssl_certificate_path))}
+				
+				ssl_private_key_path {File.expand_path("ssl/private.key", root)}
+				ssl_private_key {OpenSSL::PKey::RSA.new(File.read(ssl_private_key_path))}
+				
+				ssl_context do
+					OpenSSL::SSL::SSLContext.new.tap do |context|
+						context.cert = ssl_certificate
+						context.key = ssl_private_key
+						
+						context.session_id_context = ssl_session_id
+						
+						context.set_params
+						
+						context.setup
+					end
+				end
+			end
+			
+			add(:self_signed, :ssl) do
+				ssl_context do
+					contexts = Localhost::Authority.fetch(authority)
+					
+					contexts.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
+			end
+			
+			add(:proxy, :host) do
+				endpoint {::Async::HTTP::URLEndpoint.parse(url)}
+			end
+			
+			add(:rack, :host) do
+				config_path {::File.expand_path("config.ru", root)}
+				
+				middleware do
+					::Falcon::Server.middleware(
+						::Rack::Builder.parse_file(config_path).first, verbose: verbose
+					)
+				end
+				
+				authority 'localhost'
+				scheme 'https'
+				protocol {::Async::HTTP::Protocol::HTTP2}
+				ipc_path {::File.expand_path("server.ipc", root)}
+				
+				endpoint {ProxyEndpoint.unix(ipc_path, protocol: protocol, scheme: scheme, authority: authority)}
+				
+				bound_endpoint do
+					Async::Reactor.run do
+						Async::IO::SharedEndpoint.bound(endpoint)
+					end.wait
+				end
+				
+				server do
+					::Falcon::Server.new(middleware, bound_endpoint, protocol, scheme)
+				end
+			end
+		end
+		
+		attr :environments
+		
+		def add(name, *parents, &block)
+			raise KeyError.new("#{name} is already set", key: name) if @environments.key?(name)
+			
+			environments = parents.map{|name| @environments.fetch(name)}
+			
+			parent = Build::Environment.combine(*environments)
+			
+			@environments[name] = Build::Environment.new(parent, name: name, &block)
+		end
+		
+		def each
+			return to_enum unless block_given?
+			
+			@environments.each do |name, environment|
+				if environment.include?(:authority)
+					yield environment
+				end
+			end
+		end
+		
+		def host(name, *parents, &block)
+			add(name, :host, *parents, &block).tap do |environment|
+				environment[:authority] = name
+			end
+		end
+		
+		def proxy(name, *parents, &block)
+			add(name, :proxy, *parents, &block).tap do |environment|
+				environment[:authority] = name
+			end
+		end
+		
+		def rack(name, *parents, &block)
+			add(name, :rack, *parents, &block).tap do |environment|
+				environment[:authority] = name
+			end
+		end
+		
+		def load_file(path)
+			self.instance_eval(File.read(path), path)
+		end
+	end
+end

data/lib/falcon/hosts.rb

@@ -23,107 +23,71 @@ require 'async/io/endpoint'
 require_relative 'proxy'
 require_relative 'redirection'
 
-require 'async/container/forked'
+require 'async/container'
+require 'async/container/controller'
+require 'async/http/url_endpoint'
 
 module Falcon
 	class Host
-		def initialize
-			@app = nil
-			@app_root = nil
-			@config_path = "config.ru"
-			
-			@endpoint = nil
-			
-			@ssl_certificate = nil
-			@ssl_key = nil
-			
-			@ssl_context = nil
+		def initialize(environment)
+			@environment = environment.flatten
+			@evaluator = @environment.evaluator
 		end
 		
-		attr_accessor :app
-		attr_accessor :app_root
-		attr_accessor :config_path
-		
-		attr_accessor :endpoint
-		
-		attr_accessor :ssl_certificate
-		attr_accessor :ssl_key
-		
-		attr_accessor :ssl_context
+		def name
+			"Falcon Host for #{self.authority}"
+		end
 		
-		def freeze
-			return if frozen?
-			
-			ssl_context
-			
-			super
+		def authority
+			@evaluator.authority
 		end
 		
-		def app?
-			@app || @config_path
+		def endpoint
+			@evaluator.endpoint
 		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
+		def ssl_context
+			@evaluator.ssl_context
 		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
+		def root
+			@evaluator.root
 		end
 		
-		def ssl_certificate_path= path
-			@ssl_certificate = OpenSSL::X509::Certificate.new(File.read(path))
+		def bound_endpoint
+			@evaluator.bound_endpoint
 		end
 		
-		def ssl_key_path= path
-			@ssl_key = OpenSSL::PKey::RSA.new(File.read(path))
+		def to_s
+			"\#<#{self.class} #{@evaluator.authority}>"
 		end
 		
-		def ssl_context
-			@ssl_context ||= OpenSSL::SSL::SSLContext.new.tap do |context|
-				context.cert = @ssl_certificate
-				context.key = @ssl_key
-				
-				context.session_id_context = "falcon"
-				
-				context.set_params
-				
-				context.setup
-			end
+		def assume_privileges(path)
+			stat = File.stat(path)
+			
+			Process::GID.change_privilege(stat.gid)
+			Process::UID.change_privilege(stat.uid)
 		end
 		
-		def start(*args)
-			if self.app?
-				Async::Container::Forked.new do
-					Dir.chdir(@app_root) if @app_root
+		def run(container)
+			if @environment.include?(:server)
+				bound_endpoint = self.bound_endpoint
+				
+				container.run(count: 1, name: self.name) do |task, instance|
+					Async.logger.info(self) {"Starting application server..."}
 					
-					app = self.load_app(*args)
+					if root = self.root
+						Dir.chdir(root)
+					end
+					
+					server = @evaluator.server
 					
-					server = Falcon::Server.new(app, self.server_endpoint)
+					# Drop root privileges:
+					assume_privileges(root)
 					
 					server.run
+					
+					task.children.each(&:wait)
 				end
 			end
 		end
@@ -132,10 +96,14 @@ module Falcon
 	class Hosts
 		DEFAULT_ALPN_PROTOCOLS = ['h2', 'http/1.1'].freeze
 		
-		def initialize
+		def initialize(configuration)
 			@named = {}
 			@server_context = nil
 			@server_endpoint = nil
+			
+			configuration.each do |environment|
+				add(Host.new(environment))
+			end
 		end
 		
 		def each(&block)
@@ -157,9 +125,7 @@ module Falcon
 				end
 				
 				context.session_id_context = "falcon"
-				
 				context.alpn_protocols = DEFAULT_ALPN_PROTOCOLS
-				
 				context.set_params
 				
 				context.setup
@@ -168,83 +134,55 @@ module Falcon
 		
 		def host_context(socket, hostname)
 			if host = @named[hostname]
+				Async.logger.debug(self) {"Resolving #{hostname} -> #{host}"}
+				
 				socket.hostname = hostname
 				
 				return host.ssl_context
+			else
+				Async.logger.warn(self) {"Unable to resolve #{hostname}!"}
+				
+				return nil
 			end
 		end
 		
-		def add(name, host = Host.new, &block)
-			host = Host.new
-			
-			yield host if block_given?
-			
-			@named[name] = host.freeze
-		end
-		
-		def client_endpoints
-			Hash[
-				@named.collect{|name, host| [name, host.endpoint]}
-			]
+		def add(host)
+			@named[host.authority] = host
 		end
 		
 		def proxy
-			Proxy.new(Falcon::BadRequest, self.client_endpoints)
+			Proxy.new(Falcon::BadRequest, @named)
 		end
 		
-		def redirection
-			Redirection.new(Falcon::BadRequest, self.client_endpoints)
+		def redirection(secure_endpoint)
+			Redirection.new(Falcon::BadRequest, @named, secure_endpoint)
 		end
 		
-		def call(controller)
-			self.each do |name, host|
-				if container = host.start
-					controller << container
-				end
+		def run(container = Async::Container::Forked.new, **options)
+			@named.each do |name, host|
+				host.run(container)
 			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")
+			
+			secure_endpoint = Async::HTTP::URLEndpoint.parse(options[:bind_secure], ssl_context: self.ssl_context)
+			insecure_endpoint = Async::HTTP::URLEndpoint.parse(options[:bind_insecure])
+			
+			container.run(count: 1, name: "Falcon Proxy") do |task, instance|
+				proxy = self.proxy
 				
-				server = Falcon::Server.new(
-					proxy,
-					Async::HTTP::URLEndpoint.parse(
-						'https://0.0.0.0',
-						reuse_address: true,
-						ssl_context: hosts.ssl_context
-					)
-				)
+				proxy_server = Falcon::Server.new(proxy, secure_endpoint)
 				
-				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
+				proxy_server.run
 			end
+			
+			container.run(count: 1, name: "Falcon Redirector") do |task, instance|
+				redirection = self.redirection(secure_endpoint)
+				
+				redirection_server = Falcon::Server.new(redirection, insecure_endpoint)
+				
+				redirection_server.run
+			end
+			
+			return container
 		end
 	end
 end

data/lib/falcon/proxy.rb

@@ -86,9 +86,18 @@ module Falcon
 			headers.slice!(HOP_HEADERS)
 		end
 		
-		def prepare_request(request)
+		def prepare_request(request, host)
 			forwarded = []
 			
+			# Async.logger.info(self) do |buffer|
+			# 	buffer.puts "Request authority: #{request.authority}"
+			# 	buffer.puts "Host authority: #{host.authority}"
+			# 	buffer.puts "Endpoint authority: #{host.endpoint.authority}"
+			# end
+			
+			# The authority of the request must match the authority of the endpoint we are proxying to, otherwise SNI and other things won't work correctly.
+			request.authority = host.endpoint.authority
+			
 			if address = request.remote_address
 				request.headers.add(X_FORWARDED_FOR, address.ip_address)
 				forwarded << "for=#{address.ip_address}"
@@ -111,12 +120,12 @@ module Falcon
 		end
 		
 		def call(request)
-			if endpoint = lookup(request)
+			if host = lookup(request)
 				@count += 1
 				
-				request = self.prepare_request(request)
+				request = self.prepare_request(request, host)
 				
-				client = connect(endpoint)
+				client = connect(host.endpoint)
 				
 				client.call(request)
 			else

data/lib/falcon/redirection.rb

@@ -32,10 +32,11 @@ module Falcon
 	end
 	
 	class Redirection < Async::HTTP::Middleware
-		def initialize(app, hosts)
+		def initialize(app, hosts, endpoint)
 			super(app)
 			
 			@hosts = hosts
+			@endpoint = endpoint
 		end
 		
 		def lookup(request)
@@ -46,10 +47,14 @@ module Falcon
 		end
 		
 		def call(request)
-			if endpoint = lookup(request)
-				location = "https://#{request.authority}#{request.path}"
+			if host = lookup(request)
+				if @endpoint.default_port?
+					location = "#{@endpoint.scheme}://#{host.authority}#{request.path}"
+				else
+					location = "#{@endpoint.scheme}://#{host.authority}:#{@endpoint.port}#{request.path}"
+				end
 				
-				return Async::HTTP::Response[301, {'location' => location}, []]
+				return Async::HTTP::Response[301, [['location', location]], []]
 			else
 				super
 			end

data/lib/falcon/version.rb

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

data/server.rb

@@ -1,36 +1,20 @@
-#!/usr/bin/env ruby
+#!/usr/bin/env -S ./bin/falcon virtual --bind-insecure http://[::]:1080 --bind-secure https://[::]:1443
 
-$LOAD_PATH << File.expand_path('lib', __dir__)
+# You will want edit your `/etc/hosts`, adding the following:
+# 127.0.0.1 benchmark.localhost beer.localhost hello.localhost
 
-require 'falcon'
-require 'async/http/url_endpoint'
-require 'async/container/controller'
-require 'async/container/forked'
-
-require 'async/clock'
-require 'ruby-prof'
-
-Async.logger.level = Logger::INFO
-
-hosts = Falcon::Hosts.new
-
-hosts.add('mc.oriontransfer.co.nz') do |host|
-	host.endpoint = Async::HTTP::URLEndpoint.parse('http://hana.local:8123')
-	
-	host.ssl_certificate_path = '/etc/letsencrypt/live/mc.oriontransfer.co.nz/fullchain.pem'
-	host.ssl_key_path = '/etc/letsencrypt/live/mc.oriontransfer.co.nz/privkey.pem'
+rack 'benchmark.localhost', :self_signed do
+	root File.expand_path("examples/benchmark/", __dir__)
 end
 
-hosts.add('chick.nz') do |host|
-	host.endpoint = Async::HTTP::URLEndpoint.parse('http://hana.local:8765')
-	
-	host.ssl_certificate_path = '/etc/letsencrypt/live/chick.nz/fullchain.pem'
-	host.ssl_key_path = '/etc/letsencrypt/live/chick.nz/privkey.pem'
+rack 'beer.localhost', :self_signed do
+	root File.expand_path("examples/beer/", __dir__)
 end
 
-controller = Async::Container::Controller.new
-
-hosts.call(controller)
+rack 'hello.localhost', :self_signed do
+	root File.expand_path("examples/hello/", __dir__)
+end
 
-Process.setproctitle("Falcon Controller")
-controller.wait
+proxy 'codeotaku.localhost', :self_signed do
+	url 'https://www.codeotaku.com'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: falcon
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-01 00:00:00.000000000 Z
+date: 2019-03-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-protocol
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.20'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.20'
 - !ruby/object:Gem::Dependency
   name: async-http
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +122,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: build-environment
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: trenni
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  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
@@ -239,6 +267,7 @@ files:
 - examples/beer/config.ru
 - examples/benchmark/config.ru
 - examples/hello/config.ru
+- examples/push/client.rb
 - examples/push/config.ru
 - examples/push/index.html
 - examples/push/script.js
@@ -261,6 +290,7 @@ files:
 - lib/falcon/command.rb
 - lib/falcon/command/serve.rb
 - lib/falcon/command/virtual.rb
+- lib/falcon/configuration.rb
 - lib/falcon/endpoint.rb
 - lib/falcon/hosts.rb
 - lib/falcon/proxy.rb