ayl-beanstalk 0.2.0 → 0.3.0

data/Gemfile

@@ -2,7 +2,7 @@ source "http://rubygems.org"
 # Add dependencies required to use your gem here.
 # Example:
 #   gem "activesupport", ">= 2.3.5"
-gem 'ayl', ">= 0.2.1"
+gem 'ayl', ">= 0.3.0"
 gem 'beanstalk-client', ">= 1.1.0"
 gem 'daemons', ">= 1.1.0"
 

data/Gemfile.lock

@@ -30,7 +30,7 @@ GEM
     activesupport (3.1.2)
       multi_json (~> 1.0)
     arel (2.2.1)
-    ayl (0.2.1)
+    ayl (0.3.0)
     beanstalk-client (1.1.1)
     builder (3.0.0)
     coderay (0.9.8)
@@ -114,7 +114,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  ayl (>= 0.2.1)
+  ayl (>= 0.3.0)
   beanstalk-client (>= 1.1.0)
   bundler (>= 1.0.0)
   daemons (>= 1.1.0)

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/ayl-beanstalk.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "ayl-beanstalk"
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["j0hnds@gmail.com"]
-  s.date = "2013-07-22"
+  s.date = "2013-08-07"
   s.description = "Ayl extension to provide beanstalk support."
   s.email = "j0hnds@gmail.com"
   s.executables = ["ayl_beanstalk", "ayl_worker", "ayl_worker_control"]
@@ -33,12 +33,15 @@ Gem::Specification.new do |s|
     "lib/ayl-beanstalk.rb",
     "lib/ayl-beanstalk/command_line.rb",
     "lib/ayl-beanstalk/engine.rb",
+    "lib/ayl-beanstalk/exceptions.rb",
+    "lib/ayl-beanstalk/job.rb",
     "lib/ayl-beanstalk/pool.rb",
     "lib/ayl-beanstalk/worker.rb",
     "spec/ayl_worker_control_spec.rb",
     "spec/ayl_worker_spec.rb",
     "spec/command_line_spec.rb",
     "spec/engine_spec.rb",
+    "spec/job_spec.rb",
     "spec/spec_helper.rb",
     "spec/support/config/environment.rb",
     "spec/support/exit_code_matchers.rb",
@@ -54,7 +57,7 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ayl>, [">= 0.2.1"])
+      s.add_runtime_dependency(%q<ayl>, [">= 0.3.0"])
       s.add_runtime_dependency(%q<beanstalk-client>, [">= 1.1.0"])
       s.add_runtime_dependency(%q<daemons>, [">= 1.1.0"])
       s.add_development_dependency(%q<rspec>, [">= 2.3.0"])
@@ -63,7 +66,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<rcov>, [">= 0"])
       s.add_development_dependency(%q<pry>, [">= 0"])
     else
-      s.add_dependency(%q<ayl>, [">= 0.2.1"])
+      s.add_dependency(%q<ayl>, [">= 0.3.0"])
       s.add_dependency(%q<beanstalk-client>, [">= 1.1.0"])
       s.add_dependency(%q<daemons>, [">= 1.1.0"])
       s.add_dependency(%q<rspec>, [">= 2.3.0"])
@@ -73,7 +76,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<pry>, [">= 0"])
     end
   else
-    s.add_dependency(%q<ayl>, [">= 0.2.1"])
+    s.add_dependency(%q<ayl>, [">= 0.3.0"])
     s.add_dependency(%q<beanstalk-client>, [">= 1.1.0"])
     s.add_dependency(%q<daemons>, [">= 1.1.0"])
     s.add_dependency(%q<rspec>, [">= 2.3.0"])

data/lib/ayl-beanstalk/exceptions.rb

@@ -0,0 +1,28 @@
+module Ayl
+
+  module Beanstalk
+
+    #
+    # Raise this exception to have ayl release the current job and place it in
+    # the delay slot for the tube.
+    #
+    class RequiresJobDecay < StandardError
+
+      attr_reader :delay
+
+      def initialize(delay=nil)
+        @delay = delay
+      end
+    end
+
+    #
+    # Raise this exception to have ayl release the current job and place it in
+    # the buried slot for the tube.
+    #
+    class RequiresJobBury < StandardError
+
+    end
+
+  end
+
+end

