TorqueBox allows scaling Ruby on Rails applications by running them on the JBoss Application Server and JRuby. It provides services, scheduled jobs, asynchronous tasks, caching, and session handling that enable applications to scale across multiple servers. The presentation demonstrated how to implement common Rails application components like a Twitter streaming client and scheduled job using TorqueBox services and jobs. It also showed how to configure load balancing, caching, and messaging to make the application highly available and scalable as load increases by adding more servers to the cluster.

2. Scaling Rails Applications
with TorqueBox
Ben Browning

3. Ben Browning
•TorqueBox Contributor
•Red Hat Senior Engineer since July 2010
•Ruby yay! JVM yay! Java boo! JRuby yay!

4. The Team

5. TorqueBox
•The power of JBoss with the expressiveness of Ruby
•Rails, Sinatra, Rack and non-web applications running
on top of JBoss AS and JRuby
•Messaging, Asynchronous Tasks, Scheduled Jobs, and
Services built-in

6. Rails
“Ruby on Rails® is an open-source web framework
that’s optimized for programmer happiness and
sustainable productivity. It lets you write beautiful code
by favoring convention over configuration.” - http://
rubyonrails.org

7. Scaling
Ability to increase throughput by adding hardware

8. Learn By (Beer) Example
Let’s create an application to find the most popular beer
according to Twitter.

9. Beer Tweets
•Web front-end
•Twitter Streaming API client
•Scheduled job to clean old beer tweets
•Caching so our database doesn’t fall over

10. Web Front-end
class BeersController < ApplicationController
def most_popular
@popular_beers = Beer.most_popular(:limit => 25)
end
end

11. Twitter Streaming API Client
•Connect to Twitter’s streaming API and find all tweets
containing “beer”
•Needs to run as a daemon, outside of the web
request / response cycle

12. TorqueBox Services
•Long-running, non-web daemons that share the
runtime environment and deployment lifecycle of your
app
•A class with initialize( Hash ), start(), and stop()
methods

13. Twitter Streaming API Client
class BeerService
def initialize(options)
@client = StreamingTwitter.new(options["username"],
options["password"])
end
def start
Thread.new { find_beer }
end
def stop
@client.disconnect
end
end

14. Twitter Streaming API Client
class BeerService
def find_beer
@client.search('beer') do |tweet|
Beer.create_from_json(tweet)
end
end
end

15. Twitter Streaming API Client
config/torquebox.yml:
services:
beer_service:
username: ilikebeer
password: sodoyou

16. Clean Stale Beer
•Delete all beer-related tweets older than 7 days
•Run once an hour to prune in manageable chunks

17. Scheduled Jobs
•Tasks that need to be executed on a recurring
schedule
•A class with a run() method

18. Clean Stale Beer
class BeerCleaner
def run()
Beer.clean_older_than(7.days)
end
end

19. Clean Stale Beer
config/torquebox.yml:
jobs:
beer_cleaner:
description: Clean stale beer-related tweets
job: BeerCleaner
cron: '0 44 * * * ?'

20. Caching
We’re showing the same list of most popular beers to all
users so why hit the database on every request?

21. Caching Web Front-end
class BeersController < ApplicationController
caches_action :most_popular, :expires_in => 30.seconds
def most_popular
@popular_beers = Beer.most_popular(:limit => 25)
end
end

22. Beer Tweets
We’re collecting tweets about beer, serving the results
up via a cached web interface, and keeping our
database cleaned of stale data.

23. We’re Done, Right?
We’ve added all our features and deployed on
TorqueBox so we can handle limitless load, right?

24. Benchmarks

25. Benchmarks

26. We’re Done, Right?
No way - it’s beer and Twitter! This will be wildly
popular with social alcoholics and we need to plan
accordingly - we need to scale!

27. Performance != Scalability
Just because an application performs well on a single
server doesn’t mean it can scale.

28. Add More Servers
Well, before we can do that we need a load balancer to
route requests to multiple servers.

29. mod_cluster
The same mod_cluster you know and love to use with
JBoss AS works with TorqueBox.

30. mod_cluster
Based on Apache’s mod_proxy but with two-way
communication to JBoss and TorqueBox providing
intelligent request routing based on load.

31. mod_cluster

32. Add More Servers
As each TorqueBox instance boots it will find the other
TorqueBox and mod_cluster instances and add itself to
the cluster.

33. Sessions
•By default Rails stores all session data in cookies
•Production Rails applications usually use a database or
memcached for session storage
•TorqueBox provides its own session storage

