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.



35
36
37
38
39
 
# File 'lib/falcon/adapters/rack.rb', line 35

def initialize(app, logger = Async.logger)
  @app = app
  
  @logger = logger
end

Instance Method Details

#call(request) ⇒ Object 



87
88
89
90
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
 
# File 'lib/falcon/adapters/rack.rb', line 87

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 



166
167
168
 
# File 'lib/falcon/adapters/rack.rb', line 166

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

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



81
82
83
84
85
 
# File 'lib/falcon/adapters/rack.rb', line 81

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”.



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/falcon/adapters/rack.rb', line 42

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.



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

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