data/lib/ayl-beanstalk/job.rb

@@ -0,0 +1,73 @@
+#
+# I don't like to call this a monkey-patch. I simply want to extend the
+# Beanstalk::Job to take care of some things that are best left to it.
+# So let's just call it 'ayl Duck-punching'.
+#
+# I promise that no methods overridden here; only new methods added.
+#
+class Beanstalk::Job
+  include Ayl::Logging
+
+  #
+  # Return the body of the job as an Ayl::Message. If the message is improperly
+  # formatted, then nil is returned.
+  #
+  def ayl_message
+    @msg ||= Ayl::Message.from_hash(ybody)
+  rescue Ayl::UnrecoverableMessageException => ex
+    logger.error "Error extracting message from beanstalk job: #{ex}"
+    Ayl::Mailer.instance.deliver_message "Error extracting message from beanstalk job", ex
+    @msg = nil
+  end
+
+  #
+  # Delete the job handling any exceptions that occur during the job deletion
+  # (like the job not existing).
+  #
+  def ayl_delete
+    delete
+  rescue Exception => ex
+    logger.error "Error deleting job: #{ex}\n#{ex.backtrace.join("\n")}"
+    Ayl::Mailer.instance.deliver_message("Error deleting job", ex)
+  end
+
+  #
+  # Decay the job handling any exceptions that occur during the job decay 
+  # process.
+  #
+  def ayl_decay(delay=nil)
+    decay(*[ delay ].compact)
+  rescue Exception => ex
+    logger.error "Error decaying job: #{ex}\n#{ex.backtrace.join("\n")}"
+    Ayl::Mailer.instance.deliver_message("Error decaying job", ex)
+  end
+
+  # 
+  # Bury the job handling any exceptions that occur during the burying
+  # process.
+  #
+  def ayl_bury
+    bury
+  rescue Exception => ex
+    logger.error "Error burying job: #{ex}\n#{ex.backtrace.join("\n")}"
+    Ayl::Mailer.instance.deliver_message("Error decaying job", ex)
+  end
+
+  #
+  # Handle the decay process by deleting the job if its age is more than
+  # 60 seconds, but delaying it if it is younger than 60 seconds. Obviously
+  # we want to handle any exceptions that occur here.
+  #
+  def handle_decay(ex)
+    logger.debug "Age of job: #{age}"
+    if age > 60
+      Ayl::Mailer.instance.deliver_message("Deleting decayed job; it just took too long.", ex)
+      logger.debug "Deleting job"
+      ayl_delete
+    else
+      logger.debug "Decaying job"
+      ayl_decay
+    end
+  end
+
+end

data/lib/ayl-beanstalk/worker.rb

@@ -14,71 +14,102 @@ module Ayl
 
       def process_messages
         logger.debug "#{self.class.name} entering process_messages loop watching: #{Ayl::MessageOptions.default_queue_name}"
+
         # Set the queue that we will be watching
         pool.watch(Ayl::MessageOptions.default_queue_name)
-        while true
-          break if @stop
-          job = nil
-          begin
-            job = pool.reserve
-          rescue Exception => ex
-            logger.error "#{self.class.name} Exception in process_messages: #{ex}\n#{ex.backtrace.join("\n")}"
-            Ayl::Mailer.instance.deliver_message("#{self.class.name} Exception in process_messages.", ex)
-            delete_job(job) unless job.nil?
-            next
-          end
-          break if job.nil?
-          msg = nil
+
+        reserve_job do | job |
           begin
-            msg = Ayl::Message.from_hash(job.ybody)
-            process_message(msg)
-            delete_job(job)
-          rescue Ayl::UnrecoverableMessageException => ex
-            logger.error "#{self.class.name} Unrecoverable exception in process_messages: #{ex}"
-            Ayl::Mailer.instance.deliver_message("#{self.class.name} Unrecoverable exception in process_messages", ex)
-            delete_job(job)
+
+            process_message(job.ayl_message) unless job.ayl_message.nil?
+            job.ayl_delete
+
           rescue SystemExit
