quebert 2.0.4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13a07e8336155e0c777ed1295201b2d7d23e9bee
-  data.tar.gz: 6e3929be1a44ee006809f3b24a1ef605aed7605d
+  metadata.gz: 2bda9cb5709ea354e0ccb9822af9866fc9074795
+  data.tar.gz: 45923c3de44f7d15397732d30448931540847f50
 SHA512:
-  metadata.gz: f56a3426063aa8353e6e52f8c61bb7a76e73bdbced8df6a919872979fb33102ce0e9cbd536046ccc30fa21d1e57b38b994d275abcfd560366d6b451cf7507257
-  data.tar.gz: 2f464763bb13a6eefd45ebc46f8a2dbc3a326dff7e5968960319f37a52bcf10c3d5d5c3abf64a55d6ca009a30b12d705b65367f47d0e0ab9572969aeb5651427
+  metadata.gz: 41ad3f71924915e1ce6341b45cd8f079925dc2cfba0859bd2282d6eabf448a192841065663d0871c83830553f7b2eeb5029d6f1f5ec0f0be5c8a0a4d830dfea1
+  data.tar.gz: 466dd771292f13cae5fc7f876c23dea8bb9935dcc396a4d0fbe0e5e537f13024e6e68af71864f61e154a68f6145ee31d8e9364b90463f2dd46bcbfbb2a65e398

data/.ruby-version

@@ -0,0 +1 @@
+2.1.6

data/README.md

@@ -32,91 +32,174 @@ There are two ways to enqueue jobs with Quebert: through the Job itself, provide
 ## Jobs
 
 Quebert includes a Job class so you can implement how you want certain types of Jobs performed.
-    
-    Quebert.backend = Quebert::Backend::InProcess.new
-    
-    class WackyMathWizard < Quebert::Job
-      def perform(*nums)
-        nums.inject(0){|sum, n| sum = sum + n}
-      end
-    end
+
+```ruby
+Quebert.backend = Quebert::Backend::InProcess.new
+
+class WackyMathWizard < Quebert::Job
+  def perform(*nums)
+    nums.inject(0){|sum, n| sum = sum + n}
+  end
+end
+```
 
 You can either drop a job in a queue:
 
-    Quebert.backend.put WackyMathWizard.new(1, 2, 3)
+```ruby
+Quebert.backend.put WackyMathWizard.new(1, 2, 3)
+```
 
 Or drop it in right from the job:
 
-    WackyMathWizard.new(4, 5, 6).enqueue
+```ruby
+WackyMathWizard.new(4, 5, 6).enqueue
+```
 
 Then perform the jobs!
 
-    Quebert.backend.reserve.perform # => 6
-    Quebert.backend.reserve.perform # => 15
+```ruby
+Quebert.backend.reserve.perform # => 6
+Quebert.backend.reserve.perform # => 15
+```
+
+## Rails integration
+
+config/quebert.yml:
+
+```yaml
+development:
+  backend: beanstalk
+  host: localhost:11300
+  queue: myapp-development
+test:
+  backend: sync
+# etc.
+```
+
+config/initializers/quebert.rb:
+
+```ruby
+Quebert.config.from_hash(Rails.application.config.quebert)
+Quebert.config.logger = Rails.logger
+```
 
 ## Before/After/Around Hooks
 
 Quebert has support for providing custom hooks to be called before, after & around your jobs are being run.
 A common example is making sure that any active ActiveRecord database connections are put back on the connection pool after a job is done:
 
-    Quebert.config.after_job do
-      ActiveRecord::Base.clear_active_connections!
-    end
+```ruby
+Quebert.config.after_job do
+  ActiveRecord::Base.clear_active_connections!
+end
 
-    Quebert.config.before_job do |job|
-      # all hooks take an optional job argument
-      # in case you want to do something with that job
-    end
+Quebert.config.before_job do |job|
+  # all hooks take an optional job argument
+  # in case you want to do something with that job
+end
 
-    Quebert.config.around_job do |job|
-      # this hook gets called twice
-      # once before & once after a job is performed
-    end
+Quebert.config.around_job do |job|
+  # this hook gets called twice
+  # once before & once after a job is performed
+end
+```
 
 ## Async Sender
 
 Take any ol' class and include the Quebert::AsyncSender.
 
