tom_queue 0.0.1.dev

data/lib/tom_queue/work.rb

@@ -0,0 +1,62 @@
+module TomQueue
+
+  # Internal: This represents a single payload of "work" to 
+  #  be completed by the application. You shouldn't create it
+  #  directly, but instances will be returned by the 
+  #  QueueManager as work is de-queued.
+  #
+  class Work
+
+    # Public: The payload of the work.
+    #
+    # This is the serialized string passed to QueueManager#publish
+    # and it's up to the application to work out what to do with it!
+    attr_reader :payload
+    
+    # Internal: The set of headers associated with the AMQP message
+    #
+    # NOTE: Use of these headers directly is discouraged, as their structure
+    # is an implementation detail of this library. See Public accessors 
+    # below before grabbing data from here.
+    #
+    # This is a has of string values
+    attr_reader :headers
+
+    # Internal: The AMQP response returned when the work was delivered.
+    #
+    # NOTE: Use of data directly from this response is discouraged, for 
+    # the same reason as #headers. It's an implementation detail...
+    #
+    # Returns an AMQ::Protocol::Basic::GetOk instance
+    attr_reader :response
+
+    # Internal: The queue manager to which this work belongs
+    attr_reader :manager
+
+    # Internal: Creates the work object, probably from an AMQP get
+    #  response
+    #
+    # queue_manager - the QueueManager object that created this work
+    # amqp_response - this is the AMQP response object, i.e. the first 
+    #                 returned object from @queue.pop
+    # header        - this is a hash of headers attached to the message
+    # payload       - the raw payload of the message
+    #
+    def initialize(queue_manager, amqp_response, headers, payload)
+      @manager = queue_manager
+      @response = amqp_response
+      @headers = headers
+      @payload = payload
+    end
+
+    # Public: Ack this message, meaning the broker won't attempt to re-deliver 
+    # the message.
+    #
+    # Returns self, so you chain this `pop.ack!.payload` for example
+    def ack!
+      @manager.ack(self)
+      self
+    end
+  end
+
+end

data/spec/database.yml

@@ -0,0 +1,14 @@
+mysql:
+  adapter: mysql2
+  database: delayed_job_test
+  username: root
+  encoding: utf8
+
+postgresql:
+  adapter: postgresql
+  database: delayed_job_test
+  username: postgres
+
+sqlite3:
+  adapter: sqlite3
+  database: "/tmp/tomqueue.sqlite3"

data/spec/helper.rb

@@ -0,0 +1,75 @@
+require 'simplecov'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter
+]
+SimpleCov.start
+
+require 'logger'
+require 'rspec'
+
+begin
+  require 'protected_attributes'
+rescue LoadError
+end
+require 'delayed_job_active_record'
+require 'delayed/backend/shared_spec'
+
+Delayed::Worker.logger = Logger.new('/tmp/dj.log')
+ENV['RAILS_ENV'] = 'test'
+
+
+db_adapter, gemfile = ENV["ADAPTER"], ENV["BUNDLE_GEMFILE"]
+db_adapter ||= gemfile && gemfile[%r(gemfiles/(.*?)/)] && $1
+db_adapter ||= 'mysql'
+
+begin
+  config = YAML.load(File.read('spec/database.yml'))
+  ActiveRecord::Base.establish_connection config[db_adapter]
+  ActiveRecord::Base.logger = Delayed::Worker.logger
+  ActiveRecord::Migration.verbose = false
+
+  ActiveRecord::Schema.define do
+    create_table :delayed_jobs, :force => true do |table|
+      table.integer  :priority, :default => 0
+      table.integer  :attempts, :default => 0
+      table.text     :handler
+      table.text     :last_error
+      table.datetime :run_at
+      table.datetime :locked_at
+      table.datetime :failed_at
+      table.string   :locked_by
+      table.string   :queue
+      table.timestamps
+    end
+
+    add_index :delayed_jobs, [:priority, :run_at], :name => 'delayed_jobs_priority'
+
+    create_table :stories, :primary_key => :story_id, :force => true do |table|
+      table.string :text
+      table.boolean :scoped, :default => true
+    end
+  end
+rescue Mysql2::Error
+  if db_adapter == 'mysql'
+    $stderr.puts "\033[1;31mException when connecting to MySQL, is it running?\033[0m\n\n"
+  end
+  raise
+end
+
+# Purely useful for test cases...
+class Story < ActiveRecord::Base
+  if ::ActiveRecord::VERSION::MAJOR < 4 && ActiveRecord::VERSION::MINOR < 2
+    set_primary_key :story_id
+  else
+    self.primary_key = :story_id
+  end
+  def tell; text; end
+  def whatever(n, _); tell*n; end
+  default_scope { where(:scoped => true) }
+
+  handle_asynchronously :whatever
+end
+
+# Add this directory so the ActiveSupport autoloading works
+ActiveSupport::Dependencies.autoload_paths << File.dirname(__FILE__)

data/spec/tom_queue/deferred_work/deferred_work_manager_integration_spec.rb

