que 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df82eb95360d4f2dd2d6ae5185a209836946a5a3
+  data.tar.gz: edbd98c7b468295a1d67ff135c076def834a1f0f
+SHA512:
+  metadata.gz: d93d47004b33e2f1e7e82e05351b629238d36eb9e48b8a142f421d267217f99ba51c6916267e9fb2c636a0d0ddfc5ab680c8b1168b6f089ace6cb396bb2989a1
+  data.tar.gz: c697670fcd1525986e22fa743cbae99b7e0107143c7e2b7e5b26ab52a4bdc4ec8f1d0fcb295cc3dab1861499af42186480058fde8e5ebc1827ad6a7ddf0a515c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--profile
+--order random

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Chris Hanks
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,102 @@
+# Que
+
+A job queue that uses Postgres' advisory lock system. The aim is for job queuing to be efficient and highly concurrent (there's no need for a locked_at column or SELECT FOR UPDATE NOWAIT queries) but still very durable (with all the stability that Postgres offers).
+
+It was extracted from an app of mine where it worked well for me, but I wouldn't recommend anyone use it until it's generalized some more. It currently requires the use of Sequel as an ORM, but I expect that it could be expanded to support ActiveRecord.
+
+Features:
+  * Jobs can be queued transactionally, alongside every other change to your database.
+  * If a worker process crashes or segfaults, the jobs it was working are immediately released to be picked up by other workers.
+  * Workers are multi-threaded, similar to Sidekiq, so the same process can work many jobs at the same time.
+  * Workers can run in your web processes. This means if you're on Heroku, there's no need to have a worker process constantly running.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'que'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install que
+
+## Usage
+
+Create a jobs table that looks something like:
+
+    CREATE TABLE jobs
+    (
+      priority integer NOT NULL,
+      run_at timestamp with time zone NOT NULL DEFAULT now(),
+      job_id bigserial NOT NULL,
+      created_at timestamp with time zone NOT NULL DEFAULT now(),
+      type text NOT NULL,
+      args json NOT NULL DEFAULT '[]'::json,
+      data json NOT NULL DEFAULT '{}'::json,
+      CONSTRAINT jobs_pkey PRIMARY KEY (priority, run_at, job_id),
+      CONSTRAINT valid_priority CHECK (priority >= 1 AND priority <= 5)
+    );
+
+Start up the worker to process jobs:
+
+    # In an initializer:
+    Que::Worker.state = :async
+
+    # Alternatively, you can set state to :sync to process jobs in the same
+    # thread as they're queued, which is useful for testing, or set it to :off
+    # to simply leave them in the jobs table.
+
+Create a class for each type of job you want to run:
+
+    class ChargeCreditCard < Que::Job
+      @default_priority = 1 # Highest priority.
+
+      def perform(user_id, card_id)
+        # Do stuff.
+
+        db.transaction do
+          # Write any changes you'd like to the database.
+
+          # It's best to destroy the job in the same transaction as any other
+          # changes you make. Que will destroy the job for you after the
+          # perform method if you don't do it here, but if your job writes to
+          # the DB but doesn't destroy the job in the same transaction, it's
+          # possible that the job could be repeated in the event of a crash.
+          destroy
+        end
+      end
+    end
+
+Queue that type of job. Again, it's best to take advantage of Postgres by doing this in a transaction with other changes you're making:
+
+    DB.transaction do
+      # Persist credit card information
+      card = CreditCard.create(params[:credit_card])
+      ChargeCreditCard.queue(current_user.id, card.id)
+    end
+
+## TODO
+
+These aren't promises, just ideas for stuff that could be done in the future.
+
+  * Railtie, to make default setup easy.
+  * ActiveRecord support.
+  * Keep deleted jobs.
+  * Use LISTEN/NOTIFY for checking for new jobs, rather than signaling the worker within the same process.
+  * Multiple queues (in multiple tables?)
+  * More configurable logging that isn't tied to Rails.
+  * Integration with ActionMailer for easier mailings.
+  * Options for max_run_time and max_attempts that are specific to job classes.
+  * Rake tasks for creating/working/dropping/clearing queues.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/que.rb

