backburner 0.3.4 → 0.4.0

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 # CHANGELOG
 
-## Version 0.3.5 (Unreleased)
+## Version 0.4.0 (June 28 2013)
+
+NOTE: This is the start of working with @bradgessler to improve backburner and merge with quebert
+
+ * NEW #26 #27 Remove need for Queue mixin, allow plain ruby objects
+ * NEW Default all jobs to a single general queue rather than separate queues
+ * NEW Add support for named priorities, allowing shorthand names for priority values
 
 ## Version 0.3.4 (April 23 2013)
 

data/README.md

@@ -10,7 +10,7 @@ If you want to use beanstalk for your job processing, consider using Backburner.
 Backburner is heavily inspired by Resque and DelayedJob. Backburner stores all jobs as simple JSON message payloads.
 Persistent queues are supported when beanstalkd persistence mode is enabled.
 
-Backburner supports multiple queues, job priorities, delays, and timeouts. In addition, 
+Backburner supports multiple queues, job priorities, delays, and timeouts. In addition,
 Backburner has robust support for retrying failed jobs, handling error cases,
 custom logging, and extensible plugin hooks.
 
@@ -89,7 +89,7 @@ Backburner is extremely simple to setup. Just configure basic settings for backb
 ```ruby
 Backburner.configure do |config|
   config.beanstalk_url    = ["beanstalk://127.0.0.1", "..."]
-  config.tube_namespace   = "some-app-production"
+  config.tube_namespace   = "some.app.production"
   config.on_error         = lambda { |e| puts e }
   config.max_job_retries  = 3 # default 0 retries
   config.retry_delay      = 2 # default 5 seconds
@@ -97,37 +97,67 @@ Backburner.configure do |config|
   config.respond_timeout  = 120
   config.default_worker   = Backburner::Workers::Simple
   config.logger           = Logger.new(STDOUT)
+  config.primary_queue    = "backburner-jobs"
+  config.priority_labels  = { :custom => 50, :useless => 1000 }
 end
 ```
 
 The key options available are:
 
-| Option  | Description                                                              		  |
-| ------- | -------------------------------                                           	  |
-| `beanstalk_url`  | Address such as 'beanstalk://127.0.0.1' or an array of addresses.    |
-| `tube_namespace` | Prefix used for all tubes related to this backburner queue.          |
-| `on_error`       | Lambda invoked with the error whenever any job in the system fails.  |
-| `default_worker` | Worker class that will be used if no other worker is specified.      |
-| `max_job_retries`| Integer defines how many times to retry a job before burying.        |
-| `retry_delay`    | Integer defines the base time to wait (in secs) between job retries. |
-| `logger`         | Logger recorded to when backburner wants to report info or errors.   |
+| Option            | Description                                                          |
+| ----------------- | -------------------------------                                      |
+| `beanstalk_url`   | Address such as 'beanstalk://127.0.0.1' or an array of addresses.    |
+| `tube_namespace`  | Prefix used for all tubes related to this backburner queue.          |
+| `on_error`        | Lambda invoked with the error whenever any job in the system fails.  |
+| `default_worker`  | Worker class that will be used if no other worker is specified.      |
+| `max_job_retries` | Integer defines how many times to retry a job before burying.        |
+| `retry_delay`     | Integer defines the base time to wait (in secs) between job retries. |
+| `logger`          | Logger recorded to when backburner wants to report info or errors.   |
+| `primary_queue`   | Primary queue used for a job when an alternate queue is not given.   |
+| `priority_labels` | Hash of named priority definitions for your app.                     |
+
+## Breaking Changes
+
+Since **v0.4.0**: Jobs used to be placed into default queues based on the name of the class enqueuing i.e NewsletterJob would
+be put into a 'newsletter-job' queue. After 0.4.0, all jobs are placed into a primary queue named "my.app.namespace.backburner-jobs"
+unless otherwise specified.
 
 ## Usage
 
-Backburner allows you to create jobs and place them on a beanstalk queue, and later pull those jobs off the queue and
-process them asynchronously.
+Backburner allows you to create jobs and place them onto any number of beanstalk tubes, and later pull those jobs off the tubes and
+process them asynchronously with a worker.
 
 ### Enqueuing Jobs ###
 
-At the core, Backburner is about jobs that can be processed. Jobs are simple ruby objects with a method defined named `perform`.
+At the core, Backburner is about jobs that can be processed asynchronously. Jobs are simple ruby objects which respond to `perform`.
+
+Job objects are queued as JSON onto a tube to be later processed by a worker. Here's an example:
+
+```ruby
+class NewsletterJob
+  # required
+  def self.perform(email, body)
+    NewsletterMailer.deliver_text_to_email(email, body)
+  end
+
+  # optional, defaults to 'backburner-jobs' tube
+  def self.queue
+    "newsletter-sender"
+  end
+
+  # optional, defaults to default_priority
+  def self.queue_priority
+    1000 # most urgent priority is 0
+  end
+end
+```
 