+
             # This exception is raised when 'Kernel.exit' is called. In this case
             # we want to make sure the job is deleted, then we simply re-raise
             # the exception and we go bye-bye.
-            delete_job(job)
+            job.ayl_delete
             raise
+
+          rescue Ayl::Beanstalk::RequiresJobDecay => ex
+
+            # The code in the message body has requested that we throw this job back
+            # in the queue with a delay.
+            job.ayl_decay(ex.delay)
+
+          rescue Ayl::Beanstalk::RequiresJobBury => ex
+            
+            # The code in the message body has requested that we throw this job
+            # into the 'buried' state. This will allow a human to look the job
+            # over and determine if it can be processed
+            job.ayl_bury
+
           rescue Exception => ex
-            logger.error "#{self.class.name} Exception in process_messages: #{ex}\n#{ex.backtrace.join("\n")}"
-            if msg.options.decay_failed_job
-              handle_job_decay(job, ex)
-            else
-              delete_job(job)
-              Ayl::Mailer.instance.deliver_message("#{self.class.name} Exception in process_messages.", ex)
-            end
+
+            deal_with_unexpected_exception(job, ex)
+
           end
-        end
-      end
 
-      def handle_job_decay(job, ex)
-        logger.debug "Age of job: #{job.age}"
-        if job.age > 60
-          Ayl::Mailer.instance.deliver_message("#{self.class.name} Deleting decayed job; it just took too long.", ex)
-          logger.debug "Deleting job"
-          delete_job(job)
-        else
-          logger.debug "Decaying job"
-          decay_job(job)
-        end
+        end # reserve_job...
+
       end
 
-      def delete_job(job)
-        job.delete
-      rescue RuntimeError => ex
-        logger.error "#{self.class.name} Error deleting job: #{ex}\n#{ex.backtrace.join("\n")}"
-        Ayl::Mailer.instance.deliver_message("#{self.class.name} Error deleting job", ex)
+      private
+
+      #
+      # The main loop that gets job from the beanstalk queue to process. When a job is
+      # received it will be passed to the block for this method.
+      #
+      def reserve_job
+        while true
+          job = nil
+
+          begin
+
+            # Sit around and wait for a job to become available
+            job = pool.reserve
+
+          rescue Exception => ex
+
+            logger.error "Unexpected exception in reserve_job: #{ex}\n#{ex.backtrace.join("\n")}"
+            Ayl::Mailer.instance.deliver_message("Unexpected exception in process_messages.", ex)
+            job.ayl_delete unless job.nil?
+
+            # Notice that we are just breaking out of the loop here. Why?
+            # Think about the kinds of exceptions that occur here. They will be
+            # things like Beanstalk::OUT_OF_MEMORY errors, beanstalkd connection
+            # errors, etc. At this point, the worker is finished, kaput. Might as
+            # well report and die. That's exactly what will happen.
+            break
+            
+          end
+
+          break if job.nil?
+
+          yield job
+
+        end
       end
 
-      def decay_job(job)
-        job.decay
-      rescue RuntimeError => ex
-        logger.error "#{self.class.name} Error decaying job: #{ex}\n#{ex.backtrace.join("\n")}"
-        Ayl::Mailer.instance.deliver_message("#{self.class.name} Error decaying job", ex)
+      #
+      # Deals with the decision to decay or delete job when an unexpected
+      # exception is encountered.
+      #
+      def deal_with_unexpected_exception(job, ex)
+        logger.error "Unexpected exception in process_messages: #{ex}\n#{ex.backtrace.join("\n")}"
+        case job.ayl_message.options.failed_job_handler
+        when 'decay'
+          job.handle_decay(ex)
+        when 'delete'
+          job.ayl_delete
+          Ayl::Mailer.instance.deliver_message("Exception in process_messages. Job deleted.", ex)
+        when 'bury'
+          job.ayl_bury
+          Ayl::Mailer.instance.deliver_message("Exception in process_messages. Job buried", ex)
+        else
+          Ayl::Mailer.instance.deliver_message("Invalid failed job handler specified: #{job.ayl_message.options.failed_job_handler}", ex)
+        end
       end
 
     end