34. TorqueBox Sessions
config/initializers/session_store.rb:
BeerTweets::Application.config.
session_store TorqueBox::Session::ServletStore

35. TorqueBox Sessions
•Server-side sessions without hitting the database or
requiring an external process (memcached)
•Uses JBoss AS session replication under the hood

36. Are We Scaled Yet?
We’ve taken care of the load balancer and session
replication, but what about our Twitter Streaming API
client? How will it scale?

37. Twitter Streaming API Client
•By default our service will start on every node in the
cluster
•Sometimes that’s what you want, but not in this case;
we only want one copy of each beer tweet to be saved.

38. HASingleton Services
•TorqueBox supports highly-available singleton
services
•The service will only run on one node in the cluster
•If that node goes down, another node will start the
service

39. HASingleton Services
config/torquebox.yml:
services:
beer_service:
username: ilikebeer
password: sodoyou
singleton: true

40. Twitter Streaming API Client
•Now our service will only run on one node, but what
happens if tweets come in from Twitter faster than that
one node can process them?

41. Backgroundable
•Convert any method call into an asynchronous call
•Uses HornetQ under the hood and calls are load-
balanced across the cluster

42. Backgroundable
class BeerService
def find_beer
@client.search('beer') do |tweet|
Beer.background.create_from_json(tweet)
end
end
end

43. Asynchronous Tasks
class BeerTask < TorqueBox::Messaging::Task
def create_from_json(payload)
Beer.create_from_json(payload[:tweet])
end
end

44. Asynchronous Tasks
class BeerService
def find_beer
@client.search('beer') do |tweet|
BeerTask.async(:create_from_json, :tweet => tweet)
end
end
end

45. Twitter Streaming API Client
All nodes in our cluster will now process incoming
tweets even though only a single node maintains a http
connection to Twitter.

46. Now We’re Scaled, Right?
Not quite - we still have that pesky job that cleans stale
beer to deal with.

47. Clean Stale Beer
•By default, scheduled jobs will run on all nodes in a
cluster.
•We only want our beer cleaning job to run on a single
node.

48. HASingleton Jobs
config/torquebox.yml:
jobs:
beer_cleaner:
description: Clean stale beer-related tweets
job: BeerCleaner
cron: '0 44 * * * ?'
singleton: true

49. All Scaled?
Almost! We still need to take care of our caching.

50. Caching
•Rails ships with support for multiple cache stores (file-
based, in-memory, memcached)
•None allow multiple nodes to share a common cache
without setting up an external process

51. TorqueBoxStore
•Rails 3 ActiveSupport::Cache::Store implementation
backed by Infinispan
•Supports invalidated, replicated, and distributed
clustering modes

52. TorqueBoxStore
module BeerTweets
class Application < Rails::Application
config.cache_store :torque_box_store(:mode => :distributed,
:sync => false)
end
end

53. Are We Scaled?
As we add additional nodes to the cluster they increase
our web request throughput, background job
throughput, and cache capacity. We’re scaled!

54. But Wait, There’s More!

55. Injection
Inject CDI resources, messaging destinations, JNDI
entries, MBeans into your Ruby application
@questions = inject(‘/queues/questions’)
@datasource = inject(‘java:comp/env/jdbc/myDS’)
@thing = inject(com.mycorp.Something)
@bean = inject(‘SomeMCBean’)

56. Message Processors
class SeniorHandler < TorqueBox::Messaging::MessageProcessor
def on_message(body)
puts “Processing #{body} of #{message}”
end
end

57. Message Processors
config/torquebox.yml:
messaging:
/queues/people:
SeniorHandler:
filter: “age >= 55”
concurrency: 2

58. Queues and Topics
questions = inject(‘/queues/questions’)
answers = inject(‘/queues/answers’)
Thread.new do
questions.publish ‘What time is it?’
puts answers.receive(:timeout => 1000)
end
puts questions.receive
answers.publish Time.now

59. Queues and Topics
config/torquebox.yml:
queues:
/queues/questions:
/queues/answers:

60. BackStage
Dashboard and RESTful API to inspect and control Ruby
components

61. BackStage

62. StompBox
Easy Heroku-esque git-based deployments

63. StompBox

64. Roadmap
1.0.0 Just Released!
Upcoming:
AS7
Transactions
SSO
Drools / jBPM
Mobicents
WebSockets

65. Resources
•http://torquebox.org
•https://github.com/torquebox
•#torquebox on FreeNode
•@torquebox

66. Thanks!

67. Questions?