-Any object which responds to `perform` can be queued as a job. Job objects are queued as JSON to be later processed by a task runner.
-Here's an example:
+You can include the optional `Backburner::Queue` module so you can easily specify queue settings for this job:
 
 ```ruby
 class NewsletterJob
   include Backburner::Queue
-  queue "newsletter"  # defaults to 'newsletter-job'
+  queue "newsletter-sender"  # defaults to 'backburner-jobs' tube
   queue_priority 1000 # most urgent priority is 0
 
   def self.perform(email, body)
@@ -136,7 +166,6 @@ class NewsletterJob
 end
 ```
 
-Notice that you can include the optional `Backburner::Queue` module so you can specify a `queue` name for this job.
 Jobs can be enqueued with:
 
 ```ruby
@@ -144,8 +173,8 @@ Backburner.enqueue NewsletterJob, 'foo@admin.com', 'lorem ipsum...'
 ```
 
 `Backburner.enqueue` accepts first a ruby object that supports `perform` and then a series of parameters
-to that object's `perform` method. The queue name used by default is the normalized class name (i.e `{namespace}.newsletter-job`)
-if not otherwise specified.
+to that object's `perform` method. The queue name used by default is `{namespace}.backburner-jobs`
+unless otherwise specified.
 
 ### Simple Async Jobs ###
 
@@ -168,21 +197,21 @@ class User
   end
 end
 
-# Async works for instance methods on a persisted model
+# Async works for instance methods on a persisted object with an `id`
 @user = User.first
 @user.async(:ttr => 100, :queue => "activate").activate(@device.id)
-# ..as well as for class methods
+# ..and for class methods
 User.async(:pri => 100, :delay => 10.seconds).reset_password(@user.id)
 ```
 
-This will automatically enqueue a job for that user record that will run `activate` with the specified argument.
+This automatically enqueues a job for that user record that will run `activate` with the specified argument.
 Note that you can set the queue name and queue priority at the class level and
 you are also able to pass `pri`, `ttr`, `delay` and `queue` directly as options into `async`.
-The queue name used by default is the normalized class name (i.e `{namespace}.user`) if not otherwise specified.
+The queue name used by default is `{namespace}.backburner-jobs` if not otherwise specified.
 
 ### Working Jobs
 
-Backburner workers are processes that run forever handling jobs that get reserved. Starting a worker in ruby code is simple:
+Backburner workers are processes that run forever handling jobs that are reserved from the queue. Starting a worker in ruby code is simple:
 
 ```ruby
 Backburner.work
@@ -191,7 +220,7 @@ Backburner.work
 This will process jobs in all queues but you can also restrict processing to specific queues:
 
 ```ruby
-Backburner.work('newsletter_sender')
+Backburner.work('newsletter-sender,push-notifier')
 ```
 
 The Backburner worker also exists as a rake task:
@@ -203,13 +232,13 @@ require 'backburner/tasks'
 so you can run:
 
 ```
-$ QUEUES=newsletter-sender,push-message rake backburner:work
+$ QUEUES=newsletter-sender,push-notifier rake backburner:work
 ```
 
 You can also run the backburner binary for a convenient worker:
 
 ```
-bundle exec backburner newsletter-sender,push-message -d -P /var/run/backburner.pid -l /var/log/backburner.log
+bundle exec backburner newsletter-sender,push-notifier -d -P /var/run/backburner.pid -l /var/log/backburner.log
 ```
 
 This will daemonize the worker and store the pid and logs automatically.
