job_reactor 0.5.2 → 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4fe498b8b0ef18152ba17eaaae1b4907359c13f1
+  data.tar.gz: 4fcaed4b7cbe32e27b0dcbbd43cf00696f6458f9
+SHA512:
+  metadata.gz: 75ebee033f02d15af6987a3f12cb69f2fdc8a61b8e3f8d72a30cfcbae0a542b901f0af89a6a105381b71cb164b7068624a65eed28605d6e109e8661aa257f173
+  data.tar.gz: f0b615f30c23efcfd851f28387e62ff650ab5b590bc05165df56cda72869852b869329a81845a3edae7e1373caaab28a30c72f9a5850b83aa75beeab626d8855

data/README.markdown

@@ -3,13 +3,10 @@ JobReactor <img src='https://secure.travis-ci.org/antonmi/job_reactor.png'>
 
 JobReactor is a library for creating, scheduling and processing background jobs.
 It is asynchronous client-server distributed system based on [EventMachine][0].
-Inspired by [Resque][1], [Beanstalkd][2] ([Stalker][3]), [DelayedJob][4], and etc.
 
-To use JobReactor with [Ruby on Rails][9] you should start distributor in initializer using `JR.run` method (it launches EventMachine in separate thread).
-Then add rake task(s) which will run the node(s). If you use [Thin][10] server the solution is more complicated because 'Thin' use EventMachine too.
-So, 'rails' integration is not complete for the time being.
-We need to test the system with different servers (clusters) and automate the initialization and re-start processes.
-Collaborators, you are welcome!
+To use JobReactor with [Sinatra][11] or [Ruby on Rails][9] you should start distributor in initializer using `JR.run` method (it launches EventMachine in separate thread).
+Then add rake task(s) which will run the node(s).
+If you use server based on EventMachine such [Thin][12] use JR.wait_em_and_run method which will initialize JobReactor when EventMachine started.
 
 So, read the 'features' section and try JobReactor. You can do a lot with it.
 
@@ -76,7 +73,7 @@ end
 ```
 Run 'application.rb' in one terminal window and 'worker.rb' in another.
 Node connects to distributor, receives the job and works.
-Cool! But it was the simplest example. See 'examples' directory and read 'advanced usage'(coming soon).
+Cool! But it was the simplest example. See 'examples' directory.
 
 Features
 =============
@@ -90,7 +87,7 @@ If you don't have many jobs you can leave only one node which will be connected
 Nodes and distributors are connected via TCP. So, you can run them on any machine you can connect to.
 Nodes may use different storage or the same one. You can store vitally important jobs in database and
 simple insignificant jobs in memory.
-And more: your nodes may create jobs for others nodes and communicate with each other. See page [advanced usage].
+And more: You can run node and distributor inside one EMreactor, so your nodes may create jobs for others nodes and communicate with each other.
 3. Full job control
 -------------------
 You can add 'callback' and 'errbacks' to the job which will be called on the node.
@@ -111,9 +108,11 @@ If node is stopped or crashed it will retry stored jobs after start.
 6. EventMachine available
 -------------------------
 Remember, your jobs will be run inside EventMachine reactor! You can easily use the power of async nature of EventMachine.
-Use asynchronous [em-http-request][6], [em-websocket][7], [etc.], [etc.], and [etc].
+Use asynchronous [em-http-request][6], [em-websocket][7], and etc.
 7. Thread safe
-Eventmachine reactor loop runs in one thread. So the code in jobs executed in the given node is absolutely threadsafe.  
+--------------
+Eventmachine reactor loop runs in one thread. So the code in jobs executed in the given node is absolutely threadsafe.
+The only exception is 'defer' job, when you tell the node to run job in EM.defer block (so job will be executed in separate thread).
 8. Deferred and periodic jobs
 -----------------------------
 You can use deferred jobs which will run 'after' some time or 'run_at' given time.
@@ -153,10 +152,10 @@ And now JobReactor is ready to work.
 ``` ruby
 JR.run! do
   JR.start_node({
-    :storage => 'redis_storage',
-    :name => 'redis_node1',
-    :server => ['localhost', 5001],
-    :distributors => [['localhost', 5000]] 
+    storage: 'redis_storage',
+    name: 'redis_node1',
+    server: ['localhost', 5001],
+    distributors: [['localhost', 5000]] 
 })
 end
 ```
@@ -179,6 +178,7 @@ JR.enqueue('my_job',{arg1: 1, arg2: 2}, {after: 20}, success, error)
 
 The first argument is the name of the job, the second is the arguments hash for the job.
 The third is the options hash. If you don't specify any option job will be instant job and will be sent to any free node. You can use the following options:
+* `defer: true or false` - node will run the job in 'EM.defer' block. Be careful, the default threadpool size is 20 for EM. You can increase it by setting EM.threadpool_size = 'your value', but it is not recommended;
 * `after: seconds` - node will try run the job after  `seconds` seconds;
 * `run_at: time` - node will try run the job at given time;
 * `period: seconds` - node will run job periodically, each `seconds` seconds;
@@ -198,8 +198,10 @@ Example:
 ```ruby
 #in your 'job_file'
 job 'my_job' do |args|