@@ -0,0 +1,186 @@
+require 'tom_queue/helper'
+
+## "Integration" For lack of a better word, trying to simulate various 
+# failures, such as the deferred thread shitting itself
+#
+
+describe "DeferredWorkManager integration scenarios"  do
+  let(:manager) { TomQueue::DeferredWorkManager.instance("test-#{Time.now.to_f}") }
+  let(:consumer) { TomQueue::QueueManager.new(manager.prefix) }
+
+  # Allow us to manipulate the deferred set object to induce a crash
+  before do  
+    # Look away now...
+    class TomQueue::DeferredWorkManager
+      attr_reader :deferred_set
+    end
+    # ... and welcome back.
+  end
+
+  # Push a single piece of work through to make sure the 
+  # deferred thread is running OK
+  before do 
+    # This will start the deferred manager, and should block
+    # until the thread is actually functional
+    consumer.publish("work1", :run_at => Time.now + 0.1)
+    consumer.pop.ack!.payload.should == "work1"
+  end
+
+  describe "background thread behaviour" do
+    before do
+      consumer.publish("work2", :run_at => Time.now + 0.5)
+    end
+
+    describe "when the thread is shutdown" do
+
+      # This will shut the thread down with a single un-acked deferred messsage 
+      before { manager.ensure_stopped }
+
+      it "should restore un-acked messages when the thread is shutdown" do
+        # we would expect the message to be on the queue again, so this
+        # should "just work"
+        consumer.pop.ack!.payload.should == "work2"
+      end
+
+      it "should nullify the thread" do
+        manager.thread.should be_nil
+      end
+
+      it "should nullify the deferred_set" do
+        manager.deferred_set.should be_nil
+      end
+
+    end
+
+    describe "if (heaven forbid) the deferred thread were to crash" do
+
+      before do
+        TomQueue.exception_reporter = nil
+        # Crash the deferred thread with a YAK stampede
+        manager.deferred_set.should_receive(:pop).and_raise(RuntimeError, "Yaks Everywhere!")
+      end    
+
+      let(:crash!) do
+        thread = manager.thread
+
+        # This will triggert the thread run-loop to spin once and, hopefully, crash!
+        manager.deferred_set.interrupt
+
+        # wait for the inevitable - this will not induce a crash, just wait for the thread
+        # to die.
+        manager.thread.join
+
+        # Sanity check
+        thread.should_not be_alive
+      end
+
+      it "should start a new deferred thread on the next pop" do
+        crashed_thread = manager.thread
+
+        crash!
+
+        # We don't actually care if the pop works, just that the thread gets started
+        Timeout.timeout(0.1) { consumer.pop.ack! } rescue nil
+
+        manager.thread.should_not == crashed_thread
+        manager.thread.should be_alive
+      end
+
+      it "should nullify the thread" do
+        crash!
+        manager.thread.should be_nil
+      end
+
+      it "should nullify the deferred set" do
+        crash!
+        manager.deferred_set.should be_nil
+      end
+
+      it "should revert un-acked messages back to the broker" do
+        crash!
+        consumer.pop.ack!.payload.should == "work2"
+      end
+
+      it "should notify something if the deferred thread crashes" do
+        TomQueue.exception_reporter = double("ExceptionReporter", :notify => nil)
+
+        TomQueue.exception_reporter.should_receive(:notify) do |exception|
+          exception.should be_a(RuntimeError)
+          exception.message.should == "Yaks Everywhere!"
+        end
+
+        crash!
+      end
+      
+    end
+  end
+
+  describe "if the AMQP consumer thread crashes" do
+
+    # Tweak the deferred set to asplode when payload == "explosive"
+    before do
+      TomQueue.exception_reporter = nil
+      require 'tom_queue/deferred_work_set'
+
+      # Look away...
+      class TomQueue::DeferredWorkSet
+
+        unless method_defined?(:orig_schedule)
+          def new_schedule(run_at, message)
+            raise RuntimeError, "ENOHAIR" if message.last == "explosive"
+            orig_schedule(run_at, message)
+          end
+        end
+        alias_method :orig_schedule, :schedule
+        alias_method :schedule, :new_schedule
+      end
+      # ... welcome back
+    end
+
+    after do
+      class TomQueue::DeferredWorkSet
+        if method_defined?(:orig_schedule)
+          undef_method :schedule
+          alias_method :schedule, :orig_schedule
+        end
+      end
+    end
+
+    before do
+      manager.ensure_running
+    end
+
+    let(:crash!) do
+      consumer.publish("explosive", :run_at => Time.now + 0.2)
+    end
+
+    it "should notify the exception_reporter" do
+      TomQueue.exception_reporter = double("Reporter")
+      TomQueue.exception_reporter.should_receive(:notify) do |exception|
+        exception.should be_a(RuntimeError)
+        exception.message.should == "ENOHAIR"
+      end
+
+      crash!
+      TomQueue::DeferredWorkManager.instance(consumer.prefix).ensure_stopped
+    end
+
+    it "should work around the broken messages" do
+      consumer.publish("foo", :run_at => Time.now + 0.1)
+      crash!
+      consumer.publish("bar", :run_at => Time.now + 0.1)
+
+      consumer.pop.ack!.payload.should == "foo"
+      consumer.pop.ack!.payload.should == "bar"
+    end
+
+    it "should re-queue the message once" do
+      TomQueue.exception_reporter = double("Reporter")
+      TomQueue.exception_reporter.should_receive(:notify).twice
+      crash!
+      consumer.publish("bar", :run_at => Time.now + 0.1)
+      consumer.pop.ack!
+    end
+  end
+
+end