@@ -223,7 +252,7 @@ example from above. We'll run the following code to create a job:
 User.async.reset_password(@user.id)
 ```
 
-The following JSON will be stored in the `{namespace}.user` queue:
+The following JSON will be put on the `{namespace}.backburner-jobs` queue:
 
 ``` javascript
 {
@@ -252,6 +281,31 @@ would be stored as:
 Since all jobs are persisted in JSON, your jobs must only accept arguments that can be encoded into that format.
 This is why our examples use object IDs instead of passing around objects.
 
+### Named Priorities
+
+As of v0.4.0, Backburner has support for named priorities. beanstalkd priorities are numerical but
+backburner supports a mapping between a word and a numerical value. The following priorities are
+available by default: `high` is 0, `medium` is 100, and `low` is 200.
+
+Priorities can be customized with:
+
+```ruby
+Backburner.configure do |config|
+  config.priority_labels = { :custom => 50, :useful => 5 }
+  # or append to default priorities with
+  # config.priority_labels  = Backburner::Configuration::PRIORITY_LABELS.merge(:foo => 5)
+end
+```
+
+and then these aliases can be used anywhere that a numerical value can:
+
+```ruby
+Backburner::Worker.enqueue NewsletterJob, ["foo", "bar"], :pri => :custom
+User.async(:pri => :useful, :delay => 10.seconds).reset_password(@user.id)
+```
+
+Using named priorities can greatly simplify priority management.
+
 ### Processing Strategies
 
 In Backburner, there are several different strategies for processing jobs
@@ -276,7 +330,7 @@ end
 or determine the worker on the fly when invoking `work`:
 
 ```ruby
-Backburner.work('newsletter_sender', :worker => Backburner::Workers::ThreadsOnFork)
+Backburner.work('newsletter-sender', :worker => Backburner::Workers::ThreadsOnFork)
 ```
 
 or through associated rake tasks with:
@@ -295,7 +349,7 @@ If you are interested in helping out, please let us know.
 Workers can be easily restricted to processing only a specific set of queues as shown above. However, if you want a worker to
 process **all** queues instead, then you can leave the queue list blank.
 
-When you execute a worker without queues specified, any queue for a known job queue class with `include Backburner::Queue` will be processed.
+When you execute a worker without any queues specified, queues for known job queue class with `include Backburner::Queue` will be processed.
 To access the list of known queue classes, you can use:
 
 ```ruby
@@ -310,7 +364,7 @@ queues processed when none are specified. To do this, you can use the `default_q
 Backburner.default_queues.concat(["foo", "bar"])
 ```
 
-This will ensure that the _foo_ and _bar_ queues are processed by default. You can also add job queue names:
+This will ensure that the _foo_ and _bar_ queues are processed by any default workers. You can also add job queue names with:
 
 ```ruby
 Backburner.default_queues << NewsletterJob.queue
@@ -320,7 +374,7 @@ The `default_queues` stores the specific list of queues that should be processed
 
 ### Failures
 
-When a job fails in backburner (usually because an exception was raised), the job will be released 
+When a job fails in backburner (usually because an exception was raised), the job will be released
 and retried again (with progressive delays in between) until the `max_job_retries` configuration is reached.
 
 ```ruby
@@ -362,8 +416,8 @@ Be sure to check logs whenever things do not seem to be processing.
 ### Hooks
 
 Backburner is highly extensible and can be tailored to your needs by using various hooks that
-can be triggered across the job processing lifecycle. 
-Often using hooks is much easier then trying to monkey patch the externals. 
+can be triggered across the job processing lifecycle.
+Often using hooks is much easier then trying to monkey patch the externals.
 
 Check out [HOOKS.md](https://github.com/nesquena/backburner/blob/master/HOOKS.md) for a detailed overview on using hooks.
 
@@ -381,7 +435,7 @@ and then you can start the rake task with:
 
 ```bash
 $ rake backburner:work
-$ QUEUES=newsletter-sender,push-message rake backburner:work
+$ QUEUES=newsletter-sender,push-notifier rake backburner:work
 ```
 
 The best way to deploy these rake tasks is using a monitoring library. We suggest [God](https://github.com/mojombo/god/)

data/backburner.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.version       = Backburner::VERSION
 
-  s.add_runtime_dependency 'beaneater', '~> 0.3.0'
+  s.add_runtime_dependency 'beaneater', '~> 0.3.1'
   s.add_runtime_dependency 'dante', '~> 0.1.5'
 
   s.add_development_dependency 'rake'

data/lib/backburner/configuration.rb

@@ -1,5 +1,7 @@
 module Backburner
   class Configuration
+    PRIORITY_LABELS = { :high => 0, :medium => 100, :low => 200 }
+
     attr_accessor :beanstalk_url      # beanstalk url connection
     attr_accessor :tube_namespace     # namespace prefix for every queue
     attr_accessor :default_priority   # default job priority
@@ -10,6 +12,8 @@ module Backburner
     attr_accessor :default_queues     # default queues
     attr_accessor :logger             # logger
     attr_accessor :default_worker     # default worker class
+    attr_accessor :primary_queue      # the general queue
+    attr_accessor :priority_labels    # priority labels
 
     def initialize
       @beanstalk_url     = "beanstalk://localhost"
@@ -22,6 +26,8 @@ module Backburner
       @default_queues    = []
       @logger            = nil
       @default_worker    = Backburner::Workers::Simple
+      @primary_queue     = "backburner-jobs"
+      @priority_labels   = PRIORITY_LABELS
     end
   end # Configuration
 end # Backburner

data/lib/backburner/helpers.rb

@@ -89,13 +89,32 @@ module Backburner
         tube
       elsif tube.respond_to?(:queue) # use queue name
         tube.queue
-      elsif tube.is_a?(Class) # no queue name, use job_class
-        tube.name
+      elsif tube.is_a?(Class) # no queue name, use default
+        queue_config.primary_queue # tube.name
       else # turn into a string
         tube.to_s
       end
       [prefix.gsub(/\.$/, ''), dasherize(queue_name).gsub(/^#{prefix}/, '')].join(".").gsub(/\.+/, '.')
     end
 
-  end
-end
+    # Resolves job priority based on the value given. Can be integer, a class or nothing
+    #
+    # @example
+    #  resolve_priority(1000) => 1000
+    #  resolve_priority(FooBar) => <queue priority>
+    #  resolve_priority(nil) => <default priority>
+    #
+    def resolve_priority(pri)
+      if pri.respond_to?(:queue_priority)
+        resolve_priority(pri.queue_priority)
+      elsif pri.is_a?(String) || pri.is_a?(Symbol) # named priority
+        resolve_priority(Backburner.configuration.priority_labels[pri.to_sym])
+      elsif pri.is_a?(Fixnum) # numerical
+        pri
+      else # default
+        Backburner.configuration.default_priority
+      end
+    end
+
+  end # Helpers
+end # Backburner

data/lib/backburner/hooks.rb

@@ -1,51 +1,53 @@
 module Backburner
-  module Hooks
-    # Triggers all method hooks that match the given event type with specified arguments.
-    #
-    # @example
-    #   invoke_hook_events(:before_enqueue, 'some', 'args')
-    #   invoke_hook_events(:after_perform, 5)
-    #
-    def invoke_hook_events(event, *args)
-      res = find_hook_events(event).map { |e| send(e, *args) }
-      return false if res.any? { |result| result == false }
-      res
-    end
+  class Hooks
+    class << self
+      # Triggers all method hooks that match the given event type with specified arguments.
+      #
+      # @example
+      #   invoke_hook_events(:before_enqueue, 'some', 'args')
+      #   invoke_hook_events(:after_perform, 5)
+      #
+      def invoke_hook_events(job, event, *args)
+        res = find_hook_events(job, event).map { |e| job.send(e, *args) }
+        return false if res.any? { |result| result == false }
+        res
+      end
 
-    # Triggers all method hooks that match given around event type. Used for 'around' hooks
-    # that stack over the original task cumulatively onto one another.
-    #
-    # The final block will be the one that actually invokes the
-    # original task after calling all other around blocks.
-    #
-    # @example
-    #   around_hook_events(:around_perform) { job.perform }
-    #
-    def around_hook_events(event, *args, &block)
-      raise "Please pass a block to hook events!" unless block_given?
-      around_hooks = find_hook_events(event).reverse
-      aggregate_filter = Proc.new { |&blk| blk.call }
-      around_hooks.each do |ah|
-        prior_around_filter = aggregate_filter
-        aggregate_filter = Proc.new do |&blk|
-          method(ah).call(*args) do
-            prior_around_filter.call(&blk)
+      # Triggers all method hooks that match given around event type. Used for 'around' hooks
+      # that stack over the original task cumulatively onto one another.
+      #
+      # The final block will be the one that actually invokes the
+      # original task after calling all other around blocks.
+      #
+      # @example
+      #   around_hook_events(:around_perform) { job.perform }
+      #
+      def around_hook_events(job, event, *args, &block)
+        raise "Please pass a block to hook events!" unless block_given?
+        around_hooks = find_hook_events(job, event).reverse
+        aggregate_filter = Proc.new { |&blk| blk.call }
+        around_hooks.each do |ah|
+          prior_around_filter = aggregate_filter
+          aggregate_filter = Proc.new do |&blk|
+            job.method(ah).call(*args) do
+              prior_around_filter.call(&blk)
+            end
           end
         end
+        aggregate_filter.call(&block)
       end
-      aggregate_filter.call(&block)
-    end
 
-    protected
+      protected
 
-    # Returns all methods that match given hook type
-    #
-    # @example
-    #   find_hook_events(:before_enqueue)
-    #   # => ['before_enqueue_foo', 'before_enqueue_bar']
-    #
-    def find_hook_events(event)
-      (self.methods - Object.methods).grep(/^#{event}/).sort
+      # Returns all methods that match given hook type
+      #
+      # @example
+      #   find_hook_events(:before_enqueue)
+      #   # => ['before_enqueue_foo', 'before_enqueue_bar']
+      #
+      def find_hook_events(job, event)
+        (job.methods - Object.methods).grep(/^#{event}/).sort
+      end
     end
   end # Hooks
 end # Backburner

data/lib/backburner/job.rb

@@ -22,6 +22,7 @@ module Backburner
       @task = task
       @body = task.body.is_a?(Hash) ? task.body : JSON.parse(task.body)
       @name, @args = body["class"], body["args"]
+      @hooks = Backburner::Hooks
     rescue => ex # Job was not valid format
       self.bury
       raise JobFormatInvalid, "Job body could not be parsed: #{ex.inspect}"
@@ -41,17 +42,17 @@ module Backburner
     #
     def process
       # Invoke before hook and stop if false
-      res = job_class.invoke_hook_events(:before_perform, *args)
+      res = @hooks.invoke_hook_events(job_class, :before_perform, *args)
       return false unless res
       # Execute the job
-      job_class.around_hook_events(:around_perform, *args) do
+      @hooks.around_hook_events(job_class, :around_perform, *args) do
         timeout_job_after(task.ttr - 1) { job_class.perform(*args) }
       end
       task.delete
       # Invoke after perform hook
-      job_class.invoke_hook_events(:after_perform, *args)
+      @hooks.invoke_hook_events(job_class, :after_perform, *args)
     rescue => e
-      job_class.invoke_hook_events(:on_failure, e, *args)
+      @hooks.invoke_hook_events(job_class, :on_failure, e, *args)
       raise e
     end
 

data/lib/backburner/queue.rb

@@ -1,8 +1,6 @@
 module Backburner
   module Queue
     def self.included(base)
-      base.send(:extend, Backburner::Helpers)
-      base.send(:extend, Backburner::Hooks)
       base.extend ClassMethods
       Backburner::Worker.known_queue_classes << base
     end
@@ -18,7 +16,7 @@ module Backburner
         if name
           @queue_name = name
         else # accessor
-          @queue_name || dasherize(self.name)
+          @queue_name || Backburner.configuration.primary_queue
         end
       end
 

data/lib/backburner/version.rb

@@ -1,3 +1,3 @@
 module Backburner
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

data/lib/backburner/worker.rb

@@ -24,15 +24,15 @@ module Backburner
     #   Backburner::Worker.enqueue NewsletterSender, [self.id, user.id], :ttr => 1000
     #
     def self.enqueue(job_class, args=[], opts={})
-      pri   = opts[:pri] || job_class.queue_priority || Backburner.configuration.default_priority
+      pri   = resolve_priority(opts[:pri] || job_class)
       delay = [0, opts[:delay].to_i].max
       ttr   = opts[:ttr] || Backburner.configuration.respond_timeout
       tube  = connection.tubes[expand_tube_name(opts[:queue]  || job_class)]
-      res = job_class.invoke_hook_events(:before_enqueue, *args)
+      res = Backburner::Hooks.invoke_hook_events(job_class, :before_enqueue, *args)
       return false unless res # stop if hook is false
       data = { :class => job_class.name, :args => args }
       tube.put data.to_json, :pri => pri, :delay => delay, :ttr => ttr
-      job_class.invoke_hook_events(:after_enqueue, *args)
+      Backburner::Hooks.invoke_hook_events(job_class, :after_enqueue, *args)
       return true
     end
 
@@ -143,7 +143,7 @@ module Backburner
     def all_existing_queues
       known_queues    = Backburner::Worker.known_queue_classes.map(&:queue)
       existing_tubes  = self.connection.tubes.all.map(&:name).select { |tube| tube =~ /^#{queue_config.tube_namespace}/ }
-      known_queues + existing_tubes
+      known_queues + existing_tubes + [queue_config.primary_queue]
     end
 
     # Returns a reference to the beanstalk connection
@@ -171,7 +171,7 @@ module Backburner
       tube_names = Array(tube_names).compact if tube_names && Array(tube_names).compact.size > 0
       tube_names = nil if tube_names && tube_names.compact.empty?
       tube_names ||= Backburner.default_queues.any? ? Backburner.default_queues : all_existing_queues
-      Array(tube_names)
+      Array(tube_names).uniq
     end
 
     # Registers signal handlers TERM and INT to trigger

data/test/async_proxy_test.rb

@@ -1,21 +1,18 @@
 require File.expand_path('../test_helper', __FILE__)
 
-class AsyncUser; def self.invoke_hook_events(*args); true; end; end
+class AsyncUser; end
 
 describe "Backburner::AsyncProxy class" do
   before do
     Backburner.default_queues.clear
-  end
-
-  after do
-    clear_jobs!("async-user")
+    clear_jobs!(Backburner.configuration.primary_queue)
   end
 
   describe "for method_missing enqueue" do
     should "enqueue job onto worker with no args" do
       @async = Backburner::AsyncProxy.new(AsyncUser, 10, :pri => 1000, :ttr => 100)
       @async.foo
-      job, body = pop_one_job("async-user")
+      job, body = pop_one_job
       assert_equal "AsyncUser", body["class"]
       assert_equal [10, "foo"], body["args"]
       assert_equal 100, job.ttr
@@ -26,7 +23,7 @@ describe "Backburner::AsyncProxy class" do
     should "enqueue job onto worker with args" do
       @async = Backburner::AsyncProxy.new(AsyncUser, 10, :pri => 1000, :ttr => 100)
       @async.bar(1, 2, 3)
-      job, body = pop_one_job("async-user")
+      job, body = pop_one_job
       assert_equal "AsyncUser", body["class"]
       assert_equal [10, "bar", 1, 2, 3], body["args"]
       assert_equal 100, job.ttr

data/test/fixtures/hooked.rb

@@ -15,8 +15,6 @@ end
 
 
 class HookedObjectAfterEnqueueFail
-  extend Backburner::Hooks
-
   def self.after_enqueue_abe(*args)
     puts "!!after_enqueue_foo!! #{args.inspect}"
   end
@@ -44,8 +42,6 @@ class HookedObjectBeforePerformFail
 end
 
 class HookedObjectAfterPerformFail
-  extend Backburner::Hooks
-
   def self.after_perform_abe(*args)
     puts "!!after_perform_foo!! #{args.inspect}"
   end
@@ -56,8 +52,6 @@ class HookedObjectAfterPerformFail
 end
 
 class HookedObjectJobFailure
-  extend Backburner::Hooks
-
   def self.foo(x)
     raise HookFailError, "HookedObjectJobFailure on foo!"
   end

data/test/fixtures/test_fork_jobs.rb

@@ -11,6 +11,7 @@ end
 
 class TestJobFork
   include Backburner::Queue
+  queue "test-job-fork"
   queue_priority 1000
   def self.perform(x, y)
     Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
@@ -21,6 +22,7 @@ end
 
 class TestFailJobFork
   include Backburner::Queue
+  queue "test-fail-job-fork"
   def self.perform(x, y)
     Backburner::Workers::ThreadsOnFork.enqueue ResponseJob, [{
        :worker_raise => true

data/test/fixtures/test_jobs.rb

@@ -1,9 +1,14 @@
 $worker_test_count = 0
 $worker_success = false
 
+class TestPlainJob
+  def self.queue; "test-plain"; end
+  def self.perform(x, y); $worker_test_count += x + y + 1; end
+end
+
 class TestJob
   include Backburner::Queue
-  queue_priority 1000
+  queue_priority :medium
   def self.perform(x, y); $worker_test_count += x + y; end
 end
 

data/test/helpers_test.rb

@@ -53,7 +53,7 @@ describe "Backburner::Helpers module" do
   end # config
 
   describe "for expand_tube_name method" do
-    before { Backburner.expects(:configuration).returns(stub(:tube_namespace => "test.foo.job.")) }
+    before { Backburner.stubs(:configuration).returns(stub(:tube_namespace => "test.foo.job.", :primary_queue => "backburner-jobs"))  }
 
     it "supports base strings" do
       assert_equal "test.foo.job.email/send-news", expand_tube_name("email/send_news")
@@ -73,7 +73,55 @@ describe "Backburner::Helpers module" do
     end # queue names
 
     it "supports class names" do
-      assert_equal "test.foo.job.runtime-error", expand_tube_name(RuntimeError)
+      assert_equal "test.foo.job.backburner-jobs", expand_tube_name(RuntimeError)
     end # class names
   end # expand_tube_name
+
+  describe "for resolve_priority method" do
+    before { Backburner.configure { |config| config.default_priority = 1000 }  }
+    after  { Backburner.configure { |config| config.priority_labels = Backburner::Configuration::PRIORITY_LABELS } }
+
+    it "supports fix num priority" do
+      assert_equal 500, resolve_priority(500)
+    end
+
+    it "supports baked in priority alias" do
+      assert_equal 200, resolve_priority(:low)
+      assert_equal 0,   resolve_priority(:high)
+    end
+
+    it "supports custom priority alias" do
+      Backburner.configure { |config| config.priority_labels = { :foo => 5 } }
+      assert_equal 5,   resolve_priority(:foo)
+    end
+
+    it "supports aliased priority alias" do
+      Backburner.configure { |config| config.priority_labels = { :foo => 5, :bar => 'foo' } }
+      assert_equal 5,   resolve_priority(:bar)
+    end
+
+    it "supports classes which respond to queue_priority" do
+      job = stub(:queue_priority => 600)
+      assert_equal 600, resolve_priority(job)
+    end
+
+    it "supports classes which respond to queue_priority with named alias" do
+      job = stub(:queue_priority => :low)
+      assert_equal 200, resolve_priority(job)
+    end
+
+    it "supports classes which returns null queue_priority" do
+      job = stub(:queue_priority => nil)
+      assert_equal 1000, resolve_priority(job)
+    end
+
+    it "supports classes which don't respond to queue_priority" do
+      job = stub(:fake => true)
+      assert_equal 1000, resolve_priority(job)
+    end
+
+    it "supports default pri for null values" do
+      assert_equal 1000, resolve_priority(nil)
+    end
+  end # resolve_priority
 end

data/test/hooks_test.rb

@@ -4,19 +4,20 @@ require File.expand_path('../fixtures/hooked', __FILE__)
 describe "Backburner::Hooks module" do
   before do
     $hooked_fail_count = 0
+    @hooks = Backburner::Hooks
   end
 
   describe "for invoke_hook_events method" do
     describe "with before_enqueue" do
       it "should support successful invocation" do
-        out = silenced { @res = HookedObjectSuccess.invoke_hook_events(:before_enqueue, 5, 6) }
+        out = silenced { @res = @hooks.invoke_hook_events(HookedObjectSuccess, :before_enqueue, 5, 6) }
         assert_equal [nil, nil], @res
         assert_match /!!before_enqueue_foo!! \[5\, 6\]/, out
         assert_match /!!before_enqueue_bar!! \[5\, 6\]/, out
       end
 
       it "should support fail case" do
-        out = silenced { @res = HookedObjectBeforeEnqueueFail.invoke_hook_events(:before_enqueue, 5, 6) }
+        out = silenced { @res = @hooks.invoke_hook_events(HookedObjectBeforeEnqueueFail, :before_enqueue, 5, 6) }
         assert_equal false, @res
         assert_match /!!before_enqueue_foo!! \[5\, 6\]/, out
       end
@@ -24,26 +25,26 @@ describe "Backburner::Hooks module" do
 
     describe "with after_enqueue" do
       it "should support successful invocation" do
-        out = silenced { HookedObjectSuccess.invoke_hook_events(:after_enqueue, 7, 8) }
+        out = silenced { @hooks.invoke_hook_events(HookedObjectSuccess, :after_enqueue, 7, 8) }
         assert_match /!!after_enqueue_foo!! \[7\, 8\]/, out
         assert_match /!!after_enqueue_bar!! \[7\, 8\]/, out
       end
 
       it "should support fail case" do
         assert_raises(HookFailError) do
-          silenced { @res = HookedObjectAfterEnqueueFail.invoke_hook_events(:after_enqueue, 5, 6) }
+          silenced { @res = @hooks.invoke_hook_events(HookedObjectAfterEnqueueFail, :after_enqueue, 5, 6) }
         end
       end
     end # after_enqueue
 
     describe "with before_perform" do
       it "should support successful invocation" do
-        out = silenced { HookedObjectSuccess.invoke_hook_events(:before_perform, 1, 2) }
+        out = silenced { @hooks.invoke_hook_events(HookedObjectSuccess, :before_perform, 1, 2) }
         assert_match /!!before_perform_foo!! \[1\, 2\]/, out
       end
 
       it "should support fail case" do
-        out = silenced { @res = HookedObjectBeforePerformFail.invoke_hook_events(:before_perform, 5, 6) }
+        out = silenced { @res = @hooks.invoke_hook_events(HookedObjectBeforePerformFail, :before_perform, 5, 6) }
         assert_equal false, @res
         assert_match /!!before_perform_foo!! \[5\, 6\]/, out
       end
@@ -51,20 +52,20 @@ describe "Backburner::Hooks module" do
 
     describe "with after_perform" do
       it "should support successful invocation" do
-        out = silenced { HookedObjectSuccess.invoke_hook_events(:after_perform, 3, 4) }
+        out = silenced { @hooks.invoke_hook_events(HookedObjectSuccess, :after_perform, 3, 4) }
         assert_match /!!after_perform_foo!! \[3\, 4\]/, out
       end
 
       it "should support fail case" do
         assert_raises(HookFailError) do
-          silenced { @res = HookedObjectAfterPerformFail.invoke_hook_events(:after_perform, 5, 6) }
+          silenced { @res = @hooks.invoke_hook_events(HookedObjectAfterPerformFail, :after_perform, 5, 6) }
         end
       end
     end # after_perform
 
     describe "with on_failure" do
       it "should support successful invocation" do
-        out = silenced { HookedObjectSuccess.invoke_hook_events(:on_failure, RuntimeError, 10) }
+        out = silenced { @hooks.invoke_hook_events(HookedObjectSuccess, :on_failure, RuntimeError, 10) }
         assert_match /!!on_failure_foo!! RuntimeError \[10\]/, out
       end
     end # on_failure
@@ -74,7 +75,7 @@ describe "Backburner::Hooks module" do
     describe "with around_perform" do
       it "should support successful invocation" do
         out = silenced do
-          HookedObjectSuccess.around_hook_events(:around_perform, 7, 8) {
+          @hooks.around_hook_events(HookedObjectSuccess, :around_perform, 7, 8) {
             puts "!!FIRED!!"
           }
         end

data/test/job_test.rb

@@ -2,7 +2,6 @@ require File.expand_path('../test_helper', __FILE__)
 
 module NestedDemo
   class TestJobC
-    include Backburner::Queue
     def self.perform(x); puts "Performed #{x} in #{self}"; end
   end
 

data/test/queue_test.rb

@@ -15,7 +15,7 @@ describe "Backburner::Queue module" do
 
   describe "for queue method accessor" do
     it "should return the queue name" do
-      assert_equal "nested-demo/test-job-a", NestedDemo::TestJobA.queue
+      assert_equal Backburner.configuration.primary_queue, NestedDemo::TestJobA.queue
     end
   end # queue_name
 

data/test/test_helper.rb

@@ -84,7 +84,7 @@ class MiniTest::Spec
   end
 
   # pop_one_job(tube_name)
-  def pop_one_job(tube_name)
+  def pop_one_job(tube_name=Backburner.configuration.primary_queue)
     connection = Backburner::Worker.connection
     tube_name = [Backburner.configuration.tube_namespace, tube_name].join(".")
     connection.tubes.watch!(tube_name)

data/test/worker_test.rb

@@ -5,17 +5,36 @@ require File.expand_path('../fixtures/hooked', __FILE__)
 describe "Backburner::Worker module" do
   before do
     Backburner.default_queues.clear
+    clear_jobs!(Backburner.configuration.primary_queue)
   end
 
   describe "for enqueue class method" do
-    it "should support enqueuing job" do
+    it "should support enqueuing plain job" do
+      Backburner::Worker.enqueue TestPlainJob, [7, 9], :ttr => 100, :pri => 2000
+      job, body = pop_one_job("test-plain")
+      assert_equal "TestPlainJob", body["class"]
+      assert_equal [7, 9], body["args"]
+      assert_equal 100, job.ttr
+      assert_equal 2000, job.pri
+    end # plain
+
+    it "should support enqueuing job with class queue priority" do
       Backburner::Worker.enqueue TestJob, [3, 4], :ttr => 100
-      job, body = pop_one_job("test-job")
+      job, body = pop_one_job
+      assert_equal "TestJob", body["class"]
+      assert_equal [3, 4], body["args"]
+      assert_equal 100, job.ttr
+      assert_equal 100, job.pri
+    end # queue
+
+    it "should support enqueuing job with specified named priority" do
+      Backburner::Worker.enqueue TestJob, [3, 4], :ttr => 100, :pri => 'high'
+      job, body = pop_one_job
       assert_equal "TestJob", body["class"]
       assert_equal [3, 4], body["args"]
       assert_equal 100, job.ttr
-      assert_equal 1000, job.pri
-    end # simple
+      assert_equal 0, job.pri
+    end # queue
 
     it "should support enqueuing job with custom queue" do
       Backburner::Worker.enqueue TestJob, [6, 7], :queue => "test.bar", :pri => 5000

data/test/workers/forking_worker_test.rb

@@ -46,8 +46,8 @@ describe "Backburner::Workers::Forking module" do
     it "should properly retrieve all tubes" do
       worker = @worker_class.new
       out = capture_stdout { worker.prepare }
-      assert_contains worker.tube_names, "demo.test.test-job"
-      assert_contains @worker_class.connection.tubes.watched.map(&:name), "demo.test.test-job"
+      assert_contains worker.tube_names, "demo.test.backburner-jobs"
+      assert_contains @worker_class.connection.tubes.watched.map(&:name), "demo.test.backburner-jobs"
       assert_match /demo\.test\.test-job/, out
     end # all read
   end # prepare

data/test/workers/simple_worker_test.rb

@@ -46,8 +46,8 @@ describe "Backburner::Workers::Basic module" do
     it "should properly retrieve all tubes" do
       worker = @worker_class.new
       out = capture_stdout { worker.prepare }
-      assert_contains worker.tube_names, "demo.test.test-job"
-      assert_contains @worker_class.connection.tubes.watched.map(&:name), "demo.test.test-job"
+      assert_contains worker.tube_names, "demo.test.backburner-jobs"
+      assert_contains @worker_class.connection.tubes.watched.map(&:name), "demo.test.backburner-jobs"
       assert_match /demo\.test\.test-job/, out
     end # all read
   end # prepare
@@ -58,6 +58,17 @@ describe "Backburner::Workers::Basic module" do
       $worker_success = false
     end
 
+    it "should work a plain enqueued job" do
+      clear_jobs!("foo.bar")
+      @worker_class.enqueue TestPlainJob, [1, 2], :queue => "foo.bar"
+      silenced(2) do
+        worker = @worker_class.new('foo.bar')
+        worker.prepare
+        worker.work_one_job
+      end
+      assert_equal 4, $worker_test_count
+    end # plain enqueue
+
     it "should work an enqueued job" do
       clear_jobs!("foo.bar")
       @worker_class.enqueue TestJob, [1, 2], :queue => "foo.bar"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backburner
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-23 00:00:00.000000000 Z
+date: 2013-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: beaneater
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.1
 - !ruby/object:Gem::Dependency
   name: dante
   requirement: !ruby/object:Gem::Requirement
@@ -168,7 +168,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 336951971808813718
+      hash: 3112315075043673734
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -177,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 336951971808813718
+      hash: 3112315075043673734
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25