Class: Falcon::Service::Application

Inherits:
Proxy show all
Defined in:
lib/falcon/service/application.rb

Overview

Implements an application server using an internal clear-text proxy.

Instance Method Summary collapse

Methods inherited from Proxy

#authority, #endpoint, #name, #protocol, #root, #scheme, #ssl_context

Methods inherited from Generic

#include?, #logger, #name, wrap

Constructor Details

#initialize(environment) ⇒ Application

Returns a new instance of Application.


32
33
34
35
36
 
# File 'lib/falcon/service/application.rb', line 32

def initialize(environment)
	super
	
	@bound_endpoint = nil
end

Instance Method Details

#count ⇒ Object

Number of instances to start.


47
48
49
 
# File 'lib/falcon/service/application.rb', line 47

def count
  @environment.evaluator.count
end

#middleware ⇒ Object

The middleware that will be served by this application.


40
41
42
43
 
# File 'lib/falcon/service/application.rb', line 40

def middleware
	# In a multi-threaded container, we don't want to modify the shared evaluator's cache, so we create a new evaluator:
	@environment.evaluator.middleware
end

#preload! ⇒ Object

Preload any resources specified by the environment.


52
53
54
55
56
57
58
59
60
 
# File 'lib/falcon/service/application.rb', line 52

def preload!
	if scripts = @evaluator.preload
		scripts.each do |path|
			Console.logger.info(self) {"Preloading #{path}..."}
			full_path = File.expand_path(path, self.root)
			load(full_path)
		end
	end
end

#setup(container) ⇒ Object

Setup instances of the application into the container.


78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/falcon/service/application.rb', line 78

def setup(container)
	protocol = self.protocol
	scheme = self.scheme
	
	run_options = {
		name: self.name,
		restart: true,
	}
	
	run_options[:count] = count unless count.nil?
	
	container.run(**run_options) do |instance|
		Async do |task|
			Console.logger.info(self) {"Starting application server for #{self.root}..."}
			
			server = Server.new(self.middleware, @bound_endpoint, protocol: protocol, scheme: scheme)
			
			server.run
			
			instance.ready!
			
			task.children.each(&:wait)
		end
	end
	
	super
end

#start ⇒ Object

Prepare the bound endpoint for the application instances. Invoke #preload! to load shared resources into the parent process.


64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/falcon/service/application.rb', line 64

def start
	Console.logger.info(self) {"Binding to #{self.endpoint}..."}
	
	@bound_endpoint = Async::Reactor.run do
		Async::IO::SharedEndpoint.bound(self.endpoint)
	end.wait
	
	preload!
	
	super
end

#stop ⇒ Object

Close the bound endpoint.


107
108
109
110
111
112
 
# File 'lib/falcon/service/application.rb', line 107

def stop
	@bound_endpoint&.close
	@bound_endpoint = nil
	
	super
end