data/lib/ayl-beanstalk.rb

@@ -1,5 +1,7 @@
 require 'ayl'
 require 'beanstalk-client'
+require 'ayl-beanstalk/job'
+require 'ayl-beanstalk/exceptions'
 require 'ayl-beanstalk/pool'
 require 'ayl-beanstalk/engine'
 require 'ayl-beanstalk/worker'

data/spec/engine_spec.rb

@@ -47,7 +47,7 @@ describe Ayl::Beanstalk::Engine do
       it "should submit the specified message to beanstalk" do
         mock_pool = mock("Beanstalk::Pool")
         mock_pool.should_receive(:use).with("default")
-        mock_pool.should_receive(:yput).with( { :type => :ayl, :decay_failed_job => false, :code => "23.to_s(2)" }, 512, 0, 120)
+        mock_pool.should_receive(:yput).with( { :type => :ayl, :failed_job_handler => 'delete', :code => "23.to_s(2)" }, 512, 0, 120)
 
         ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
 

data/spec/job_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'beanstalk-client'
+
+describe Beanstalk::Job do
+  
+  before(:each) do
+    @job = Beanstalk::Job.new(nil,nil,nil)
+    @job.stub_chain(:logger, :error)
+    @job.stub_chain(:logger, :debug)
+  end
+
+  context '#ayl_message' do
+
+    it "should return the message constructed from the body of the job" do
+      @job.stub(:ybody).and_return('the body')
+      msg = Ayl::Message.new(nil,nil,nil)
+      Ayl::Message.should_receive(:from_hash).with('the body').and_return(msg)
+
+      @job.ayl_message.should == msg
+    end
+
+    it "should return the same message constructed from the body of the job on subsequent calls" do
+      @job.stub(:ybody).and_return('the body')
+      msg = Ayl::Message.new(nil,nil,nil)
+      Ayl::Message.should_receive(:from_hash).with('the body').and_return(msg)
+
+      @job.ayl_message.should == msg
+
+      @job.ayl_message.should == msg
+    end
+
+    it "should return nil and send an email if the message body was bad" do
+      @job.stub(:ybody).and_return('the body')
+      msg = Ayl::Message.new(nil,nil,nil)
+      ex = Ayl::UnrecoverableMessageException.new
+      Ayl::Message.should_receive(:from_hash).with('the body').and_raise(ex)
+
+      Ayl::Mailer.should_receive(:instance).and_return do 
+        mock("Mailer").tap do | mock_mailer |
+          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
+        end
+      end
+
+      @job.ayl_message.should == nil
+    end
+
+  end
+
+  context '#ayl_delete' do
+
+    it "should call the delete method on the job" do
+      @job.should_receive(:delete)
+
+      @job.ayl_delete
+    end
+
+    it "should send an email if the delete method raises an exception" do
+      ex = Exception.new
+      @job.should_receive(:delete).and_raise(ex)
+
+      Ayl::Mailer.should_receive(:instance).and_return do 
+        mock("Mailer").tap do | mock_mailer |
+          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
+        end
+      end
+
+      @job.ayl_delete
+    end
+
+  end
+
+  context '#ayl_decay' do
+
+    it "should call the decay with no arguments when nil delay is specified" do
+      @job.should_receive(:decay).with()
+
+      @job.ayl_decay(nil)
+    end
+
+    it "should call the decay with no arguments when no delay is specified" do
+      @job.should_receive(:decay).with()
+
+      @job.ayl_decay
+    end
+
+    it "should call the decay with no arguments when no delay is specified" do
+      @job.should_receive(:decay).with(10)
+
+      @job.ayl_decay(10)
+    end
+
+    it "should send an email if the decay method raises an exception" do
+      ex = Exception.new
+      @job.should_receive(:decay).and_raise(ex)
+
+      Ayl::Mailer.should_receive(:instance).and_return do 
+        mock("Mailer").tap do | mock_mailer |
+          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
+        end
+      end
+
+      @job.ayl_decay
+    end
+
+  end
+
+  context '#ayl_bury' do
+
+    it "should call the bury method on the job" do
+      @job.should_receive(:bury)
+
+      @job.ayl_bury
+    end
+
+    it "should send an email if the bury method raises an exception" do
+      ex = Exception.new
+      @job.should_receive(:bury).and_raise(ex)
+
+      Ayl::Mailer.should_receive(:instance).and_return do 
+        mock("Mailer").tap do | mock_mailer |
+          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
+        end
+      end
+
+      @job.ayl_bury
+    end
+
+  end
+
+  context '#handle_decay' do
+
+    it "should decay the job if the age of the job is less than 60 seconds" do
+      @job.should_receive(:age).at_least(1).times.and_return(2)
+      @job.should_receive(:ayl_decay)
+      
+      ex = Exception.new
+
+      @job.handle_decay(ex)
+    end
+
+    it "should decay the job if the age of the job is exactly 60 seconds" do
+      @job.should_receive(:age).at_least(1).times.and_return(60)
+      @job.should_receive(:ayl_decay)
+      
+      ex = Exception.new
+
+      @job.handle_decay(ex)
+    end
+
+    it "should delete the job and send an email if the job was older than 60 seconds" do
+      @job.should_receive(:age).at_least(1).times.and_return(61)
+      @job.should_receive(:ayl_delete)
+      
+      ex = Exception.new
+
+      Ayl::Mailer.should_receive(:instance).and_return do 
+        mock("Mailer").tap do | mock_mailer |
+          mock_mailer.should_receive(:deliver_message).with(anything(), ex)
+        end
+      end
+
+      @job.handle_decay(ex)
+    end
+
+  end
+
+end

