From Rails to the Webserver to the Browser (Ruby Kaigi)

From Rails to the web server to the browser David
Padilla @dabit

David Padilla - @dabit From Rails to the webserver to
the browser

David Padilla @dabit

www.crowdint.com

Image from: ezilon.com

Population Tokyo Colima 0 3,750,000.00 7,500,000.00 11,250,000.00 15,000,000.00

MagmaConf

Manzanillo, Mexico

June 5 - 7

MagmaConf

From Rails to the web server to the browser

Life of a Request

www.app.com/hello

www.app.com/hello HTTP Request

HTTP Request

<html> <head> <title>Railsconf</title> </head> <body>LOL</body> </html>

class App def call(env) # ... return [http_code, headers, body]
end end

[http_code, headers, body]

[http_code, headers, body] Integer

[http_code, headers, body] Integer Hash

[http_code, headers, body] Integer Hash Responds to :each

Somewhere on the web server...

# ... # ... # ... @app.call(env) # ... #
... # ...

Somewhere on the Application...

class App def call(env) # ... return [http_code, headers, body]
end end

conﬁg.ru

require 'rack/app' run Rack::App.new conﬁg.ru

rackup

All Rails apps are Rack apps

class HelloController def show render text: "Hello World" end end
app/controllers/hello_controller.rb

App::Application.routes.draw do root to: "hello#show" end conﬁg/routes.rb

class TestServer < Test::Unit::TestCase def test_the_request uri = URI('http://127.0.0.1:9292') assert
"Hello World", Net::HTTP.get(uri) end end test/test.rb

@app.call({ "REQUEST_METHOD" => "GET", "PATH_INFO" => "/", "rack.input" => ""
})

[status, headers, body] Rack

StringIO.new(“Hello World”)

class App def call(env) content = "Hello World" status_code =
200 headers = { "Content-Length" => content.length.to_s } [status_code, headers, [content]] end end rack/app.rb

Webservers

# ... # ... # ... @app.call(env) # ... #
... # ...

thin start

module Thin # The uterly famous Thin HTTP server. #
It listen for incoming request through # a given +backend+ # and forward all request to +app+. # # == TCP server # Create a new TCP server on bound # to <tt>host:port</tt> by specifiying +host+ # and +port+ as the first 2 arguments. # # Thin::Server.start('0.0.0.0', 3000, app) lib/thin/server.rb

Thin::Server.start('0.0.0.0', 3000, app) thin start

# Start the server and listen for connections. def start
raise ArgumentError, 'app required' unless @app log ">> Thin web server (v#{VERSION::STRING} codename #{VERSION::C debug ">> Debugging ON" trace ">> Tracing ON" log ">> Maximum connections set to #{@backend.maximum_connections}" log ">> Listening on #{@backend}, CTRL+C to stop" @backend.start end lib/thin/server.rb

@backend.start lib/thin/server.rb

