falcon 0.34.5 → 0.35.0

data/lib/falcon/{host.rb → command/proxy.rb}

@@ -18,55 +18,49 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'service'
+require_relative '../controller/proxy'
+require_relative 'paths'
+
+require 'samovar'
 
 module Falcon
-	class Host < Service
-		def name
-			"Falcon Host for #{self.authority}"
-		end
-		
-		def authority
-			@evaluator.authority
-		end
-		
-		def endpoint
-			@evaluator.endpoint
-		end
-		
-		def ssl_context
-			@evaluator.ssl_context
-		end
-		
-		def root
-			@evaluator.root
-		end
-		
-		def bound_endpoint
-			@evaluator.bound_endpoint
-		end
-		
-		def to_s
-			"\#<#{self.class} #{@evaluator.authority}>"
-		end
-		
-		def run(container)
-			if @environment.include?(:server)
-				bound_endpoint = self.bound_endpoint
-				
-				container.run(name: self.name, restart: true) do |task, instance|
-					Async.logger.info(self) {"Starting application server, binding to #{self.endpoint}..."}
-					
-					server = @evaluator.server
-					
-					server.run
-					
-					task.children.each(&:wait)
+	module Command
+		class Proxy < Samovar::Command
+			self.description = "Proxy to one or more backend hosts."
+			
+			options do
+				option '--bind <address>', "Bind to the given hostname/address", default: "https://[::]:443"
+			end
+			
+			many :paths
+			
+			include Paths
+			
+			def controller
+				Controller::Proxy.new(self)
+			end
+			
+			def container_class
+				Async::Container.best_container_class
+			end
+			
+			def container_options
+				{}
+			end
+			
+			def call
+				Async.logger.info(self) do |buffer|
+					buffer.puts "Falcon Proxy v#{VERSION} taking flight!"
+					buffer.puts "- Binding to: #{@options[:bind]}"
+					buffer.puts "- To terminate: Ctrl-C or kill #{Process.pid}"
+					buffer.puts "- To reload: kill -HUP #{Process.pid}"
 				end
 				
-				container.attach do
-					bound_endpoint.close
-				end
+				self.controller.run
+			end
+			
+			def endpoint(**options)
+				Async::HTTP::Endpoint.parse(@options[:bind], **options)
 			end
 		end
 	end

data/lib/falcon/command/redirect.rb

@@ -0,0 +1,72 @@
+# 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 '../controller/redirect'
+require_relative 'paths'
+
+require 'samovar'
+
+module Falcon
+	module Command
+		class Redirect < Samovar::Command
+			self.description = "Redirect from insecure HTTP to secure HTTP."
+			
+			options do
+				option '--bind <address>', "Bind to the given hostname/address", default: "http://[::]:80"
+				option '--redirect <address>', "Redirect using this address as a template.", default: "https://[::]:443"
+			end
+			
+			many :paths
+			
+			include Paths
+			
+			def controller
+				Controller::Redirect.new(self)
+			end
+			
+			def container_class
+				Async::Container.best_container_class
+			end
+			
+			def container_options
+				{}
+			end
+			
+			def call
+				Async.logger.info(self) do |buffer|
+					buffer.puts "Falcon Redirect v#{VERSION} taking flight!"
+					buffer.puts "- Binding to: #{@options[:bind]}"
+					buffer.puts "- To terminate: Ctrl-C or kill #{Process.pid}"
+					buffer.puts "- To reload: kill -HUP #{Process.pid}"
+				end
+				
+				self.controller.run
+			end
+			
+			def endpoint(**options)
+				Async::HTTP::Endpoint.parse(@options[:bind], **options)
+			end
+			
+			def redirect_endpoint(**options)
+				Async::HTTP::Endpoint.parse(@options[:redirect], **options)
+			end
+		end
+	end
+end

data/lib/falcon/command/serve.rb

@@ -20,8 +20,10 @@
 
 require_relative '../server'
 require_relative '../endpoint'
+require_relative '../controller/serve'
 
 require 'async/container'
+
 require 'async/io/trap'
 require 'async/io/host_endpoint'
 require 'async/io/shared_endpoint'
@@ -40,16 +42,16 @@ module Falcon
 			self.description = "Run an HTTP server."
 			
 			options do
-				option '-b/--bind <address>', "Bind to the given hostname/address", default: "https://localhost:9292"
+				option '-b/--bind <address>', "Bind to the given hostname/address.", default: "https://localhost:9292"
 				
