em-jack 0.0.4 → 0.0.5

data/lib/em-jack.rb

@@ -5,8 +5,12 @@ require 'em-jack/errors'
 require 'em-jack/beanstalk_connection'
 require 'em-jack/connection'
 
+Dir["#{File.dirname(__FILE__)}/em-jack/handlers/*.rb"].each do |file|
+  require file
+end
+
 module EMJack
   module VERSION
-    STRING = '0.0.4'
+    STRING = '0.0.5'
   end
 end

data/lib/em-jack/connection.rb

@@ -4,8 +4,19 @@ require 'yaml'
 module EMJack
   class Connection
     RETRY_COUNT = 5
- 
+
+    @@handlers = []
+
     attr_accessor :host, :port
+
+    def self.register_handler(handler)
+      @@handlers ||= []
+      @@handlers << handler
+    end
+
+    def self.handlers
+      @@handlers
+    end
     
     def initialize(opts = {})
       @host = opts[:host] || 'localhost'
@@ -62,18 +73,6 @@ module EMJack
       add_deferrable(&blk)
     end
 
-    def each_job(&blk)
-      work = Proc.new do
-        r = reserve
-        r.callback do |job|
-          blk.call(job)
-
-          EM.next_tick { work.call }
-        end
-      end
-      work.call
-    end
-
     def stats(type = nil, val = nil, &blk)
       case(type)
       when nil then @conn.send(:stats)
@@ -99,10 +98,14 @@ module EMJack
       @conn.send(:delete, job.jobid)
       add_deferrable(&blk)
     end
-    
-    def release(job, &blk)
+
+    def release(job, opts = {}, &blk)
       return if job.nil?
-      @conn.send(:release, job.jobid, 0, 0)
+
+      pri = (opts[:priority] || 65536).to_i
+      delay = (opts[:delay] || 0).to_i
+
+      @conn.send(:release, job.jobid, pri, delay)
       add_deferrable(&blk)
     end
 
@@ -123,14 +126,25 @@ module EMJack
       @conn.send_with_data(:put, m, pri, delay, ttr, m.length)
       add_deferrable(&blk)
     end
-  
+
+    def each_job(timeout = nil, &blk)
+      work = Proc.new do
+        r = reserve(timeout)
+        r.callback do |job|
+          blk.call(job)
+
+          EM.next_tick { work.call }
+        end
+      end
+      work.call
+    end
+
     def connected
       @retries = 0
     end
 
     def disconnected
-      # XXX I think I need to run out the deferrables as failed here
-      # since the connection was dropped
+      @deferrables.each { |df| df.fail(:disconnected) }
 
       raise EMJack::Disconnected if @retries >= RETRY_COUNT
       @retries += 1
@@ -156,7 +170,7 @@ module EMJack
     def on_error(&blk)
       @error_callback = blk
     end
-  
+
     def received(data)
       @data << data
 
@@ -166,75 +180,30 @@ module EMJack
 
         first = @data[0..(idx + 1)]
 
-        handled = false
-        %w(OUT_OF_MEMORY INTERNAL_ERROR DRAINING BAD_FORMAT
-           UNKNOWN_COMMAND EXPECTED_CRLF JOB_TOO_BIG DEADLINE_SOON
-           TIMED_OUT NOT_FOUND).each do |cmd|
-          next unless first =~ /^#{cmd}\r\n/i
-          df = @deferrables.shift
-          df.fail(cmd.downcase.to_sym)
-
-          @data = @data[(cmd.length + 2)..-1]
-          handled = true
-          break
-        end
-        next if handled
-
-        case (first)
-        when /^DELETED\r\n/ then
-          df = @deferrables.shift
-          df.succeed
+        df = @deferrables.shift
+        handled, skip = false, false
+        EMJack::Connection.handlers.each do |h|
+          handles, bytes = h.handles?(first)
 
-        when /^INSERTED\s+(\d+)\r\n/ then
-          df = @deferrables.shift
-          df.succeed($1.to_i)
+          next unless handles
+          bytes = bytes.to_i
 
-        when /^RELEASED\r\n/ then
-          df = @deferrables.shift
-          df.succeed
+          # 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
+          break if body.nil? && bytes > 0
 
-        when /^BURIED\s+(\d+)\r\n/ then
-          df = @deferrables.shift
-          df.fail(:buried, $1.to_i)
-
-        when /^USING\s+(.*)\r\n/ then
-          df = @deferrables.shift
-          df.succeed($1)
-
-        when /^WATCHING\s+(\d+)\r\n/ then
-          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
-
-          body, @data = extract_body(bytes, @data)
-          break if body.nil?
-
-          df = @deferrables.shift
-          df.succeed(YAML.load(body))
-          next
-
-        when /^RESERVED\s+(\d+)\s+(\d+)\r\n/ then
-          id = $1.to_i
-          bytes = $2.to_i
-
-          body, @data = extract_body(bytes, @data)
-          break if body.nil?
-
-          df = @deferrables.shift
-          job = EMJack::Job.new(self, id, body)
-          df.succeed(job)
-          next
-          
-        else
-          break
+          handled = h.handle(df, first, body)
+          break if handled
         end
 
+        @deferrables.unshift(df) unless handled
+
+        # not handled means there wasn't enough data to process a complete response
+        break unless handled
+        next unless @data.index(/\r\n/)
+      
         @data = @data[(@data.index(/\r\n/) + 2)..-1]
         @data = "" if @data.nil?
       end

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

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

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

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

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

@@ -0,0 +1,19 @@
+module EMJack
+  module Handler
+    class Errors
+      RESPONSE = /^(OUT_OF_MEMORY|INTERNAL_ERROR|DRAINING|BAD_FORMAT|UNKNOWN_COMMAND|EXPECTED_CRLF|JOB_TOO_BIG|DEADLINE_SOON|TIMED_OUT|NOT_FOUND)\r\n/i
+
+      def self.handles?(response)
+        response =~ RESPONSE
+      end
+
+      def self.handle(deferrable, response, body)
+        return false unless response =~ RESPONSE
+        deferrable.fail($1.downcase.to_sym)
+        true
+      end
+
+      EMJack::Connection.register_handler(EMJack::Handler::Errors)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+module EMJack
+  module Handler
+    class NotIgnored
+      RESPONSE = /^NOT_IGNORED\r\n/
+
+      def self.handles?(response)
+        response =~ RESPONSE
+      end
+      
+      def self.handle(deferrable, response, body)
+        return false unless response =~ RESPONSE
+
+        deferrable.fail("Can't ignore only watched tube")
+        true
+      end
+
+      EMJack::Connection.register_handler(EMJack::Handler::NotIgnored)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module EMJack
+  module Handler
+    class Ok
+      RESPONSE = /^OK\s+(\d+)\r\n/
+
+      def self.handles?(response)
+        if response =~ RESPONSE
+          [true, $1.to_i]
+        else
+          false
+        end
+      end
+
+      def self.handle(deferrable, response, body)
+        return false unless response =~ RESPONSE
+        bytes = $1.to_i
+
+        deferrable.succeed(YAML.load(body))
+        true
+      end
+
+      EMJack::Connection.register_handler(EMJack::Handler::Ok)
+    end
+  end
+end

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

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

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

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

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

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

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

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

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: em-jack
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - dan sinclair
@@ -9,19 +14,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-17 00:00:00 -05:00
+date: 2010-03-02 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: An evented Beanstalk client.
 email: dj2@everburning.com
 executables: []
@@ -38,6 +45,16 @@ files:
 - lib/em-jack/connection.rb
 - lib/em-jack/errors.rb
 - lib/em-jack/job.rb
+- lib/em-jack/handlers/buried.rb
+- lib/em-jack/handlers/inserted.rb
+- lib/em-jack/handlers/not_ignored.rb
+- lib/em-jack/handlers/ok.rb
+- lib/em-jack/handlers/released.rb
+- lib/em-jack/handlers/reserved.rb
+- lib/em-jack/handlers/using.rb
+- lib/em-jack/handlers/watching.rb
+- lib/em-jack/handlers/deleted.rb
+- lib/em-jack/handlers/errors.rb
 has_rdoc: true
 homepage: http://github.com/dj2/em-jack/
 licenses: []
@@ -55,18 +72,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: An evented Beanstalk client.