def select_backend(host, port, options) case when options.has_key?(:backend) raise ArgumentError, ":backend
must be options[:backend].new(host, port, optio when options.has_key?(:swiftiply) Backends::SwiftiplyClient.new(host, por when host.include?('/') Backends::UnixServer.new(host) else Backends::TcpServer.new(host, port) end end lib/thin/server.rb

lib/thin/backends/tcp_server.rb

module Thin module Backends # Backend to act as a
TCP socket server. class TcpServer < Base # Address and port on which the server is listening for connections. attr_accessor :host, :port def initialize(host, port) @host = host @port = port super() end # Connect the server def connect @signature = EventMachine.start_server(@host, @port, Connection, &method(:initializ end # Stops the server def disconnect EventMachine.stop_server(@signature) end def to_s "#{@host}:#{@port}" end end end end lib/thin/backends/tcp_server.rb

# Connect the server def connect @signature = EventMachine.start_server(@ end

EventMachine

module Connection def post_init # A client connected end def
receive_data data # Data received end def unbind # Client disconnected end end EventMachine.start_server("0.0.0.0", 8081, Connection) EventMachine

# Connect the server def connect @signature = EventMachine.start_server(@ end

ne.start_server(@host, @port, Connection, &metho lib/thin/backends/tcp_server.rb

lib/thin/connection.rb

# Called when data is received from the client. def
receive_data(data) @idle = false trace { data } process if @request.parse(data) rescue InvalidRequest => e log "!! Invalid request" log_error e post_process Response::BAD_REQUEST end lib/thin/connection.rb

Thin::Request

lib/thin/request.rb

# Parse a chunk of data into the request environment
# Raises a +InvalidRequest+ if invalid. # Returns +true+ if the parsing is complete. def parse(data) if @parser.finished? # Header finished, can only be some more body @body << data else # Parse more header using the super parser @data << data raise InvalidRequest, 'Header longer than allowed' if @data.size > MAX_HEADER @nparsed = @parser.execute(@env, @data, @nparsed) # Transfert to a tempfile if body is very big move_body_to_tempfile if @parser.finished? && content_length > MAX_BODY end if finished? # Check if header and body are complete @data = nil @body.rewind true # Request is fully parsed else false # Not finished, need more data end end lib/thin/request.rb

Mongrel Parser

/** * Copyright (c) 2005 Zed A. Shaw * You
can redistribute it and/or modify * it under the same terms as Ruby. */ #ifndef http11_parser_h #define http11_parser_h #include <sys/types.h> #if defined(_WIN32) #include <stddef.h> #endif

GET /index.html HTTP/1.1 Host:localhost HTTP Request

GET /index.html HTTP/1.1\r\n Host:localhost\r\n\r\n HTTP Request

# Called when data is received from the client def
receive_data(data) @idle = false trace { data } process if @request.parse(data) rescue InvalidRequest => e log "!! Invalid request" log_error e post_process Response::BAD_REQUEST end lib/thin/connection.rb

# Called when all data was received and # the
request is ready to be processed. def process if threaded? @request.threaded = true EventMachine.defer(method(:pre_process), me else @request.threaded = false post_process(pre_process) end end lib/thin/connection.rb

request is ready to be processed. def process if threaded? @request.threaded = true EventMachine.defer(method(:pre_process), else @request.threaded = false post_process(pre_process) end end lib/thin/connection.rb

def pre_process # Add client info to the request env
@request.remote_address = remote_address # Connection may be closed unless the App# # It should be noted that connection objec # callback is no longer referenced, so be @request.async_callback = method(:post_pro if @backend.ssl? @request.env["rack.url_scheme"] = "https if cert = get_peer_cert @request.env['rack.peer_cert'] = cert end end

end # When we're under a non-async framework l #
off async responses using the callback i # in removing this. response = AsyncResponse catch(:async) do # Process the request calling the Rack a response = @app.call(@request.env) end response rescue Exception handle_error # Pass through error response can_persist? && @request.persistent? ? Res end

end # When we're under a non-async framework l #
off async responses using the callback i # in removing this. response = AsyncResponse catch(:async) do # Process the request calling the Rack a response = @app.call(@request.env) end response rescue Exception handle_error # Pass through error response can_persist? && @request.persistent? ? Res end lib/thin/connection.rb

request is ready to be processed. def process if threaded? @request.threaded = true EventMachine.defer(method(:pre_process), else @request.threaded = false post_process(pre_process) end end lib/thin/connection.rb

request is ready to be processed. def process if threaded? @request.threaded = true EventMachine.defer(method(:pre_process), else @request.threaded = false post_process(pre_process) end end

HTTP/1.1 200 OK Content-Length: 11 Hello World HTTP Response

Unicorn

EventMachine

EventMachine No

@app.call(env)

@app.call(env) YES

lib/unicorn/http_server.rb def process_client(client)

Uses the mongrel parser

Uses the mongrel parser Kinda

What we’ve learned so far

EventMachine.start_server("0.0.0.0", 8081, Connection)

GET /index.html HTTP/1.1 Host:localhost

GET /index.html HTTP/1.1 Host:localhost { "REQUEST_METHOD" => "GET", "PATH_INFO" =>
"/", "rack.input" => "" }

@app.call({ "REQUEST_METHOD" => "GET", "PATH_INFO" => "/", "rack.input" => ""
})

[http_code, headers, body]

[http_code, headers, body] HTTP/1.1 200 OK Content-Length: 11 Hello World

HTTP/1.1 200 OK Content-Length: 11 Hello World

Our own Webserver

module Server def receive_data(data) puts data end end rack/server.rb

module Server def receive_data(data) request = Thin::Request.new request.parse(data) puts request.env
end end rack/server.rb

def receive_data(data) request = Thin::Request.new request.parse(data) app = App.new response
= app.call(request.env) end rack/server.rb

HTTP/1.1 200 OK Content-Length: 11 Hello World HTTP Response

Do not try this at home

Do not try this in production

Be curious

dabit/rails-server-browser

El ﬁn

Thank you! David Padilla @dabit [email protected]

From Rails to the Webserver to the Browser (Rub...

From Rails to the Webserver to the Browser (Ruby Kaigi)

More Decks by David Padilla

Other Decks in Technology

Featured

Transcript