em-jack 0.0.8 → 0.0.9

data/README.rdoc

@@ -1,10 +1,8 @@
 = EMJack
 An attempt to wrap portions of the Beanstalk protocol with EventMachine. Every command
-will return a deferrable object. That object will succeed or fail depending on the 
+will return a deferrable object. That object will succeed or fail depending on the
 reply returned from Beanstalk.
 
-The current, default, errback is to print the error message received.
-
 One thing to keep in mind. The Beanstalk protocol executes all commands serially.
 So, if you send a reserve command and there are no jobs Beanstalk _won't_ process
 any of the commands that come after the reserve until the reserve completes.
@@ -19,25 +17,25 @@ are no available jobs.
 = Examples
   EM.run {
     jack = EMJack::Connection.new
-  
+
     r = jack.use('mytube')
     r.callback { |tube| puts "Using #{tube}" }
-  
+
     r = jack.reserve
     r.callback do |job|
       puts job.jobid
 
       r2 = jack.delete(job) { puts "Successfully deleted" }
     end
-  
+
     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 = jack.stats(:tube, "mytube")
     r.callback { |stats| puts "Total jobs #{stats['total-jobs']}" }
-    
+
     r = jack.list(:used)
     r.callback { |tubes| puts "There are #{tubes.length} tubes defined" }
   }
@@ -45,12 +43,13 @@ are no available jobs.
   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 
+  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
   the queue is empty, the client will block and wait for a new job.
 
   If multiple workers connect to the queue Beanstalkd will round-robin between
   the workers.
