Background Jobs
com BackgrounDRb
da série "Palestras na Softa"
blog.softa.com.br
Recomende: workingwithrails.com/person/9354

BackgrounDRb
BackgrounDRb é um agendador e servidor de tarefas em
Ruby.
Seu objetivo principal é ser utilizado com aplicações Ruby on
Rails - plugin - para desafogar tarefas de longa duração.
É feito com PACKET e não DRb. Mas pra entender o conceito,
vamos lá...

DRb
Isso é um "tipo" de digressão.
DRb é o Distributed Ruby.
Sim, um CORBA simplificado do Ruby.
Serialização de objetos sobre TCP.
DRb em Ruby é Standard Library.
http://ruby-doc.org/stdlib/libdoc/drb/rdoc/index.html

Hello DRb World
Clone:
git://github.com/softa/hello_drb_world.git

Simple (server)
require 'drb'
class TestServer
def doit
"Hello, Distributed World"
end
end
server = TestServer.new
DRb.start_service('druby://localhost:9000', server)
DRb.thread.join

Simple (client)
require 'drb'
DRb.start_service()
obj = DRbObject.new(nil, 'druby://localhost:9000')
p obj.doit

Math (server)
require 'drb'
class MathServer
attr_accessor :total
def initialize(initial_value)
@total = initial_value
end
def sum(value) @total += value; end
def subtract(value) @total -= value; end
def multiply(value) @total *= value; end
def divide(value) @total /= value; end
end
DRb.start_service('druby://localhost:9000', MathServer.new(0))
DRb.thread.join

Math (client)
require 'drb'
DRb.start_service()
math = DRbObject.new(nil, 'druby://localhost:9000')
puts math.sum(10)
puts math.multiply(2)
puts math.subtract(5)
puts math.divide(3)

Math
$ ruby client.rb
10
20
15
5
$ ruby client.rb
15
30
25
8

Chat (server and client)
Open the files... please

Agora... BackgrounDRb
Fim da digressão.

Instalação do BackgrounDRb
GEMS necessárias:
sudo gem install chronic packet
Instalando:
script/plugin install git://github.com/gnufied/backgroundrb.git
sudo su postgres
createuser hello_backgroundrb_world
^d
rake db:create
rake backgroundrb:setup
(...gera migrações...)
rake db:migrate
DONE!

Instalação do BackgrounDRb
Todo o código em:
http://github.com/softa/hello_backgroundrb_world

Iniciando do BackgrounDRb
script/backgroundrb start
script/backgroundrb start -e ENVIRONMENT

Config básico
config/backgroundrb.yml
---
:backgroundrb:
:port: 11006
:ip: 0.0.0.0

Conceitos-chave
Server
Um server que recebe as chamadas. Deve ser startado uma vez junto com o web
server.
MiddleMan
Classe disponível (Factory) no Rails para chamar as tarefas dos workers em
background, programar execuções ou busca informação sobre as tarefas.
Worker
É uma classes que define as tarefas possíveis de se utilizar. Cada worker inicia um
processo próprio ao iniciar o server.
Job
É a execução de um método de um worker.

Conceitos-chave
cache
Hash com informações sobre a execução de um job.
job_key
Variável disponível no Worker para referenciar unicamente um Job.
assync_*
Executa o método * em background agora.
enq_*
Executa o método * em background no futuro.

Rake
rake -T backgroundrb
# Generate a migration for the backgroundrb queue table.
rake backgroundrb:queue_migration
# Drops and recreate backgroundrb queue table
rake backgroundrb:redo_queue
# Remove backgroundrb from your rails application
rake backgroundrb:remove
# Setup backgroundrb in your rails application
rake backgroundrb:setup
# update backgroundrb config files from your rails application
rake backgroundrb:update
# Generate documentation for the backgroundrb plugin
rake doc:plugins:backgroundrb

