que 0.0.1 → 0.1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: que
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-07 00:00:00.000000000 Z
+date: 2013-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,7 +73,21 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -87,14 +101,28 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Durable job queueing with PostgreSQL.
+description: A job queue that uses PostgreSQL's advisory locks for speed and reliability.
 email:
 - christopher.m.hanks@gmail.com
 executables: []
@@ -107,17 +135,37 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/generators/que/install_generator.rb
+- lib/generators/que/templates/add_que.rb
 - lib/que.rb
+- lib/que/adapters/active_record.rb
+- lib/que/adapters/base.rb
+- lib/que/adapters/connection_pool.rb
+- lib/que/adapters/pg.rb
+- lib/que/adapters/sequel.rb
 - lib/que/job.rb
+- lib/que/railtie.rb
+- lib/que/rake_tasks.rb
+- lib/que/sql.rb
 - lib/que/version.rb
 - lib/que/worker.rb
 - que.gemspec
+- spec/adapters/active_record_spec.rb
+- spec/adapters/connection_pool_spec.rb
+- spec/adapters/pg_spec.rb
+- spec/adapters/sequel_spec.rb
+- spec/connection_spec.rb
+- spec/helper_spec.rb
+- spec/pool_spec.rb
+- spec/queue_spec.rb
 - spec/spec_helper.rb
-- spec/unit/error_spec.rb
-- spec/unit/queue_spec.rb
-- spec/unit/work_spec.rb
-- spec/unit/worker_spec.rb
-homepage: ''
+- spec/support/helpers.rb
+- spec/support/jobs.rb
+- spec/support/shared_examples/adapter.rb
+- spec/support/shared_examples/multithreaded_adapter.rb
+- spec/work_spec.rb
+- spec/worker_spec.rb
+homepage: https://github.com/chanks/que
 licenses:
 - MIT
 metadata: {}
@@ -140,10 +188,20 @@ rubyforge_project:
 rubygems_version: 2.1.9
 signing_key: 
 specification_version: 4
-summary: Durable, efficient job queueing with PostgreSQL.
+summary: A PostgreSQL-based Job Queue
 test_files:
+- spec/adapters/active_record_spec.rb
+- spec/adapters/connection_pool_spec.rb
+- spec/adapters/pg_spec.rb
+- spec/adapters/sequel_spec.rb
+- spec/connection_spec.rb
+- spec/helper_spec.rb
+- spec/pool_spec.rb
+- spec/queue_spec.rb
 - spec/spec_helper.rb
-- spec/unit/error_spec.rb
-- spec/unit/queue_spec.rb
-- spec/unit/work_spec.rb
-- spec/unit/worker_spec.rb
+- spec/support/helpers.rb
+- spec/support/jobs.rb
+- spec/support/shared_examples/adapter.rb
+- spec/support/shared_examples/multithreaded_adapter.rb
+- spec/work_spec.rb
+- spec/worker_spec.rb

data/spec/unit/error_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe "Que::Job error handling" do
-  class ErrorJob < Que::Job
-    def perform(*args)
-      raise "Boo!"
-    end
-  end
-
-  it "should increment the error_count, persist the error message and reschedule the job" do
-    ErrorJob.queue
-
-    proc { Que::Job.work }.should raise_error RuntimeError, "Boo!"
-    Que::Job.count.should be 1
-
-    job = Que::Job.first
-    data = JSON.load(job.data)
-    data['error_count'].should be 1
-    data['error_message'].should =~ /Boo!/
-    job.run_at.should be_within(1).of Time.now + 4
-  end
-
-  it "should reschedule jobs with exponentially increasing times" do
-    ErrorJob.queue
-    Que::Job.dataset.update :data => JSON.dump(:error_count => 5)
-
-    proc { Que::Job.work }.should raise_error RuntimeError, "Boo!"
-    Que::Job.count.should be 1
-
-    job = Que::Job.first
-    data = JSON.load(job.data)
-    data['error_count'].should be 6
-    data['error_message'].should =~ /Boo!/
-    job.run_at.should be_within(1).of Time.now + 1299
-  end
-
-  it "should handle errors from jobs that cannot be deserialized" do
-    DB[:jobs].insert :type => 'NonexistentJob', :priority => 1
-    proc { Que::Job.work }.should raise_error NameError, /uninitialized constant NonexistentJob/
-
-    job = DB[:jobs].first
-    JSON.load(job[:data])['error_count'].should be 1
-    job[:run_at].should be_within(1).of Time.now + 4
-  end
-end

