Building Scalable, Stateful Servers with Rails

1. Building Scalable Servers
With EventMachine and Rails
Dave Troy
Chief Executive Officer
davetroy@shortmail.com
@davetroy
facebook.com/davetroy

3. EventMachine

4. EventMachine
DRY

5. EventMachine
DRY
DRAG

6. EventMachine
DRY
DRAG
(Don’t Repeat Aman Gupta)

7. require ‘aman_gupta’

8. EventMachine
scalable non-blocking i/o in ruby

9. About Me
Aman Gupta
San Francisco, CA
Been maintaining EventMachine for 18
months (last 4 releases)
Ruby Hero 2009
amqp, REE patches, perftools.rb, gdb.rb,
memprof
github.com/tmm1
@tmm1

10. What is EventMachine?
Implementation of the Reactor pattern
similar to Python’s Twisted also node.js, libev
Ruby VM Support
Ruby 1.8 (MRI)
Ruby 1.9 (YARV) c++ reactor
Rubinius
JRuby java reactor
+ simple Pure Ruby version

11. What is I/O?
Generally Network I/O
mysql query responses
http responses
memcache results
Most web applications are I/O bound, not CPU bound
Basic idea behind EM: Instead of waiting on a response
from the network, use that time to process other
requests

12. What can I use EM for?
Scaling I/O heavy applications
handle 5-10k concurrent connections with a single
ruby process
Any type of network I/O
http requests
sending emails
custom tcp proxies
data access
redis
couchdb
mysql
postgres
casandra
memcached

13. Simple TCP Server
TCPServer#accept require 'socket'
server = TCPServer.new(2202)
to accept
while client = server.accept
connections from msg = client.readline
new clients client.write "You said: #{msg}"
client.close
TCPSocket#read* end
blocks, so you can
require 'socket'
only handle one server = TCPServer.new(2202)
client at a time while true
Thread.new(server.accept){ |client|
Common Solution: msg = client.readline
client.write "You said: #{msg}"
use a thread per client.close
client }
end

14. require 'socket'
inbound server = TCPServer.new(2202)
list of clients clients = []
buffer per buffers = {}
client IO.select returns while true
sockets = [server] + clients
readable/writable readable, writable = IO.select(sockets)
sockets readable.each do |sock|
begin
if sock == server
clients << server.accept_nonblock
else
client, buf = sock, buffers[sock] ||= ''
read in available data,
buf << client.read_nonblock(1024)
process if full line received if buf =~ /^.+?r?n/
client.write "You said: #{buf}"
Non-Blocking I/O
client.close
buffers.delete(client)
clients.delete(client)
end
Alternative to end
rescue Errno::EAGAIN, Errno::EWOULDBLOCK
threads: simply don’t # socket would block, try again later
end
block end
end

15. EM does Non-Blocking I/O
handles low module EchoServer
level sockets def post_init
for you @buf = ''
end
inbound/ def receive_data(data)
@buf << data
outbound if @buf =~ /^.+?r?n/
buffers for send_data "You said: #{@buf}"
close_connection_after_writing
maximal end
throughput end
end
efficient i/o with
writev/readv require 'eventmachine'
EM.run do
EM.start_server '0.0.0.0', 2202, EchoServer
epoll & kqueue end
support

16. So, what’s a Reactor?
while reactor_running?
expired_timers.each{ |timer| timer.process }
new_network_io.each{ |io| io.process }
end
reactor is simply a single threaded while loop, called
the “reactor loop”
your code “reacts” to incoming events
if your event handler takes too long, other events
cannot fire
lesson: never block the reactor while reactor_running?
while true
no sleep(1) end
no long loops (100_000.times) # reactor is blocked!
no blocking I/O (mysql queries) end
no polling (while !condition)

17. Writing Asynchronous Code
synchronous ruby code uses return values
ret = operation()
do_something_with(ret)
evented async code uses blocks instead
operation{ |ret| do_something_with(ret) }
different from how you usually use ruby blocks. the block
is stored and invoked later (it’s asynchronous)
puts(1) puts(1)
1.times{ puts(2) } operation{ puts(3) }
puts(3) puts(2)

18. Receiving Email Using ActionMailer
port 25 postfix
(smtp) (spool)
fork
process
Action pgsql
Mailer ActiveRecord (db)

19. Receiving Email Using LMTP
port 25 postfix
(smtp) (spool)
port 8081
(lmtp)
EM pgsql
(w/Rails) ActiveRecord (db)

20. Receiving Email — Scalably via LMTP
postfix postfix message
(spool) (spool) systems
EM EM EM EM
(w/Rails) (w/Rails) (w/Rails) (w/Rails)

21. LMTP Daemon
http://tools.ietf.org/html/rfc2033

22. POP3 Daemon
http://tools.ietf.org/html/rfc1939

23. IMAP Daemon
http://tools.ietf.org/html/rfc3501

24. EventMachine
Geo Firehose LISTEN
8192
(one connection - Port 80)
250, 500, 1000 Connections
twittervision.com/
Apache
stream
RewriteRule ^/stream(.*)$ http://127.0.0.1:8192%{REQUEST_URI} [P,QSA,L]

25. replyz.com
Does Anybody Know...?
mailstrom.co
mailstrom.410labs.com
Power Tools for Your Inbox
shortmail.com
Email, simplified.

26. Some Other Handy Stuff...
• start_tls: secure any TCP connection
• Timers: Periodic, Once, Scheduled
• epoll, kqueue, threadpool_size
• set_effective_user (listen on protected ports)
• teh docs: http://eventmachine.rubyforge.org/EventMachine.html

27. So, Some Stuff To Remember...
• EventMachine: awesome for I/O, events
• Code is Data, Data is Code
• Often Working with State Machines
• Don’t peg the CPU. No really, don’t.
• TEBWTDI
• Testing can be interesting

28. Dave Troy
Chief Executive Officer
davetroy@shortmail.com
@davetroy
facebook.com/davetroy
Tomorrow @ BohConf!
http://emrubyconf.com/