Gerador
script/generate worker WorkerName [options]
Rails Info:
-v, --version Show the Rails version number and quit.
-h, --help Show this help message and quit.
General Options:
-p, --pretend Run but do not make any changes.
-f, --force Overwrite files that already exist.
-s, --skip Skip files that already exist.
-q, --quiet Suppress normal output.
-t, --backtrace Debugging: show backtrace on errors.
-c, --svn Modify files with subversion. (Note: svn must be in path)
-g, --git Modify files with git. (Note: git must be in path)
Description:
The worker generator creates stubs for a new BackgrounDRb worker.
The generator takes a worker name as its argument. The worker name may be
given in CamelCase or under_score and should not be suffixed with 'Worker'.
The generator creates a worker class in lib/workers and a test suite in
test/unit.
Example:
./script/generate worker Tail
This will create an Tail worker:
Model: lib/workers/tail_worker.rb
Test: test/unit/tail_worker_test.rb

Executar apenas um método
(com Ajax!)
script/generate worker Counter
CounterController CounterController
:: start_counting :: show_count
MiddleMan Ajax
CounterWorker CounterController
:: start :: get_count
MiddleMan

Worker
class CounterWorker < BackgrounDRb::MetaWorker
set_worker_name :counter_worker
def create(args = nil)
end
def start
cache[job_key] = 0
add_periodic_timer(2) { increment }
end
def increment
cache[job_key] += 1
logger.warn "((#{cache[job_key]}))"
end
end

Controller
script/generate controller Count start_counting show_count get_count
def start_counting
t = Time.now.to_s
session[:job_key] = t
MiddleMan.worker(:counter_worker)
.async_start(:job_key => t)
redirect_to :action => :show_count
end

Controller
MiddleMan.worker(:counter_worker)
.async_start(:job_key => t)

Controller
def show_count
end
# app/views/counter/show_count
<h1>Count#show_count</h1>
<div id="count"></div>
<script>
new Ajax.PeriodicalRequest
('count','/counter/get_count')
</script>

Controller
def get_count
return render :text =>
MiddleMan.worker(:counter_worker).ask_result(session[:job_key])
end

Resultado

Executar um método no futuro
friend = Contact.find_by_name 'Rafael Lunardini'
MiddleMan.worker(:birthday_worker)
.enq_send_congrats(:args => friend,
:scheduled_at => friend.birthdate_in_this_year)
task = Task.find_by_name 'Reunião Unicórnio'
MiddleMan.worker(:task_worker)
.enq_notice(:args => task,
:scheduled_at => task.next_date)

Executar um método periodicamente
# config/backgroundrb.yml
---
:backgroundrb:
:port: 11006
:ip: 0.0.0.0
:schedules:
:nightly_worker:
:make_nightly_stuff:
:trigger_args: 0 30 4 * * * *
Igual ao CRON, hum?

Executar um método periodicamente
Também rola isso:
:schedules:
:foo_worker:
:foobar:
:trigger_args:
:start: <%= Time.now + 5.seconds %>
:end: <%= Time.now + 10.minutes %>
:repeat_interval: <%= 1.minute %>

Advanced stuff
class ConnectorWorker < BackgrounDRb::MetaWorker
set_worker_name :connector_worker
def chat
require 'drb'
DRb.start_service()
@chat = DRbObject.new(nil, 'druby://localhost:9000')
@chat.login("Bot")
add_periodic_timer(5) { talk }
end
def talk
@chat.send_message("Bot", "i'm talking...")
end
end

Advanced stuff
class TimeServer
def receive_data(p_data)
end
def post_init
add_periodic_timer(2) { say_hello_world }
end
def connection_completed
end
def say_hello_world
p "***************** : invoking hello world #{Time.now}"
send_data("Hello Worldn")
end
end
class ServerWorker < BackgrounDRb::MetaWorker
set_worker_name :server_worker
def create(args = nil)
start_server("0.0.0.0",11009,TimeServer) do |client_connection|
client_connection.say_hello_world
end
end
end