-    Quebert.backend = Quebert::Backend::InProcess.new
-
-    class Greeter
-      include Quebert::AsyncSender::Class
-      
-      def initialize(name)
-        @name = name
-      end
-      
-      def sleep_and_greet(time_of_day)
-        sleep 10000 # Sleeping, get it?
-        "Oh! Hi #{name}! Good #{time_of_day}."
-      end
-      
-      def self.budweiser_greeting(name)
-        "waaazup #{name}!"
-      end
-    end
-    
-    walmart_greeter = Greeter.new("Brad")
+```ruby
+Quebert.backend = Quebert::Backend::InProcess.new
+
+class Greeter
+  include Quebert::AsyncSender::Class
+
+  def initialize(name)
+    @name = name
+  end
+
+  def sleep_and_greet(time_of_day)
+    sleep 10000 # Sleeping, get it?
+    "Oh! Hi #{name}! Good #{time_of_day}."
+  end
+
+  def self.budweiser_greeting(name)
+    "waaazup #{name}!"
+  end
+end
+
+walmart_greeter = Greeter.new("Brad")
+```
 
 Remember the send method in ruby?
 
-    walmart_greeter.send(:sleep_and_greet, "morning")
-    # ... time passes, you wait as greeter snores obnoxiously ...
-    # => "Oh! Hi Brad! Good morning."
+```ruby
+walmart_greeter.send(:sleep_and_greet, "morning")
+# ... time passes, you wait as greeter snores obnoxiously ...
+# => "Oh! Hi Brad! Good morning."
+```
 
 What if the method takes a long time to run and you want to queue it? async.send it!
 
-    walmart_greeter.async.sleep_and_greet("morning")
-    # ... do some shopping and come back later when the dude wakes up
-    
-Quebert figures out how to *serialize the class, throw it on a worker queue, re-instantiate it on the other side, and finish up the work.
+```ruby
+walmart_greeter.async.sleep_and_greet("morning")
+# ... do some shopping and come back later when the dude wakes up
+```
+
+Quebert figures out how to serialize the class, throw it on a worker queue, re-instantiate it on the other side, and finish up the work.
+
+```ruby
+Quebert.backend.reserve.perform # => "Oh! Hi Brad! Good morning."
+# ... Sorry dude! I'm shopping already
+```
 
-    Quebert.backend.reserve.perform # => "Oh! Hi Brad! Good morning."
-    # ... Sorry dude! I'm shopping already
-    
 Does it work on Class methods? Yeah, that was easier than making instance methods work:
 
-    Quebert.async.budweiser_greeting("Corey")
-    Quebert.backend.reserve.perform # => "waazup Corey!"
+```ruby
+Quebert.async.budweiser_greeting("Coraline")
+Quebert.backend.reserve.perform # => "waazup Coraline!"
+```
 
 * Only basic data types are included for serialization. Serializers may be customized to include support for different types.
+
+## Backends
+
+* Beanstalk: Enqueue jobs in a beanstalkd service. The workers run in a separate process. Typically used in production environments.
+* Sync: Perform jobs immediately upon enqueuing. Typically used in testing environments.
+* InProcess: Enqueue jobs in an in-memory array. A worker will need to reserve a job to perform.
+
+## Using multiple queues
+
+To start a worker pointed at a non-default queue (e.g., a Quebert "tube"), start the process with `-q`:
+
+```sh
+bundle exec quebert -q other-tube
+```
+
+Then specify the queue name in your job:
+
+```ruby
+class FooJob < Quebert::Job
+  def queue
+    "other-tube"
+  end
+
+  def perform(args)
+    # ...
+  end
+end
+```
+
+## Beanstalk: Changing a job's TTR
+
+```ruby
+class FooJob < Quebert::Job
+  def ttr
+    5.minutes
+  end
+
+  def perform(args)
+    # ...
+  end
+end
+```

data/lib/quebert/backend/beanstalk.rb

@@ -1,33 +1,39 @@
-require 'beaneater'
+require "beaneater"
+require "forwardable"
 
 module Quebert
   module Backend
-    
     # Manage jobs on a Beanstalk queue out of process
     class Beanstalk
-      def initialize(host, tube_name)
-        @host, @tube_name = host, tube_name
+      extend Forwardable
+      include Logging
+
+      # A buffer time in seconds added to the Beanstalk TTR for Quebert to do
+      # its own job cleanup The job will perform based on the Beanstalk TTR,
+      # but Beanstalk hangs on to the job just a little longer so that Quebert
+      # can bury the job or schedule a retry with the appropriate delay
+      TTR_BUFFER = 5
+
+      attr_reader :host, :queue
+      attr_writer :queues
+
+      def initialize(host, queue)
+        @host = host
+        @queue = queue
+        @queues = []
       end
 
-      def put(job, *args)
-        priority, delay, ttr = args
-        opts = {}
-        opts[:pri]   = priority unless priority.nil?
-        opts[:delay] = delay    unless delay.nil?
-        opts[:ttr]   = ttr      unless ttr.nil?
-        tube.put job.to_json, opts
+      def self.configure(opts = {})
+        new(opts.fetch(:host, "127.0.0.1:11300"), opts.fetch(:queue))
       end
 
       def reserve_without_controller(timeout=nil)
-        tube.reserve timeout
+        watch_tubes
+        beanstalkd_tubes.reserve(timeout)
       end
 
       def reserve(timeout=nil)
-        Controller::Beanstalk.new reserve_without_controller(timeout), self
-      end
-
-      def peek(state)
-        tube.peek state
+        Controller::Beanstalk.new(reserve_without_controller(timeout))
       end
 
       # For testing purposes... I think there's a better way to do this though.
@@ -39,24 +45,47 @@ module Quebert
           reserve_without_controller.delete
         end
         while peek(:buried) do
-          tube.kick
+          kick
           reserve_without_controller.delete
         end
       end
-      
-      def self.configure(opts={})
-        opts[:host] ||= ['127.0.0.1:11300']
-        new(opts[:host], opts[:tube])
+
+      # TODO add a queue param?
+      def_delegators :default_tube, :peek, :kick
+
+      def put(job)
+        tube = beanstalkd_tubes[job.queue || queue]
+        tube.put(job.to_json,
+          :pri => job.priority,
+          :delay => job.delay,
+          :ttr => job.ttr + TTR_BUFFER)
       end
 
       private
-      def pool
-        @pool ||= Beaneater::Pool.new Array(@host)
+
+      def default_tube
+        @default_tube ||= beanstalkd_tubes[queue]
+      end
+
+      def beanstalkd_connection
+        @beanstalkd_connection ||= Beaneater.new(host)
+      end
+
+      def beanstalkd_tubes
+        beanstalkd_connection.tubes
+      end
+
+      def watch_tubes
+        if queues != @watched_tube_names
+          @watched_tube_names = queues
+          logger.info "Watching beanstalkd queues #{@watched_tube_names.inspect}"
+          beanstalkd_tubes.watch!(*@watched_tube_names)
+        end
       end
 
-      def tube
-        @tube ||= pool.tubes[@tube_name]
+      def queues
+        @queues.empty? ? [queue] : @queues
       end
     end
   end
-end
+end

data/lib/quebert/command_line_runner.rb

@@ -28,6 +28,7 @@ module Quebert
                                     "(default: #{@options[:pid]})")                   { |file| @options[:pid] = file }
         opts.on("-C", "--config FILE", "Load options from config file")               { |file| @options[:config] = file }
         opts.on("-c", "--chdir DIR", "Change to dir before starting")                 { |dir| @options[:chdir] = File.expand_path(dir) }
+        opts.on("-q", "--queues LIST", "Specify queue name(s)")                       { |list| @options[:queues] = list.split(",") }
       end
     end
 
@@ -58,7 +59,9 @@ module Quebert
         require config
       end
 
-      Worker.new.start
+      worker = Worker.new
+      worker.queues = params[:queues] if params[:queues]
+      worker.start
     end
 
   private
@@ -70,4 +73,4 @@ module Quebert
       end
     end
   end
-end
+end

data/lib/quebert/controller/beanstalk.rb

@@ -6,33 +6,33 @@ module Quebert
     class Beanstalk < Base
       include Logging
 
-      attr_reader :beanstalk_job, :queue, :job
+      attr_reader :beanstalk_job, :job
 
       MAX_TIMEOUT_RETRY_DELAY = 300
       TIMEOUT_RETRY_DELAY_SEED = 2
       TIMEOUT_RETRY_GROWTH_RATE = 3
 
-      def initialize(beanstalk_job, queue)
-        @beanstalk_job, @queue = beanstalk_job, queue
+      def initialize(beanstalk_job)
+        @beanstalk_job = beanstalk_job
         @job = Job.from_json(beanstalk_job.body)
       rescue Job::Delete
         beanstalk_job.delete
-        log "Deleted on initialization", :error
+        job_log "Deleted on initialization", :error
       rescue Job::Release
-        beanstalk_job.release @job.priority, @job.delay
-        log "Released on initialization with priority: #{@job.priority} and delay: #{@job.delay}", :error
+        beanstalk_job.release job.priority, job.delay
+        job_log "Released on initialization with priority: #{job.priority} and delay: #{job.delay}", :error
       rescue Job::Bury
         beanstalk_job.bury
-        log "Buried on initialization", :error
-      rescue Exception => e
+        job_log "Buried on initialization", :error
+      rescue => e
         beanstalk_job.bury
-        log "Exception caught on initialization. #{e.inspect}", :error
+        job_log "Error caught on initialization. #{e.inspect}", :error
         raise
       end
 
       def perform
-        log "Performing with args #{job.args.inspect}"
-        log "Beanstalk Job Stats: #{beanstalk_job.stats.inspect}"
+        job_log "Performing with args #{job.args.inspect}"
+        job_log "Beanstalk Job Stats: #{beanstalk_job.stats.inspect}"
 
         result = false
         time = Benchmark.realtime do
@@ -40,33 +40,33 @@ module Quebert
           beanstalk_job.delete
         end
 
-        log "Completed in #{(time*1000*1000).to_i/1000.to_f} ms\n"
+        job_log "Completed in #{(time*1000*1000).to_i/1000.to_f} ms\n"
         result
       rescue Job::Delete
-        log "Deleting job", :error
+        job_log "Deleting job", :error
         beanstalk_job.delete
-        log "Job deleted", :error
+        job_log "Job deleted", :error
       rescue Job::Release
-        log "Releasing with priority: #{@job.priority} and delay: #{@job.delay}", :error
-        beanstalk_job.release :pri => @job.priority, :delay => @job.delay
-        log "Job released", :error
+        job_log "Releasing with priority: #{job.priority} and delay: #{job.delay}", :error
+        beanstalk_job.release :pri => job.priority, :delay => job.delay
+        job_log "Job released", :error
       rescue Job::Bury
-        log "Burrying job", :error
+        job_log "Burrying job", :error
         beanstalk_job.bury
-        log "Job burried", :error
+        job_log "Job burried", :error
       rescue Job::Timeout => e
-        log "Job timed out. Retrying with delay. #{e.inspect} #{e.backtrace.join("\n")}", :error
+        job_log "Job timed out. Retrying with delay. #{e.inspect} #{e.backtrace.join("\n")}", :error
         retry_with_delay
         raise
       rescue Job::Retry
         # The difference between the Retry and Timeout class is that
-        # Retry does not log an exception where as Timeout does
-        log "Manually retrying with delay"
+        # Retry does not job_log an exception where as Timeout does
+        job_log "Manually retrying with delay"
         retry_with_delay
-      rescue Exception => e
-        log "Exception caught on perform. Burying job. #{e.inspect} #{e.backtrace.join("\n")}", :error
+      rescue => e
+        job_log "Error caught on perform. Burying job. #{e.inspect} #{e.backtrace.join("\n")}", :error
         beanstalk_job.bury
-        log "Job buried", :error
+        job_log "Job buried", :error
         raise
       end
 
@@ -75,23 +75,27 @@ module Quebert
         delay = TIMEOUT_RETRY_DELAY_SEED + TIMEOUT_RETRY_GROWTH_RATE**beanstalk_job.stats["releases"].to_i
 
         if delay > MAX_TIMEOUT_RETRY_DELAY
-          log "Max retry delay exceeded. Burrying job"
+          job_log "Max retry delay exceeded. Burrying job"
           beanstalk_job.bury
-          log "Job burried"
+          job_log "Job burried"
         else
-          log "TTR exceeded. Releasing with priority: #{@job.priority} and delay: #{delay}"
-          beanstalk_job.release :pri => @job.priority, :delay => delay
-          log "Job released"
+          job_log "TTR exceeded. Releasing with priority: #{job.priority} and delay: #{delay}"
+          beanstalk_job.release :pri => job.priority, :delay => delay
+          job_log "Job released"
         end
       rescue ::Beaneater::NotFoundError
-        log "Job ran longer than allowed. Beanstalk already deleted it!!!!", :error
+        job_log "Job ran longer than allowed. Beanstalk already deleted it!!!!", :error
         # Sometimes the timer doesn't behave correctly and this job actually runs longer than
         # allowed. At that point the beanstalk job no longer exists anymore. Lets let it go and don't blow up.
       end
 
-      def log(message, level=:info)
+      def job_log(message, level=:info)
         # Have the job write to the log file so that we catch the details of the job
-        job.send(:log, message, level)
+        if job
+          job.send(:log, message, level)
+        else
+          Quebert.logger.send(level, message)
+        end
       end
     end
   end

data/lib/quebert/job.rb

@@ -6,7 +6,7 @@ module Quebert
     include Logging
 
     attr_reader :args
-    attr_accessor :priority, :delay, :ttr
+    attr_accessor :priority, :delay, :ttr, :queue
 
     # Prioritize Quebert jobs as specified in https://github.com/kr/beanstalkd/blob/master/doc/protocol.txt.
     class Priority
@@ -21,11 +21,6 @@ module Quebert
     # By default, the job should live for 10 seconds tops.
     DEFAULT_JOB_TTR = 10
 
-    # A buffer time in seconds added to the Beanstalk TTR for Quebert to do its own job cleanup
-    # The job will perform based on the Beanstalk TTR, but Beanstalk hangs on to the job just a
-    # little longer so that Quebert can bury the job or schedule a retry with the appropriate delay
-    QUEBERT_TTR_BUFFER = 5
-
     # Exceptions are used for signaling job status... ewww. Yank this out and
     # replace with a more well thought out controller.
     NotImplemented = Class.new(StandardError)
@@ -57,7 +52,7 @@ module Quebert
       # Honor the timeout and kill the job in ruby-space. Beanstalk
       # should be cleaning up this job and returning it to the queue
       # as well.
-      val = ::Timeout.timeout(@ttr, Job::Timeout){ perform(*args) }
+      val = ::Timeout.timeout(ttr, Job::Timeout){ perform(*args) }
 
       Quebert.config.around_job(self)
       Quebert.config.after_job(self)
@@ -66,9 +61,9 @@ module Quebert
     end
 
     # Accepts arguments that override the job options and enqueu this stuff.
-    def enqueue(opts={})
-      opts.each { |opt, val| self.send("#{opt}=", val) }
-      self.class.backend.put self, @priority, @delay, @ttr + QUEBERT_TTR_BUFFER
+    def enqueue(override_opts={})
+      override_opts.each { |opt, val| self.send("#{opt}=", val) }
+      backend.put(self)
     end
 
     # Serialize the job into a JSON string that we can put on the beandstalkd queue.
@@ -87,6 +82,10 @@ module Quebert
       @backend = backend
     end
 
+    def backend
+      self.class.backend
+    end
+
     def self.backend
       @backend || Quebert.configuration.backend
     end

data/lib/quebert/serializer.rb

@@ -1,6 +1,6 @@
 module Quebert
   module Serializer
-    
+
     # Does this mean you could queue a job that could queue a job? Whoa!
     class Job
       def self.serialize(job)
@@ -9,21 +9,23 @@ module Quebert
           'args' => serialize_args(job.args),
           'priority' => job.priority,
           'delay' => job.delay,
-          'ttr' => job.ttr
+          'ttr' => job.ttr,
+          'queue' => job.queue
         }
       end
-      
+
       def self.deserialize(hash)
         hash = Support.stringify_keys(hash)
         job = Support.constantize(hash['job']).new(*deserialize_args(hash['args']))
         job.priority = hash['priority']
         job.delay = hash['delay']
         job.ttr = hash['ttr']
+        job.queue = hash['queue']
         job
       end
-      
+
     private
-    
+
       # Reflect on each arg and see if it has a seralizer
       def self.serialize_args(args)
         args.map do |arg|
@@ -37,7 +39,7 @@ module Quebert
           hash
         end
       end
-      
+
       # Find a serializer and/or push out a value
       def self.deserialize_args(args)
         args.map do |arg|
@@ -50,7 +52,7 @@ module Quebert
         end
       end
     end
-    
+
     # Deal with converting an AR to/from a hash that we can send over the wire.
     class ActiveRecord
       def self.serialize(record)
@@ -60,7 +62,7 @@ module Quebert
         end
         { 'model' => record.class.model_name.to_s, 'attributes' => attrs }
       end
-      
+
       def self.deserialize(hash)
         hash = Support.stringify_keys(hash)
         model = Support.constantize(hash.delete('model'))
@@ -81,6 +83,5 @@ module Quebert
         end
       end
     end
-    
   end
 end

data/lib/quebert/version.rb

@@ -1,3 +1,3 @@
 module Quebert
-  VERSION = "2.0.4"
+  VERSION = "3.0.0"
 end

data/lib/quebert/worker.rb

@@ -2,9 +2,10 @@ module Quebert
   class Worker
     include Logging
 
-    attr_accessor :exception_handler, :backend
+    attr_accessor :exception_handler, :backend, :queues
 
     def initialize
+      @queues = []
       yield self if block_given?
     end
 
@@ -14,10 +15,13 @@ module Quebert
       Signal.trap('INT') { safe_stop }
 
       logger.info "Worker started with #{backend.class.name} backend\n"
+
+      backend.queues = queues if backend.respond_to?(:queues=)
+
       while @controller = backend.reserve do
         begin
           @controller.perform
-        rescue Exception => error
+        rescue => error
           if exception_handler
             exception_handler.call(
               error,
@@ -26,7 +30,7 @@ module Quebert
               :worker => self
             )
           else
-            raise error
+            raise
           end
         end
         @controller = nil

data/quebert.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   # specify any dependencies here; for example:
   # s.add_development_dependency "rspec"
   s.add_runtime_dependency "json"
-  s.add_runtime_dependency "beaneater"
-  
+  s.add_runtime_dependency "beaneater", "~> 1.0"
+
   s.add_development_dependency 'rspec', '2.7.0'
-end
+end

data/spec/backend_spec.rb

@@ -51,6 +51,18 @@ describe Backend::Beanstalk  do
       @q.reserve.perform.should eql(num)
     end
   end
+
+  it "should consume from multiple queues" do
+    @q.queues = ["a", "b"]
+    job1 = Adder.new(1)
+    job1.queue = "a"
+    @q.put(job1)
+    job2 = Adder.new(2)
+    job2.queue = "b"
+    @q.put(job2)
+    @q.reserve.perform.should eql(1)
+    @q.reserve.perform.should eql(2)
+  end
 end
 
 describe Backend::Sync do

data/spec/configuration_spec.rb

@@ -3,18 +3,19 @@ require 'spec_helper'
 describe Configuration do
   context "from hash" do
     before(:all) do
-      @config = Configuration.new.from_hash('backend' => 'beanstalk', 'host' => 'localhost:11300', 'tube' => 'quebert-config-test')
+      @config = Configuration.new.from_hash(
+        "backend" => "beanstalk",
+        "host" => "localhost:11300",
+        "queue" => "quebert-config-test")
     end
-    
+
     it "should configure backend" do
       backend = @config.backend
       backend.should be_instance_of(Quebert::Backend::Beanstalk)
       # Blech, gross nastiness in their lib, but we need to look in to see if this stuff as configed
-      pool = backend.send(:pool)
-      pool.connections.first.address.should eql('localhost:11300')
-      tube = backend.send(:tube)
-      tube.name.should eql('quebert-config-test')
+      backend.send(:beanstalkd_connection).connection.host.should eql("localhost")
+      backend.send(:beanstalkd_connection).connection.port.should eql(11300)
+      backend.send(:default_tube).name.should eql("quebert-config-test")
     end
-    
   end
-end
+end

data/spec/consumer_spec.rb

@@ -4,7 +4,7 @@ describe Controller::Base do
   it "should perform job" do
     Controller::Base.new(Adder.new(1,2)).perform.should eql(3)
   end
-  
+
   it "should rescue all raised job actions" do
     [ReleaseJob, DeleteJob, BuryJob].each do |job|
       lambda{
@@ -16,34 +16,34 @@ end
 
 describe Controller::Beanstalk do
   before(:all) do
-    @q = Backend::Beanstalk.configure(:host => 'localhost:11300', :tube => 'quebert-test-jobs-actions')
+    @q = Backend::Beanstalk.configure(:host => "localhost:11300",
+      :queue => "quebert-test-jobs-actions")
   end
-  
+
   before(:each) do
     @q.drain!
   end
-  
+
   it "should delete job off queue after succesful run" do
     @q.put Adder.new(1, 2)
     @q.peek(:ready).should_not be_nil
     @q.reserve.perform.should eql(3)
     @q.peek(:ready).should be_nil
   end
-  
+
   it "should bury job if an exception occurs in job" do
     @q.put Exceptional.new
     @q.peek(:ready).should_not be_nil
     lambda{ @q.reserve.perform }.should raise_exception
     @q.peek(:buried).should_not be_nil
   end
-  
+
   it "should bury an AR job if an exception occurs deserializing it" do
-    @user = User.new(:first_name => "John", :last_name => "Doe", :email => "jdoe@gmail.com")
-    @user.id = 1
-    @q.put Serializer::ActiveRecord.serialize(@user)
-    @q.peek(:ready).should_not be_nil
+    tube = @q.send(:default_tube)
+    tube.put({:foo => "bar"}.to_json)
+    tube.peek(:ready).should_not be_nil
     lambda{ @q.reserve.perform }.should raise_exception
-    @q.peek(:buried).should_not be_nil
+    tube.peek(:buried).should_not be_nil
   end
 
   context "job actions" do
@@ -53,14 +53,14 @@ describe Controller::Beanstalk do
       @q.reserve.perform
       @q.peek(:ready).should be_nil
     end
-    
+
     it "should release job" do
       @q.put ReleaseJob.new
       @q.peek(:ready).should_not be_nil
       @q.reserve.perform
       @q.peek(:ready).should_not be_nil
     end
-    
+
     it "should bury job" do
       @q.put BuryJob.new
       @q.peek(:ready).should_not be_nil
@@ -79,7 +79,7 @@ describe Controller::Beanstalk do
     job.beanstalk_job.stats["releases"].should eql(0)
     job.beanstalk_job.stats["delay"].should eql(0)
     lambda{job.perform}.should raise_exception(Quebert::Job::Timeout)
-    
+
     @q.peek(:ready).should be_nil
     beanstalk_job = @q.peek(:delayed)
     beanstalk_job.should_not be_nil
@@ -91,7 +91,7 @@ describe Controller::Beanstalk do
     # lets set the max retry delay so it should bury instead of delay
     redefine_constant Quebert::Controller::Beanstalk, :MAX_TIMEOUT_RETRY_DELAY, 1
     lambda{@q.reserve.perform}.should raise_exception(Quebert::Job::Timeout)
-    
+
     @q.peek(:ready).should be_nil
     @q.peek(:delayed).should be_nil
     @q.peek(:buried).should_not be_nil

data/spec/job_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Quebert::Job do
-  
+
   before(:all) do
     Adder.backend = @q = Quebert::Backend::InProcess.new
   end
@@ -13,23 +13,26 @@ describe Quebert::Job do
   it "should perform!" do
     Adder.new(1,2,3).perform!.should eql(6)
   end
-  
+
   it "should perform 0 arg jobs" do
     Adder.new.perform!.should eql(0)
   end
-  
+
   it "should raise not implemented on base job" do
     lambda {
       Job.new.perform
     }.should raise_exception(Quebert::Job::NotImplemented)
   end
-  
+
   it "should convert job to and from JSON" do
     args = [1,2,3]
-    serialized = Adder.new(*args).to_json
+    job = Adder.new(*args)
+    job.queue = "foo"
+    serialized = job.to_json
     unserialized = Adder.from_json(serialized)
-    unserialized.should be_instance_of(Adder)
+    unserialized.should be_a(Adder)
     unserialized.args.should eql(args)
+    unserialized.queue.should eql("foo")
   end
 
   it "should have default MEDIUM priority" do
@@ -54,20 +57,20 @@ describe Quebert::Job do
         ReleaseJob.new.perform
       }.should raise_exception(Job::Release)
     end
-    
+
     it "should raise delete" do
       lambda{
         DeleteJob.new.perform
       }.should raise_exception(Job::Delete)
     end
-    
+
     it "should raise bury" do
       lambda{
         BuryJob.new.perform
       }.should raise_exception(Job::Bury)
     end
   end
-  
+
   context "job queue" do
     it "should enqueue" do
       lambda{
@@ -113,7 +116,7 @@ describe Quebert::Job do
           job = @q.reserve
           job.beanstalk_job.pri.should eql(1)
           job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Job::QUEBERT_TTR_BUFFER)
+          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
 
         it "should enqueue and honor beanstalk options" do
@@ -121,7 +124,7 @@ describe Quebert::Job do
           job = @q.reserve
           job.beanstalk_job.pri.should eql(1)
           job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Job::QUEBERT_TTR_BUFFER)
+          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
       end
 
@@ -132,7 +135,7 @@ describe Quebert::Job do
           job = @q.reserve
           job.beanstalk_job.pri.should eql(1)
           job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Job::QUEBERT_TTR_BUFFER)
+          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
 
         it "should enqueue and honor beanstalk options" do
@@ -140,12 +143,12 @@ describe Quebert::Job do
           job = @q.reserve
           job.beanstalk_job.pri.should eql(1)
           job.beanstalk_job.delay.should eql(2)
-          job.beanstalk_job.ttr.should eql(300 + Job::QUEBERT_TTR_BUFFER)
+          job.beanstalk_job.ttr.should eql(300 + Quebert::Backend::Beanstalk::TTR_BUFFER)
         end
       end
     end
   end
-  
+
   context "Timeout" do
     it "should respect TTR option" do
       lambda {

data/spec/support/jobs.rb

@@ -36,6 +36,6 @@ end
 
 class Exceptional < Quebert::Job
   def perform
-    raise Exception
+    fail
   end
-end
+end

data/spec/worker_spec.rb

@@ -20,13 +20,13 @@ describe Worker do
 
     it "should default to Quebert.config.worker.exception_handler handler" do
       @q.put Exceptional.new
-      Quebert.config.worker.exception_handler = Proc.new{|e, opts| e.should be_instance_of(Exception) }
+      Quebert.config.worker.exception_handler = Proc.new{|e, opts| e.should be_a(StandardError) }
       lambda{ @w.start }.should_not raise_exception
     end
 
     it "should intercept exceptions" do
       @q.put Exceptional.new
-      @w.exception_handler = Proc.new{|e, opts| e.should be_instance_of(Exception) }
+      @w.exception_handler = Proc.new{|e, opts| e.should be_a(StandardError) }
       lambda{ @w.start }.should_not raise_exception
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quebert
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 3.0.0
 platform: ruby
 authors:
 - Brad Gessler
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-28 00:00:00.000000000 Z
+date: 2015-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -30,16 +30,16 @@ dependencies:
   name: beaneater
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -64,8 +64,8 @@ extra_rdoc_files: []
 files:
 - ".document"
 - ".gitignore"
-- ".rbenv-version"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - Gemfile
 - Guardfile
@@ -131,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: quebert
-rubygems_version: 2.2.2
+rubygems_version: 2.2.3
 signing_key: 
 specification_version: 4
 summary: A worker queue framework built around beanstalkd

data/.rbenv-version

@@ -1 +0,0 @@
-2.1.2