Class: Falcon::Adapters::Rack

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

Constant Summary collapse

HTTP_X_FORWARDED_PROTO = 
'HTTP_X_FORWARDED_PROTO'.freeze
REMOTE_ADDR = 
'REMOTE_ADDR'.freeze
CONTENT_TYPE = 
'CONTENT_TYPE'.freeze
CONTENT_LENGTH = 
'CONTENT_LENGTH'.freeze

Instance Method Summary collapse

Constructor Details

#initialize(app, logger = Async.logger) ⇒ Rack

Returns a new instance of Rack.

Raises:

  • (ArgumentError) 


37
38
39
40
41
42
43
 
# File 'lib/falcon/adapters/rack.rb', line 37

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

Instance Method Details

#call(request) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
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
135
136
137
138
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
 
# File 'lib/falcon/adapters/rack.rb', line 91

def call(request)
	request_path, query_string = request.path.split('?', 2)
	server_name, server_port = (request.authority || '').split(':', 2)
	
	env = {
		::Rack::RACK_VERSION => [2, 0, 0],
		
		::Rack::RACK_INPUT => Input.new(request.body),
		::Rack::RACK_ERRORS => $stderr,
		
		::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.
		::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.
		::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.
		::Rack::PATH_INFO => request_path,
		
		# The portion of the request URL that follows the ?, if any. May be empty, but is always required!
		::Rack::QUERY_STRING => query_string || '',
		
		# 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:
		::Rack::SERVER_NAME => server_name || '',
		::Rack::SERVER_PORT => server_port || '',
	}
	
	self.unwrap_request(request, env)
	
	if request.hijack?
		env[::Rack::RACK_IS_HIJACK] = true
		
		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
			
			# This is implicitly returned:
			env[::Rack::RACK_HIJACK_IO] = io
		end
	else
		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
	# 
	# 	Task.current.async do
	# 		hijack.call(body)
	# 	end
	# 	return nil
	# end
	
	# if env['rack.hijack_io']
	# 	return nil
	# end
	
	return make_response(request, status, headers, body)
rescue => exception
	@logger.error "#{exception.class}: #{exception.message}\n\t#{$!.backtrace.join("\n\t")}"
	
	return failure_response(exception)
end

#failure_response(exception) ⇒ Object 



170
171
172
 
# File 'lib/falcon/adapters/rack.rb', line 170

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

#make_response(request, status, headers, body) ⇒ Object 



85
86
87
88
89
 
# File 'lib/falcon/adapters/rack.rb', line 85

def make_response(request, status, headers, body)
	# @logger.debug(request) {"Rack response: #{status} #{headers.inspect} #{body.class}"}
	
	return Response.wrap(status, headers, body)
end

#unwrap_headers(headers, env) ⇒ Object

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



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/falcon/adapters/rack.rb', line 46

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}\n#{value}"
		else
			env[http_key] = value
		end
	end
end

#unwrap_request(request, env) ⇒ Object

Process the incoming request into a valid rack env.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/falcon/adapters/rack.rb', line 59

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