data/spec/worker_spec.rb

@@ -5,7 +5,7 @@ require 'active_record/errors'
 
 describe Ayl::Beanstalk::Worker do
 
-  context "Message Processing" do
+  context '#reserve_job' do
 
     before(:each) do
       Kernel.stub(:puts)
@@ -13,217 +13,222 @@ describe Ayl::Beanstalk::Worker do
       @worker.stub_chain(:logger, :info)
       @worker.stub_chain(:logger, :error)
       @worker.stub_chain(:logger, :debug)
-      Ayl::MessageOptions.default_queue_name = 'default'
-    end
-    
-    it "should wait for a message to be received from beanstalk and process it" do
-      Ayl::MessageOptions.default_queue_name = 'the_queue_name'
-      mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:delete)
-      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "23.to_s(2)" })
 
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("the_queue_name")
-      # Returns nil on the second call.
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+      @mock_pool = mock("Beanstalk::Pool")
       
-      mock_message = mock("Ayl::Message")
-      mock_message.should_receive(:evaluate)
-      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "23.to_s(2)" }).and_return(mock_message)
+      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(@mock_pool)
+    end
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+    it "should loop until there are no more jobs from beanstalk" do
+      mock_job1 = mock("Beanstalk::Job")
+      mock_job2 = mock("Beanstalk::Job")
 
-      @worker.process_messages
+      @mock_pool.should_receive(:reserve).and_return(mock_job1, mock_job2, nil)
+
+      index = 0
+
+      @worker.send(:reserve_job) do | job |
+        job.should == [ mock_job1, mock_job2 ][index]
+        index += 1
+      end
+
+      index.should == 2
       
     end
 
-    it "should raise an UnrecoverableMessageException when the message body is not a valid hash" do
-      mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:delete)
-      mock_job.should_receive(:ybody).and_return("a string")
-      mock_job.should_not_receive(:age)
-
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      # Returns nil on the second call.
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+    it "should report any exception while waiting for a job" do
+      @mock_pool.should_receive(:reserve).and_raise('It blew')
 
-      Ayl::Message.stub(:from_hash).with("a string").and_raise(Ayl::UnrecoverableMessageException)
+      mock_mailer = mock("Mailer")
+      mock_mailer.should_receive(:deliver_message).with(any_args())
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      Ayl::Mailer.should_receive(:instance).and_return(mock_mailer)
 
