Background Jobs - Com BackgrounDRb

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

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

Background Jobs - Com BackgrounDRb

More Related Content

What's hot (20)

Similar to Background Jobs - Com BackgrounDRb (20)

More from Juan Maiz (10)

Recently uploaded (20)

Background Jobs - Com BackgrounDRb