job_queue 0.0.9

data/README.markdown

@@ -0,0 +1,58 @@
+JobQueue
+========
+
+`job_queue` allows you to use lots of message queues with exactly the same interface so you don't need to worry about which queue to pick :)
+
+This should get you started:
+
+    require 'rubygems'
+    require 'job_queue'
+
+Before you can do anything you must specify an adapter to use
+
+    JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+
+Jobs can then be simply added to the queue
+
+    JobQueue.put("flubble bubble")
+    
+In your workers you'll want to subscribe to a queue
+
+    JobQueue.subscribe do |job|
+      puts job
+    end
+
+This subscribe block takes care of waiting for the next job to arrive and the block is passed exactly what you passed in. If you want to exit the loop just throw :stop.
+
+    JobQueue.subscribe do |job|
+      # Wait - I changed my mind!
+      throw :stop
+    end
+
+What should you put on the queue
+--------------------------------
+
+You might love Ruby right now, but why lock yourself in? Often the kinds of things you use queues for are the kind of things you'll want to optimize. This is a good place to start:
+
+    JSON.generate({:some => "hash"})
+    JSON.parse(job)
+
+Can you show me a nice processing daemon?
+-----------------------------------------
+
+Yes. Just a minute...
+
+Adapters
+========
+
+Take your pick! Right now we have:
+
+Beanstalk
+---------
+<http://xph.us/software/beanstalkd/>
+
+AMQP
+----
+<http://github.com/tmm1/amqp/>
+
+You need to run all your code within an eventmachine loop to use AMQP.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 9
+:major: 0
+:minor: 0

data/lib/job_queue/adapters/amqp_adapter.rb

@@ -0,0 +1,28 @@
+require 'mq'
+
+class JobQueue::AMQPAdapter
+  def initialize(options = {})
+    amq = MQ.new
+    @exchange = amq.direct('photo', :durable => true)
+    @queue = amq.queue('photo_worker', :durable => true)
+    @queue.bind(@exchange)
+  end
+  
+  def put(string)
+    @queue.publish(string, :persistent => true)
+  end
+  
+  def subscribe(error_report, &block)
+    EM.add_periodic_timer(0) do
+      begin
+        @queue.pop do |header, body| 
+          next unless body
+          JobQueue.logger.debug "AMQP received #{body}"
+          yield body
+        end
+      rescue => e
+        error_report.call(job.body, e)
+      end
+    end
+  end
+end

data/lib/job_queue/adapters/beanstalk_adapter.rb

@@ -0,0 +1,106 @@
+require 'beanstalk-client'
+require 'timeout'
+
+class JobQueue::BeanstalkAdapter
+  def initialize(options = {})
+    @hosts = options[:hosts] || 'localhost:11300'
+  end
+
+  def put(string, queue, priority, ttr)
+    ttr = ttr.floor #rounding because Beanstalk doesnt accept float numbers
+    raise JobQueue::ArgumentError, "TTR must be greater than 1" if ttr < 2
+
+    delay = 0
+    job_info = beanstalk_pool(queue).put_and_report_conn \
+      string, priority, delay, ttr
+    "#{job_info[:host]}_#{job_info[:id]}"
+  rescue Beanstalk::NotConnected
+    raise JobQueue::NoConnectionAvailable
+  end
+
+  def subscribe(error_report, cleanup_task, queue, &block)
+    pool = BeanstalkPoolFix.new([@hosts].flatten, queue)
+    loop do
+      begin
+        job = pool.reserve(1)
+        time_left = job.stats["time-left"]
+        JobQueue.logger.debug "Beanstalk received #{job.body}"
+        Timeout::timeout([time_left - 1, 1].max) do
+          yield job.body
+        end
+        job.delete
+      rescue Timeout::Error
+        cleanup_task.call(job.body)
+        JobQueue.logger.warn "Job timed out"
+        begin
+          job.delete
+        rescue Beanstalk::NotFoundError
+          JobQueue.logger.error "Job timed out and could not be deleted"
+        end
+      rescue Beanstalk::TimedOut
+        # Do nothing - retry to reseve (from another host?)
+      rescue => e
+        if job
+          error_report.call(job.body, e)
+          begin
+            job.delete
+          rescue Beanstalk::NotFoundError
+            JobQueue.logger.error "Job failed but could not be deleted"
+          end
+        else
+          JobQueue.logger.error "Unhandled exception: #{e.message}\n" \
+            "#{e.backtrace.join("\n")}\n"
+        end
+      end
+    end
+  end
+
+  def job_stats(job_id)
+    host, id = job_id.split('_')
+    beanstalk_pool.job_stats(id).select { |k, v| k == host }[0][1]
+  rescue Beanstalk::NotFoundError
+    nil
+  end
+
+  def queue_length(queue)
+    beanstalk_pool.stats_tube(queue)["total-jobs"]
+  rescue Beanstalk::NotFoundError
+    0
+  end
+
+  def beanstalk_pool(queue='default')
+    @beanstalk_pools ||= {}
+    @beanstalk_pools[queue] ||= begin
+      BeanstalkPoolFix.new([@hosts].flatten, queue)
+    end
+  end
+
+  class BeanstalkPoolFix < Beanstalk::Pool
+    def put_and_report_conn(body, pri=65536, delay=0, ttr=120)
+      send_to_rand_conn_and_report(:put, body, pri, delay, ttr)
+    end
+
+    def send_to_rand_conn_and_report(*args)
+      connect()
+      retry_wrap{
+        conn = pick_connection
+        {:host => conn.addr, :id => call_wrap(conn, *args)}
+      }
+    end
+
+    def job_stats(id)
+      make_hash(send_to_all_conns(:job_stats, id))
+    end
+
+    private
+
+    def call_wrap(c, *args)
+      self.last_conn = c
+      c.send(*args)
+    rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Beanstalk::UnexpectedResponse => ex
+      # puts "Beanstalk exception: #{ex.class}" # Useful for debugging
+      self.remove(c) unless ex.class == Beanstalk::TimedOut
+      raise ex
+    end
+  end
+end

data/lib/job_queue/adapters/test_adapter.rb

@@ -0,0 +1,53 @@
+# This adapter is designed for testing purposes.
+#
+# Features supported:
+#
+# named queues: yes
+# priority: no
+# ttr: no
+#
+# Additionally this queue can be inspeced with JobQueue.adapter.queue('name')
+#
+class JobQueue::TestAdapter
+  def initialize(options = {})
+    @queues = {}
+  end
+
+  def put(string, queue, priority, ttr)
+    @queues[queue] ||= []
+    @queues[queue] << string
+  end
+
+  def subscribe(error_report, cleanup_task, queue, &block)
+    loop do
+      begin
+        if get_queue(queue).empty?
+          sleep 0.1
+        else
+          job = get_queue(queue).shift
+          yield job
+        end
+      rescue => e
+        error_report.call(job, e)
+      end
+    end
+  end
+
+  # Additional method for TestAdapter to allow easy queue inspection with
+  #
+  # JobQueue.adapter.queue('foo')
+  #
+  def queue(queue = 'default')
+    get_queue(queue)
+  end
+
+  def queue_length(queue)
+    @queues[queue].size
+  end
+
+  private
+
+  def get_queue(queue)
+    @queues[queue] || []
+  end
+end

data/lib/job_queue/adapters/verbose_adapter.rb

@@ -0,0 +1,23 @@
+# This isn't a queue at all, it just writes to standard output.
+# 
+# It might be useful for testing.
+# 
+class JobQueue::VerboseAdapter
+  def initialize(options = {})
+    
+  end
+  
+  def put(string, queue, priority, ttr)
+    JobQueue.logger.debug "===== NEW JOB ADDED TO QUEUE ===="
+    JobQueue.logger.debug string
+    JobQueue.logger.debug "===== END OF MESSAGE ============"
+  end
+  
+  def subscribe(error_report, &block)
+    raise "Not implemented. Use a better adapter!!"
+  end
+
+  def queue_length(queue)
+    raise "Not supported"
+  end
+end

data/lib/job_queue/job_queue.rb

@@ -0,0 +1,71 @@
+# JobQueue abstracts the task of adding work to a queue.
+# 
+# Beanstalk is fantastic, but maybe not "enterprise grade".
+# 
+# AMQP is fantastic, but it's bloody complex and has to run inside an
+# eventmachine loop.
+# 
+# Take your pick!
+# 
+# Before use, an adapter must be chosen:
+# 
+#   JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+# 
+# Jobs can then be simply added to the queue with
+# 
+#   JobQueue.put("flubble bubble")
+# 
+class JobQueue
+  class << self
+    attr_accessor :adapter
+    attr_accessor :logger
+    
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDOUT)
+        logger.level = Logger::WARN
+        logger.debug("Created logger")
+        logger
+      end
+    end
+  end
+
+  def self.put(string, options = {})
+    queue = options[:queue] || 'default'
+    priority = options[:priority] || 50
+    ttr = options[:ttr] || 60
+    adapter.put(string, queue, priority, ttr)
+  end
+
+  def self.subscribe(options = {}, &block)
+    queue = options[:queue] || 'default'
+    error_report = options[:error_report] || Proc.new do |job_body, e|
+      JobQueue.logger.error \
+        "Job failed\n" \
+        "==========\n" \
+        "Job content: #{job_body.inspect}\n" \
+        "Exception: #{e.message}\n" \
+        "#{e.backtrace.join("\n")}\n" \
+        "\n"
+    end
+    cleanup_task = options[:cleanup] || lambda {}
+    catch :stop do
+      adapter.subscribe(error_report, cleanup_task, queue, &block)
+    end
+  end
+
+  # Returns a hash of info (exact details dependent on adapter)
+  def self.job_stats(job_id)
+    adapter.job_stats(job_id)
+  end
+
+  def self.queue_length(queue = nil)
+    adapter.queue_length(queue)
+  end
+
+  class NoConnectionAvailable < RuntimeError
+  end
+
+  class ArgumentError < ::ArgumentError
+  end
+end

data/lib/job_queue.rb

@@ -0,0 +1,7 @@
+require 'logger'
+require 'job_queue/job_queue'
+
+JobQueue.autoload 'AMQPAdapter', 'job_queue/adapters/amqp_adapter'
+JobQueue.autoload 'BeanstalkAdapter', 'job_queue/adapters/beanstalk_adapter'
+JobQueue.autoload 'TestAdapter', 'job_queue/adapters/test_adapter'
+JobQueue.autoload 'VerboseAdapter', 'job_queue/adapters/verbose_adapter'

data/spec/amqp_adapter_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe JobQueue::AMQPAdapter do
+  
+  it "should write onto queue and fetch stuff back off" do
+    pending "need to figure out a nice way of running rspec inside EM block"
+  end
+end

data/spec/beanstalk_adapter_spec.rb

@@ -0,0 +1,322 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/common_adapter_spec'
+
+describe JobQueue::BeanstalkAdapter do
+  before :each do
+    # On OSX we the -d flag doesn't work for beanstalk 1.3. This is a
+    # workaround for that issue. We sleep a little to let processes start.
+    system "beanstalkd -p 10001 &"
+    system "beanstalkd -p 10002 &"
+    system "beanstalkd -p 11300 &"
+    sleep 0.1
+  end
+
+  after :each do
+    system "killall beanstalkd"
+  end
+
+  describe '#new' do
+    before(:each) do
+      @pool = JobQueue::BeanstalkAdapter::BeanstalkPoolFix.new([
+        'localhost:11300'
+      ])
+    end
+
+    it "should default to localhost:11300" do
+      JobQueue::BeanstalkAdapter::BeanstalkPoolFix.should_receive(:new).with(
+        ['localhost:11300'],
+        "default"
+      ).and_return @pool
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+      JobQueue.put('test')
+    end
+
+    it "should accept one beanstalk instance" do
+      JobQueue::BeanstalkAdapter::BeanstalkPoolFix.should_receive(:new).with(
+        ['12.34.56.78:12345'],
+        'default'
+      ).and_return(@pool)
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new(
+        :hosts => '12.34.56.78:12345'
+      )
+      JobQueue.put('test')
+    end
+
+    it "should allow multiple beanstalk instances" do
+      JobQueue::BeanstalkAdapter::BeanstalkPoolFix.should_receive(:new).with(
+        ['12.34.56.78:12345', '87.65.43.21:54321'],
+        'default'
+      ).and_return(@pool)
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new({
+        :hosts => ['12.34.56.78:12345', '87.65.43.21:54321']
+      })
+      JobQueue.put('test')
+    end
+  end
+
+  describe "put" do
+    before :each do
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+    end
+
+    it "should return the job id" do
+      job_id = JobQueue.put("hello 1")
+      job_id.should == "localhost:11300_1"
+    end
+
+    it "should assign job priority" do
+      jobs = ["1","2","3"]
+      JobQueue.put(jobs[2], :priority => 3)
+      JobQueue.put(jobs[1], :priority => 2)
+      JobQueue.put(jobs[0], :priority => 1)
+
+      jobs_received = []
+      should_not_timeout(0.5) {
+        index = 0
+        JobQueue.subscribe do |job_body|
+          index += 1
+          jobs_received << job_body
+          throw :stop if index == 3
+        end
+      }
+
+      jobs_received.should == jobs
+    end
+
+    it "should be able to retrieve job stats by id" do
+      job_id = JobQueue.put("hello 1")
+      job_id.should == "localhost:11300_1"
+      JobQueue.put("hello 2")
+      stats = JobQueue.job_stats("localhost:11300_1")
+
+      stats["id"].should == 1
+      stats["tube"].should == "default"
+    end
+
+    it "should raise error when no connections exist" do
+      system "killall beanstalkd"
+      lambda {
+        JobQueue.put('test')
+      }.should raise_error(JobQueue::NoConnectionAvailable)
+    end
+
+    it "should succeed when one connection fails" do
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new({
+        :hosts => ['localhost:10001', 'localhost:666']
+      })
+      10.times{ job_id = JobQueue.put("hello 1")}
+    end
+
+    it "should raise an error if a ttr of < 2 is specified" do
+      lambda {
+        JobQueue.put('test', :ttr => 1.9)
+      }.should raise_error(JobQueue::ArgumentError)
+
+      lambda {
+        JobQueue.put('test', :ttr => 2)
+      }.should_not raise_error(JobQueue::ArgumentError)
+    end
+  end
+
+  describe "subscribe" do
+    before :each do
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+    end
+
+    it "should delete a job once it has been succesfully excecuted" do
+      job_id = JobQueue.put('testdeleted')
+      JobQueue.put('foo')
+      index = 0
+      JobQueue.subscribe do |body|
+        index += 1
+        throw :stop if index == 2
+      end
+      JobQueue.job_stats(job_id).should be_nil
+    end
+
+    it "should report and error and delete the job if a job times out" do
+      job_id = JobQueue.put("job1", :ttr => 2)
+      JobQueue.put('test')
+
+      JobQueue.logger.should_receive(:warn).with("Job timed out")
+
+      index = 0
+      JobQueue.subscribe do |body|
+        index += 1
+        throw :stop if index == 2
+        sleep 2.2
+      end
+
+      JobQueue.job_stats(job_id).should be_nil
+    end
+
+    it "should allow a client to cleanup if a job times out" do
+      JobQueue.put('jobcleanup', :ttr => 2)
+      JobQueue.put('test')
+
+      cleanup = nil
+
+      index = 0
+      JobQueue.subscribe(:cleanup => lambda { |job| FileUtils.rm(job) }) do |body|
+        file = File.open(body, 'w')
+        file << "hello"
+        file.flush
+
+        index += 1
+        throw :stop if index == 2
+        sleep 2.2
+      end
+
+      File.exists?('jobcleanup').should be_false
+    end
+
+    # This test is for a patch that fixes a connection leaking issue in
+    # beanstalk-client 1.0.2
+    it "should not open more connections to beanstalk over time" do
+      # Every 1.5 seconds, add a new job to the queue and check how many
+      # connections are currently open according to beanstalkd.
+      connections = []
+      Thread.new do
+        pool = Beanstalk::Pool.new(["localhost:11300"])
+        loop do
+          sleep 1.5
+          JobQueue.put("job")
+          connections << pool.stats["total-connections"]
+        end
+      end
+
+      # Subscribe for 3 loops - gives time for a few timeouts to occur (1s)
+      i = 0
+      JobQueue.subscribe do |job|
+        i += 1
+        throw :stop if i == 3
+      end
+
+      # The number of connections should have been constant
+      connections.uniq.size.should == 1
+    end
+  end
+
+  describe "job_stats" do
+    before :each do
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+    end
+
+    it "should gracefully deal with jobs where connection no longer exists" do
+      JobQueue.job_stats("localhost:11305_1").should be_nil
+    end
+
+    it "should gracefully deal with jobs where job doesn't exist" do
+      JobQueue.job_stats("localhost:11300_1").should be_nil
+    end
+  end
+
+  describe "when connecting to one instance" do
+    before :each do
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new
+    end
+
+    describe "common" do
+      it_should_behave_like "JobQueue adapter named queues"
+      it_should_behave_like "JobQueue adapter queue length"
+    end
+
+    it "should write onto queue and fetch stuff back off" do
+      JobQueue.put("hello")
+
+      should_not_timeout {
+        JobQueue.subscribe do |job|
+          @job = job
+          throw :stop
+        end
+      }
+
+      @job.should == "hello"
+    end
+
+    it "should output message if error raised in job" do
+      JobQueue.put("hello")
+      JobQueue.put("hello2")
+
+      JobQueue.logger.should_receive(:error).with(/Job failed\w*/)
+
+      should_not_timeout {
+        index = 0
+        JobQueue.subscribe do |job|
+          index +=1
+          raise 'foo' if index == 1
+          throw :stop
+        end
+      }
+    end
+
+    it "should use error_report block if supplied" do
+      JobQueue.put("hello")
+      JobQueue.put("hello2")
+
+      error_report = Proc.new do |job, e|
+        JobQueue.logger.error "Yikes that broke matey!"
+      end
+
+      JobQueue.logger.should_receive(:error).with("Yikes that broke matey!")
+
+      should_not_timeout {
+        index = 0
+        JobQueue.subscribe(:error_report => error_report) do |job|
+          index +=1
+          raise 'foo' if index == 1
+          throw :stop
+        end
+      }
+    end
+  end
+
+  describe "when connecting to multiple instances" do
+    before :each do
+      JobQueue.adapter = JobQueue::BeanstalkAdapter.new({
+        :hosts => ['localhost:10001', 'localhost:10002']
+      })
+    end
+
+    describe "common" do
+      it_should_behave_like "JobQueue adapter queue length"
+    end
+
+    it "should be possible to put jobs" do
+      JobQueue.put('test')
+      JobQueue.subscribe do |job|
+        job.should == 'test'
+        throw :stop
+      end
+    end
+
+    # TODO: This test is brittle.
+    it "should be possible to retrieve all jobs supplied" do
+      # Put some jobs on the queue
+      jobs = []
+      (1..8).each do |i|
+        body = i
+        JobQueue.put("#{body}")
+        jobs << body
+      end
+
+      should_not_timeout(3.5) {
+        JobQueue.subscribe do |job|
+          jobs.delete job.to_i
+          throw :stop if jobs.empty?
+        end
+      }
+    end
+
+    it "should not log any errors when reserve times out" do
+      JobQueue.logger.should_not_receive(:error)
+      begin
+        Timeout::timeout(1.5) do
+          JobQueue.subscribe { |job| }
+        end
+      rescue Timeout::Error
+        #Do nothing - timeout expected
+      end
+    end
+  end
+end

data/spec/common_adapter_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+shared_examples_for 'JobQueue adapter basic' do
+  it "should write onto queue and fetch stuff back off" do
+    JobQueue.put("hello")
+
+    JobQueue.subscribe do |job|
+      @job = job
+      throw :stop
+    end
+
+    @job.should == "hello"
+  end
+
+  it "should pull items off in the order the were added" do
+    JobQueue.put("foo")
+    JobQueue.put("bar")
+
+    retrieved_jobs = []
+
+    begin
+      Timeout::timeout(0.5) do
+        JobQueue.subscribe do |job|
+          retrieved_jobs << job
+        end
+      end
+    rescue Timeout::Error
+
+    end
+
+    retrieved_jobs[0].should == "foo"
+    retrieved_jobs[1].should == "bar"
+    retrieved_jobs[2].should == nil
+  end
+end
+
+shared_examples_for "JobQueue adapter named queues" do
+  it "should put jobs onto a named queue and only read off that queue" do
+    JobQueue.put("hello", :queue => "test")
+    lambda {
+      Timeout.timeout(0.1) do
+        JobQueue.subscribe(:queue => "foo") do |job|
+          throw :stop
+        end
+      end
+    }.should raise_error(Timeout::Error)
+    should_not_timeout {
+      JobQueue.subscribe(:queue => "test") do |body|
+        body.should == 'hello'
+        throw :stop
+      end
+    }
+  end
+end
+
+shared_examples_for "JobQueue adapter queue length" do
+  it "should report the length of the named queue" do
+    JobQueue.queue_length('test').should == 0
+    5.times { JobQueue.put("hello", :queue => "test") }
+    JobQueue.queue_length('test').should == 5
+  end
+end