-      @worker.process_messages
+      @worker.send(:reserve_job) do | job |
+      end
     end
 
-    it "should raise an UnrecoverableJobException when the message body is not a valid job type" do
-      mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:delete)
-      mock_job.should_receive(:ybody).and_return({ :type => :junk, :code => "Dog" })
-      mock_job.should_not_receive(:age)
+  end
 
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      # Returns nil on the second call.
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+  context '#deal_with_unexpected_exception' do
 
-      Ayl::Message.stub(:from_hash).with({ :type => :junk, :code => "Dog" }).and_raise(Ayl::UnrecoverableMessageException)
+    before(:each) do
+      Kernel.stub(:puts)
+      @worker = Ayl::Beanstalk::Worker.new
+      @worker.stub_chain(:logger, :info)
+      @worker.stub_chain(:logger, :error)
+      @worker.stub_chain(:logger, :debug)
+    end
+      
+    it "should call the job's handle_decay method if the message requires the job to decay" do
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:ayl_message).and_return do 
+        mock("message").tap do | mock_message |
+          mock_message.should_receive(:options).and_return do
+            mock("options").tap do | mock_options |
+              mock_options.should_receive(:failed_job_handler).and_return('decay')
+            end
+          end
+        end
+      end
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      mock_exception = mock("Exception")
+      mock_exception.should_receive(:backtrace).and_return([])
+      mock_job.should_receive(:handle_decay).with(mock_exception)
 
-      @worker.process_messages
+      @worker.send(:deal_with_unexpected_exception, mock_job, mock_exception)
     end
 
-    it "should raise an UnrecoverableJobException when there is no code in the message body" do
+    it "should call the job's ayl_delete method if the message requires the job to be deleted" do
       mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:delete)
-      mock_job.should_receive(:ybody).and_return({ :type => :ayl })
-      mock_job.should_not_receive(:age)
+      mock_job.should_receive(:ayl_message).and_return do 
+        mock("message").tap do | mock_message |
+          mock_message.should_receive(:options).and_return do
+            mock("options").tap do | mock_options |
+              mock_options.should_receive(:failed_job_handler).and_return('delete')
+            end
+          end
+        end
+      end
 
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      # Returns nil on the second call.
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+      mock_exception = mock("Exception")
+      mock_exception.should_receive(:backtrace).and_return([])
+      mock_job.should_receive(:ayl_delete)
 
-      Ayl::Message.stub(:from_hash).with({ :type => :ayl }).and_raise(Ayl::UnrecoverableMessageException)
+      mock_mailer = mock("Mailer")
+      mock_mailer.should_receive(:deliver_message).with(any_args())
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      Ayl::Mailer.should_receive(:instance).and_return(mock_mailer)
 
-      @worker.process_messages
+      @worker.send(:deal_with_unexpected_exception, mock_job, mock_exception)
     end
 
-    it "should not decay a job that receives an active-record exception when the default message options are used" do
+    it "should call the job's ayl_bury method if the message requires the job to be buried" do
       mock_job = mock("Beanstalk::Job")
-      mock_job.should_not_receive(:decay)
-      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "Dog" })
-      mock_job.should_not_receive(:age)
-      mock_job.should_receive(:delete)
-
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
-
-      mock_message = mock("Ayl::Message")
-      mock_message.should_receive(:evaluate).and_raise(ActiveRecord::RecordNotFound)
-      mock_message.should_receive(:options).and_return do 
-        mock("Options").tap do | mock_opts |
-          mock_opts.should_receive(:decay_failed_job).and_return(false)
+      mock_job.should_receive(:ayl_message).and_return do 
+        mock("message").tap do | mock_message |
+          mock_message.should_receive(:options).and_return do
+            mock("options").tap do | mock_options |
+              mock_options.should_receive(:failed_job_handler).and_return('bury')
+            end
+          end
         end
       end
-      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "Dog" }).and_return(mock_message)
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      mock_exception = mock("Exception")
+      mock_exception.should_receive(:backtrace).and_return([])
+      mock_job.should_receive(:ayl_bury)
 
