queue_classic 0.2.2 → 0.3.1

data/lib/queue_classic.rb

@@ -2,16 +2,16 @@ require 'json'
 require 'pg'
 require 'uri'
 
-$: << File.expand_path("lib")
+$: << File.expand_path(__FILE__, 'lib')
 
 require 'queue_classic/durable_array'
+require 'queue_classic/database'
 require 'queue_classic/worker'
 require 'queue_classic/queue'
-require 'queue_classic/api'
 require 'queue_classic/job'
 
 module QC
-  extend Api
+  def self.method_missing(sym, *args, &block)
+    Queue.send(sym, *args, &block)
+  end
 end
-
-QC::Queue.instance.setup :data_store => QC::DurableArray.new(:database => ENV["DATABASE_URL"])

data/lib/queue_classic/database.rb

@@ -0,0 +1,128 @@
+module QC
+  class Database
+
+    MAX_TOP_BOUND = 9
+    DEFAULT_QUEUE_NAME = "queue_classic_jobs"
+
+    def self.create_queue(name)
+      db = new(name)
+      db.create_table
+      db.disconnect
+      true
+    end
+
+    attr_reader :table_name
+
+    def initialize(queue_name=nil)
+      @top_boundry = ENV["TOP_BOUND"] || MAX_TOP_BOUND
+      @table_name = queue_name || DEFAULT_QUEUE_NAME
+      @db_params = URI.parse(ENV["DATABASE_URL"])
+    end
+
+    def init_db
+      drop_table
+      create_table
+      load_functions
+    end
+
+    def waiting_conns
+      execute("SELECT * FROM pg_stat_activity WHERE datname = '#{@name}' AND waiting = 't' AND application_name = 'queue_classic'")
+    end
+
+    def all_conns
+      execute("SELECT * FROM pg_stat_activity WHERE datname = '#{@name}' AND application_name = 'queue_classic'")
+    end
+
+    def silence_warnings
+      execute("SET client_min_messages TO 'warning'")
+    end
+
+    def execute(sql)
+      connection.exec(sql)
+    end
+
+    def disconnect
+      connection.finish
+    end
+
+    def connection
+      if defined? @connection
+        @connection
+      else
+        @name = @db_params.path.gsub("/","")
+        @connection = PGconn.connect(
+          :dbname   => @db_params.path.gsub("/",""),
+          :user     => @db_params.user,
+          :password => @db_params.password,
+          :host     => @db_params.host
+        )
+        @connection.exec("LISTEN queue_classic_jobs")
+        @connection.exec("SET application_name = 'queue_classic'")
+        silence_warnings unless ENV["LOGGING_ENABLED"]
+        @connection
+      end
+    end
+
+    def drop_table
+      execute("DROP TABLE IF EXISTS #{@table_name} CASCADE")
+    end
+
+    def create_table
+      execute("CREATE TABLE #{@table_name} (id serial, details text, locked_at timestamp)")
+      execute("CREATE INDEX #{@table_name}_id_idx ON #{@table_name} (id)")
+    end
+
+    def load_functions
+      execute(<<-EOD)
+        -- We are declaring the return type to be queue_classic_jobs.
+        -- This is ok since I am assuming that all of the users added queues will
+        -- have identical columns to queue_classic_jobs.
+        -- When QC supports queues with columns other than the default, we will have to change this.
+
+        CREATE OR REPLACE FUNCTION lock_head(tname varchar) RETURNS SETOF queue_classic_jobs AS $$
+        DECLARE
+          unlocked integer;
+          relative_top integer;
+          job_count integer;
+        BEGIN
+          SELECT TRUNC(random() * #{@top_boundry} + 1) INTO relative_top;
+          EXECUTE 'SELECT count(*) FROM' || tname || '' INTO job_count;
+
+          IF job_count < 10 THEN
+            relative_top = 0;
+          END IF;
+
+          LOOP
+            BEGIN
+              EXECUTE 'SELECT id FROM '
+                || tname::regclass
+                || ' WHERE locked_at IS NULL'
+                || ' ORDER BY id ASC'
+                || ' LIMIT 1'
+                || ' OFFSET ' || relative_top
+                || ' FOR UPDATE NOWAIT'
+              INTO unlocked;
+              EXIT;
+            EXCEPTION
+              WHEN lock_not_available THEN
+                -- do nothing. loop again and hope we get a lock
+            END;
+          END LOOP;
+
+
+          RETURN QUERY EXECUTE 'UPDATE '
+            || tname::regclass
+            || ' SET locked_at = (CURRENT_TIMESTAMP)'
+            || ' WHERE id = $1'
+            || ' AND locked_at is NULL'
+            || ' RETURNING *'
+          USING unlocked;
+
+          RETURN;
+        END;
+        $$ LANGUAGE plpgsql;
+      EOD
+    end
+
+  end
+end

data/lib/queue_classic/durable_array.rb

@@ -1,77 +1,62 @@
 module QC
   class DurableArray
 
-    def initialize(args={})
-      @db_string  = args[:database]
+    def initialize(database)
+      @database = database
+      @table_name = @database.table_name
     end
 
     def <<(details)
-      execute("INSERT INTO jobs (details) VALUES ('#{details.to_json}')")
-      execute("NOTIFY jobs, 'new-job'")
+      execute("INSERT INTO #{@table_name} (details) VALUES ('#{details.to_json}')")
+      execute("NOTIFY queue_classic_jobs, 'new-job'")
     end
 
     def count
-      execute("SELECT COUNT(*) from jobs")[0]["count"].to_i
+      execute("SELECT COUNT(*) FROM #{@table_name}")[0]["count"].to_i
     end
 
     def delete(job)
-      execute("DELETE FROM jobs WHERE id = #{job.id}")
+      execute("DELETE FROM #{@table_name} WHERE id = #{job.id}")
       job
     end
 
     def find(job)
-      find_one {"SELECT * FROM jobs WHERE id = #{job.id}"}
+      find_one {"SELECT * FROM #{@table_name} WHERE id = #{job.id}"}
+    end
+
+    def search_details_column(q)
+      find_many { "SELECT * FROM #{@table_name} WHERE details LIKE '%#{q}%'" }
     end
 
     def lock_head
-      job = nil
-      connection.transaction do
-        if job = find_one {"SELECT * FROM jobs WHERE locked_at IS NULL ORDER BY id ASC LIMIT 1 FOR UPDATE"}
-          execute("UPDATE jobs SET locked_at = (CURRENT_TIMESTAMP) WHERE id = #{job.id} AND locked_at IS NULL")
-        end
-      end
-      job
+      find_one { "SELECT * FROM lock_head('#{@table_name}')" }
     end
 
     def first
       if job = lock_head
         job
       else
-        execute("LISTEN jobs")
-        connection.wait_for_notify {|e,p,msg| job = lock_head if msg == "new-job" }
+        @database.connection.wait_for_notify(1) {|e,p,msg| job = lock_head if msg == "new-job" }
         job
       end
     end
 
     def each
-      execute("SELECT * FROM jobs ORDER BY id ASC").each do |r|
+      execute("SELECT * FROM #{@table_name} ORDER BY id ASC").each do |r|
         yield Job.new(r)
       end
     end
 
-    def execute(sql)
-      connection.exec(sql)
+    def find_one(&blk)
+      find_many(&blk).pop
     end
 
-    def find_one
-      res = execute(yield)
-      if res.count > 0
-        res.map {|r| Job.new(r)}.pop
-      end
+    def find_many
+      execute(yield).map {|r| Job.new(r)}
     end
 
-    def connection
-      db_params = URI.parse(@db_string)
-      @connection ||= if db_params.scheme == "postgres"
-        PGconn.connect(
-          :dbname   => db_params.path.gsub("/",""),
-          :user     => db_params.user,
-          :password => db_params.password,
-          :host     => db_params.host
-        )
-      else
-        PGconn.connect(:dbname => @db_string)
-      end
+    def execute(sql)
+      @database.execute(sql)
     end
 
   end

data/lib/queue_classic/job.rb

@@ -30,5 +30,13 @@ module QC
       end
     end
 
+    def work
+      if params.class == Array
+        klass.send(method,*params)
+      else
+        klass.send(method,params)
+      end
+    end
+
   end
 end

data/lib/queue_classic/queue.rb

@@ -1,30 +1,85 @@
-require 'singleton'
+module QC
+  module AbstractQueue
 
-module  QC
-  class Queue
-    include Singleton
-    def setup(args={})
-      @data = args[:data_store]
+    def enqueue(job,*params)
+      if job.respond_to?(:details) and job.respond_to?(:params)
+        job = job.signature
+        params = *job.params
+      end
+      array << {"job" => job, "params" => params}
     end
 
-    def enqueue(job,params)
-      @data << {"job" => job, "params" => params}
+    def dequeue
+      array.first
     end
 
-    def dequeue
-      @data.first
+    def query(signature)
+      array.search_details_column(signature)
     end
 
     def delete(job)
-      @data.delete(job)
+      array.delete(job)
     end
 
     def delete_all
-      @data.each {|j| delete(j) }
+      array.each {|j| delete(j) }
     end
 
     def length
-      @data.count
+      array.count
+    end
+
+  end
+end
+
+module QC
+  module ConnectionHelper
+
+    def connection_status
+      {:total => database.all_conns.count, :waiting => database.waiting_conns.count}
+    end
+
+    def disconnect
+      database.disconnect
     end
+
+  end
+end
+
+module  QC
+  class Queue
+
+    include AbstractQueue
+    extend AbstractQueue
+
+    include ConnectionHelper
+    extend ConnectionHelper
+
+    def self.array
+      if defined? @@array
+        @@array
+      else
+        @@database = Database.new
+        @@array = DurableArray.new(@@database)
+      end
+    end
+
+    def self.database
+      @@database
+    end
+
+    def initialize(queue_name)
+      @database = Database.new(queue_name)
+      @array = DurableArray.new(@database)
+    end
+
+    def array
+      @array
+    end
+
+    def database
+      @database
+    end
+
   end
 end

data/lib/queue_classic/tasks.rb

@@ -1,13 +1,29 @@
 namespace :jobs do
+
   task :work  => :environment do
     QC::Worker.new.start
   end
+
 end
+
 namespace :qc do
-  task :work do
+
+  task :work  => :environment do
     QC::Worker.new.start
   end
-  task :jobs do
+
+  task :jobs => :environment do
     QC.queue_length
   end
+
+  task :load_functions => :environment do
+    db = QC::Database.new
+    db.load_functions
+    db.disconnect
+  end
+
+  task :create_queue, :name, :needs => :environment do |t,args|
+    QC::Database.create_queue(args[:name])
+  end
+
 end

data/lib/queue_classic/worker.rb

@@ -1,18 +1,42 @@
 module QC
   class Worker
 
+    def initialize
+      @running = true
+      @queue = QC::Queue.new(ENV["QUEUE"])
+      handle_signals
+    end
+
+    def running?
+      @running
+    end
+
+    def handle_signals
+      %W(INT TRAP).each do |sig|
+        trap(sig) do
+          if running?
+            @running = false
+          else
+            raise Interrupt
+          end
+        end
+      end
+    end
+
     def start
-      loop { work }
+      while running? do
+        work
+      end
     end
 
     def work
-      if job = QC.dequeue #blocks until we have a job
+      if job = @queue.dequeue #blocks until we have a job
         begin
-          QC.work(job)
+          job.work
         rescue Object => e
           handle_failure(job,e)
         ensure
-          QC.delete(job)
+          @queue.delete(job)
         end
       end
     end

data/readme.md

@@ -0,0 +1,33 @@
+# Queue Classic
+__Beta 0.3.1__
+
+__Queue Classic 0.3.1 is in Beta.__ I have been using this library with 30-150 Heroku workers and have had great results.
+
+I am using this in production applications and plan to maintain and support this library for a long time.
+
+Queue Classic is a queueing library for Ruby apps (Rails, Sinatra, Etc...) Queue Classic features a blocking dequeue, database maintained locks and
+no ridiculous dependencies. As a matter of fact, Queue Classic only requires the __pg__ and __json__.
+
+[Discussion Group](http://groups.google.com/group/queue_classic)
+
+[Wiki](https://github.com/ryandotsmith/queue_classic/wiki)
+
+## Installation
+
+1. $ gem install queue_classic
+2. psql=# CREATE TABLE queue_classic_jobs (id serial, details text, locked_at timestamp);
+3. psql=# CREATE INDEX queue_classic_jobs_id_idx ON queue_classic_jobs (id);
+4. $ rake qc:load_functions
+5. irb: QC.enqueue "Class.method", "arg"
+6. $ rake jobs:work
+
+### Upgrade from < 0.2.3 to 0.3.0
+
+  $ psql your_database
+  your_database=# ALTER TABLE jobs RENAME TO queue_classic_jobs;
+
+### Dependencies
+
+  Postgres version 9
+
+  Ruby (gems: pg, json)

data/test/database_helpers.rb

@@ -1,49 +1,11 @@
 module DatabaseHelpers
 
-  def clean_database
-    drop_table
-    create_table
-    disconnect
+  def init_db(table_name=nil)
+    database  = QC::Database.new(table_name)
+    database.silence_warnings
+    database.init_db
+    database.disconnect
+    true
   end
 
-  def create_database
-    postgres.exec "CREATE DATABASE #{ENV['DATABASE_URL']}"
-  end
-
-  def drop_database
-    postgres.exec "DROP DATABASE IF EXISTS #{ENV['DATABASE_URL']}"
-  end
-
-  def create_table
-    jobs_db.exec(
-      "CREATE TABLE jobs"    +
-      "("                    +
-      "id        SERIAL,"    +
-      "details   text,"      +
-      "locked_at timestamp without time zone" +
-      ");"
-    )
-    jobs_db.exec("CREATE INDEX jobs_id_idx ON jobs (id)")
-  end
-
-  def drop_table
-    jobs_db.exec("DROP TABLE IF EXISTS jobs")
-  end
-
-  def disconnect
-    jobs_db.finish
-    postgres.finish
-  end
-
-  def jobs_db
-    @jobs_db ||= PGconn.connect(:dbname => ENV["DATABASE_URL"])
-    @jobs_db.exec("SET client_min_messages TO 'warning'")
-    @jobs_db
-  end
-
-  def postgres
-    @postgres ||= PGconn.connect(:dbname => 'postgres')
-    @postgres.exec("SET client_min_messages TO 'warning'")
-    @postgres
-  end
 end

data/test/durable_array_test.rb

@@ -1,95 +1,92 @@
 require File.expand_path("../helper.rb", __FILE__)
 
-class DurableArrayTest < MiniTest::Unit::TestCase
-  include DatabaseHelpers
+context "DurableArray" do
 
-  def test_first_decodes_json
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
-
-    array << {"test" => "ok"}
-    assert_equal({"test" => "ok"}, array.first.details)
+  setup do
+    @database = QC::Database.new
+    @database.drop_table
+    @database.init_db
+    @array = QC::DurableArray.new(@database)
   end
 
-  def test_count_returns_number_of_rows
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
+  teardown do
+    @database.disconnect
+  end
 
-    array << {"test" => "ok"}
-    assert_equal 1, array.count
-    array << {"test" => "ok"}
-    assert_equal 2, array.count
+  test "decode json into hash" do
+    @array << {"test" => "ok"}
+    assert_equal({"test" => "ok"}, @array.first.details)
   end
 
-  def test_first_returns_fsrst_job
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
+  test "count returns number of rows" do
+    @array << {"test" => "ok"}
+    assert_equal 1, @array.count
+    @array << {"test" => "ok"}
+    assert_equal 2, @array.count
+  end
 
+  test "first returns first job" do
     job = {"job" => "one"}
-    array << job
-    assert_equal job, array.first.details
+    @array << job
+    assert_equal job, @array.first.details
   end
 
-  def test_first_returns_first_job_when_many_are_in_array
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
-
-    array << {"job" => "one"}
-    array << {"job" => "two"}
-    assert_equal({"job" => "one"}, array.first.details)
+  test "first returns first job when many are in the array" do
+    @array << {"job" => "one"}
+    @array << {"job" => "two"}
+    assert_equal({"job" => "one"}, @array.first.details)
   end
 
-  def test_delete_removes_job_from_array
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
+  test "find_many returns empty array when nothing is found" do
+    assert_equal([], @array.find_many {"select * from queue_classic_jobs"})
+  end
 
-    array << {"job" => "one"}
-    job = array.first
+  test "delete removes job from the array" do
+    @array << {"job" => "one"}
+    job = @array.first
 
     assert_equal( {"job" => "one"}, job.details)
 
-    assert_equal(1,array.count)
-    array.delete(job)
-    assert_equal(0,array.count)
+    assert_equal(1,@array.count)
+    @array.delete(job)
+    assert_equal(0,@array.count)
   end
 
-  def test_delete_returns_job_after_delete
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
-
-    array << {"job" => "one"}
-    job = array.first
+  test "delete returns job after delete" do
+    @array << {"job" => "one"}
+    job = @array.first
 
     assert_equal({"job" => "one"}, job.details)
 
-    res = array.delete(job)
+    res = @array.delete(job)
     assert_equal({"job" => "one"}, res.details)
   end
 
-  def test_each_yields_the_details_for_each_job
-    clean_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
-
-    array << {"job" => "one"}
-    array << {"job" => "two"}
+  test "each yields the details for each job" do
+    @array << {"job" => "one"}
+    @array << {"job" => "two"}
     results = []
-    array.each {|v| results << v.details}
+    @array.each {|v| results << v.details}
     assert_equal([{"job" => "one"},{"job" => "two"}], results)
   end
 
-  def test_connection_builds_db_connection_for_uri
-    array = QC::DurableArray.new(:database => "postgres://ryandotsmith:@localhost/queue_classic_test")
-    assert_equal "ryandotsmith", array.connection.user
-    assert_equal "localhost", array.connection.host
-    assert_equal "queue_classic_test", array.connection.db
+  test "connection build db connection from uri" do
+    a = QC::Database.new("postgres://ryandotsmith:@localhost/queue_classic_test")
+    assert_equal "ryandotsmith", a.connection.user
+    assert_equal "localhost", a.connection.host
+    assert_equal "queue_classic_test", a.connection.db
+    a.disconnect
   end
 
-  def test_connection_builds_db_connection_for_database
-    array = QC::DurableArray.new(:database => "queue_classic_test")
-
-    # FIXME not everyone will have a postgres user named: ryandotsmith
-    assert_equal "ryandotsmith", array.connection.user
-    assert_equal "queue_classic_test", array.connection.db
+  test "seach" do
+    @array << {"job" => "A.signature"}
+    jobs = @array.search_details_column("A.signature")
+    assert_equal "A.signature", jobs.first.signature
   end
 
+  test "seach when data will not match" do
+    @array << {"job" => "A.signature"}
+    jobs = @array.search_details_column("B.signature")
+    assert_equal [], jobs
+  end
 end

data/test/helper.rb

@@ -1,22 +1,12 @@
 $: << File.expand_path("lib")
 $: << File.expand_path("test")
 
-ENV["DATABASE_URL"] = 'queue_classic_test'
-
 require 'queue_classic'
 require 'database_helpers'
 
 require 'minitest/unit'
 MiniTest::Unit.autorun
 
-def set_data_store(store=nil)
-  QC::Queue.instance.setup(
-    :data_store => (
-      store || QC::DurableArray.new(:database => ENV["DATABASE_URL"])
-    )
-  )
-end
-
 def context(*args, &block)
   return super unless (name = args.first) && block
   klass = Class.new(MiniTest::Unit::TestCase) do

data/test/job_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path("../helper.rb", __FILE__)
 
-context "QC::Job" do
+context "Job" do
 
   test "initialize takes details as JSON" do
     job = QC::Job.new(

data/test/queue_test.rb

@@ -1,33 +1,60 @@
 require File.expand_path("../helper.rb", __FILE__)
 
-class QueueTest < MiniTest::Unit::TestCase
-  include DatabaseHelpers
+context "Queue" do
 
-  def test_queue_is_singleton
-    assert_equal QC::Queue, QC::Queue.instance.class
+  setup { init_db }
+
+  test "Queue class responds to enqueue" do
+    QC::Queue.enqueue("Klass.method")
+  end
+
+  test "Queue class has a default table name" do
+    QC::Queue.enqueue("Klass.method")
+  end
+
+  test "Queue class responds to dequeue" do
+    QC::Queue.enqueue("Klass.method")
+    assert_equal "Klass.method", QC::Queue.dequeue.signature
   end
 
-  def test_queue_setup
-    QC::Queue.instance.setup :data_store => []
-    assert_equal [], QC::Queue.instance.instance_variable_get(:@data)
+  test "Queue class responds to delete" do
+    QC::Queue.enqueue("Klass.method")
+    job = QC::Queue.dequeue
+    QC::Queue.delete(job)
   end
 
-  def test_queue_length
-    QC::Queue.instance.setup :data_store => []
-    QC::Queue.instance.enqueue "job","params"
+  test "Queue class responds to delete_all" do
+    2.times { QC::Queue.enqueue("Klass.method") }
+    job1,job2 = QC::Queue.dequeue, QC::Queue.dequeue
+    QC::Queue.delete_all
+  end
 
-    assert_equal 1, QC::Queue.instance.length
+  test "Queue class return the length of the queue" do
+    2.times { QC::Queue.enqueue("Klass.method") }
+    assert_equal 2, QC::Queue.length
   end
 
-  def test_queue_delete_all
-    QC::Queue.instance.setup :data_store => []
+  test "Queue class finds jobs using query method" do
+    QC::Queue.enqueue("Something.hard_to_find")
+    jobs = QC::Queue.query("Something.hard_to_find")
+    assert_equal 1, jobs.length
+    assert_equal "Something.hard_to_find", jobs.first.signature
+  end
 
-    QC::Queue.instance.enqueue "job","params"
-    QC::Queue.instance.enqueue "job","params"
+  test "queue instance responds to enqueue" do
+    QC::Queue.enqueue("Something.hard_to_find")
+    init_db(:custom_queue_name)
+    @queue = QC::Queue.new(:custom_queue_name)
+    @queue.enqueue "Klass.method"
+    @queue.disconnect
+  end
 
-    assert_equal 2, QC::Queue.instance.length
-    QC::Queue.instance.delete_all
-    assert_equal 0, QC::Queue.instance.length
+  test "queue only uses 1 connection per class" do
+    QC::Queue.length
+    QC::Queue.enqueue "Klass.method"
+    QC::Queue.delete QC::Queue.dequeue
+    QC::Queue.dequeue
+    assert_equal 1, QC.connection_status[:total]
   end
 
 end

data/test/worker_test.rb

@@ -6,7 +6,7 @@ class TestNotifier
 end
 
 # This not only allows me to test what happens
-# when a failure occures but it also demonstrates
+# when a failure occurs but it also demonstrates
 # how to override the worker to handle failures the way
 # you want.
 class TestWorker < QC::Worker
@@ -20,31 +20,26 @@ class TestWorker < QC::Worker
   end
 end
 
-class WorkerTest < MiniTest::Unit::TestCase
-  include DatabaseHelpers
+context "Worker" do
 
-  def test_working_a_job
-    set_data_store
-    clean_database
+  setup do
+    init_db
+    @worker = TestWorker.new
+  end
 
-    QC.enqueue "TestNotifier.deliver", {}
-    worker = TestWorker.new
+  test "working a job" do
+    QC::Queue.enqueue "TestNotifier.deliver", {}
 
-    assert_equal(1, QC.queue_length)
-    worker.work
-    assert_equal(0, QC.queue_length)
-    assert_equal(0, worker.failed_count)
+    assert_equal(1, QC::Queue.length)
+    @worker.work
+    assert_equal(0, QC::Queue.length)
+    assert_equal(0, @worker.failed_count)
   end
 
-  def test_rescue_failed_jobs
-    set_data_store
-    clean_database
-
-    QC.enqueue "TestNotifier.no_method", {}
-    worker = TestWorker.new
+  test "resuce failed job" do
+    QC::Queue.enqueue "TestNotifier.no_method", {}
 
-    worker.work
-    assert_equal 1, worker.failed_count
+    @worker.work
+    assert_equal 1, @worker.failed_count
   end
-
 end

metadata

@@ -1,12 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: queue_classic
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 2
-  version: 0.2.2
+  prerelease: 
+  version: 0.3.1
 platform: ruby
 authors: 
 - Ryan Smith
@@ -14,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-16 00:00:00 -08:00
+date: 2011-04-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,10 +21,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 10
-        - 1
         version: 0.10.1
   type: :runtime
   version_requirements: *id001
@@ -40,12 +32,10 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        segments: 
-        - 0
         version: "0"
   type: :runtime
   version_requirements: *id002
-description: Queue Classic is an alternative queueing library for Ruby apps (Rails, Sinatra, Etc...) Queue Classic features asynchronous job polling, database maintained locks and no ridiculous dependencies. As a matter of fact, Queue Classic only requires the pg and json.
+description: Queue Classic (beta) is a queueing library for Ruby apps (Rails, Sinatra, Etc...) Queue Classic features asynchronous job polling, database maintained locks and no ridiculous dependencies. As a matter of fact, Queue Classic only requires the pg and json.
 email: ryan@heroku.com
 executables: []
 
@@ -54,15 +44,14 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- readme.markdown
-- lib/queue_classic/api.rb
+- readme.md
+- lib/queue_classic/database.rb
 - lib/queue_classic/durable_array.rb
 - lib/queue_classic/job.rb
 - lib/queue_classic/queue.rb
 - lib/queue_classic/tasks.rb
 - lib/queue_classic/worker.rb
 - lib/queue_classic.rb
-- test/api_test.rb
 - test/database_helpers.rb
 - test/durable_array_test.rb
 - test/helper.rb
@@ -70,7 +59,7 @@ files:
 - test/queue_test.rb
 - test/worker_test.rb
 has_rdoc: true
-homepage: http://github.com/ryandotsmith/Queue-Classic
+homepage: http://github.com/ryandotsmith/queue_classic
 licenses: []
 
 post_install_message: 
@@ -83,26 +72,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: Queue Classic is an alternative queueing library for Ruby apps (Rails, Sinatra, Etc...) Queue Classic features asynchronous job polling, database maintained locks and no ridiculous dependencies. As a matter of fact, Queue Classic only requires the pg and json.(simple)
+summary: Queue Classic (beta) is a queueing library for Ruby apps (Rails, Sinatra, Etc...) Queue Classic features asynchronous job polling, database maintained locks and no ridiculous dependencies. As a matter of fact, Queue Classic only requires the pg and json.(simple)
 test_files: 
-- test/api_test.rb
 - test/durable_array_test.rb
 - test/job_test.rb
 - test/queue_test.rb

data/lib/queue_classic/api.rb

@@ -1,50 +0,0 @@
-module QC
-  module Api
-
-    def queue
-      @queue ||= Queue.instance
-    end
-
-    def enqueue(job,*params)
-      if job.respond_to?(:details) and job.respond_to?(:params)
-        p = *job.params
-        queue.enqueue(job.signature, p)
-      else
-        queue.enqueue(job,params)
-      end
-    end
-
-    def dequeue
-      queue.dequeue
-    end
-
-    def delete(job)
-      queue.delete(job)
-    end
-
-    def delete_all
-      queue.delete_all
-    end
-
-    def queue_length
-      queue.length
-    end
-
-    def work(job)
-      klass   = job.klass
-      method  = job.method
-      params  = job.params
-
-      if params.class == Array
-        klass.send(method,*params)
-      else
-        klass.send(method,params)
-      end
-    end
-
-    def logging_enabled?
-      ENV["LOGGING"]
-    end
-
-  end
-end

data/readme.markdown

@@ -1,218 +0,0 @@
-# Queue Classic
-__Beta 0.2.2__
-
-__Queue Classic 0.2.2 is in Beta.__ I have been using this library with 30-50 Heroku workers and have had great results.
-
-I am using this in production applications and plan to maintain and support this library for a long time.
-
-Queue Classic is an alternative queueing library for Ruby apps (Rails, Sinatra, Etc...) Queue Classic features a blocking dequeue, database maintained locks and
-no ridiculous dependencies. As a matter of fact, Queue Classic only requires the __pg__ and __json__.
-
-## Installation
-
-### TL;DR
-1. gem install queue_classic
-2. add jobs table to your database
-3. QC.enqueue "Class.method", :arg1 => val1
-4. rake qc:work
-
-### Dependencies
-
-  Postgres version 9
-
-  Ruby (gems: pg, json)
-
-### Gem
-
-    gem install queue_classic
-
-### Database
-
-Queue Classic needs a database, so make sure that DATABASE_URL points to your database. If you are unsure about whether this var is set, run:
-    echo $DATABASE_URL
-in your shell. If you are using Heroku, this var is set and pointing to your primary database.
-
-Once your Database is set, you will need to add a jobs table. If you are using rails, add a migration with the following tables:
-
-    class CreateJobsTable < ActiveRecord::Migration
-      def self.up
-        create_table :jobs do |t|
-          t.text :details
-          t.timestamp :locked_at
-          t.index :id
-        end
-      end
-
-      def self.down
-        drop_table :jobs
-      end
-    end
-After running this migration, your database should be ready to go. As a sanity check, enqueue a job and then issue a SELECT in the postgres console.
-
-Be sure and add the index to the id column. This will help out the worker if the queue should ever reach an obscene length. It made a huge difference
-when running the benchmark.
-
-__script/console__
-    QC.enqueue "Class.method"
-__Terminal__
-    psql you_database_name
-    select * from jobs;
-You should see the job "Class.method"
-
-### Rakefile
-
-As a convenience, I added a rake task that responds to `rake jobs:work` There are also rake tasks in the `qc` name space.
-To get access to these tasks, Add `require 'queue_classic/tasks'` to your Rakefile.
-
-## Fundamentals
-
-### Enqueue
-
-To place a job onto the queue, you should specify a class and a class method. There are a few ways to enqueue:
-
-    QC.enqueue('Class.method', :arg1 => 'value1', :arg2 => 'value2')
-
-Requires:
-
-    class Class
-      def self.method(args)
-        puts args["arg1"]
-      end
-    end
-
-    QC.enqueue('Class.method', 'value1', 'value2')
-
-Requires:
-
-    class Class
-      def self.method(arg1,arg2)
-        puts arg1
-        puts arg2
-      end
-    end
-
-
-The job gets stored in the jobs table with a details field set to: `{ job: Class.method, params: {arg1: value1, arg2: value2}}` (as JSON)
-Here is a more concrete example of a job implementation using a Rails ActiveRecord Model:
-
-    class Invoice < ActiveRecord::Base
-      def self.process(invoice_id)
-        invoice = find(invoice_id)
-        invoice.process!
-      end
-
-      def self.process_all
-        Invoice.all do |invoice|
-          QC.enqueue "Invoice.process", invoice.id
-        end
-      end
-    end
-
-
-### Dequeue
-
-Traditionally, a queue's dequeue operation will remove the item from the queue. However, Queue Classic will not delete the item from the queue right away; instead, the workers will lock
-the job and then the worker will delete the job once it has finished working it. Queue Classic's greatest strength is it's ability to safely lock jobs. Unlike other
-database backed queing libraries, Queue Classic uses the database time to lock. This allows you to be more relaxed about the time synchronization amongst your worker machines.
-
-Queue Classic takes advantage of Postgres' PUB/SUB featuers to dequeue a job. Basically there is a channel in which the workers LISTEN. When a new job is added to the queue, the queue sends NOTIFY
-messages on the channel. Once a NOTIFY is sent, each worker races to acquire a lock on a job. A job is awareded to the victor while the rest go back to wait for another job. This eliminates
-the need to Sleep & Select.
-
-### The Worker
-
-The worker calls dequeue and then calls the enqueued method with the supplied arguments. Once the method terminates, the job is deleted from the queue. In the case that your method
-does not terminate, or the worker unexpectingly dies, Queue Classic will do following:
-
-* Rescue the Exception %
-* Call handle_failure(job,exception)
-* Delete the job
-
-% - To my knowledge, the only thing that can usurp ensure is a segfault.
-
-By default, handle_failure will puts the job and the exception. This is not very good and you should override this method. It is simple to do so.
-If you are using Queue Classic with Rails, You should:
-
-1. Remove require 'queue_classic/tasks' from Rakefile
-2. Create new file in lib/tasks. Call it queue_classic.rb (name is arbitrary)
-3. Insert something like the following:
-
-    require 'queue_classic'
-
-    class MyWorker < QC::Worker
-      def handle_failure(job,exception)
-        # You can do many things inside of this method. Here are a few examples:
-
-        # Log to Exceptional
-        Exceptional.handle(exception, "Background Job Failed" + job.inspect)
-
-        # Log to Hoptoad
-        HoptoadNotifier.notify(
-            :error_class   => "Background Job",
-            :error_message => "Special Error: #{e.message}",
-            :parameters    => job.details
-        )
-
-        # Log to STDOUT (Heroku Logplex listens to stdout)
-        puts job.inspect
-        puts exception.inspect
-        puts exception.backtrace
-
-        # Retry the job
-        QC.enqueue(job)
-
-      end
-    end
-
-    namespace :jobs do
-      task :work  => :environment do
-        MyWorker.new.start
-      end
-    end
-
-## Performance
-I am pleased at the performance of Queue Classic. It ran 3x faster than the DJ. (I have yet to benchmark redis backed queues)
-
-    ruby benchmark.rb
-                    user     system      total        real
-                0.950000   0.620000   1.570000 (  9.479941)
-
-Hardware: Mac Book Pro 2.8 GHz Intel Core i7. SSD. 4 GB memory.
-
-Software: Ruby 1.9.2-p0, PostgreSQL 9.0.2
-
-It is fast because:
-
-* I wrote my own SQL
-* I do not create many Ruby Objects
-* I do not call very many methods
-
-## FAQ
-
-How is this different than DJ?
-> TL;DR = Store job as JSON (better introspection), Queue manages the time for locking jobs (workers can be out of sync.), No magic (less code), Small footprint (ORM Free).
-
-> __Introspection__ I want the data in the queue to be as simple as possible. Since we only store the Class, Method and Args, introspection into the queue is
-quite simple.
-
-> __Locking__ You might have noticed that DJ's worker calls Time.now(). In a cloud environment, this could allow for workers to be confused about
-the status of a job. Classic Queue locks a job using Postgres' TIMESTAMP function.
-
-> __Magic__ I find disdain for methods on my objects that have nothing to do with the purpose of the object. Methods like "should" and "delay"
-are quite distasteful and obscure what is actually going on. If you use TestUnit for this reason, you might like Queue Classic. Anyway, I think
-the fundamental concept of a message queue is not that difficult to grasp; therefore, I have taken the time to make Queue Classic as transparent as possilbe.
-
-> __Footprint__ You don't need ActiveRecord or any other ORM to find the head or add to the tail. Take a look at the DurableArray class to see the SQL Classic Queue employees.
-
-Why doesn't your queue retry failed jobs?
-> I believe the Class method should handle any sort of exception.  Also, I think
-that the model you are working on should know about it's state. For instance, if you are
-creating jobs for the emailing of newsletters; put a emailed_at column on your newsletter model
-and then right before the job quits, touch the emailed_at column. That being said, you can do whatever you
-want in handle_failure. I will not decide what is best for your application.
-
-Can I use this library with 50 Heroku Workers?
-> Yes.
-
-Is Queue Classic ready for production? Can I do it live?!?
-> I started this project on 1/24/2011. I have been using this in production for some high-traffic apps at Heroku since 2/24/2011.

data/test/api_test.rb

@@ -1,40 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-context "QC::Api" do
-  setup { clean_database }
-
-  test "enqueue takes a job without params" do
-    QC.enqueue "Notifier.send"
-
-    job = QC.dequeue
-    assert_equal({"job" => "Notifier.send", "params" => [] }, job.details)
-  end
-
-  test "enqueue takes a hash" do
-    QC.enqueue "Notifier.send", {:arg => 1}
-
-    job = QC.dequeue
-    assert_equal({"job" => "Notifier.send", "params" => [{"arg" => 1}] }, job.details)
-  end
-
-  test "enqueue takes a job" do
-    h = {"id" => 1, "details" => {"job" => 'Notifier.send'}.to_json, "locked_at" => nil}
-    job = QC::Job.new(h)
-    QC.enqueue(job)
-
-    job = QC.dequeue
-    assert_equal({"job" => "Notifier.send", "params" => []}, job.details)
-  end
-
-  test "enqueue takes a job and maintain params" do
-    h = {"id" => 1, "details" => {"job" => 'Notifier.send', "params" => ["1"]}.to_json, "locked_at" => nil}
-    job = QC::Job.new(h)
-    QC.enqueue(job)
-
-    job = QC.dequeue
-    assert_equal({"job" => "Notifier.send", "params" => ["1"]}, job.details)
-  end
-
-
-end
-