data/spec/job_queue_spec.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe JobQueue do
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'job_queue'
+
+def should_not_timeout(timeout = 0.1)
+  lambda {
+    Timeout.timeout(timeout) do
+      yield
+    end
+  }.should_not raise_error(Timeout::Error)
+end

data/spec/test_adapter_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/common_adapter_spec'
+
+describe JobQueue::TestAdapter do
+  before :all do
+    JobQueue.adapter = JobQueue::TestAdapter.new
+  end
+  
+  it_should_behave_like 'JobQueue adapter basic'
+  
+  it_should_behave_like "JobQueue adapter named queues"
+  
+  it_should_behave_like "JobQueue adapter queue length"
+
+  it "should allow queue inspection as a hash" do
+    JobQueue.adapter.queue.should == []
+    JobQueue.put('hello')
+    JobQueue.adapter.queue.should == ['hello']
+  end
+end

data/spec/verbose_adapter_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe JobQueue::VerboseAdapter do
+  before :all do
+    JobQueue.adapter = JobQueue::VerboseAdapter.new
+  end
+  
+  it "should write onto queue and output a very verbose message to stdout" do
+    JobQueue.logger.should_receive(:debug).with("===== NEW JOB ADDED TO QUEUE ====")
+    JobQueue.logger.should_receive(:debug).with("hello")
+    JobQueue.logger.should_receive(:debug).with("===== END OF MESSAGE ============")
+    
+    JobQueue.put("hello")
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: job_queue
+version: !ruby/object:Gem::Version 
+  version: 0.0.9
+platform: ruby
+authors: 
+- Martyn Loughran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-26 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: JobQueue means you don't have to worry about your queue any more!
+email: me@mloughran.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.markdown
+- VERSION.yml
+- lib/job_queue/adapters/amqp_adapter.rb
+- lib/job_queue/adapters/beanstalk_adapter.rb
+- lib/job_queue/adapters/test_adapter.rb
+- lib/job_queue/adapters/verbose_adapter.rb
+- lib/job_queue/job_queue.rb
+- lib/job_queue.rb
+- spec/amqp_adapter_spec.rb
+- spec/beanstalk_adapter_spec.rb
+- spec/common_adapter_spec.rb
+- spec/job_queue_spec.rb
+- spec/spec_helper.rb
+- spec/test_adapter_spec.rb
+- spec/verbose_adapter_spec.rb
+has_rdoc: true
+homepage: http://github.com/mloughran/job_queue
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: JobQueue means you don't have to worry about your queue any more!
+test_files: []
+