-      @worker.process_messages
-      
+      mock_mailer = mock("Mailer")
+      mock_mailer.should_receive(:deliver_message).with(any_args())
+
+      Ayl::Mailer.should_receive(:instance).and_return(mock_mailer)
+
+      @worker.send(:deal_with_unexpected_exception, mock_job, mock_exception)
     end
 
-    it "should decay a job that receives an active-record exception on receipt of message that is less than 60 seconds old" do
-      mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:decay)
-      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "Dog" })
-      mock_job.should_receive(:age).exactly(2).times.and_return(10)
+  end
+
+  context "Message Processing" do
+
+    before(:each) do
+      Kernel.stub(:puts)
+      @worker = Ayl::Beanstalk::Worker.new
+      @worker.stub_chain(:logger, :info)
+      @worker.stub_chain(:logger, :error)
+      @worker.stub_chain(:logger, :debug)
+      Ayl::MessageOptions.default_queue_name = 'the queue name'
 
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+      @mock_pool = mock("Beanstalk::Pool")
+      @mock_pool.should_receive(:watch).with('the queue name')
+      @worker.stub(:pool).and_return(@mock_pool)
+    end
 
+    it "should process a message received from beanstalk" do
       mock_message = mock("Ayl::Message")
-      mock_message.should_receive(:evaluate).and_raise(ActiveRecord::RecordNotFound)
-      mock_message.should_receive(:options).and_return do 
-        mock("Options").tap do | mock_opts |
-          mock_opts.should_receive(:decay_failed_job).and_return(true)
-        end
-      end
-      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "Dog" }).and_return(mock_message)
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:ayl_message).at_least(1).times.and_return(mock_message)
+      mock_job.should_receive(:ayl_delete)
+
+      @worker.should_receive(:process_message).with(mock_message)
+
+      @worker.should_receive(:reserve_job).and_yield(mock_job)
 
       @worker.process_messages
     end
 
-    it "should delete a job that receives an active-record exception on receipt of message that is more than 60 seconds old" do
+    it "should do nothing if the received message is invalid (nil)" do
       mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:delete)
-      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "Dog" })
-      mock_job.should_receive(:age).exactly(2).times.and_return(65)
+      mock_job.should_receive(:ayl_message).at_least(1).times.and_return(nil)
+      mock_job.should_receive(:ayl_delete)
 
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+      @worker.should_not_receive(:process_message)
 
-      mock_message = mock("Ayl::Message")
-      mock_message.should_receive(:evaluate).and_raise(ActiveRecord::RecordNotFound)
-      mock_message.should_receive(:options).and_return do 
-        mock("Options").tap do | mock_opts |
-          mock_opts.should_receive(:decay_failed_job).and_return(true)
-        end
-      end
-      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "Dog" }).and_return(mock_message)
-
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      @worker.should_receive(:reserve_job).and_yield(mock_job)
 
       @worker.process_messages
     end
 
-    it "should not attempt to decay the job if there is a problem deleting a job after the message is successfully processed" do
+    it "should delete the job and re-raise the exception on a SystemExit" do
+      mock_message = mock("Ayl::Message")
 
       mock_job = mock("Beanstalk::Job")
-      mock_job.should_receive(:delete).and_raise("Delete failed for some reason")
-      mock_job.should_receive(:ybody).and_return({ :type => :ayl, :code => "23.to_s(2)" })
-      mock_job.should_not_receive(:age)
+      mock_job.should_receive(:ayl_message).at_least(1).times.and_return(mock_message)
+      mock_job.should_receive(:ayl_delete)
+
+      @worker.should_receive(:process_message).with(mock_message).and_raise(SystemExit)
 
-      mock_pool = mock("Beanstalk::Pool")
-      mock_pool.should_receive(:watch).with("default")
-      mock_pool.should_receive(:reserve).and_return(mock_job, nil)
+      @worker.should_receive(:reserve_job).and_yield(mock_job)
 
+      lambda { @worker.process_messages }.should raise_error(SystemExit)
+    end
+
+    it "should decay the job if the message requires it" do
       mock_message = mock("Ayl::Message")
