Rack
Rack provides a minimal interface between webservers supporting Ruby and Ruby frameworks. This
might seem a fairly simple thing, but it gives us a lot of power. One of the things it enables is
Rack Middleware which is a filter that can be used to intercept a request and alter the response
as a request is made to an application.
To use Rack, provide an app: an object that responds to the call method, taking the environment
hash as a parameter, and returning an Array with three elements:
- The HTTP response code
- A Hash of headers
- The response body, which must respond to each
Init environment
Create gemset
$ rvm use ruby-2.6.6@rack --createBash
Install Rack
$ gem install rackBash
Create folder for application
$ mkdir racker $ cd racker/Bash
Rack Application
config.ru
class Racker def call(env) [200, { 'Content-Type' => 'text/plain' }, ['Something happens!']] end end run Racker.newRuby
$ rackupBash
$ curl http://localhost:9292 Something happens!Bash
Rackup
rackup is a useful tool for running Rack applications,
which uses the Rack::Builder DSL to configure middleware and build up applications easily.
Rackup automatically figures out the environment it is run in,
and runs your application as FastCGI, CGI, or standalone with Puma, Thin or WEBrick from the same configuration.
To rackup the application we need to create a file with .ru file extension,
then drop our simple application inside it and use the rackup command line tool to start it.
rackup - https://github.com/rack/rack/blob/master/bin/rackup
Rack::Builder - https://github.com/rack/rack/blob/master/lib/rack/builder.rb
Accepted env hash
{ "GATEWAY_INTERFACE"=>"CGI/1.1", "PATH_INFO"=>"/", "QUERY_STRING"=>"", "REMOTE_ADDR"=>"::1", "REMOTE_HOST"=>"::1", "REQUEST_METHOD"=>"GET", "REQUEST_URI"=>"http://localhost:9292/", "SCRIPT_NAME"=>"", "SERVER_NAME"=>"localhost", "SERVER_PORT"=>"9292", "SERVER_PROTOCOL"=>"HTTP/1.1", "SERVER_SOFTWARE"=>"WEBrick/1.3.1 (Ruby/2.3.2/2016-11-15)", "HTTP_HOST"=>"localhost:9292", "HTTP_CONNECTION"=>"keep-alive", "HTTP_UPGRADE_INSECURE_REQUESTS"=>"1", "HTTP_USER_AGENT"=>"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36", "HTTP_ACCEPT"=>"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8", "HTTP_ACCEPT_ENCODING"=>"gzip, deflate, sdch, br", "HTTP_ACCEPT_LANGUAGE"=>"en-US,en;q=0.8,ru;q=0.6", "rack.version"=>[1, 3], "rack.multithread"=>true, "REQUEST_PATH"=>"/", "rack.tempfiles"=>[] }Ruby
Rack Middleware
Each middleware is responsible of calling the next.
middlewares/custom_header.rb
module Middlewares class CustomHeader def initialize(app) @app = app end def call(env) status, headers, body = @app.call(env) headers['X-Custom-Header'] = 'content' [status, headers, body] end end endRuby
middlewares/welcome.rb
module Middlewares class Welcome def initialize(app) @app = app end def call(env) req = Rack::Request.new(env).path if req == '/welcome' [200, { 'Content-Type' => 'text/plain' }, ['Welcome!']] else @app.call(env) end end end endRuby
config.ru
require './middlewares/custom_header' require './middlewares/welcome' app = Rack::Builder.new do use Middlewares::Welcome use Middlewares::CustomHeader run proc { |env| [200, { 'Content-Type' => 'text/plain' }, ['Hello!']] } end run appRuby
$ rackupBash
Response
config.ru
class Racker def call(env) Rack::Response.new('We use Rack::Response! Yay!').finish end end run Racker.newRuby
$ rackupSh
$ curl http://localhost:9292 We use Rack::Response! Yay!Sh
Just make it useful
config.ru
require './middlewares/racker' run Middlewares::Racker.newRuby
middlewares/racker.rb
require 'erb' module Middlewares class Racker def call(env) Rack::Response.new(render('index.html.erb')).finish end private def render(template) path = File.expand_path("../lib/views/#{template}", __FILE__) ERB.new(File.read(path)).result(binding) end end endRuby
lib/views/index.html.erb
<!DOCTYPE html> <html> <head> <title>WEB page</title> </head> <body> <div id='container'> <h1>We can load HTML! Wow!</h1> </div> </body> </html>HTML
$ rackupBash
$ curl http://localhost:9292 <!DOCTYPE html> <html> <head> <title>WEB page</title> </head> <body> <div id='container'> <h1>We can load HTML! Wow!</h1> </div> </body> </html>Bash
Request
middlewares/racker.rb
require 'erb' module Middlewares class Racker def call(env) request = Rack::Request.new(env) case request.path when '/' then respond(render('index.html.erb')) else respond('Not Found', 404) end end private def render(template) path = File.expand_path("../views/#{template}", __FILE__) ERB.new(File.read(path)).result(binding) end def respond(*args) Rack::Response.new(*args).finish end end endRuby
$ rackupBash
$ curl http://localhost:9292 <!DOCTYPE html> <html> <head> <title>WEB page</title> </head> <body> <div id='container'> <h1>We can load HTML! Wow!</h1> </div> </body> </html>Bash
$ curl http://localhost:9292/page Not FoundBash
Just do it a little complicated
config.ru
require './middlewares/racker' run Middlewares::RackerRuby
middlewares/racker.rb
require 'erb' module Middlewares class Racker def self.call(env) new(env).response.finish end def initialize(env) @request = Rack::Request.new(env) end def response case @request.path when '/' then Rack::Response.new(render('index.html.erb')) when '/update_word' Rack::Response.new do |response| response.set_cookie('word', @request.params['word']) response.redirect('/') end else Rack::Response.new('Not Found', 404) end end def render(template) path = File.expand_path("../lib/views/#{template}", __FILE__) ERB.new(File.read(path)).result(binding) end def word @request.cookies['word'] || 'Nothing' end end endRuby
lib/views/index.html.erb
<!DOCTYPE html> <html> <head> <title>WEB page</title> </head> <body> <div id="container"> <h1>You said '<%= word %>'</h1> <p>Say something new</p> <form method="post" action="/update_word"> <input name="word" type="text"> <input type="submit" value="Say!"> </form> </div> </body> </html>HTML
rackup
$ rackupBash
Go to http://localhost:9292
After submit
Use middleware
config.ru
require './middlewares/racker' use Rack::Static, urls: ['/stylesheets'], root: 'public' run Middlewares::RackerRuby
lib/views/index.html.erb
<!DOCTYPE html> <html> <head> <title>WEB page</title> <link rel="stylesheet" href="/stylesheets/application.css" type="text/css"> </head> <body> <div id="container"> <h1>You said '<%= word %>'</h1> <p>Say something new</p> <form method="post" action="/update_word"> <input name="word" type="text"> <input type="submit" value="Say!"> </form> </div> </body> </html>HTML
public/stylesheets/application.css
body { background-color: #4B7399; font-family: Verdana; font-size: 14px; } #container { width: 75%; margin: 0 auto; background-color: #FFF; padding: 20px 40px; border: solid 1px black; margin-top: 20px; } a { color: #0000FF; }CSS
$ rackupBash
$ curl http://localhost:9292/stylesheets/application.css body { background-color: #4B7399; font-family: Verdana; font-size: 14px; } #container { width: 75%; margin: 0 auto; background-color: #FFF; padding: 20px 40px; border: solid 1px black; margin-top: 20px; } a { color: #0000FF; }Bash
Url to Rack::Static - https://github.com/rack/rack/blob/master/lib/rack/static.rb
Rack::Reloader
When you change some code in your application (except config.ru) you need to ‘rackup’ your application one more time.
The reason is that Rack is not able to reload the code of application.
For such reason, it’s recommended to use Rack::Reloader middleware
Using Reloader in middlewares
config.ru
require_relative './middlewares/racker' use Rack::Reloader use Rack::Static, :urls => ['/assets'], :root => 'public' run Middlewares::RackerRuby
Rack::Sessions
If your application needs to work with sessions or with cookies you could add Rack::Sessions::Cookie middleware to your config.ru file.
You must add it between Rack::Reloader and running the application
Using Rack Sessions
config.ru
use Rack::Reloader use Rack::Static, :urls => ['/assets'], :root => 'public' use Rack::Session::Cookie, :key => 'rack.session', :domain => 'foo.com', :path => '/', :expire_after => 2592000, :secret => 'change_me', :old_secret => 'also_change_me' run Middlewares::RackerRuby
Using Rack Sessions
middlewares/racker.rb
module Middlewares class Racker def self.call(env) new(env).response.finish end def initialize(env) @request = Rack::Request.new(env) end def response case @request.path when '/' return Rack::Response.new("My name is #{@request.session[:name]}", 200) if session_present? Rack::Response.new { |response| response.redirect("/endpoint_where_session_starts") } when '/endpoint_where_session_starts' Rack::Response.new do |response| @request.session[:name] = 'John Doe' unless session_present? response.redirect('/') end else Rack::Response.new('Not Found', 404) end end private def session_present? @request.session.key?(:name) end end endRuby
Into Rails
config.ru
# This file is used by Rack-based servers to start the application. require_relative 'config/environment' run Rails.applicationRuby
Rails rack middleware
$ rake middleware use Rack::Sendfile use ActionDispatch::Static use ActionDispatch::Executor use ActiveSupport::Cache::Strategy::LocalCache::Middleware use Rack::Runtime use Rack::MethodOverride use ActionDispatch::RequestId use Rails::Rack::Logger use ActionDispatch::ShowExceptions use WebConsole::Middleware use ActionDispatch::DebugExceptions use ActionDispatch::RemoteIp use ActionDispatch::Reloader use ActionDispatch::Callbacks use ActiveRecord::Migration::CheckPending use ActionDispatch::Cookies use ActionDispatch::Session::CookieStore use ActionDispatch::Flash use Rack::Head use Rack::ConditionalGet use Rack::ETag run TestRailsRack::Application.routesBash
Rails on Rack guides - http://guides.rubyonrails.org/rails_on_rack.html
Rack Specs
Adding helper gem for testing
$ bundle add rack-testBash
spec_helper.rb
require "rack/test" ... include Rack::Test::Methods ...Ruby
Test your requests with rack-test helpers
RSpec.describe Racker do def app Rack::Builder.parse_file('config.ru').first end context 'with rack env' do let(:user_name) { 'John Doe' } let(:env) { { 'HTTP_COOKIE' => "user_name=#{user_name}" } } it 'returns ok status' do get '/', {}, env expect(last_response.body).to include(user_name) end end context 'statuses' do it 'returns status not found' do get '/unknown' expect(last_response).to be_not_found end it 'returns status ok' do get '/' expect(last_response).to be_ok end end context 'cookies' do it 'sets cookies' do set_cookie('user_id=123') get '/' expect(last_request.cookies).to eq({"user_id"=>"123"}) end end context 'redirects' do it 'redirects' do post '/some_url' expect(last_response).to be_redirect expect(last_response.header["Location"]).to eq('/redirect_url') end end endRuby
Codebreaker Web
It’s time to move your Codebreaker to web interface!
Here are all the details of the task.
The End
1/33
Rack
Rack provides a minimal interface between webservers supporting Ruby and Ruby frameworks. This
might seem a fairly simple thing, but it gives us a lot of power. One of the things it enables is
Rack Middleware which is a filter that can be used to intercept a request and alter the response
as a request is made to an application.
To use Rack, provide an app: an object that responds to the call method, taking the environment
hash as a parameter, and returning an Array with three elements:
The HTTP response code
A Hash of headers
The response body, which must respond to each