@@ -0,0 +1,10 @@
+require 'que/version'
+
+module Que
+  autoload :Job,    'que/job'
+  autoload :Worker, 'que/worker'
+
+  class << self
+    attr_accessor :logger
+  end
+end

data/lib/que/job.rb

@@ -0,0 +1,185 @@
+require 'json'
+
+module Que
+  class Job < Sequel::Model
+    # The Job priority scale:
+    #   1 = Urgent. Somebody's staring at a spinner waiting on this.
+    #   2 = ASAP. Should happen within a few minutes of the run_at time.
+    #   3 = Time-sensitive. Sooner is better than later.
+    #   4 = Time-insensitive. Shouldn't get delayed forever, though.
+    #   5 = Whenever. Timing doesn't matter. May be a huge backlog of these.
+
+    unrestrict_primary_key
+
+    plugin :single_table_inheritance, :type, :key_map   => proc(&:to_s),
+                                             :model_map => proc{|s| const_get "::#{s}"}
+
+    class Retry < StandardError; end
+
+    class << self
+      # Default is lowest priority, meaning jobs can be done whenever.
+      def default_priority
+        @default_priority ||= 5
+      end
+
+      def queue(*args)
+        create values_for_args *args
+      end
+
+      def work(options = {})
+        # Since we're taking session-level advisory locks, we have to hold the
+        # same connection throughout the process of getting a job, working it,
+        # deleting it, and removing the lock.
+
+        DB.synchronize do
+          begin
+            return unless job = LOCK.call(:priority => options[:priority] || 5)
+
+            # Edge case: It's possible for the lock statement to have grabbed a
+            # job that's already been worked, if the statement took its MVCC
+            # snapshot while the job was processing (making it appear to still
+            # exist), but didn't actually attempt to lock it until the job was
+            # finished (making it appear to be unlocked). Now that we have the
+            # job lock, we know that a previous worker would have deleted it by
+            # now, so we just make sure it still exists before working it.
+            this = dataset.where(:priority => job[:priority], :run_at => job[:run_at], :job_id => job[:job_id])
+            return if this.empty?
+
+            # Split up model instantiation from the DB query, so that model
+            # instantiation errors can be caught.
+            model = sti_load(job)
+
+            # Track how long different jobs take to process.
+            start = Time.now
+            model.work
+            time = Time.now - start
+            Que.logger.info "Worked job in #{(time * 1000).round(1)} ms: #{model.inspect}" if Que.logger
+
+            # Most jobs destroy themselves transactionally in #work. If not,
+            # take care of them. Jobs that don't destroy themselves run the risk
+            # of being repeated after a crash.
+            model.destroy unless model.destroyed?
+
+            # Make sure to return the finished job.
+            model
+          rescue Retry
+            # Don't destroy the job or mark it as having errored. It can be
+            # retried as soon as it is unlocked.
+          rescue => error
+            if job && data = JSON.load(job[:data])
+              count = (data['error_count'] || 0) + 1
+
+              this.update :run_at => Time.now + (count ** 4 + 3),
+                          :data   => JSON.dump(:error_count => count, :error_message => error.message, :error_backtrace => error.backtrace.join("\n"))
+            end
+
+            raise
+          ensure
+            DB.get{pg_advisory_unlock(job[:job_id])} if job
+          end
+        end
+      end
+
+      private
+
+      def values_for_args(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+
+        result = {}
+        result[:run_at]   = opts.delete(:run_at)   if opts[:run_at]
+        result[:priority] = opts.delete(:priority) if opts[:priority]
+
+        args << opts if opts.any?
+        result[:args] = JSON.dump(args)
+
+        result
+      end
+    end
+
+    # Send the args attribute to the perform() method.
+    def work
+      perform(*JSON.parse(args))
+    end
+
+    # Call perform on a job to run it. No perform method means NOOP.
+    def perform(*args)
+    end
+
+    def destroyed?
+      !!@destroyed
+    end
+
+    private
+
+    # If we add any more callbacks here, make sure to also special-case them in
+    # queue_array above.
+    def before_create
+      self.priority ||= self.class.default_priority
+
+      # If there's no run_at set, the job needs to be run immediately, so we
+      # need to trigger a worker to work it after it's committed and visible.
+      if run_at.nil?
+        case Worker.state
+          when :sync  then DB.after_commit { Job.work     }
+          when :async then DB.after_commit { Worker.wake! }
+        end
+      end
+
+      super
+    end
+
+    def after_destroy
+      super
+      @destroyed = true
+    end
+
+    sql = <<-SQL
+      WITH RECURSIVE cte AS (
+        SELECT (job).*, pg_try_advisory_lock((job).job_id) AS locked
+        FROM (
+          SELECT job
+          FROM jobs AS job
+          WHERE ((run_at <= now()) AND (priority <= ?))
+          ORDER BY priority, run_at, job_id
+          LIMIT 1
+        ) AS t1
+        UNION ALL (
+        SELECT (job).*, pg_try_advisory_lock((job).job_id) AS locked
+        FROM (
+          SELECT (
+            SELECT job
+            FROM jobs AS job
+            WHERE ((run_at <= now()) AND (priority <= ?) AND ((priority, run_at, job_id) > (cte.priority, cte.run_at, cte.job_id)))
+            ORDER BY priority, run_at, job_id
+            LIMIT 1
+          ) AS job
+          FROM cte
+          WHERE NOT cte.locked
+          LIMIT 1
+        ) AS t1)
+      )
+      SELECT *
+      FROM cte
+      WHERE locked
+    SQL
+
+    LOCK = DB[sql, :$priority, :$priority].prepare(:first, :lock_job)
+
+    # An alternate scheme using LATERAL, which will arrive in Postgres 9.3.
+    # Basically the same, but benchmark to see if it's faster/just as reliable.
+
+    # with recursive
+    #  t as (select *, pg_try_advisory_lock(s.job_id) as locked
+    #          from (select * from jobs j
+    #                 where run_at >= now()
+    #                 order by priority, run_at, job_id limit 1) s
+    #        union all
+    #        select j.*, pg_try_advisory_lock(j.job_id)
+    #          from (select * from t where not locked) t,
+    #               lateral (select * from jobs
+    #                         where run_at >= now()
+    #                           and (priority,run_at,job_id) > (t.priority,t.run_at,t.job_id)
+    #                         order by priority, run_at, job_id limit 1) j
+    # select * from t where locked;
+  end
+end

data/lib/que/version.rb

@@ -0,0 +1,3 @@
+module Que
+  VERSION = '0.0.1'
+end

data/lib/que/worker.rb

@@ -0,0 +1,216 @@
+module Que
+  # There are multiple workers running at a given time, each with a given
+  # minimum priority that they care about for jobs. A worker will continuously
+  # look for jobs and work them. If there's no job available, the worker will go
+  # to sleep until it is awakened by an external thread.
+
+  # Use Worker.state = ... to set the current state. There are three states:
+  #   :async => Work jobs in dedicated threads. Used in production.
+  #   :sync  => Work jobs immediately, as they're queued, in the current thread. Used in testing.
+  #   :off   => Don't work jobs at all. Must use Job#work or Job.work explicitly.
+
+  # Worker.wake! will wake up the sleeping worker with the lowest minimum job
+  # priority. Worker.wake! may be run by another thread handling a web request,
+  # or by the wrangler thread (which wakes a worker every five seconds, to
+  # handle scheduled jobs). It only has an effect when running in async mode.
+
+  class Worker
+    # Each worker has a corresponding thread, which contains two variables:
+    # :directive, to define what it should be doing, and :state, to define what
+    # it's actually doing at the moment. Need to be careful that these variables
+    # are only modified by a single thread at a time (hence, MonitorMixin).
+    include MonitorMixin
+
+    # The Worker class itself needs to be protected as well, to make sure that
+    # multiple threads aren't stopping/starting it at the same time.
+    extend MonitorMixin
+
+    # Default worker priorities. Rule of thumb: number of lowest-priority
+    # workers should equal number of processors available to us.
+    PRIORITIES = [5, 5, 5, 5, 4, 3, 2, 1].freeze
+
+    # Which errors should signal a worker that it should hold off before trying
+    # to grab another job, in order to avoid spamming the logs.
+    DELAYABLE_ERRORS = %w(
+      Sequel::DatabaseConnectionError
+      Sequel::DatabaseDisconnectError
+    )
+
+    # How long the wrangler thread should wait between pings of the database.
+    # Future directions: when we have multiple dynos, add rand() to this value
+    # in the wrangler loop below, so that the dynos' checks will be spaced out.
+    SLEEP_PERIOD = 5
+
+    # How long to sleep, in repeated increments, for something to happen.
+    WAIT_PERIOD = 0.0001 # 0.1 ms
+
+    # How long a worker should wait before trying to get another job, in the
+    # event of a database connection problem.
+    ERROR_PERIOD = 5
+
+    attr_reader :thread, :priority
+
+    def initialize(priority)
+      super() # For MonitorMixin
+
+      # These threads have a bad habit of never even having their directive and
+      # state set if we do it inside their threads. So instead, force the issue
+      # by doing it outside and holding them up via a queue until their initial
+      # state is set.
+      q = Queue.new
+
+      @priority = priority
+      @thread = Thread.new do
+        q.pop
+        job = nil
+
+        loop do
+          sleep! unless work_job
+
+          if @thread[:directive] == :sleep
+            @thread[:state] = :sleeping
+            sleep
+          end
+        end
+      end
+
+      # All workers are working when first instantiated.
+      synchronize { @thread[:directive], @thread[:state] = :work, :working }
+
+      # Now the worker can start.
+      q.push nil
+
+      # Default thread priority is 0 - make worker threads a bit less important
+      # than threads that are handling requests.
+      @thread.priority = -1
+    end
+
+    # If the worker is asleep, wakes it up and returns truthy. If it's already
+    # awake, does nothing and returns falsy.
+    def wake!
+      synchronize do
+        if sleeping?
+          # There's a very brief period of time where the worker may be marked
+          # as sleeping but the thread hasn't actually gone to sleep yet.
+          wait until @thread.stop?
+          @thread[:directive] = :work
+
+          # Have to set state here so that another poke immediately after this
+          # one doesn't see the current state as sleeping.
+          @thread[:state] = :working
+
+          # Now it's safe to wake up the worker.
+          @thread.wakeup
+        end
+      end
+    end
+
+    def sleep!
+      synchronize { @thread[:directive] = :sleep }
+    end
+
+    def awake?
+      synchronize do
+        %w(sleeping working).include?(@thread[:state].to_s) &&
+        %w(sleep work).include?(@thread[:directive].to_s) &&
+        %w(sleep run).include?(@thread.status)
+      end
+    end
+
+    def wait_for_sleep
+      wait until synchronize { sleeping? }
+    end
+
+    private
+
+    def work_job
+      Job.work(:priority => priority)
+    rescue => error
+      self.class.notify_error "Worker error!", error
+      sleep ERROR_PERIOD if DELAYABLE_ERRORS.include?(error.class.to_s)
+      return true # There's work available.
+    end
+
+    def sleeping?
+      @thread[:state] == :sleeping
+    end
+
+    def wait
+      sleep WAIT_PERIOD
+    end
+
+    # The Worker class is responsible for managing the worker instances.
+    class << self
+      def state=(state)
+        synchronize do
+          Que.logger.info "Setting Worker to #{state}..." if Que.logger
+          case state
+          when :async
+            # If this is the first time starting up Worker, start up all workers
+            # immediately, for the case of a restart during heavy app usage.
+            workers
+            # Make sure the wrangler thread is running, it'll do the rest.
+            @wrangler ||= Thread.new { loop { wrangle } }
+          when :sync, :off
+            # Put all the workers to sleep.
+            workers.each(&:sleep!).each(&:wait_for_sleep)
+          else
+            raise "Bad Worker state! #{state.inspect}"
+          end
+
+          Que.logger.info "Set Worker to #{state}" if Que.logger
+          @state = state
+        end
+      end
+
+      def state
+        synchronize { @state ||= :off }
+      end
+
+      def async?
+        state == :async
+      end
+
+      # All workers are up and processing jobs?
+      def up?(*states)
+        synchronize { async? && workers.map(&:priority) == PRIORITIES && workers.all?(&:awake?) }
+      end
+
+      def workers
+        @workers || synchronize { @workers ||= PRIORITIES.map { |i| new(i) } }
+      end
+
+      # Wake up just one worker to work a job, if running async.
+      def wake!
+        synchronize { async? && workers.find(&:wake!) }
+      end
+
+      def notify_error(message, error)
+        log_error message, error
+        #ExceptionNotifier.notify_exception(error)
+      rescue => error
+        log_error "Error notification error!", error
+      end
+
+      private
+
+      # The wrangler runs this method continuously.
+      def wrangle
+        sleep SLEEP_PERIOD
+        wake!
+      rescue => error
+        notify_error "Wrangler Error!", error
+      end
+
+      def log_error(message, error)
+        if Que.logger
+          Que.logger.error <<-ERROR
+#{message}
+#{error.message}
+#{error.backtrace.join("\n")}
+          ERROR
+        end
+      end
+    end
+  end
+end

data/que.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'que/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'que'
+  spec.version       = Que::VERSION
+  spec.authors       = ["Chris Hanks"]
+  spec.email         = ['christopher.m.hanks@gmail.com']
+  spec.description   = %q{Durable job queueing with PostgreSQL.}
+  spec.summary       = %q{Durable, efficient job queueing with PostgreSQL.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.14.1'
+  spec.add_development_dependency 'pry'
+
+  spec.add_dependency 'sequel'
+  spec.add_dependency 'pg'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'sequel'
+require 'que'
+
+DB = Sequel.connect "postgres://postgres:@localhost/que"
+
+DB.drop_table? :jobs
+DB.run <<-SQL
+  CREATE TABLE jobs
+  (
+    priority integer NOT NULL,
+    run_at timestamp with time zone NOT NULL DEFAULT now(),
+    job_id bigserial NOT NULL,
+    created_at timestamp with time zone NOT NULL DEFAULT now(),
+    type text NOT NULL,
+    args json NOT NULL DEFAULT '[]'::json,
+    data json NOT NULL DEFAULT '{}'::json,
+    CONSTRAINT jobs_pkey PRIMARY KEY (priority, run_at, job_id),
+    CONSTRAINT valid_priority CHECK (priority >= 1 AND priority <= 5)
+  );
+SQL
+
+RSpec.configure do |config|
+  config.before do
+    Que::Worker.state = :off
+    DB[:jobs].delete
+  end
+end
+
+Que::Worker.state = :async # Boot up.
+
+# For use when debugging specs:
+# require 'logger'
+# Que.logger = Logger.new(STDOUT)
+# DB.loggers << Logger.new(STDOUT)

data/spec/unit/error_spec.rb

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,168 @@
+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

@@ -0,0 +1,31 @@
+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

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: que
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Hanks
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Durable job queueing with PostgreSQL.
+email:
+- christopher.m.hanks@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/que.rb
+- lib/que/job.rb
+- lib/que/version.rb
+- lib/que/worker.rb
+- que.gemspec
+- 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: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: Durable, efficient job queueing with PostgreSQL.
+test_files:
+- spec/spec_helper.rb
+- spec/unit/error_spec.rb
+- spec/unit/queue_spec.rb
+- spec/unit/work_spec.rb
+- spec/unit/worker_spec.rb