Class: Falcon::Adapters::Rack

Inherits:
Object
  • Object
show all
Defined in:
lib/falcon/adapters/rack.rb

Defined Under Namespace

Classes: FullHijack

Constant Summary collapse

HTTP_HOST =

CGI keys <tools.ietf.org/html/rfc3875#section-4.1>:

'HTTP_HOST'
PATH_INFO = 
'PATH_INFO'
REQUEST_METHOD = 
'REQUEST_METHOD'
REQUEST_PATH = 
'REQUEST_PATH'
REQUEST_URI = 
'REQUEST_URI'
SCRIPT_NAME = 
'SCRIPT_NAME'
QUERY_STRING = 
'QUERY_STRING'
SERVER_PROTOCOL = 
'SERVER_PROTOCOL'
SERVER_NAME = 
'SERVER_NAME'
SERVER_PORT = 
'SERVER_PORT'
REMOTE_ADDR = 
'REMOTE_ADDR'
CONTENT_TYPE = 
'CONTENT_TYPE'
CONTENT_LENGTH = 
'CONTENT_LENGTH'
RACK_VERSION =

Rack environment variables:

'rack.version'
RACK_ERRORS = 
'rack.errors'
RACK_LOGGER = 
'rack.logger'
RACK_INPUT = 
'rack.input'
RACK_MULTITHREAD = 
'rack.multithread'
RACK_MULTIPROCESS = 
'rack.multiprocess'
RACK_RUNONCE = 
'rack.run_once'
RACK_URL_SCHEME = 
'rack.url_scheme'
RACK_HIJACK = 
'rack.hijack'
RACK_IS_HIJACK = 
'rack.hijack?'
RACK_HIJACK_IO = 
'rack.hijack_io'
ASYNC_HTTP_REQUEST =

Async::HTTP specific metadata:

"async.http.request"
HTTP_X_FORWARDED_PROTO =

Header constants:

'HTTP_X_FORWARDED_PROTO'

Instance Method Summary collapse

Constructor Details

#initialize(app) ⇒ Rack

Initialize the rack adaptor middleware.

Raises:

  • (ArgumentError) 


77
78
79
80
81
 
# File 'lib/falcon/adapters/rack.rb', line 77

def initialize(app)
	@app = app
	
	raise ArgumentError, "App must be callable!" unless @app.respond_to?(:call)
end

Instance Method Details

#call(request) ⇒ Object

Build a rack `env` from the incoming request and apply it to the rack middleware.



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/falcon/adapters/rack.rb', line 139

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],
		
		ASYNC_HTTP_REQUEST => request,
		
		RACK_INPUT => Input.new(request.body),
		RACK_ERRORS => $stderr,
		RACK_LOGGER => Console.logger,
		
		RACK_MULTITHREAD => true,
		RACK_MULTIPROCESS => true,
		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,
		
		# 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 => '',
		
		# 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,
		REQUEST_PATH => request_path,
		REQUEST_URI => request.path,

		# The portion of the request URL that follows the ?, if any. May be empty, but is always required!
		QUERY_STRING => query_string || '',
		
		# The server protocol (e.g. HTTP/1.1):
		SERVER_PROTOCOL => request.version,
		
		# The request scheme:
		RACK_URL_SCHEME => request.scheme,
		
		# I'm not sure what sane defaults should be here:
		SERVER_NAME => server_name,
		SERVER_PORT => server_port,
		
		# We support both request and response hijack.
		RACK_IS_HIJACK => true,
	}
	
	self.unwrap_request(request, env)
	
	full_hijack = false
	
	if request.hijack?
		env[RACK_HIJACK] = lambda do
			wrapper = request.hijack!
			full_hijack = true
			
			# 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
			
			# This is implicitly returned:
			env[RACK_HIJACK_IO] = io
		end
	end
	
	status, headers, body = @app.call(env)
	
	# If there was a full hijack:
	if full_hijack
		raise FullHijack, "The connection was hijacked."
	else
		return Response.wrap(status, headers, body, request)
	end
rescue => exception
	Console.logger.error(self) {exception}
	
	return failure_response(exception)
end

#failure_response(exception) ⇒ Object

Generate a suitable response for the given exception.



219
220
221
 
# File 'lib/falcon/adapters/rack.rb', line 219

def failure_response(exception)
	Protocol::HTTP::Response.for_exception(exception)
end

#unwrap_headers(headers, env) ⇒ Object

Unwrap raw HTTP headers into the CGI-style expected by Rack middleware.

Rack separates multiple headers with the same key, into a single field with multiple lines.



89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/falcon/adapters/rack.rb', line 89

def unwrap_headers(headers, env)
	headers.each do |key, value|
		http_key = "HTTP_#{key.upcase.tr('-', '_')}"
		
		if current_value = env[http_key]
			env[http_key] = "#{current_value};#{value}"
		else
			env[http_key] = value
		end
	end
end

#unwrap_request(request, env) ⇒ Object

Process the incoming request into a valid rack `env`.

  • Set the `env` and `env` based on the incoming request body.

  • Set the `env` header to the request authority.

  • Set the `env` header to the request scheme.

  • Set `env` to the request remote adress.



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/falcon/adapters/rack.rb', line 110

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[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