In this article we will discuss how we can sail with Rack in a real-world problem.
What Is Rack
Rack is a minimalistic Ruby Web server Interface. As a matter of fact, we can use Rack to build web applications if we follow its protocol. Notably, the protocol is straightforward. We need a Ruby object that responds to the call method which returns a three-element Array:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
# rack_hello_world.rb require 'rack' class HelloWorldApp def self.call(env) # 200 is the HTTP status code # the second element is the response HTTP header hash # finally the last element is the response body ['200', {'Content-Type' => 'text/html'}, ['A hello world rack app.']] end end Rack::Handler::WEBrick.run HelloWorldApp |
To try the above rack application:
|
1 2 3 |
$ gem install rack $ mkdir rack_hello_world $ cd rack_hello_world |
Write the rack_hello_world.rb file and execute:
|
1 2 |
$ ruby rack_hello_world.rb $ curl -I http://localhost:8080 |
The Middleware
We can compose Rack applications together using middlewares. A middleware basically lets us wrap different inputs and outputs in order to integrate them into our problem-solving.
One common usage is in Rails. For example, Rails uses middlewares to wrap HTTP requests in a simple way.
Continuing from the previous example lets implement a middleware which will add some headers to our response:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# rack_hello_world.rb # ... class AddSomeHeaders def initialize(app) @app = app end def call(env) @app.call(env).tap { |status, headers, body| headers['X-awesome'] = true } end end app = Rack::Builder.new do use AddSomeHeaders run HelloWorldApp end Rack::Server.start app: app |
The response headers:
|
1 2 3 4 5 6 7 8 |
$ curl -I http://localhost:8080 # => HTTP/1.1 200 OK # => Content-Type: text/html # => X-Awesome: true # => Server: WEBrick/1.3.1 (Ruby/2.3.3/2016-11-21) # => Date: Thu, 01 Jan 2018 21:29:53 GMT # => Content-Length: 23 # => Connection: Keep-Alive |
The Real World
For a real-world usage of a Rack middleware, we can open the Rails project.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# /actionpack/lib/action_dispatch/middleware/ssl.rb # I simplified the call for the article's purpose def call(env) request = Request.new env if request.ssl? @app.call(env).tap do |status, headers, body| set_hsts_header! headers end end end |
As a matter of fact, we can observe that the tap is being used. This basically enables us to manipulate the app object(here the response) in a clean way at a later time. To put it differently, the logic is that @app.call(env) will have to return before the tap block gets executed.
The above is equivalent to:
|
1 2 3 4 5 6 7 8 9 |
def call(env) request = Request.new env if request.ssl? res = @app.call(env) res[1] = set_hsts_header! res[1] res end end |
It’s important to realize that if we want to place a middleware before the ActionDispatch::SSL one we would have to tap(sic) into the object after the ActionDispatch::SSL middleware is done.
Indeed, we can observe this functionality if we extend our previous example:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
# rack_hello_world.rb # ... class EditSomeHeaders def initialize(app) @app = app end def call(env) @app.call(env).tap do |status, headers, body| headers.delete('X-awesome') headers['X-double-awesome'] = 'true' end end end app = Rack::Builder.new do use EditSomeHeaders use AddSomeHeaders run HelloWorldApp end Rack::Handler::WEBrick.run app |
Notice how EditSomeHeaders is being placed before AddSomeHeaders in the middleware stack.
To clarify, execute:
|
1 2 3 4 5 6 7 8 |
$ curl -I http://localhost:8080 # => HTTP/1.1 200 OK # => Content-Type: text/html # => X-Double-Awesome: true # => This has changed # => Server: WEBrick/1.3.1 (Ruby/2.3.3/2016-11-21) # => Date: Thu, 01 Jan 2018 22:24:29 GMT # => Content-Length: 23 # => Connection: Keep-Alive |
Meanwhile, the full code example is available on github.
Takeaway
In this article, we’ve explored the basic concepts of Rack, built a Rack middleware and investigated how Rails utilizes
Rack to enforce the SSL policy.
All things considered, reading the code under the hood of a famous or well-engineered library or framework can teach us new methodologies and ways of solving problems. In essence, going through the Rails source code taught us how to use the tap method to manipulate a Rack object that is being manipulated later in the stack.