+
     EM.run {
       jack = EMJack::Connection.new
 

data/lib/em-jack.rb

@@ -11,6 +11,6 @@ end
 
 module EMJack
   module VERSION
-    STRING = '0.0.8'
+    STRING = '0.0.9'
   end
 end

data/lib/em-jack/connection.rb

@@ -3,6 +3,8 @@ require 'yaml'
 
 module EMJack
   class Connection
+    include EM::Deferrable
+
     RETRY_COUNT = 5
 
     @@handlers = []
@@ -43,14 +45,20 @@ module EMJack
 
     def use(tube, &blk)
       return if @used_tube == tube
-      @used_tube = tube
-      @conn.send(:use, tube)
+
+      callback {
+        @used_tube = tube
+        @conn.send(:use, tube)
+      }
+
       add_deferrable(&blk)
     end
 
     def watch(tube, &blk)
       return if @watched_tubes.include?(tube)
-      @conn.send(:watch, tube)
+
+      callback { @conn.send(:watch, tube) }
+
       df = add_deferrable(&blk)
       df.callback { @watched_tubes.push(tube) }
       df
@@ -58,44 +66,96 @@ module EMJack
 
     def ignore(tube, &blk)
       return unless @watched_tubes.include?(tube)
-      @conn.send(:ignore, tube)
+
+      callback { @conn.send(:ignore, tube) }
+
       df = add_deferrable(&blk)
       df.callback { @watched_tubes.delete(tube) }
       df
     end
 
     def reserve(timeout = nil, &blk)
-      if timeout
-        @conn.send(:'reserve-with-timeout', timeout)
-      else
-        @conn.send(:reserve)
-      end
+      callback {
+        if timeout
+          @conn.send(:'reserve-with-timeout', timeout)
+        else
+          @conn.send(:reserve)
+        end
+      }
+
+      add_deferrable(&blk)
+    end
+
+    def peek(type = nil, &blk)
+      callback {
+        case(type.to_s)
+        when /^\d+$/ then @conn.send(:peek, type)
+        when "ready" then @conn.send(:'peek-ready')
+        when "delayed" then @conn.send(:'peek-delayed')
+        when "buried" then @conn.send(:'peek-buried')
+        else raise EMJack::InvalidCommand.new
+        end
+      }
+
       add_deferrable(&blk)
     end
 
     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
+      callback {
+        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(&blk)
     end
 
     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
+      callback {
+        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(&blk)
     end
 
     def delete(job, &blk)
       return if job.nil?
-      @conn.send(:delete, job.jobid)
+
+      callback { @conn.send(:delete, job.jobid) }
+
+      add_deferrable(&blk)
+    end
+
+    def touch(job, &blk)
+      return if job.nil?
+
+      callback { @conn.send(:touch, job.jobid) }
+
+      add_deferrable(&blk)
+    end
+
+    def bury(job, pri, &blk)
+      callback { @conn.send(:bury, job.jobid, pri) }
+
+      add_deferrable(&blk)
+    end
+
+    def kick(count = 1, &blk)
+      callback { @conn.send(:kick, count) }
+
+      add_deferrable(&blk)
+    end
+
+    def pause(tube, delay, &blk)
+      callback { @conn.send(:'pause-tube', delay) }
+
       add_deferrable(&blk)
     end
 
@@ -105,12 +165,14 @@ module EMJack
       pri = (opts[:priority] || 65536).to_i
       delay = (opts[:delay] || 0).to_i
 
-      @conn.send(:release, job.jobid, pri, delay)
+      callback { @conn.send(:release, job.jobid, pri, delay) }
+
       add_deferrable(&blk)
     end
 
     def put(msg, opts = nil, &blk)
       opts = {} if opts.nil?
+
       pri = (opts[:priority] || 65536).to_i
       pri = 65536 if pri< 0
       pri = 2 ** 32 if pri > (2 ** 32)
@@ -123,7 +185,8 @@ module EMJack
 
       m = msg.to_s
 
-      @conn.send_with_data(:put, m, pri, delay, ttr, m.length)
+      callback { @conn.send_with_data(:put, m, pri, delay, ttr, m.length) }
+
       add_deferrable(&blk)
     end
 
@@ -141,25 +204,26 @@ module EMJack
 
     def connected
       @retries = 0
+      succeed
     end
 
     def disconnected
-      @deferrables.each { |df| df.fail(:disconnected) }
+      d = @deferrables.dup
       @deferrables = []
 
+      set_deferred_status(nil)
+      d.each { |df| df.fail(:disconnected) }
+
       raise EMJack::Disconnected if @retries >= RETRY_COUNT
+
       @retries += 1
-      EM.add_timer(1) { @conn.reconnect(@host, @port) }
+      EM.add_timer(5) { @conn.reconnect(@host, @port) }
     end
 
     def add_deferrable(&blk)
       df = EM::DefaultDeferrable.new
-      df.errback do |err|
-        if @error_callback
-          @error_callback.call(err)
-        else
-          puts "ERROR: #{err}"
-        end
+      if @error_callback
+        df.errback { |err| @error_callback.call(err) }
       end
 
       df.callback &blk if block_given?
@@ -192,7 +256,7 @@ module EMJack
           # if this handler requires us to receive a body make sure we can get
           # the full length of body. If not, we'll go around and wait for more
           # data to be received
-          body, @data = extract_body(bytes, @data) unless bytes <= 0
+          body, @data = extract_body!(bytes, @data) unless bytes <= 0
           break if body.nil? && bytes > 0
 
           handled = h.handle(df, first, body, self)
@@ -210,7 +274,7 @@ module EMJack
       end
     end
 
-    def extract_body(bytes, data)
+    def extract_body!(bytes, data)
       rem = data[(data.index(/\r\n/) + 2)..-1]
       return [nil, data] if rem.length < bytes
 

data/lib/em-jack/handlers/buried.rb

@@ -1,7 +1,7 @@
 module EMJack
   module Handler
     class Buried
-      RESPONSE = /^BURIED\s+(\d+)\r\n/
+      RESPONSE = /^BURIED(\s+(\d+))?\r\n/
 
       def self.handles?(response)
         response =~ RESPONSE
@@ -10,7 +10,16 @@ module EMJack
       def self.handle(deferrable, response, body, conn=nil)
         return false unless response =~ RESPONSE
 
-        deferrable.fail(:buried, $1.to_i)
+        # if there is an id this is the response of a put command
+        # otherwise, it's either the result of a BURY command or
+        # a release command. I'm assuming the latter 2 are success
+        # and the first is a failure
+        id = $2
+        if id.nil?
+          deferrable.succeed
+        else
+          deferrable.fail(:buried, id.to_i)
+        end
         true
       end
       

data/lib/em-jack/handlers/kicked.rb

@@ -0,0 +1,20 @@
+module EMJack
+  module Handler
+    class Kicked
+      RESPONSE = /^KICKED\s+(\d+)\r\n/
+
+      def self.handles?(response)
+        response =~ RESPONSE
+      end
+
+      def self.handle(deferrable, response, body, conn=nil)
+        return false unless response =~ RESPONSE
+
+        deferrable.succeed($1.to_i)
+        true
+      end
+
+      EMJack::Connection.register_handler(EMJack::Handler::Kicked)
+    end
+  end
+end

data/lib/em-jack/handlers/paused.rb

@@ -0,0 +1,20 @@
+module EMJack
+  module Handler
+    class Paused
+      RESPONSE = /^PAUSED\r\n/
+
+      def self.handles?(response)
+        response =~ RESPONSE
+      end
+
+      def self.handle(deferrable, response, body, conn=nil)
+        return false unless response =~ RESPONSE
+
+        deferrable.succeed
+        true
+      end
+
+      EMJack::Connection.register_handler(EMJack::Handler::Paused)
+    end
+  end
+end

data/lib/em-jack/handlers/reserved.rb

@@ -1,11 +1,11 @@
 module EMJack
   module Handler
     class Reserved
-      RESPONSE = /^RESERVED\s+(\d+)\s+(\d+)\r\n/
+      RESPONSE = /^(RESERVED|FOUND)\s+(\d+)\s+(\d+)\r\n/
 
       def self.handles?(response)
         if response =~ RESPONSE
-          [true, $2.to_i]
+          [true, $3.to_i]
         else
           false
         end
@@ -13,8 +13,8 @@ module EMJack
 
       def self.handle(deferrable, response, body, conn)
         return false unless response =~ RESPONSE
-        id = $1.to_i
-        bytes = $2.to_i
+        id = $2.to_i
+        bytes = $3.to_i
 
         job = EMJack::Job.new(conn, id, body)
         deferrable.succeed(job)

data/lib/em-jack/handlers/touched.rb

@@ -0,0 +1,20 @@
+module EMJack
+  module Handler
+    class Touched
+      RESPONSE = /^TOUCHED\r\n/
+
+      def self.handles?(response)
+        response =~ RESPONSE
+      end
+
+      def self.handle(deferrable, response, body, conn=nil)
+        return false unless response =~ RESPONSE
+
+        deferrable.succeed
+        true
+      end
+
+      EMJack::Connection.register_handler(EMJack::Handler::Touched)
+    end
+  end
+end

data/lib/em-jack/job.rb

@@ -1,13 +1,13 @@
 module EMJack
   class Job
     attr_accessor :jobid, :body, :ttr, :conn
-    
+
     def initialize(conn, jobid, body)
       @conn = conn
       @jobid = jobid.to_i
       @body = body
     end
-    
+
     def delete(&blk)
       @conn.delete(self, &blk)
     end
@@ -20,6 +20,14 @@ module EMJack
       @conn.stats(:job, self, &blk)
     end
 
+    def touch(&blk)
+      @conn.touch(self, &blk)
+    end
+
+    def bury(delay, &blk)
+      @conn.bury(self, delay, &blk)
+    end
+
     def to_s
       "#{@jobid} -- #{body.inspect}"
     end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 8
-  version: 0.0.8
+  - 9
+  version: 0.0.9
 platform: ruby
 authors: 
 - dan sinclair
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-23 00:00:00 -04:00
+date: 2010-03-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -55,6 +55,9 @@ files:
 - lib/em-jack/handlers/watching.rb
 - lib/em-jack/handlers/deleted.rb
 - lib/em-jack/handlers/errors.rb
+- lib/em-jack/handlers/paused.rb
+- lib/em-jack/handlers/touched.rb
+- lib/em-jack/handlers/kicked.rb
 has_rdoc: true
 homepage: http://github.com/dj2/em-jack/
 licenses: []