-#do smth
-args.merge!(result: 'Yay!')
+  #do smth
+  args.merge!(result: 'Yay!')
+end
+
 #in your application
 #success feedback
 success = proc {|args| puts args}
@@ -293,14 +295,15 @@ __Note__, feedbacks are kept in memory in your application, so they disappear wh
 
 Job Storage
 ==========
-Now you can store your job in [Redis][5] storage (`'redis_storage`') or in memory (`'memory_storage'`).
+Now you can store your jobs in [Redis][5] storage (`'redis_storage`') or in memory (`'memory_storage'`).
+We use [em-hiredis](https://github.com/mloughran/em-hiredis) gem
 Only the first, of course, 'really' persists the jobs. You can use the last one if you don't want install Redis, don't need retry jobs and need more speed (by the way, the difference in performance is not so great - Redis is very fast).
+You can easily integrate your own storage. Just make it EventMachine compatible.
 
-The default host and port for Redis server are:
+The default url for Redis server are:
 
 ```ruby
-JR.config[:redis_host] = 'localhost'
-JR.config[:redis_port] = 6379
+JR.config[:hiredis_url] = "redis://127.0.0.1:6379/0"
 ```
 
 JobReactor works asynchronously with Redis using [em-redis][8] library to increase the speed.
@@ -314,6 +317,7 @@ The informaion about jobs is saved several times during processing. This informa
 * failed_at - the time when job was failed;
 * last_error - the error occured;
 * period - period (for periodic jobs);
+* defer - 'true' or 'false', flag to run job in EM.defer block;
 * status - job status ('new', 'in progress', 'queued', 'complete', 'error', 'failed', 'cancelled');
 * attempt - the number of attempt;
 * make_after - when to start job again (in seconds after last save);
@@ -332,6 +336,16 @@ JR.config[:retry_jobs_at_start] = true
 ```
 
 We provide simple `JR::RedisMonitor` module to check the Redis storage from irb console (or from your app).
+We use synchronous [redis](https://github.com/redis/redis-rb) gem.
+Connect to Redis by:
+
+```ruby
+JR.config[:redis_host] = 'localhost'
+JR.config[:redis_port] = 6379
+```
+
+
+
 See methods:
 
 ```ruby
@@ -344,7 +358,7 @@ JR::RedisMonitor.destroy_all_jobs_for(node_name)
 
 License
 =======
-The MIT License - Copyright (c) 2012 Anton Mishchuk
+The MIT License - Copyright (c) 2012-2013 Anton Mishchuk
 
 [0]: http://rubyeventmachine.com
 [1]: https://github.com/defunkt/resque
@@ -357,3 +371,5 @@ The MIT License - Copyright (c) 2012 Anton Mishchuk
 [8]: https://github.com/madsimian/em-redis
 [9]: http://rubyonrails.org/
 [10]: http://code.macournoyer.com/thin/
+[11]: http://www.sinatrarb.com/
+[12]: http://code.macournoyer.com/thin/

data/lib/job_reactor.rb

@@ -1,6 +1,6 @@
 require 'eventmachine'
 require 'job_reactor/job_reactor'
-require 'job_reactor/logger'
+require 'job_reactor/job_logger'
 require 'job_reactor/node'
 require 'job_reactor/distributor'
 
@@ -15,27 +15,37 @@ require 'job_reactor/distributor'
 module JobReactor
   extend self
 
-  def run(&block)
+  def run
     Thread.new do
       if EM.reactor_running?
-        block.call if block_given?
+        yield if block_given?
         JR.ready!
       else
         EM.run do
-          block.call if block_given?
+          yield if block_given?
           JR.ready!
         end
       end
     end
   end
 
-  def run!(&block)
+  def run!
     if EM.reactor_running?
-      block.call if block_given?
+      yield if block_given?
       JR.ready!
     else
       EM.run do
-        block.call if block_given?
+        yield if block_given?
+        JR.ready!
+      end
+    end
+  end
+
+  def wait_em_and_run
+    Thread.new do
+      sleep(0.1) until EM.reactor_running?
+      EM.schedule do
+        yield if block_given?
         JR.ready!
       end
     end

data/lib/job_reactor/distributor.rb

@@ -10,27 +10,27 @@ module JobReactor
     # EM::PeriodicTimer.new(10) { JR::Logger.log nodes}.
     #
     def nodes
-      @@nodes ||= []
+      @nodes ||= []
     end
 
     # Contains connections pool - all node connections.
     #
     def connections
-      @@connections ||= []
+      @connections ||= []
     end
 
     def server
-      @@connect_to || "#{@@host}:#{@@port}"
+      @connect_to || "#{@host}:#{@port}"
     end
 
     # Starts distributor on given hast and port.
     # See JR.start_distributor documentation.
     #
     def start(host, port, opts = {})
-      @@connect_to = opts[:connect_to] && opts[:connect_to].join(':')
-      @@host = host
-      @@port = port
-      JR::Logger.log "Distributor listens #{host}:#{port}"
+      @connect_to = opts[:connect_to] && opts[:connect_to].join(':')
+      @host = host
+      @port = port
+      JR::JobLogger.log "Distributor listens #{host}:#{port}"
       EM.start_server(host, port, JobReactor::Distributor::Server)
     end
 
@@ -44,7 +44,7 @@ module JobReactor
         data = Marshal.dump(hash)
         connection.send_data(data)
         connection.lock
-        JR::Logger.log "Distributor sent job '#{hash['name']}' to '#{connection.name}'"
+        JR::JobLogger.log "Distributor sent job '#{hash['name']}' to '#{connection.name}'"
       else
         EM.next_tick do
           send_data_to_node(hash)

data/lib/job_reactor/distributor/client.rb

@@ -31,7 +31,7 @@ module JobReactor
       end
 
       def unbind
-        JR::Logger.log "#{@name} disconnected"
+        JR::JobLogger.log "#{@name} disconnected"
         close_connection
         JobReactor::Distributor.connections.delete(self)
       end

data/lib/job_reactor/distributor/server.rb

@@ -4,14 +4,14 @@ module JobReactor
     class Server < EM::Connection
 
       def post_init
-        JR::Logger.log 'Begin node handshake'
+        JR::JobLogger.log 'Begin node handshake'
       end
 
       def receive_data(data)
         data = Marshal.load(data)
         if data[:node_info]
           node_info = data[:node_info]
-          JR::Logger.log "Receive data from node: #{data[:node_info]}"
+          JR::JobLogger.log "Receive data from node: #{data[:node_info]}"
           JobReactor::Distributor.nodes << node_info
           connection = EM.connect(*node_info[:server], Client, node_info[:name])
           JobReactor::Distributor.connections << connection

data/lib/job_reactor/{logger.rb → job_logger.rb}

@@ -1,23 +1,27 @@
 module JobReactor
-  module Logger
+  module JobLogger
 
     # Sets the output stream
     #
-    @@logger_method = JR.config[:logger_method]
+    def self.logger_method
+      @logger_method ||= JR.config[:logger_method]
+    end
 
     def self.stdout=(value)
-      @@stdout = value
+      @stdout = value
     end
 
     def self.stdout
-      @@stdout ||= $stdout
+      @stdout ||= $stdout
     end
 
     # Logs message to output stream
     #
     def self.log(msg)
-      stdout.public_send(@@logger_method, '-'*100)
-      stdout.public_send(@@logger_method, msg)
+      if logger_method
+        stdout.public_send(logger_method, "-----#{Time.now.utc}-----")
+        stdout.public_send(logger_method, msg)
+      end
     end
 
     # Builds string for job event and log it

data/lib/job_reactor/job_reactor.rb

@@ -22,18 +22,18 @@ module JobReactor
     # Accessors to jobs.
     #
     def jobs
-      @@jobs ||= { }
+      @jobs ||= { }
     end
 
     # Ready flag.
-    # @@ready is true when block is called inside EM reactor.
+    # @ready is true when block is called inside EM reactor.
     #
     def ready!
-      @@ready = true
+      @ready = true
     end
 
     def ready?
-      (@@ready ||= false) && EM.reactor_running?
+      (@ready ||= false) && EM.reactor_running?
     end
 
     # Parses jobs.
@@ -66,11 +66,11 @@ module JobReactor
     end
 
     def succ_feedbacks
-      @@succ_feedbacks ||= { }
+      @succ_feedbacks ||= { }
     end
 
     def err_feedbacks
-      @@err_feedbacks ||= { }
+      @err_feedbacks ||= { }
     end
 
     # Here is the only method user can call inside the application (excepts start-up methods, of course).
@@ -90,6 +90,9 @@ module JobReactor
     # JR.enqueue 'job', {arg1: 'arg1', arg2: 'arg2'}
     #
     # You can add the following options:
+    # :defer - run job in EM.defer block (in separate thread). Default is false.
+    #  Be careful, the default threadpool size is 20 for EM.
+    #  You can increase it by setting EM.threadpool_size = 'your value', but it is not recommended.
     # :run_at - run at given time;
     # :after - run after some time (in seconds);
     # :period - will make periodic job which will be launched every opts[:period] seconds;
@@ -97,7 +100,7 @@ module JobReactor
     # :not_node - to do not send job to the node;
     #
     # Example:
-    # JR.enqueue 'job', {arg1: 'arg1'}, {period: 100, node: 'my_favorite_node'}
+    # JR.enqueue 'job', {arg1: 'arg1'}, {period: 100, node: 'my_favorite_node', defer: true}
     # JR.enqueue 'job', {arg1: 'arg1'}, {after: 10, not_node: 'some_node'}
     #
     # You can add 'success feedback' and 'error feedback'. We use term 'feedback' to distinguish them from callbacks and errbacks which are executed on the node side.
@@ -109,7 +112,7 @@ module JobReactor
     # error = proc { |args| result = args }
     # JR.enqueue 'job', { arg1: 'arg1'}, {}, success, error
     #
-    def enqueue(name, args = { }, opts = { }, success_proc = nil, error_proc = nil)
+    def enqueue(name, args = {}, opts = {}, success_proc = nil, error_proc = nil)
       hash = { 'name' => name, 'args' => args, 'attempt' => 0, 'status' => 'new', 'defer' => 'false' }
 
       hash.merge!('period' => opts[:period]) if opts[:period]
@@ -121,7 +124,7 @@ module JobReactor
 
       hash.merge!('distributor' => JR::Distributor.server)
 
-      hash.merge!('defer' => 'true') if opts[:defer]
+      hash.merge!('defer' => opts[:defer] ? 'true' : 'false')
 
       add_succ_feedbacks!(hash, success_proc) if success_proc.is_a? Proc
       add_err_feedbacks!(hash, error_proc) if error_proc.is_a? Proc
@@ -219,7 +222,7 @@ module JobReactor
     #
     def add_start_callback(job)
       job.callback do
-        JR::Logger.log_event(:start, job)
+        JR::JobLogger.log_event(:start, job)
       end
     end
 
@@ -227,7 +230,7 @@ module JobReactor
     #
     def add_last_callback(job)
       job.callback do
-        JR::Logger.log_event(:complete, job)
+        JR::JobLogger.log_event(:complete, job)
       end
     end
 
@@ -235,7 +238,7 @@ module JobReactor
     #
     def add_start_errback(job)
       job.errback do
-        JR::Logger.log_event(:error, job)
+        JR::JobLogger.log_event(:error, job)
       end
     end
 
@@ -243,7 +246,7 @@ module JobReactor
     #
     def add_complete_errback(job)
       job.errback do
-        JR::Logger.log_event(:error_complete, job)
+        JR::JobLogger.log_event(:error_complete, job)
       end
     end
 

data/lib/job_reactor/job_reactor/config.rb

@@ -1,8 +1,6 @@
-# Names are informative
-# TODO
 module JobReactor
   def self.config
-    @@config ||= {}
+    @config ||= {}
   end
 end
 
@@ -19,15 +17,8 @@ JR.config[:remove_done_jobs] = true
 JR.config[:remove_cancelled_jobs] = true
 JR.config[:remove_failed_jobs] = false
 
+JR.config[:hiredis_url] = "redis://localhost:6379"
 JR.config[:redis_host] = 'localhost'
 JR.config[:redis_port] = 6379
 
-JR.config[:logger_method] = :puts
-
-#TODO next releases with rails support
-#JR.config[:active_record_adapter] = 'mysql2'
-#JR.config[:active_record_database] = 'em'
-#JR.config[:active_record_user] = ''
-#JR.config[:active_record_password] = ''
-#JR.config[:active_record_table_name] = 'reactor_jobs'
-#JR.config[:use_custom_active_record_connection] = true
+JR.config[:logger_method] = :puts  #nil for complete disable any messages

data/lib/job_reactor/job_reactor/exceptions.rb

@@ -1,9 +1,7 @@
 module JobReactor
 
-  class NoSuchJob < RuntimeError
-  end
-  class CancelJob < Exception
-  end
+  class NoSuchJob < RuntimeError; end
+  class CancelJob < Exception; end
 
 end
 

data/lib/job_reactor/job_reactor/job_parser.rb

@@ -17,10 +17,11 @@
 #     errbacks: [[]]
 #  }
 # }
+#
 # Names of callbacks and errbacks are optional and may be used just for description
 #
 # Job and job_callbacks are absolutely identical on the node side.
-# They become callback of the Deferrable instance. 'job' is the first callback, 'job_callbacks' are the next
+# They become callbacks of the Deferrable instance. 'job' is the first callback, 'job_callbacks' are the next
 #
 # Use job_callbacks to split your job into small parts.
 # You can send additional arguments from one callback to another by merging them into 'args'.
@@ -35,7 +36,7 @@
 # end
 #
 # This is true for errbacks too. Note that you can't access additional arguments added in callbacks in your errbacks
-# In errbacks you also have :error key in args which point the error message
+# In errbacks you also have :error key in args which point the error message.
 #
 # Note, that callbacks and errbacks are called one after another synchronously in one EM tick.
 #

data/lib/job_reactor/job_reactor/storages.rb

@@ -3,22 +3,17 @@
 # save(hash).
 # load(hash).
 # destroy(hash).
-# jobs_for(name).
+# jobs_for(name). The method is called when node starts.
 # The last one is used when node is restarting to retry saved jobs.
 # The storage may not be thread safe, because each node manage it own jobs and don't now anything about others.
 
 # Defines storages for lazy loading
 
-# TODO
-# require 'active_record'
-# class JobReactor::ActiveRecordStorage < ::ActiveRecord::Base; end
-
 module JobReactor::MemoryStorage; end
 module JobReactor::RedisStorage; end
 
 module JobReactor
   STORAGES = {
-      #'active_record_storage' => JobReactor::ActiveRecordStorage,
       'memory_storage' => JobReactor::MemoryStorage,
       'redis_storage' => JobReactor::RedisStorage
   }

data/lib/job_reactor/node.rb

@@ -4,7 +4,13 @@ module JobReactor
   class Node
 
     def initialize(opts)
-      @config = { storage: opts[:storage], name: opts[:name], server: opts[:server], connect_to: opts[:connect_to], distributors: opts[:distributors]}
+      @config = {
+          storage: opts[:storage],
+          name: opts[:name],
+          server: opts[:server],
+          connect_to: opts[:connect_to],
+          distributors: opts[:distributors]
+      }
     end
 
     def config
@@ -45,7 +51,7 @@ module JobReactor
     #
     def connect_to(distributor)
       if connections[distributor]
-        JR::Logger.log "Searching for distributor #{distributor.join(' ')}"
+        JR::JobLogger.log "Searching for distributor #{distributor.join(' ')}"
         connections[distributor].reconnect(*distributor)
       else
         connections.merge!(distributor => EM.connect(*distributor, Client, self, distributor))

data/lib/job_reactor/node/client.rb

@@ -8,7 +8,7 @@ module JobReactor
       end
 
       def post_init
-        JR::Logger.log("Searching for distributor: #{@distributor.join(' ')} ...")
+        JR::JobLogger.log("Searching for distributor: #{@distributor.join(' ')} ...")
       end
 
       def lock
@@ -34,7 +34,7 @@ module JobReactor
       # Sends node credentials to distributor.
       #
       def connection_completed
-        JR::Logger.log('Begin distributor handshake')
+        JR::JobLogger.log('Begin distributor handshake')
         data = {node_info: {name: @node.config[:name], server: @node.server} }
         data = Marshal.dump(data)
         send_data(data)

data/lib/job_reactor/node/server.rb

@@ -13,7 +13,7 @@ module JobReactor
       #Ok, node is connected and ready to work
       #
       def post_init
-        JR::Logger.log("#{@node.name} ready to work")
+        JR::JobLogger.log("#{@node.name} ready to work")
       end
 
       # It is the place where job life cycle begins.
@@ -25,7 +25,7 @@ module JobReactor
       #
       def receive_data(data)
         hash = Marshal.load(data)
-        JR::Logger.log("#{@node.name} received job: #{hash}")
+        JR::JobLogger.log("#{@node.name} received job: #{hash}")
         hash.merge!('node' => @node.name)
         @storage.save(hash) do |hash|
           @node.schedule(hash)

data/lib/job_reactor/storages/memory_storage.rb

@@ -2,37 +2,36 @@
 module JobReactor
   module MemoryStorage
 
-    @@storage = { }
 
     class << self
       def storage
-        @@storage
+        @storage ||= {}
       end
 
-      def load(hash, &block)
+      def load(hash)
         hash = storage[hash['id']]
         if hash
-          hash_copy = { }
+          hash_copy = {}
           hash.each { |k, v| hash_copy.merge!(k => v) }
-          block.call(hash_copy) if block_given?
+          yield hash_copy if block_given?
         end
       end
 
-      def save(hash, &block)
+      def save(hash)
         unless (hash['id'])
           id = Time.now.to_f.to_s
           hash.merge!('id' => id)
         end
         storage.merge!(hash['id'] => hash)
 
-        block.call(hash) if block_given?
+        yield hash if block_given?
       end
 
       def destroy(hash)
         storage.delete(hash['id'])
       end
 
-      def jobs_for(name, &block)  #No persistance
+      def jobs_for(name, &block)  #No persistence
         nil
       end
     end

data/lib/job_reactor/storages/redis_monitor.rb

@@ -2,12 +2,12 @@ require 'redis'
 module JobReactor
   module RedisMonitor
 
-    ATTRS = %w(id name args last_error run_at failed_at attempt period make_after status distributor on_success on_error)
+    ATTRS = %w(id name args last_error run_at failed_at attempt period make_after status distributor on_success on_error defer)
 
     extend self
 
     def storage
-      @@storage ||= Redis.new(host: JR.config[:redis_host], port: JR.config[:redis_port])
+      @storage ||= Redis.new(host: JR.config[:redis_host], port: JR.config[:redis_port])
     end
 
     # Returns all job for given node.

data/lib/job_reactor/storages/redis_storage.rb

@@ -1,21 +1,19 @@
 # TODO comment it
-require 'em-redis'
+require 'em-hiredis'
 
 module JobReactor
   module RedisStorage
-    @@storage = EM::Protocols::Redis.connect(host: JobReactor.config[:redis_host], port: JobReactor.config[:redis_port])
     ATTRS = %w(id name args last_error run_at failed_at attempt period make_after status distributor on_success on_error defer)
 
     class << self
 
       def storage
-        @@storage
+        @storage ||= EM::Hiredis.connect(JobReactor.config[:hiredis_url])
       end
 
-      def load(hash, &block)
+      def load(hash)
         key = "#{hash['node']}_#{hash['id']}"
         hash_copy = {'node' => hash['node']} #need new object, because old one has been 'failed'
-
         storage.hmget(key, *ATTRS) do |record|
           unless record.compact.empty?
             ATTRS.each_with_index do |attr, i|
@@ -26,26 +24,26 @@ module JobReactor
             end
             hash_copy['args'] = Marshal.load(hash_copy['args'])
 
-            block.call(hash_copy) if block_given?
+            yield hash_copy if block_given?
           end
         end
       end
 
-
-      def save(hash, &block)
+      def save(hash)
         hash.merge!('id' => Time.now.to_f.to_s) unless hash['id']
         key = "#{hash['node']}_#{hash['id']}"
         args, hash['args'] = hash['args'], Marshal.dump(hash['args'])
 
         storage.hmset(key, *ATTRS.map{|attr| [attr, hash[attr]]}.flatten) do
           hash['args'] = args
-
-          block.call(hash) if block_given?
+          yield hash if block_given?
         end
       end
 
       def destroy(hash)
-        storage.del("#{hash['node']}_#{hash['id']}")
+        storage.del("#{hash['node']}_#{hash['id']}") do
+          yield hash if block_given?
+        end
       end
 
       def destroy_all_jobs_for(name)
@@ -53,7 +51,7 @@ module JobReactor
         storage.del(*storage.keys(pattern))
       end
 
-      def jobs_for(name, &block)
+      def jobs_for(name)
         pattern = "*#{name}_*"
         storage.keys(pattern) do |keys|
           keys.each do |key|
@@ -64,7 +62,7 @@ module JobReactor
               self.load(hash) do |hash|
                 if hash['status'] != 'complete' && hash['status'] != 'cancelled' && hash['status'] != 'failed'
                 else
-                  block.call(hash)
+                  yield hash if block_given?
                 end
               end
             end

metadata

@@ -1,113 +1,104 @@
 --- !ruby/object:Gem::Specification
 name: job_reactor
 version: !ruby/object:Gem::Version
-  version: 0.5.2
-  prerelease: 
+  version: 0.6.0
 platform: ruby
 authors:
 - Anton Mishchuk
-- Andrey Rozhkovskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-18 00:00:00.000000000 Z
+date: 2013-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: em-redis
+  name: em-hiredis
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! "    JobReactor is a library for creating, scheduling and processing
-  background jobs.\n    It is asynchronous client-server distributed system based
-  on EventMachine.\n    Inspired by DelayedJob, Resque, Beanstalkd, and etc.\n"
+description: |2
+      JobReactor is a library for creating, scheduling and processing background jobs.
+      It is asynchronous client-server distributed system based on EventMachine.
 email: anton.mishchuk@gmial.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/job_reactor.rb
-- lib/job_reactor/node/server.rb
+- lib/job_reactor/job_reactor/job_parser.rb
+- lib/job_reactor/job_reactor/config.rb
+- lib/job_reactor/job_reactor/exceptions.rb
+- lib/job_reactor/job_reactor/storages.rb
+- lib/job_reactor/storages/redis_storage.rb
+- lib/job_reactor/storages/redis_monitor.rb
+- lib/job_reactor/storages/memory_storage.rb
+- lib/job_reactor/distributor/client.rb
+- lib/job_reactor/distributor/server.rb
+- lib/job_reactor/job_logger.rb
 - lib/job_reactor/node/client.rb
+- lib/job_reactor/node/server.rb
 - lib/job_reactor/node.rb
 - lib/job_reactor/job_reactor.rb
-- lib/job_reactor/distributor/server.rb
-- lib/job_reactor/distributor/client.rb
-- lib/job_reactor/storages/redis_monitor.rb
-- lib/job_reactor/storages/memory_storage.rb
-- lib/job_reactor/storages/redis_storage.rb
 - lib/job_reactor/distributor.rb
-- lib/job_reactor/logger.rb
-- lib/job_reactor/job_reactor/storages.rb
-- lib/job_reactor/job_reactor/exceptions.rb
-- lib/job_reactor/job_reactor/job_parser.rb
-- lib/job_reactor/job_reactor/config.rb
+- lib/job_reactor.rb
 - README.markdown
 homepage: http://github.com/antonmi/job_reactor
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Simple, powerful and high scalable job queueing and background workers system
   based on EventMachine
 test_files: []