Techmosis Rails

Ruby on Rails techmosis @last.fm, feb 2009

... some fundamentals

“one stack” approach [M+V+C]

“thou shalt not repeat thyself” (it’s a religion)

convention over conﬁguration (table names)

brought established software engineering principles into “scripting” environments

model: ActiveRecord

class Foo < ActiveRecord::Base belongs_to :bar # insert rails magic here end

# standard query Foo.find(:all, :conditions=>["name=?", "kittens"]) # provided by AR Foo.find_by_name("kittens") # avoid N+1 Foo.find(:all, :include=>:bar) # custom Foo.find_by_sql("select foos.* from foos where....")

view: erb or haml?

erb: php style <%= foo %>

haml: nested structure

!!! %html{ :xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en" } %head %meta{ "http-equiv" => "content-type", :content => "text/html; charset=utf-8" }/ %title= page_title = render :partial => "shared/icon" = stylesheet_link_tag 'screen', :media => 'screen' /[if IE] %style{:type=>"text/css"} * html { overﬂow-y: scroll; overﬂow-x: hidden; } = javascript_include_tag 'prototype' = javascript_include_tag 'lowpro' = javascript_include_tag 'velcro' = controller_assets /[if IE] = stylesheet_link_tag 'ie', :media => 'screen' %body %div#page %div#content = @content_for_layout %div#footer = render :partial => "shared/footer"

testing: rspec {model, view, controller}

BDD (behaviour driven development)

# model spec describe "generating api key" do it "should create an api key entry in the db" do lambda { @howard.generate_api_key! }.should change(ApiKey, :count).by(1) end end # controller spec describe "an admin" do describe "with a valid API key" do before do @howard.generate_api_key! end it "should be able to fetch the latest graph" do get :latest, :params=>{:api_key => @howard.api_key}, :response=>200 end it "should be able to fetch meta data" do #... end end end

deployment

historically very painful (mod_fcgi, mongrel+ mod_proxy_balancer, mod_rewrite...) too many options...

complicated to set up.

<VirtualHost *:80> ServerName <%= servername>> DocumentRoot "/rails_root/public" <Directory "/rails_root/public"> Options FollowSymLinks AllowOverride None Order allow,deny Allow from all Header append Cache-Control "private, must-revalidate, max-age=0" </Directory> <Proxy balancer://<%= clustername %>> <% startport.upto(startport + servers - 1) do |p| -%> BalancerMember http://127.0.0.1:<%= p %> <% end -%> ProxySet lbmethod=bytraffic ProxySet maxattempts=5 </Proxy> ProxyTimeout 300 RewriteEngine On # Check for maintenance ﬁle and redirect all requests RewriteCond %{DOCUMENT_ROOT}/system/maintenance.html -f RewriteCond %{SCRIPT_FILENAME} !maintenance.html RewriteRule ^.*$ /system/maintenance.html [L] # Rewrite index to check for static RewriteRule ^/$ /index.html [QSA] # Rewrite to check for Rails cached page RewriteRule ^([^.]+)$ $1.html [QSA] # Redirect all non-static requests to cluster RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f RewriteRule ^/(.*)$ balancer://<%= clustername %>%{REQUEST_URI} [P,QSA,L]

btw: don’t use mongrel (it leaks memory)

a new standard emerges: rack

not tied to rails, can be used with many ruby based frameworks

call a method... app.call(env)

which returns an array with 3 elements... [200, 'Content-Type'=>'text/plain', 'Hello World']

for apache2 there is...

mod_rails / mod_rack (phusion passenger)

it’s quite simple...

LoadModule passenger_module /usr/lib/passenger/mod_passenger.so PassengerRoot /usr PassengerRuby /usr/bin/ruby1.8 <VirtualHost *:80> ServerName myserver.com DocumentRoot "/rails_root/public" </VirtualHost>

but...

how to get the code deployed?

capistrano

what cap does for you: • remote code checkout via VCS • shell execution on remote servers (in parallel) • rollback to last release (symlink) • extensible (not just for rails!)

set :repository, "http://myrepo.com/myapp/trunk/" role :web, "www.example.com" role :db, "db1.example.com", :primary => true desc "reloads apache conﬁg" task :reload , :roles=>:web do sudo "/etc/init.d/httpd reload", :pty => true end

monitoring apps: god (“like monit, but awesome”)

start_port = 3000 count =5 (start_port...start_port+count).each do |port| God.watch do |w| w.start = "sh -c 'mongrel_rails start -p #{port} -c #{RAILS_ROOT}" w.interval = 5.seconds w.grace = 5.seconds # restart if memory or cpu is too high w.restart_if do |restart| restart.condition(:memory_usage) do |c| c.interval = 20 c.above = 500 * 1024 # max_mem MB c.times = [3, 5] end end w.notify = “foo@bar.com” end end

exception_notiﬁer

console

scaling rails

processes vs threads

new in rails 2.2: multithreading! def dispatch if ActionController::Base.allow_concurrency dispatch_unlocked else @@guard.synchronize do dispatch_unlocked end end end (ﬁnally...)

new: connection pooling (actually required for multithreaded apps)

what’s good / interesting?

active community (some call it “ghetto”)

some really good plugins (acts_as_*)

quick development + testing

ActiveRecord scopes

Post.with_scope(:ﬁnd => {:conditions => ["user_id = ?", current_user.id]} do @user_posts = Post.ﬁnd(:all) end

easy RESTful development

map.resources :tasks, :member => { :run => :post }, :collection => { :run_all => :post } # tasks => GET /tasks # new_task => PUT /tasks/new # update_task(@task) => POST /tasks/1/update # run_task(@task) => POST /tasks/1/run # run_all_tasks => POST /tasks/run_all class TasksController < ApplicationController def index @task = Task.find(:all) end def update @task = Task.find(params[:id]) @task.update_attributes!(params[:task]) end def run @task = Task.find(params[:id]) @task.run! end end

ActiveResource

class Task < ActiveResource::Base self.site = "http://api.example.com" end @task = Task.new(:when=>Time.now) @task.save # POST http://api.example.com/tasks/create @task.id # => 1 @task = Task.ﬁnd(1) # GET http://api.example.com/tasks/1.xml

creating feeds

class TasksController < ApplicationController def index @tasks = Task.ﬁnd(:all) respond_to do |format| format.html format.atom end end end # from tasks/index.atom.builder atom_feed(:url => formatted_tasks_url(:atom)) do |feed| feed.title("Tasks") feed.updated(Time.now.utc) for task in @tasks feed.entry(task) do |entry| entry.title(task.name) entry.content(task.content) end end end

what’s bad?

too much magic (method_missing, really...)

monkey patching / metaprogramming (too much !)

module ActiveSupport #:nodoc: module CoreExtensions #:nodoc: module Array #:nodoc: # Makes it easier to access parts of an array. module Access # Equal to <tt>self[1]</tt>. def second self[1] end # Equal to <tt>self[2]</tt>. def third self[2] end # Equal to <tt>self[3]</tt>. def fourth self[3] end #.... #WTF? # Equal to <tt>self[41]</tt>. Also known as accessing "the reddit". def forty_two self[41] end end end end

monolithic architecture

“If you’re not doing it the ‘Rails way’...

...ur doing it wrong!”

native extensions = deployment headaches

alternatively...

deploy your app on the JVM: JRuby on Rails

you need: ActiveRecord-JDBC (more options)

integrate with java libraries

deploy on: jetty, glassﬁsh, ...

it’s faster! (about twice as fast)

future

rails3 aka merb

merb? (mongrel+erb)

“clean-room” implementation of rails

modular design, choice of frameworks (no “merb way”)

merb-slices (apps in django?)

current trends

micro-frameworks: sinatra

Techmosis Rails

by Jan Berkel on Nov 03, 2009

Accessibility

Categories

Tags

Upload Details

Usage Rights

Statistics

Techmosis Rails — Presentation Transcript