data/spec/unit/queue_spec.rb

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe "Que::Job.queue" do
-  it "should create a job in the DB" do
-    Que::Job.queue :param1 => 4, :param2 => 'ferret', :param3 => false
-    Que::Job.count.should == 1
-
-    job = Que::Job.first
-    job.type.should == 'Que::Job'
-    job.run_at.should be_within(1).of Time.now
-    job.priority.should be 5 # Defaults to lowest priority.
-    JSON.load(job.args).should == [{'param1' => 4, 'param2' => 'ferret', 'param3' => false}]
-  end
-
-  it "should accept a :run_at argument" do
-    time = Time.at(Time.now.to_i)
-    Que::Job.queue :user_id => 4, :test_number => 8, :run_at => time
-
-    Que::Job.count.should == 1
-    job = Que::Job.first
-    job.type.should == 'Que::Job'
-    job.run_at.should == time
-    job.priority.should == 5
-    JSON.load(job.args).should == [{'user_id' => 4, 'test_number' => 8}]
-  end
-
-  it "should accept a :priority argument" do
-    Que::Job.queue :user_id => 4, :test_number => 8, :priority => 1
-
-    Que::Job.count.should == 1
-    job = Que::Job.first
-    job.type.should == 'Que::Job'
-    job.run_at.should be_within(1).of Time.now
-    job.priority.should be 1
-    JSON.load(job.args).should == [{'user_id' => 4, 'test_number' => 8}]
-  end
-
-  it "should respect a default_priority for the class" do
-    class TestPriorityJob < Que::Job
-      @default_priority = 2
-    end
-
-    TestPriorityJob.queue :user_id => 4, :test_number => 8
-
-    Que::Job.count.should == 1
-    job = Que::Job.first
-    job.type.should == 'TestPriorityJob'
-    job.run_at.should be_within(1).of Time.now
-    job.priority.should be 2
-    JSON.load(job.args).should == [{'user_id' => 4, 'test_number' => 8}]
-  end
-
-  it "should let a :priority option override a default_priority for the class" do
-    class OtherTestPriorityJob < Que::Job
-      @default_priority = 2
-    end
-
-    OtherTestPriorityJob.queue :user_id => 4, :test_number => 8, :priority => 4
-
-    Que::Job.count.should == 1
-    job = Que::Job.first
-    job.type.should == 'OtherTestPriorityJob'
-    job.run_at.should be_within(1).of Time.now
-    job.priority.should be 4
-    JSON.load(job.args).should == [{'user_id' => 4, 'test_number' => 8}]
-  end
-end

data/spec/unit/work_spec.rb