data/spec/tom_queue/deferred_work/deferred_work_manager_spec.rb

@@ -0,0 +1,134 @@
+require 'tom_queue/helper'
+
+describe TomQueue::DeferredWorkManager do
+
+
+  describe "thread control" do
+    let(:manager) { TomQueue::DeferredWorkManager.instance("test-#{Time.now.to_f}") }
+
+    it "should expose the thread via a #thread accessor" do
+      manager.thread.should be_nil
+      manager.ensure_running
+      manager.thread.should be_a(Thread)
+    end
+
+    describe "ensure_running" do
+      it "should start the thread if it's not running" do
+        manager.ensure_running
+        manager.thread.should be_alive
+      end
+
+      it "should do nothing if the thread is already running" do
+        manager.ensure_running
+        first_thread = manager.thread
+        manager.ensure_running
+        manager.thread.should == first_thread
+      end
+
+      it "should re-start a dead thread" do
+        manager.ensure_running
+        manager.thread.kill
+        manager.thread.join
+        manager.ensure_running
+        manager.thread.should be_alive
+      end
+    end
+
+    describe "ensure_stopped" do
+      it "should block until the thread has stopped" do
+        manager.ensure_running
+        thread = manager.thread
+        manager.ensure_stopped
+        thread.should_not be_alive
+      end
+
+      it "should set the thread to nil" do
+        manager.ensure_running
+        manager.ensure_stopped
+        manager.thread.should be_nil
+      end
+
+      it "should do nothing if the thread is already stopped" do
+        manager.ensure_running
+        manager.ensure_stopped
+        manager.ensure_stopped
+      end
+    end
+  end
+
+  describe "DeferredWorkManager.instance - singleton accessor" do
+
+    it "should return a DelayedWorkManager instance" do
+      TomQueue::DeferredWorkManager.instance('some.prefix').should be_a(TomQueue::DeferredWorkManager)
+    end
+
+    it "should use the default prefix if none is provided" do
+      TomQueue.default_prefix = 'default.prefix'
+      TomQueue::DeferredWorkManager.instance.prefix.should == 'default.prefix'
+    end
+
+    it "should raise an exception if no prefix is provided and default isn't set" do
+      TomQueue.default_prefix = nil
+      lambda {
+        TomQueue::DeferredWorkManager.instance
+      }.should raise_exception(ArgumentError, 'prefix is required')
+    end
+
+    it "should return the same object for the same prefix" do
+      TomQueue::DeferredWorkManager.instance('some.prefix').should == TomQueue::DeferredWorkManager.instance('some.prefix')
+      TomQueue::DeferredWorkManager.instance('another.prefix').should == TomQueue::DeferredWorkManager.instance('another.prefix')
+    end
+
+    it "should return a different object for different prefixes" do
+      TomQueue::DeferredWorkManager.instance('some.prefix').should_not == TomQueue::DeferredWorkManager.instance('another.prefix')
+    end
+    it "should set the prefix for the instance created" do
+      TomQueue::DeferredWorkManager.instance('some.prefix').prefix.should == 'some.prefix'
+      TomQueue::DeferredWorkManager.instance('another.prefix').prefix.should == 'another.prefix'
+    end
+  end
+
+  describe "DeferredWorkManager.instances - running instance collection" do
+
+    it "should return an empty hash if no instances have been created" do
+      TomQueue::DeferredWorkManager.instances.should == {}
+    end
+
+    it "should return a hash of created instances, keyed on the prefix" do
+      some_prefix = TomQueue::DeferredWorkManager.instance('some.prefix')
+      another_prefix = TomQueue::DeferredWorkManager.instance('another.prefix')
+
+      TomQueue::DeferredWorkManager.instances.should == {
+        "some.prefix"    => some_prefix,
+        "another.prefix" => another_prefix
+      }
+    end
+
+    it "should dupe the hash before returning" do
+      value = TomQueue::DeferredWorkManager.instances
+      TomQueue::DeferredWorkManager.instance('some.prefix')
+      value.should == {}
+    end
+
+    it "should freeze the hash before returning" do
+      lambda {
+        TomQueue::DeferredWorkManager.instances['foo'] = 'bar'
+      }.should raise_exception(/frozen/)
+    end
+  end
+
+  describe "for testing - DeferredWorkManager.reset! method" do
+
+    it "should return nil" do
+      TomQueue::DeferredWorkManager.reset!.should be_nil
+    end
+
+    it "should cleared the singleton instances" do
+      first_singleton = TomQueue::DeferredWorkManager.instance('prefix')
+      TomQueue::DeferredWorkManager.reset!
+      TomQueue::DeferredWorkManager.instance('prefix').should_not == first_singleton
+    end
+  end
+
+
+end