-				option '-p/--port <number>', "Override the specified port", type: Integer
+				option '-p/--port <number>', "Override the specified port.", type: Integer
 				option '-h/--hostname <hostname>', "Specify the hostname which would be used for certificates, etc."
-				option '-t/--timeout <duration>', "Specify the maximum time to wait for blocking operations.", type: Float, default: nil
+				option '-t/--timeout <duration>', "Specify the maximum time to wait for non-blocking operations.", type: Float, default: nil
 				
-				option '-c/--config <path>', "Rackup configuration file to load", default: 'config.ru'
-				option '--preload', "Preload the bundle before creating containers"
+				option '-c/--config <path>', "Rackup configuration file to load.", default: 'config.ru'
+				option '--preload', "Preload the bundle before creating containers."
 				
-				option '--forked | --threaded | --hybrid', "Select a specific parallelism model", key: :container, default: :forked
+				option '--forked | --threaded | --hybrid', "Select a specific parallelism model.", key: :container, default: :forked
 				
 				option '-n/--count <count>', "Number of instances to start.", default: Async::Container.processor_count, type: Integer
 				
@@ -68,7 +70,11 @@ module Falcon
 				end
 			end
 			
-			def load_app(verbose)
+			def verbose?
+				@parent&.verbose?
+			end
+			
+			def load_app(verbose = self.verbose?)
 				rack_app, options = Rack::Builder.parse_file(@options[:config])
 				
 				return Server.middleware(rack_app, verbose: verbose), options
@@ -95,6 +101,10 @@ module Falcon
 				slice_options(:hostname, :port, :reuse_port, :timeout)
 			end
 			
+			def endpoint
+				Endpoint.parse(@options[:bind], **endpoint_options)
+			end
+			
 			def client_endpoint
 				Async::HTTP::Endpoint.parse(@options[:bind], **endpoint_options)
 			end
@@ -103,62 +113,22 @@ module Falcon
 				Async::HTTP::Client.new(client_endpoint)
 			end
 			
-			def run(verbose = false)
-				if @options[:preload]
-					Bundler.require(:preload)
-				end
-				
-				endpoint = Endpoint.parse(@options[:bind], **endpoint_options)
-				
-				bound_endpoint = Async::Reactor.run do
-					Async::IO::SharedEndpoint.bound(endpoint)
-				end.wait
-				
-				Async.logger.info(endpoint) do |buffer|
-					buffer.puts "Falcon v#{VERSION} taking flight! Using #{container_class} #{container_options}"
+			def controller
+				Controller::Serve.new(self)
+			end
+			
+			def call
+				Async.logger.info(self.endpoint) do |buffer|
+					buffer.puts "Falcon v#{VERSION} taking flight! Using #{self.container_class} #{self.container_options}."
 					buffer.puts "- To terminate: Ctrl-C or kill #{Process.pid}"
+					buffer.puts "- To reload configuration: kill -HUP #{Process.pid}"
 				end
 				
-				debug_trap = Async::IO::Trap.new(:USR1)
-				debug_trap.ignore!
-				
-				container = container_class.new
-				
-				container.attach do
-					bound_endpoint.close
-				end
-				
-				container.run(name: "Falcon Server", restart: true, **container_options) do |task, instance|
-					task.async do
-						if debug_trap.install!
-							Async.logger.info(instance) do
-								"- Per-process status: kill -USR1 #{Process.pid}"
-							end
-						end
-						
-						debug_trap.trap do
-							Async.logger.info(self) do |buffer|
-								task.reactor.print_hierarchy(buffer)
-							end
-						end
-					end
-					
-					app, _ = load_app(verbose)
-					
-					server = Falcon::Server.new(app, bound_endpoint, endpoint.protocol, endpoint.scheme)
-					
-					server.run
-					
-					task.children.each(&:wait)
+				if @options[:preload]
+					Bundler.require(:preload)
 				end
 				
-				return container
-			end
-			
-			def call
-				container = run(parent.verbose?)
-				
-				container.wait
+				self.controller.run
 			end
 		end
 	end

data/lib/falcon/command/supervisor.rb

@@ -40,11 +40,11 @@ module Falcon
 				end
 			end
 			
-			class Statistics < Samovar::Command
-				self.description = "Show statistics about the process group."
+			class Metrics < Samovar::Command
+				self.description = "Show metrics about the falcon processes."
 				
 				def call(stream)
-					stream.puts({please: 'statistics'}.to_json, separator: "\0")
+					stream.puts({please: 'metrics'}.to_json, separator: "\0")
 					response = JSON.parse(stream.gets("\0"), symbolize_names: true)
 					
 					pp response