@@ -1,168 +0,0 @@
-require 'spec_helper'
-
-describe "Que::Job.work" do
-  it "should automatically delete jobs from the database's queue" do
-    Que::Job.count.should be 0
-    Que::Job.queue
-    Que::Job.count.should be 1
-    Que::Job.work
-    Que::Job.count.should be 0
-  end
-
-  it "should pass a job's arguments to its perform method" do
-    class JobWorkTest < Que::Job
-      def perform(*args)
-        $passed_args = args
-      end
-    end
-
-    JobWorkTest.queue 5, 'ferret', :lazy => true
-
-    Que::Job.work
-    $passed_args.should == [5, 'ferret', {'lazy' => true}]
-  end
-
-  it "should prefer a job with higher priority" do
-    Que::Job.queue
-    Que::Job.queue :priority => 1
-
-    Que::Job.select_order_map(:priority).should == [1, 5]
-    Que::Job.work
-    Que::Job.select_order_map(:priority).should == [5]
-  end
-
-  it "should prefer a job that was scheduled to run longer ago" do
-    now  = Time.at(Time.now.to_i) # Prevent rounding errors by rounding to the nearest second.
-    recently = now - 60
-    long_ago = now - 61
-
-    Que::Job.queue :run_at => recently
-    Que::Job.queue :run_at => long_ago
-
-    Que::Job.select_order_map(:run_at).should == [long_ago, recently]
-    Que::Job.work
-    Que::Job.select_order_map(:run_at).should == [recently]
-  end
-
-  it "should only work a job whose run_at has already passed" do
-    now  = Time.at(Time.now.to_i) # Prevent rounding errors by rounding to the nearest second.
-    past = now - 60
-    soon = now + 60
-
-    Que::Job.queue :run_at => past
-    Que::Job.queue :run_at => soon
-
-    Que::Job.select_order_map(:run_at).should == [past, soon]
-    Que::Job.work
-    Que::Job.select_order_map(:run_at).should == [soon]
-    Que::Job.work
-    Que::Job.select_order_map(:run_at).should == [soon]
-  end
-
-  it "should prefer a job that was scheduled earlier, and therefore has a lower job_id" do
-    time = Time.now - 60
-    Que::Job.queue :run_at => time
-    Que::Job.queue :run_at => time
-
-    a, b = Que::Job.select_order_map(:job_id)
-    Que::Job.work
-    Que::Job.select_order_map(:job_id).should == [b]
-  end
-
-  it "should lock the job it selects" do
-    $q1, $q2 = Queue.new, Queue.new
-
-    class LockJob < Que::Job
-      def perform(*args)
-        $q1.push nil
-        $q2.pop
-      end
-    end
-
-    job = LockJob.queue
-    @thread = Thread.new { Que::Job.work }
-
-    # Wait until job is being worked.
-    $q1.pop
-
-    # Job should be advisory-locked...
-    DB.select{pg_try_advisory_lock(job.job_id)}.single_value.should be false
-
-    # ...and Job.work should ignore advisory-locked jobs.
-    Que::Job.work.should be nil
-
-    # Let LockJob finish.
-    $q2.push nil
-
-    # Make sure there aren't any errors.
-    @thread.join
-  end
-
-  it "that raises a Que::Job::Retry should abort the job, leaving it to be retried" do
-    class RetryJob < Que::Job
-      def perform(*args)
-        raise Que::Job::Retry
-      end
-    end
-
-    job = RetryJob.queue
-    Que::Job.count.should be 1
-    Que::Job.work
-    Que::Job.count.should be 1
-
-    same_job = Que::Job.first
-    same_job.job_id.should == job.job_id
-    same_job.run_at.should == job.run_at
-    same_job.data['error_count'].should be nil
-  end
-
-  it "should handle subclasses of other jobs" do
-    $class_job_array = []
-
-    class ClassJob < Que::Job
-      def perform(*args)
-        $class_job_array << 2
-      end
-    end
-
-    class SubclassJob < ClassJob
-      def perform(*args)
-        $class_job_array << 1
-        super
-      end
-    end
-
-    SubclassJob.queue
-    Que::Job.get(:type).should == 'SubclassJob'
-    Que::Job.work
-    $class_job_array.should == [1, 2]
-  end
-
-  describe "should support a logger" do
-    before do
-      @logger = Object.new
-      def @logger.method_missing(m, message)
-        @messages ||= []
-        @messages << message
-      end
-      Que.logger = @logger
-    end
-
-    after do
-      Que.logger = nil
-    end
-
-    def messages
-      @logger.instance_variable_get(:@messages)
-    end
-
-    it "should write messages to the logger" do
-      Que::Job.queue
-      Que::Job.work
-
-      messages.should be_an_instance_of Array
-      messages.length.should == 1
-      messages[0].should =~ /\AWorked job in/
-    end
-  end
-end

data/spec/unit/worker_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Que::Worker do
-  class ExceptionJob < Que::Job
-    def perform(*args)
-      raise "Blah!"
-    end
-  end
-
-  it "should not be taken out by an error, and keep looking for jobs" do
-    ExceptionJob.queue
-    Que::Job.queue
-
-    Que::Worker.state = :async
-    Que::Worker.wake!
-    @worker = Que::Worker.workers.first
-
-    {} until @worker.thread[:state] == :sleeping
-
-    # Job was worked, ExceptionJob remains.
-    Que::Job.select_map(:type).should == ['ExceptionJob']
-  end
-
-  it "#async? and #up? should return whether Worker is async and whether there are workers running, respectively" do
-    Que::Worker.should_not be_async
-    Que::Worker.should_not be_up
-    Que::Worker.state = :async
-    Que::Worker.should be_async
-    Que::Worker.should be_up
-  end
-end