em-jack 0.0.3 → 0.0.4

data/README.rdoc

@@ -26,25 +26,24 @@ are no available jobs.
     r = jack.reserve
     r.callback do |job|
       puts job.jobid
-      process(job)
-      
-      r2 = jack.delete(job)
-      r2.callback { puts "Successfully deleted" }
+
+      r2 = jack.delete(job) { puts "Successfully deleted" }
     end
   
-    r = jack.put("my message", :ttr => 300)
-    r.callback { |jobid| puts "put successful #{jobid}" }
+    r = jack.put("my message", :ttr => 300) { |jobid| puts "put successful #{jobid}" }
   
     r = jack.stats
-    r.callback { |stats| puts "Server up for #{stats['uptime']} seconds" "}
+    r.callback { |stats| puts "Server up for #{stats['uptime']} seconds" }
     
     r = jack.stats(:tube, "mytube")
     r.callback { |stats| puts "Total jobs #{stats['total-jobs']}" }
     
-    r = jack.list(:tubes)
+    r = jack.list(:used)
     r.callback { |tubes| puts "There are #{tubes.length} tubes defined" }
   }
 
+  Each of the Jack commands allows an optional block to be provided. If the block is given
+  it will be setup as the callback on the deferrable.
 
   EMJack#each_job is useful for scenarios where the client is a job worker 
   and intended to process jobs continuously as they become available. Once 
@@ -77,4 +76,6 @@ contact me by email at dj2 at everburning dot com.
 
 
 = Contributors
-Peter Kieltyka (EMJack#each_job)
+Charles Melbye (cmelbye)
+Peter Kieltyka (pkieltyka)
+Martyn Loughran (mloughran)

data/lib/em-jack.rb

@@ -7,6 +7,6 @@ require 'em-jack/connection'
 
 module EMJack
   module VERSION
-    STRING = '0.0.3'
+    STRING = '0.0.4'
   end
 end

data/lib/em-jack/connection.rb

@@ -30,86 +30,87 @@ module EMJack
       end
     end
     
-    def use(tube)
+    def use(tube, &blk)
       return if @used_tube == tube
       @used_tube = tube
       @conn.send(:use, tube)
-      add_deferrable
+      add_deferrable(&blk)
     end
     
-    def watch(tube)
+    def watch(tube, &blk)
       return if @watched_tubes.include?(tube)
-      @watched_tubes.push(tube)
       @conn.send(:watch, tube)
-      add_deferrable
+      df = add_deferrable(&blk)
+      df.callback { @watched_tubes.push(tube) }
+      df
     end
     
-    def ignore(tube)
-      return if not @watched_tubes.include?(tube)
-      @watched_tubes.delete(tube)
+    def ignore(tube, &blk)
+      return unless @watched_tubes.include?(tube)
       @conn.send(:ignore, tube)
-      add_deferrable
+      df = add_deferrable(&blk)
+      df.callback { @watched_tubes.delete(tube) }
+      df
     end
 
-    def reserve(timeout = nil)
+    def reserve(timeout = nil, &blk)
       if timeout
         @conn.send(:'reserve-with-timeout', timeout)
       else
         @conn.send(:reserve)
       end
-      add_deferrable
+      add_deferrable(&blk)
     end
 
-    def each_job(&block)
+    def each_job(&blk)
       work = Proc.new do
         r = reserve
         r.callback do |job|
-          block.call(job)
+          blk.call(job)
+
           EM.next_tick { work.call }
         end
       end
       work.call
     end
 
-    def stats(type = nil, val = nil)
+    def stats(type = nil, val = nil, &blk)
       case(type)
       when nil then @conn.send(:stats)
       when :tube then @conn.send(:'stats-tube', val)
       when :job then @conn.send(:'stats-job', val.jobid)
       else raise EMJack::InvalidCommand.new
       end
-      add_deferrable
+      add_deferrable(&blk)
     end
 
-    def list(type = nil)
+    def list(type = nil, &blk)
       case(type)
       when nil then @conn.send(:'list-tubes')
       when :used then @conn.send(:'list-tube-used')
       when :watched then @conn.send(:'list-tubes-watched')
       else raise EMJack::InvalidCommand.new
       end
-      add_deferrable
+      add_deferrable(&blk)
     end
 
-    def delete(job)
+    def delete(job, &blk)
       return if job.nil?
       @conn.send(:delete, job.jobid)
-      add_deferrable
+      add_deferrable(&blk)
     end
     
-    def release(job)
+    def release(job, &blk)
       return if job.nil?
       @conn.send(:release, job.jobid, 0, 0)
-      add_deferrable
+      add_deferrable(&blk)
     end
-    
-    def put(msg, opts = {})
+
+    def put(msg, opts = nil, &blk)
+      opts = {} if opts.nil?
       pri = (opts[:priority] || 65536).to_i
-      if pri< 0
-         pri = 65536
-      elsif pri > (2 ** 32)
-        pri = 2 ** 32
-      end
+      pri = 65536 if pri< 0
+      pri = 2 ** 32 if pri > (2 ** 32)
       
       delay = (opts[:delay] || 0).to_i
       delay = 0 if delay < 0
@@ -120,7 +121,7 @@ module EMJack
       m = msg.to_s
       
       @conn.send_with_data(:put, m, pri, delay, ttr, m.length)
-      add_deferrable
+      add_deferrable(&blk)
     end
   
     def connected
@@ -136,14 +137,26 @@ module EMJack
       EM.add_timer(1) { @conn.reconnect(@host, @port) }
     end
 
-    def add_deferrable
+    def add_deferrable(&blk)
       df = EM::DefaultDeferrable.new
-      df.errback { |err| puts "ERROR: #{err}" }
+      df.errback do |err|
+        if @error_callback
+          @error_callback.call(err)
+        else
+          puts "ERROR: #{err}"
+        end
+      end
       
+      df.callback &blk if block_given?
+
       @deferrables.push(df)
       df
     end
   
+    def on_error(&blk)
+      @error_callback = blk
+    end
+  
     def received(data)
       @data << data
 
@@ -176,6 +189,10 @@ module EMJack
           df = @deferrables.shift
           df.succeed($1.to_i)
 
+        when /^RELEASED\r\n/ then
+          df = @deferrables.shift
+          df.succeed
+
         when /^BURIED\s+(\d+)\r\n/ then
           df = @deferrables.shift
           df.fail(:buried, $1.to_i)
@@ -188,6 +205,10 @@ module EMJack
           df = @deferrables.shift
           df.succeed($1.to_i)
 
+        when /^NOT_IGNORED\r\n/ then
+          df = @deferrables.shift
+          df.fail("Can't ignore only watched tube")
+
         when /^OK\s+(\d+)\r\n/ then
           bytes = $1.to_i
 
@@ -222,9 +243,11 @@ module EMJack
     def extract_body(bytes, data)
       rem = data[(data.index(/\r\n/) + 2)..-1]
       return [nil, data] if rem.length < bytes
+
       body = rem[0..(bytes - 1)]
       data = rem[(bytes + 2)..-1]
       data = "" if data.nil?
+
       [body, data]
     end
   end  

data/lib/em-jack/job.rb

@@ -8,12 +8,12 @@ module EMJack
       @body = body
     end
     
-    def delete
-      @conn.delete(self)
+    def delete(&blk)
+      @conn.delete(self, &blk)
     end
     
-    def stats
-      @conn.stats(:job, self)
+    def stats(&blk)
+      @conn.stats(:job, self, &blk)
     end
 
     def to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: em-jack
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - dan sinclair
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-11 00:00:00 -06:00
+date: 2009-11-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency