em-beanstalk 0.0.4 → 0.0.5

data/README.rdoc

@@ -13,12 +13,14 @@ any of the commands that come after the reserve until the reserve completes.
 This is a bit of a gotcha when sending a series of reserve, delete, etc and there
 are no available jobs.
 
-= Dependencies
- - EventMachine
- - RSpec  (to run the tests)
- - EM::Spec
+== Dependencies
+ - eventmachine
 
-= Examples
+=== For testing
+ - rspec
+ - em-spec
+
+== Examples
   EM.run {
     jack = EM::Beanstalk.new
   
@@ -40,27 +42,40 @@ are no available jobs.
     jack.list(:tubes) { |tubes| puts "There are #{tubes.length} tubes defined" }
   }
 
+If you need custom error handling, you can chain the error event handler
 
-  EM::Beanstalk#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.
+== Examples
+EM.run {
+  jack = EM::Beanstalk.new
 
-  If multiple workers connect to the queue Beanstalkd will round-robin between
-  the workers.
-    EM.run {
-      jack = EM::Beanstalk.new
+  jack.delete(job_id) {
+    puts "deleted job!"
+  }.error {|message|
+    puts "I couldn't delete the job because of #{message}"
+  }
+}
 
-      jack.each_job do |job|
-        puts "Got job ##{job.id}: #{job}"
+EM::Beanstalk#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 process(job)
-          jack.delete(job) { puts "*Deleted #{job}*" }
-        else
-          # something went horribly wrong!
-        end
-      end
+If multiple workers connect to the queue Beanstalkd will round-robin between
+the workers.
+
+  EM.run {
+    jack = EM::Beanstalk.new
 
-      def process(job)
-        # Some kind of job processing
+    jack.each_job do |job|
+      puts "Got job ##{job.id}: #{job}"
+
+      if process(job)
+        jack.delete(job) { puts "*Deleted #{job}*" }
+      else
+        # something went horribly wrong!
       end
-    }
+    end
+
+    def process(job)
+      # Some kind of job processing
+    end
+  }

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/em-beanstalk.rb

@@ -4,6 +4,7 @@ require 'yaml'
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
 
 require 'em-beanstalk/job'
+require 'em-beanstalk/defer'
 require 'em-beanstalk/connection'
 
 module EM
@@ -12,23 +13,26 @@ module EM
     Disconnected   = Class.new(RuntimeError)
     InvalidCommand = Class.new(RuntimeError)
 
+    Body = Struct.new(:body, :data)
+    
     module VERSION
       STRING = File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
     end
 
     attr_accessor :host, :port
-    attr_reader :default_priority, :default_delay, :default_ttr
+    attr_reader :default_priority, :default_delay, :default_ttr, :default_error_callback
   
     def initialize(opts = nil)
-      @host = opts && opts[:host] || 'localhost'
-      @port = opts && opts[:port] || 11300
-      @tube = opts && opts[:tube]
-      @retry_count = opts && opts[:retry_count] || 5
-      @default_priority = opts && opts[:default_priority] || 65536
-      @default_delay = opts && opts[:default_delay] || 0
-      @default_ttr = opts && opts[:default_ttr] || 300
-      @default_timeout = opts && opts[:timeout] || 5
-    
+      @host                   = opts && opts[:host] || 'localhost'
+      @port                   = opts && opts[:port] || 11300
+      @tube                   = opts && opts[:tube]
+      @retry_count            = opts && opts[:retry_count] || 5
+      @default_priority       = opts && opts[:default_priority] || 65536
+      @default_delay          = opts && opts[:default_delay] || 0
+      @default_ttr            = opts && opts[:default_ttr] || 300
+      @default_timeout        = opts && opts[:timeout] || 5
+      @default_error_callback = opts && opts[:default_error_callback] || Proc.new{ |error| puts "ERROR: #{error.inspect}" }
+      
       @used_tube = 'default'
       @watched_tubes = [@used_tube]
     
@@ -125,9 +129,9 @@ module EM
   
     def list(type = nil, &block)
       case(type)
-      when nil then @conn.send(:'list-tubes')
-      when :use, :used then @conn.send(:'list-tube-used')
-      when :watch, :watched then @conn.send(:'list-tubes-watched')
+      when :tube, :tubes, nil then @conn.send(:'list-tubes')
+      when :use, :used        then @conn.send(:'list-tube-used')
+      when :watch, :watched   then @conn.send(:'list-tubes-watched')
       else raise EM::Beanstalk::InvalidCommand.new
       end
       add_deferrable(&block)
@@ -187,17 +191,8 @@ module EM
     end
 
     def add_deferrable(&block)
-      df = EM::DefaultDeferrable.new
-      df.errback do
-        if @error_callback
-          @error_callback.call
-        else
-          puts "ERROR"
-        end
-      end
-    
+      df = Defer.new(default_error_callback, &block)
       @deferrables.push(df)
-      df.callback(&block) if block
       df
     end
 
@@ -206,88 +201,78 @@ module EM
     end
 
     def received(data)
+      puts "received: #{data.inspect}"
       @data << data
-
+      
       until @data.empty?
-        idx = @data.index(/(.*?\r\n)/)
+        idx = @data.index(/(.*?)\r\n/)
         break if idx.nil?
 
         first = $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
+        when /^DELETED/
           df = @deferrables.shift
           df.succeed
-
-        when /^INSERTED\s+(\d+)\r\n/ then
+        when /^INSERTED\s+(\d+)/
           df = @deferrables.shift
           df.succeed($1.to_i)
-
-        when /^RELEASED\r\n/ then
+        when /^RELEASED/
           df = @deferrables.shift
           df.succeed
-
-        when /^BURIED\s+(\d+)\r\n/ then
+        when /^BURIED\s+(\d+)/
           df = @deferrables.shift
           df.fail(:buried, $1.to_i)
-
-        when /^USING\s+(.*)\r\n/ then
+        when /^USING\s+(.*)/
           df = @deferrables.shift
           df.succeed($1)
-
-        when /^WATCHING\s+(\d+)\r\n/ then
+        when /^WATCHING\s+(\d+)/
           df = @deferrables.shift
           df.succeed($1.to_i)
-
-        when /^OK\s+(\d+)\r\n/ then
+        when /^OK\s+(\d+)/
           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
+          if body = extract_body(bytes, @data)
+            @data = body.data
+            df = @deferrables.shift
+            df.succeed(YAML.load(body.body))
+            next
+          else
+            break
+          end
+        when /^RESERVED\s+(\d+)\s+(\d+)/
           id = $1.to_i
           bytes = $2.to_i
-
-          body, @data = extract_body(bytes, @data)
-          break if body.nil?
-
+          if body = extract_body(bytes, @data)
+            @data = body.data
+            df = @deferrables.shift
+            job = EM::Beanstalk::Job.new(self, id, body.body)
+            df.succeed(job)
+            next
+          else
+            break
+          end
+        # error state
+        when /^(OUT_OF_MEMORY|INTERNAL_ERROR|DRAINING|BAD_FORMAT|UNKNOWN_COMMAND|EXPECTED_CRLF|JOB_TOO_BIG|DEADLINE_SOON|TIMED_OUT|NOT_FOUND)/
           df = @deferrables.shift
-          job = EM::Beanstalk::Job.new(self, id, body)
-          df.succeed(job)
-          next
+          df.fail($1.downcase.to_sym)
+          @data = @data[($1.length + 2)..-1]
         else
           break
         end
-        @data.slice!(0, first.size)
+        @data.slice!(0, first.size + 2)
       end
     end
   
     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]
+      if rem.length < bytes
+        nil
+      else
+        body = rem[0..(bytes - 1)]
+        data = rem[(bytes + 2)..-1]
+        data = "" if data.nil?
+        Body.new(body, data)
+      end
     end
   end  
 end

data/lib/em-beanstalk/defer.rb

@@ -0,0 +1,15 @@
+module EventMachine
+  class Beanstalk
+    class Defer < EM::DefaultDeferrable
+      def initialize(default_error_callback = nil, &block)
+        errback(&default_error_callback) if default_error_callback
+        callback(&block) if block
+      end
+      
+      def error(&block)
+        errback(&block)
+        self
+      end
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -20,6 +20,16 @@ describe EM::Beanstalk, "integration" do
     end
   end
 
+  it 'should use errback' do
+    conn = EM::Beanstalk.new
+    conn.delete(123123) {
+      fail
+    }.error { |err|
+      puts "err! #{err.inspect}"
+      done
+    } 
+  end
+
   it 'should send the "use" command' do
     conn = EM::Beanstalk.new
     conn.use('my-lovely-tube') do 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: em-beanstalk
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Dan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-04 00:00:00 -05:00
+date: 2009-12-07 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,6 +37,7 @@ files:
 - VERSION
 - lib/em-beanstalk.rb
 - lib/em-beanstalk/connection.rb
+- lib/em-beanstalk/defer.rb
 - lib/em-beanstalk/job.rb
 - spec/connection_spec.rb
 - spec/integration_spec.rb