-      mock_message.should_receive(:evaluate)
-      Ayl::Message.stub(:from_hash).with({ :type => :ayl, :code => "23.to_s(2)" }).and_return(mock_message)
 
-      ::Beanstalk::Pool.should_receive(:new).with([ "localhost:11300" ]).and_return(mock_pool)
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:ayl_message).at_least(1).times.and_return(mock_message)
+      mock_job.should_receive(:ayl_decay).with(20)
 
-      expect { @worker.process_messages }.not_to raise_error
-    end
-  end
+      @worker.should_receive(:process_message).with(mock_message).and_raise(Ayl::Beanstalk::RequiresJobDecay.new(20))
 
-  context '#delete_job' do
+      @worker.should_receive(:reserve_job).and_yield(mock_job)
 
-    before(:each) do
-      Kernel.stub(:puts)
-      @worker = Ayl::Beanstalk::Worker.new
-      @worker.stub_chain(:logger, :info)
-      @worker.stub_chain(:logger, :error)
-      @worker.stub_chain(:logger, :debug)
-      Ayl::MessageOptions.default_queue_name = 'default'
+      @worker.process_messages
     end
 
-    it "should not raise an exception if the job.delete fail" do
-      mock_job = mock("Job")
-      mock_job.should_receive(:delete).and_raise("Delete failed for some reason")
+    it "should bury the job if the message requires it" do
+      mock_message = mock("Ayl::Message")
 
-      expect { @worker.delete_job(mock_job) }.not_to raise_error
-    end
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:ayl_message).at_least(1).times.and_return(mock_message)
+      mock_job.should_receive(:ayl_bury)
 
-  end
+      @worker.should_receive(:process_message).with(mock_message).and_raise(Ayl::Beanstalk::RequiresJobBury)
 
-  context '#decay_job' do
+      @worker.should_receive(:reserve_job).and_yield(mock_job)
 
-    before(:each) do
-      Kernel.stub(:puts)
-      @worker = Ayl::Beanstalk::Worker.new
-      @worker.stub_chain(:logger, :info)
-      @worker.stub_chain(:logger, :error)
-      @worker.stub_chain(:logger, :debug)
-      Ayl::MessageOptions.default_queue_name = 'default'
+      @worker.process_messages
     end
 
-    it "should not raise an exception if the job.delete fail" do
-      mock_job = mock("Job")
-      mock_job.should_receive(:decay).and_raise("Decay failed for some reason")
+    it "should handle all other unexpected exceptions" do
+      mock_message = mock("Ayl::Message")
+
+      mock_job = mock("Beanstalk::Job")
+      mock_job.should_receive(:ayl_message).at_least(1).times.and_return(mock_message)
 
-      expect { @worker.decay_job(mock_job) }.not_to raise_error
+      ex = Exception.new
+
+      @worker.should_receive(:process_message).with(mock_message).and_raise(ex)
+
+      @worker.should_receive(:reserve_job).and_yield(mock_job)
+      @worker.should_receive(:deal_with_unexpected_exception).with(mock_job, ex)
+
+      @worker.process_messages
     end
 
   end
 
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ayl-beanstalk
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-22 00:00:00.000000000 Z
+date: 2013-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ayl
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: 0.3.0
 - !ruby/object:Gem::Dependency
   name: beanstalk-client
   requirement: !ruby/object:Gem::Requirement
@@ -165,12 +165,15 @@ files:
 - lib/ayl-beanstalk.rb
 - lib/ayl-beanstalk/command_line.rb
 - lib/ayl-beanstalk/engine.rb
+- lib/ayl-beanstalk/exceptions.rb
+- lib/ayl-beanstalk/job.rb
 - lib/ayl-beanstalk/pool.rb
 - lib/ayl-beanstalk/worker.rb
 - spec/ayl_worker_control_spec.rb
 - spec/ayl_worker_spec.rb
 - spec/command_line_spec.rb
 - spec/engine_spec.rb
+- spec/job_spec.rb
 - spec/spec_helper.rb
 - spec/support/config/environment.rb
 - spec/support/exit_code_matchers.rb
@@ -190,7 +193,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2726199589731342968
+      hash: -3806134538379917538
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: