backburner 0.0.3 → 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# CHANGELOG
+
+## Released 0.0.1 (Nov 4th 2012)
+
+ * Switch to beaneater as new ruby beanstalkd client
+ * Add support for array of connections in `beanstalk_url`

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in backburner.gemspec
-gemspec
+gemspec

data/README.md

@@ -1,19 +1,20 @@
 # Backburner
 
-Backburner is a [beanstalkd](http://kr.github.com/beanstalkd/)-powered job queue which can handle a very high volume of jobs.
-You create background jobs and place those on multiple work queues to be processed later.
+Backburner is a [beanstalkd](http://kr.github.com/beanstalkd/)-powered job queue that can handle a very high volume of jobs.
+You create background jobs and place them on multiple work queues to be processed later.
 
-Processing background jobs reliably has never been easier then with beanstalkd and Backburner. This gem works with any ruby-based
-web framework but is especially suited for use with [Sinatra](http://sinatrarb.com), [Padrino](http://padrinorb.com) and Rails.
+Processing background jobs reliably has never been easier than with beanstalkd and Backburner. This gem works with any ruby-based
+web framework, but is especially suited for use with [Sinatra](http://sinatrarb.com), [Padrino](http://padrinorb.com) and Rails.
 
 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.
-Backburner can be a persistent queue if the beanstalk persistence mode is enabled, supports multiple queues, priorities, delays, and timeouts.
+Backburner can be a persistent queue when the beanstalk persistence mode is enabled.
+It supports multiple queues, priorities, delays, and timeouts.
 
 ## Why Backburner?
 
-Backburner is well tested and has a familiar, no-nonsense approach to job processing but that is of secondary importance.
-Let's face it; there are a lot of options for background job processing. [DelayedJob](https://github.com/collectiveidea/delayed_job),
+Backburner is well tested and has a familiar, no-nonsense approach to job processing, but that is of secondary importance.
+Let's face it, there are a lot of options for background job processing. [DelayedJob](https://github.com/collectiveidea/delayed_job),
 and [Resque](https://github.com/defunkt/resque) are the first that come to mind immediately. So, how do we make sense
 of which one to use? And why use Backburner over other alternatives?
 
@@ -22,7 +23,7 @@ libraries under the hood. Every job queue requires a queue store that jobs are p
 In the case of Resque, jobs are processed through **Redis**, a persistent key-value store. In the case of DelayedJob, jobs are processed through
 **ActiveRecord** and a database such as PostgreSQL.
 
-The work queue underlying these gems tells you infinitely more about the differences then anything else.
+The work queue underlying these gems tells you infinitely more about the differences than anything else.
 Beanstalk is probably the best solution for job queues available today for many reasons.
 The real question then is... "Why Beanstalk?".
 
@@ -33,26 +34,26 @@ Illya has an excellent blog post
 Adam Wiggins posted [an excellent comparison](http://adam.heroku.com/past/2010/4/24/beanstalk_a_simple_and_fast_queueing_backend/).
 
 You will quickly see that **beanstalkd** is an underrated but incredible project that is extremely well-suited as a job queue.
-Significantly better suited for this task then Redis or a database. Beanstalk is a simple,
+Significantly better suited for this task than Redis or a database. Beanstalk is a simple,
 and a very fast work queue service rolled into a single binary - it is the memcached of work queues.
 Originally built to power the backend for the 'Causes' Facebook app, it is a mature and production ready open source project.
 [PostRank](http://www.postrank.com) uses beanstalk to reliably process millions of jobs a day.
 
 A single instance of Beanstalk is perfectly capable of handling thousands of jobs a second (or more, depending on your job size)
 because it is an in-memory, event-driven system. Powered by libevent under the hood,
-it requires zero setup (launch and forget, ala memcached), optional log based persistence, an easily parsed ASCII protocol,
+it requires zero setup (launch and forget, à la memcached), optional log based persistence, an easily parsed ASCII protocol,
 and a rich set of tools for job management that go well beyond a simple FIFO work queue.
 
 Beanstalk supports the following features natively, out of the box, without any questions asked:
 
- * **Parallel Queues** - Supports multiple work queues, which are created and deleted on demand.
- * **Reliable** - Beanstalk’s reserve, work, delete cycle, with a timeout on a job, means bad clients basically can't lose a job.
+ * **Parallel Queues** - Supports multiple work queues created on demand.
+ * **Reliable** - Beanstalk’s reserve, work, delete cycle ensures reliable processing.
  * **Scheduling** - Delay enqueuing jobs by a specified interval to schedule processing later.
- * **Fast** - Beanstalkd is **significantly** [faster then alternatives](http://adam.heroku.com/past/2010/4/24/beanstalk_a_simple_and_fast_queueing_backend). Easily processes thousands of jobs a second.
- * **Priorities** - Specify a higher priority and those jobs will jump ahead to be processed first accordingly.
- * **Persistence** - Jobs are stored in memory for speed (ala memcached), but also logged to disk for safe keeping.
- * **Federation** - Fault-tolerance and horizontal scalability is provided the same way as Memcache - through federation by the client.
- * **Buried jobs** - When a job causes an error, you can bury it which keeps it around for later debugging and inspection.
+ * **Fast** - Processes thousands of jobs per second; **significantly** [faster than alternatives](http://adam.heroku.com/past/2010/4/24/beanstalk_a_simple_and_fast_queueing_backend).
+ * **Priorities** - Specify priority so important jobs can be processed quickly.
+ * **Persistence** - Jobs are stored in memory for speed, but logged to disk for safe keeping.
+ * **Federation** - Horizontal scalability provided through federation by the client.
+ * **Error Handling** - Bury any job which causes an error for later debugging and inspection.
 
 Keep in mind that these features are supported out of the box with beanstalk and require no special code within this gem to support.
 In the end, **beanstalk is the ideal job queue** while also being ridiculously easy to install and setup.
@@ -82,7 +83,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.beanstalk_url = ["beanstalk://127.0.0.1", "beanstalk://127.0.0.1:11301"]
   config.tube_namespace = "some.app.production"
   config.on_error = lambda { |e| puts e }
   config.default_priority = 65536
@@ -90,6 +91,10 @@ Backburner.configure do |config|
 end
 ```
 
+The `beanstalk_url` supports a string such as 'beanstalk://127.0.0.1' or an array of addresses.
+The `tube_namespace` is the prefix used for all tubes related to this backburner queue.
+The `on_error` is a callback that gets invoked with the error whenever a job fails
+
 ## Usage
 
 Backburner allows you to create jobs and place them on a beanstalk queue, and later pull those jobs off the queue and
@@ -133,8 +138,8 @@ includes `Backburner::Performable`. Async enqueuing works for both instance and
 ```ruby
 class User
   include Backburner::Performable
-  queue "newsletter"  # defaults to 'newsletter-job'
-  queue_priority 1000 # most urgent priority is 0
+  queue "user-jobs"  # defaults to 'user'
+  queue_priority 500 # most urgent priority is 0
 
   def activate(device_id)
     @device = Device.find(device_id)
@@ -148,14 +153,15 @@ end
 
 # Async works for instance methods on a persisted model
 @user = User.first
-@user.async(:pri => 1000, :ttr => 100, :queue => "user.activate").activate(@device.id)
+@user.async(:ttr => 100, :queue => "activate").activate(@device.id)
 # ..as well as 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.
+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.
-Note you are able to pass `pri`, `ttr`, `delay` and `queue` directly as options into `async`.
 
 ### Working Jobs
 
@@ -196,8 +202,8 @@ This will daemonize the worker and store the pid and logs automatically.
 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. To access the list of known
-queue classes, you can use:
+When you execute a worker without queues specified, any queue for a known job queue class with `include Backburner::Queue` will be processed.
+To access the list of known queue classes, you can use:
 
 ```ruby
 Backburner::Worker.known_queue_classes
@@ -236,22 +242,28 @@ If a job fails in beanstalk, the job is automatically buried and must be 'kicked
 
 Right now, all logging happens to standard out and can be piped to a file or any other output manually. More on logging coming later.
 
-### Front-end
+### Web Front-end
 
-To be completed is an admin dashboard that provides insight into beanstalk jobs via a simple Sinatra front-end. Coming soon.
+Be sure to check out the Sinatra-powered project [beanstalkd_view](https://github.com/denniskuczynski/beanstalkd_view)
+by [denniskuczynski](http://github.com/denniskuczynski) which provides an excellent overview of the tubes and
+jobs processed by your beanstalk workers. An excellent addition to your Backburner setup.
 
 ### Workers in Production
 
 Once you have Backburner setup in your application, starting workers is really easy. Once [beanstalkd](http://kr.github.com/beanstalkd/download.html)
 is installed, your best bet is to use the built-in rake task that comes with Backburner. Simply add the task to your Rakefile:
 
-    # Rakefile
-    require 'backburner/tasks'
+```ruby
+# Rakefile
+require 'backburner/tasks'
+```
 
 and then you can start the rake task with:
 
-    $ rake backburner:work
-    $ QUEUES=newsletter-sender,push-message rake backburner:work
+```bash
+$ rake backburner:work
+$ QUEUES=newsletter-sender,push-message rake backburner:work
+```
 
 The best way to deploy these rake tasks is using a monitoring library. We suggest [God](https://github.com/mojombo/god/)
 which watches processes and ensures their stability. A simple God recipe for Backburner can be found in

data/backburner.gemspec

@@ -15,10 +15,10 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.version       = Backburner::VERSION
 
-  s.add_runtime_dependency 'beanstalk-client', '~> 1.1'
+  s.add_runtime_dependency 'beaneater', '~> 0.1.1'
   s.add_runtime_dependency 'dante', '~> 0.1.5'
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest', '~> 4.1.0'
   s.add_development_dependency 'mocha'
 end

data/lib/backburner.rb

@@ -1,4 +1,4 @@
-require 'beanstalk-client'
+require 'beaneater'
 require 'json'
 require 'uri'
 require 'timeout'

data/lib/backburner/connection.rb

@@ -6,6 +6,8 @@ module Backburner
 
     attr_accessor :url, :beanstalk
 
+    # Constructs a backburner connection
+    # `url` can be a string i.e 'localhost:3001' or an array of addresses.
     def initialize(url)
       @url = url
       connect!
@@ -22,7 +24,7 @@ module Backburner
 
     # Connects to a beanstalk queue
     def connect!
-      @beanstalk ||= Beanstalk::Pool.new(beanstalk_addresses)
+      @beanstalk ||= Beaneater::Pool.new(beanstalk_addresses)
     end
 
     # Returns the beanstalk queue addresses
@@ -31,8 +33,8 @@ module Backburner
     #   beanstalk_addresses => ["localhost:11300"]
     #
     def beanstalk_addresses
-      uris = self.url.split(/[\s,]+/)
-      uris.map {|uri| beanstalk_host_and_port(uri)}
+      uris = self.url.is_a?(Array) ? self.url : self.url.split(/[\s,]+/)
+      uris.map { |uri| beanstalk_host_and_port(uri) }
     end
 
     # Returns a host and port based on the uri_string given

data/lib/backburner/job.rb

@@ -19,7 +19,7 @@ module Backburner
     #
     def initialize(task)
       @task = task
-      @body = JSON.parse(task.body)
+      @body = task.body.is_a?(Hash) ? task.body : JSON.parse(task.body)
       @name, @args = body["class"], body["args"]
     end
 
@@ -46,12 +46,12 @@ module Backburner
     #   job_class # => NewsletterSender
     #
     def job_class
-      handler = constantize(name) rescue nil
-      raise(JobNotFound, name) unless handler
+      handler = constantize(self.name) rescue nil
+      raise(JobNotFound, self.name) unless handler
       handler
     end
 
-    # Timeout job after given time
+    # Timeout job within specified block after given time.
     #
     # @example
     #   timeout_job_after(3) { do_something! }

data/lib/backburner/version.rb

@@ -1,3 +1,3 @@
 module Backburner
-  VERSION = "0.0.3"
+  VERSION = "0.1.0"
 end

data/lib/backburner/worker.rb

@@ -15,7 +15,7 @@ module Backburner
     # Enqueues a job to be processed later by a worker
     # Options: `pri` (priority), `delay` (delay in secs), `ttr` (time to respond), `queue` (queue name)
     #
-    # @raise [Beanstalk::NotConnected] If beanstalk fails to connect.
+    # @raise [Beaneater::NotConnected] If beanstalk fails to connect.
     # @example
     #   Backburner::Worker.enqueue NewsletterSender, [self.id, user.id], :ttr => 1000
     #
@@ -23,9 +23,9 @@ module Backburner
       pri   = opts[:pri] || job_class.queue_priority || Backburner.configuration.default_priority
       delay = [0, opts[:delay].to_i].max
       ttr   = opts[:ttr] || Backburner.configuration.respond_timeout
-      connection.use expand_tube_name(opts[:queue]  || job_class)
+      tube  = connection.tubes[expand_tube_name(opts[:queue]  || job_class)]
       data = { :class => job_class.name, :args => args }
-      connection.put data.to_json, pri, delay, ttr
+      tube.put data.to_json, :pri => pri, :delay => delay, :ttr => ttr
     end
 
     # Starts processing jobs in the specified tube_names
@@ -39,7 +39,7 @@ module Backburner
 
     # Returns the worker connection
     # @example
-    #   Backburner::Worker.connection # => <Beanstalk::Pool>
+    #   Backburner::Worker.connection # => <Beaneater::Pool>
     def self.connection
       @connection ||= Connection.new(Backburner.configuration.beanstalk_url)
     end
@@ -72,7 +72,7 @@ module Backburner
     # Setup beanstalk tube_names and watch all specified tubes for jobs.
     # Used to prepare job queues before processing jobs.
     #
-    # @raise [Beanstalk::NotConnected] If beanstalk fails to connect.
+    # @raise [Beaneater::NotConnected] If beanstalk fails to connect.
     # @example
     #   @worker.prepare
     #
@@ -81,10 +81,7 @@ module Backburner
       self.tube_names = Array(self.tube_names)
       self.tube_names.map! { |name| expand_tube_name(name)  }
       log_info "Working #{tube_names.size} queues: [ #{tube_names.join(', ')} ]"
-      self.tube_names.uniq.each { |name| self.connection.watch(name) }
-      self.connection.list_tubes_watched.each do |server, tubes|
-        tubes.each { |tube| self.connection.ignore(tube) unless self.tube_names.include?(tube) }
-      end
+      self.connection.tubes.watch!(*self.tube_names)
     end
 
     # Reserves one job within the specified queues
@@ -95,7 +92,7 @@ module Backburner
     #   @worker.work_one_job
     #
     def work_one_job
-      job = Backburner::Job.new(self.connection.reserve)
+      job = Backburner::Job.new(self.connection.tubes.reserve)
       self.class.log_job_begin(job.body)
       job.process
       self.class.log_job_end(job.name)
@@ -112,7 +109,7 @@ module Backburner
     # Filtered for tubes that match the known prefix
     def all_existing_queues
       known_queues    = Backburner::Worker.known_queue_classes.map(&:queue)
-      existing_tubes  = self.connection.list_tubes.values.flatten.uniq.select { |tube| tube =~ /^#{tube_namespace}/ }
+      existing_tubes  = self.connection.tubes.all.map(&:name).select { |tube| tube =~ /^#{tube_namespace}/ }
       known_queues + existing_tubes
     end
 

data/test/connection_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../test_helper', __FILE__)
 
 describe "Backburner::Connection class" do
-  describe "for initialize" do
+  describe "for initialize with single url" do
     before do
       @connection = Backburner::Connection.new("beanstalk://localhost")
     end
@@ -11,7 +11,23 @@ describe "Backburner::Connection class" do
     end
 
     it "should setup beanstalk connection" do
-      assert_kind_of Beanstalk::Pool, @connection.beanstalk
+      assert_kind_of Beaneater::Pool, @connection.beanstalk
+    end
+  end # initialize single connection
+
+  describe "for initialize with multiple urls" do
+    it "should support single string with commas" do
+      @connection = Backburner::Connection.new("beanstalk://localhost,beanstalk://localhost")
+      connections = @connection.beanstalk.connections
+      assert_equal 2, connections.size
+      assert_equal ['localhost:11300','localhost:11300'], connections.map(&:address)
+    end
+
+    it "should support array of connections" do
+      @connection = Backburner::Connection.new(['beanstalk://127.0.0.1:11300','beanstalk://localhost'])
+      connections = @connection.beanstalk.connections
+      assert_equal 2, @connection.beanstalk.connections.size
+      assert_equal ['127.0.0.1:11300','localhost:11300'], connections.map(&:address)
     end
   end # initialize
 
@@ -29,7 +45,7 @@ describe "Backburner::Connection class" do
     end
 
     it "delegate methods to beanstalk connection" do
-      assert_equal "localhost:11300", @connection.list_tubes.keys.first
+      assert_equal "localhost", @connection.connections.first.host
     end
   end # delegator
 end # Connection

data/test/job_test.rb

@@ -13,9 +13,24 @@ module NestedDemo
 end
 
 describe "Backburner::Job module" do
-  describe "for initialize method" do
+  describe "for initialize method with hash" do
     before do
-      @task_body =  { :class => "NewsletterSender", :args => ["foo@bar.com", "bar@foo.com"] }
+      @task_body =  { "class" => "NewsletterSender", "args" => ["foo@bar.com", "bar@foo.com"] }
+      @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
+    end
+
+    it "should create job with correct task data" do
+      @job = Backburner::Job.new(@task)
+      assert_equal @task, @job.task
+      assert_equal ["class", "args"], @job.body.keys
+      assert_equal @task_body["class"], @job.name
+      assert_equal @task_body["args"], @job.args
+    end
+  end # initialize with json
+
+  describe "for initialize method with json string" do
+    before do
+      @task_body =  { "class" => "NewsletterSender", "args" => ["foo@bar.com", "bar@foo.com"] }
       @task = stub(:body => @task_body.to_json, :ttr => 120, :delete => true, :bury => true)
     end
 
@@ -23,16 +38,16 @@ describe "Backburner::Job module" do
       @job = Backburner::Job.new(@task)
       assert_equal @task, @job.task
       assert_equal ["class", "args"], @job.body.keys
-      assert_equal @task_body[:class], @job.name
-      assert_equal @task_body[:args], @job.args
+      assert_equal @task_body["class"], @job.name
+      assert_equal @task_body["args"], @job.args
     end
-  end # initialize
+  end # initialize with json
 
   describe "for process method" do
     describe "with valid task" do
       before do
-        @task_body =  { :class => "NestedDemo::TestJobC", :args => [56] }
-        @task = stub(:body => @task_body.to_json, :ttr => 120, :delete => true, :bury => true)
+        @task_body =  { "class" => "NestedDemo::TestJobC", "args" => [56] }
+        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
         @task.expects(:delete).once
       end
 
@@ -45,8 +60,8 @@ describe "Backburner::Job module" do
 
     describe "with invalid task" do
       before do
-        @task_body =  { :class => "NestedDemo::TestJobD", :args => [56] }
-        @task = stub(:body => @task_body.to_json, :ttr => 120, :delete => true, :bury => true)
+        @task_body =  { "class" => "NestedDemo::TestJobD", "args" => [56] }
+        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
         @task.expects(:delete).never
       end
 
@@ -58,8 +73,8 @@ describe "Backburner::Job module" do
 
     describe "with invalid class" do
       before do
-        @task_body =  { :class => "NestedDemo::TestJobY", :args => [56] }
-        @task = stub(:body => @task_body.to_json, :ttr => 120, :delete => true, :bury => true)
+        @task_body =  { "class" => "NestedDemo::TestJobY", "args" => [56] }
+        @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
         @task.expects(:delete).never
       end
 
@@ -72,8 +87,8 @@ describe "Backburner::Job module" do
 
   describe "for bury method" do
     before do
-      @task_body =  { :class => "NestedDemo::TestJobC", :args => [56] }
-      @task = stub(:body => @task_body.to_json, :ttr => 120, :delete => true, :bury => true)
+      @task_body =  { "class" => "NestedDemo::TestJobC", "args" => [56] }
+      @task = stub(:body => @task_body, :ttr => 120, :delete => true, :bury => true)
       @task.expects(:bury).once
     end
 

data/test/test_helper.rb

@@ -86,11 +86,8 @@ class MiniTest::Spec
   def pop_one_job(tube_name)
     connection = Backburner::Worker.connection
     tube_name = [Backburner.configuration.tube_namespace, tube_name].join(".")
-    connection.watch(tube_name)
-    connection.list_tubes_watched.each do |server, tubes|
-      tubes.each { |tube| connection.ignore(tube) unless tube == tube_name }
-    end
-    silenced(3) { @res = connection.reserve }
-    return @res, JSON.parse(@res.body)
+    connection.tubes.watch!(tube_name)
+    silenced(3) { @res = connection.tubes.reserve }
+    return @res, @res.body
   end
 end # MiniTest::Spec

data/test/worker_test.rb

@@ -63,7 +63,7 @@ describe "Backburner::Worker module" do
   describe "for connection class method" do
     it "should return the beanstalk connection" do
       assert_equal "beanstalk://localhost", Backburner::Worker.connection.url
-      assert_kind_of Beanstalk::Pool, Backburner::Worker.connection.beanstalk
+      assert_kind_of Beaneater::Pool, Backburner::Worker.connection.beanstalk
     end
   end # connection
 
@@ -104,7 +104,7 @@ describe "Backburner::Worker module" do
       worker = Backburner::Worker.new(["foo", "bar"])
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.foo", "demo.test.bar"], worker.tube_names
-      assert_same_elements ["demo.test.foo", "demo.test.bar"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], Backburner::Worker.connection.tubes.watched.map(&:name)
       assert_match /demo\.test\.foo/, out
     end # multiple
 
@@ -112,7 +112,7 @@ describe "Backburner::Worker module" do
       worker = Backburner::Worker.new("foo")
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.foo"], worker.tube_names
-      assert_same_elements ["demo.test.foo"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_same_elements ["demo.test.foo"], Backburner::Worker.connection.tubes.watched.map(&:name)
       assert_match /demo\.test\.foo/, out
     end # single
 
@@ -121,7 +121,7 @@ describe "Backburner::Worker module" do
       worker = Backburner::Worker.new
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.foo", "demo.test.bar"], worker.tube_names
-      assert_same_elements ["demo.test.foo", "demo.test.bar"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_same_elements ["demo.test.foo", "demo.test.bar"], Backburner::Worker.connection.tubes.watched.map(&:name)
       assert_match /demo\.test\.foo/, out
     end
 
@@ -130,7 +130,7 @@ describe "Backburner::Worker module" do
       worker = Backburner::Worker.new
       out = capture_stdout { worker.prepare }
       assert_equal ["demo.test.bar"], worker.tube_names
-      assert_same_elements ["demo.test.bar"], Backburner::Worker.connection.list_tubes_watched.values.first
+      assert_same_elements ["demo.test.bar"], Backburner::Worker.connection.tubes.watched.map(&:name)
       assert_match /demo\.test\.bar/, out
     end # all assign
 
@@ -138,7 +138,7 @@ describe "Backburner::Worker module" do
       worker = Backburner::Worker.new
       out = capture_stdout { worker.prepare }
       assert_contains worker.tube_names, "demo.test.test-job"
-      assert_contains Backburner::Worker.connection.list_tubes_watched.values.first, "demo.test.test-job"
+      assert_contains Backburner::Worker.connection.tubes.watched.map(&:name), "demo.test.test-job"
       assert_match /demo\.test\.test-job/, out
     end # all read
   end # prepare

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: backburner
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,27 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-28 00:00:00.000000000 Z
+date: 2012-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: beanstalk-client
-  requirement: &2152606520 !ruby/object:Gem::Requirement
+  name: beaneater
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: 0.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *2152606520
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: dante
-  requirement: &2152605920 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +37,15 @@ dependencies:
         version: 0.1.5
   type: :runtime
   prerelease: false
-  version_requirements: *2152605920
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.5
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152605440 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,21 +53,31 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152605440
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: &2152604860 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
   type: :development
   prerelease: false
-  version_requirements: *2152604860
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.0
 - !ruby/object:Gem::Dependency
   name: mocha
-  requirement: &2152604240 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +85,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152604240
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Beanstalk background job processing made easy
 email:
 - nesquena@gmail.com
@@ -76,6 +101,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -128,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Reliable beanstalk background job processing made easy for Ruby and Sinatra