@@ -53,8 +53,8 @@ module Falcon
 			
 			nested :command, {
 				'restart' => Restart,
-				'statistics' => Statistics,
-			}, default: 'statistics'
+				'metrics' => Metrics,
+			}, default: 'metrics'
 			
 			def endpoint
 				Async::IO::Endpoint.unix(@options[:path])

data/lib/falcon/command/top.rb

@@ -0,0 +1,79 @@
+# 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 'serve'
+require_relative 'host'
+require_relative 'virtual'
+require_relative 'proxy'
+require_relative 'redirect'
+require_relative 'supervisor'
+
+require_relative '../version'
+
+require 'samovar'
+
+module Falcon
+	module Command
+		class Top < Samovar::Command
+			self.description = "An asynchronous HTTP server."
+			
+			options do
+				option '--verbose | --quiet', "Verbosity of output for debugging.", key: :logging
+				option '-h/--help', "Print out help information."
+				option '-v/--version', "Print out the application version."
+			end
+			
+			nested :command, {
+				'serve' => Serve,
+				'host' => Host,
+				'virtual' => Virtual,
+				'proxy' => Proxy,
+				'redirect' => Redirect,
+				'supervisor' => Supervisor,
+			}, default: 'serve'
+			
+			def verbose?
+				@options[:logging] == :verbose
+			end
+			
+			def quiet?
+				@options[:logging] == :quiet
+			end
+			
+			def call
+				# if verbose?
+				# 	Async.logger.debug!
+				# elsif quiet?
+				# 	Async.logger.warn!
+				# else
+				# 	Async.logger.info!
+				# end
+				# 
+				if @options[:version]
+					puts "#{self.name} v#{Falcon::VERSION}"
+				elsif @options[:help]
+					self.print_usage
+				else
+					@command.call
+				end
+			end
+		end
+	end
+end

data/lib/falcon/command/virtual.rb

@@ -18,80 +18,45 @@
 # 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_relative '../configuration'
-
-require 'async/container'
-require 'async/container/controller'
-
-require 'async/io/host_endpoint'
-require 'async/io/shared_endpoint'
-require 'async/io/ssl_endpoint'
+require_relative '../controller/virtual'
+require_relative 'paths'
 
 require 'samovar'
 
-require 'rack/builder'
-require 'rack/server'
-
 module Falcon
 	module Command
 		class Virtual < Samovar::Command
 			self.description = "Run one or more virtual hosts with a front-end proxy."
 			
 			options do
-				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://[::]"
+				option '--bind-insecure <address>', "Bind redirection to the given hostname/address", default: "http://[::]:8080"
+				option '--bind-secure <address>', "Bind proxy to the given hostname/address", default: "https://[::]:8443"
 			end
 			
 			many :paths
 			
-			def assume_privileges(path)
-				stat = File.stat(path)
-				
-				Process::GID.change_privilege(stat.gid)
-				Process::UID.change_privilege(stat.uid)
-				
-				home = Etc.getpwuid(stat.uid).dir
-				
-				return {
-					'HOME' => home,
-				}
+			include Paths
+			
+			def controller
+				Controller::Virtual.new(self)
 			end
 			
-			def spawn(path, container, **options)
-				container.spawn(name: self.name, restart: true) do |instance|
-					env = assume_privileges(path)
-					
-					instance.exec(env, "bundle", "exec", path, **options)
-				end
+			def bind_secure
+				@options[:bind_secure]
 			end
 			
-			def run(verbose = false)
-				configuration = Configuration.new(verbose)
-				container = Async::Container.new
-				
-				@paths.each do |path|
-					path = File.expand_path(path)
-					root = File.dirname(path)
-					
-					configuration.load_file(path)
-					
-					spawn(path, container, chdir: root)
-				end
-				
-				hosts = Hosts.new(configuration)
-				
-				hosts.run(container, **@options)
-				
-				return container
+			def bind_insecure
+				@options[:bind_insecure]
 			end
 			
 			def call
-				container = run(parent.verbose?)
+				Async.logger.info(self) do |buffer|
+					buffer.puts "Falcon Virtual v#{VERSION} taking flight!"
+					buffer.puts "- To terminate: Ctrl-C or kill #{Process.pid}"
+					buffer.puts "- To reload all sites: kill -HUP #{Process.pid}"
+				end
 				
-				container.wait
+				self.controller.run
 			end
 			
 			def insecure_endpoint(**options)