queue_classic 0.2.0 → 0.2.1

data/lib/queue_classic/api.rb

@@ -6,7 +6,11 @@ module QC
     end
 
     def enqueue(job,*params)
-      queue.enqueue(job,params)
+      if job.respond_to?(:details) and job.respond_to?(:params)
+        queue.enqueue(job.signature, (job.params || []))
+      else
+        queue.enqueue(job,params)
+      end
     end
 
     def dequeue
@@ -17,6 +21,10 @@ module QC
       queue.delete(job)
     end
 
+    def delete_all
+      queue.delete_all
+    end
+
     def queue_length
       queue.length
     end
@@ -26,7 +34,11 @@ module QC
       method  = job.method
       params  = job.params
 
-      klass.send(method,params)
+      if params.class == Array
+        klass.send(method,*params)
+      else
+        klass.send(method,params)
+      end
     end
 
     def logging_enabled?

data/lib/queue_classic/durable_array.rb

@@ -3,9 +3,6 @@ module QC
 
     def initialize(args={})
       @db_string  = args[:database]
-      @connection = connection
-      execute("SET client_min_messages TO 'warning'")
-      with_log("setup PG LISTEN") { execute("LISTEN jobs") }
     end
 
     def <<(details)
@@ -18,7 +15,7 @@ module QC
     end
 
     def delete(job)
-      with_log("deleting job #{job.id}") { execute("DELETE FROM jobs WHERE id = #{job.id}") }
+      execute("DELETE FROM jobs WHERE id = #{job.id}")
       job
     end
 
@@ -28,7 +25,7 @@ module QC
 
     def lock_head
       job = nil
-      @connection.transaction do
+      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
@@ -40,37 +37,32 @@ module QC
       if job = lock_head
         job
       else
-        @connection.wait_for_notify {|e,p,msg| job = lock_head if msg == "new-job" }
+        execute("LISTEN jobs")
+        connection.wait_for_notify {|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|
-        yield(JSON.parse(r["details"]))
+        yield Job.new(r)
       end
     end
 
     def execute(sql)
-      @connection.async_exec(sql)
+      connection.exec(sql)
     end
 
     def find_one
       res = execute(yield)
       if res.count > 0
-        res.map do |r|
-          Job.new(
-            "id"        => r["id"],
-            "details"   => JSON.parse( r["details"]),
-            "locked_at" => r["locked_at"]
-          )
-        end.pop
+        res.map {|r| Job.new(r)}.pop
       end
     end
 
     def connection
       db_params = URI.parse(@db_string)
-      if db_params.scheme == "postgres"
+      @connection ||= if db_params.scheme == "postgres"
         PGconn.connect(
           :dbname   => db_params.path.gsub("/",""),
           :user     => db_params.user,
@@ -82,19 +74,5 @@ module QC
       end
     end
 
-    def with_log(msg)
-      res = yield
-      if QC.logging_enabled?
-        log(msg)
-        log(res.cmd_status)           if res.respond_to?(:cmd_status)
-        log(res.result_error_message) if res.respond_to?(:result_error_message)
-      end
-      res
-    end
-
-    def log(msg)
-      puts "| \t" + msg
-    end
-
   end
 end

data/lib/queue_classic/job.rb

@@ -4,19 +4,24 @@ module QC
 
     def initialize(args={})
       @id        = args["id"]
-      @details   = args["details"]
+      @details   = JSON.parse(args["details"])
       @locked_at = args["locked_at"]
     end
 
     def klass
-      Kernel.const_get(details["job"].split(".").first)
+      eval(details["job"].split(".").first)
     end
 
     def method
       details["job"].split(".").last
     end
 
+    def signature
+      details["job"]
+    end
+
     def params
+      return [] unless details["params"]
       params = details["params"]
       if params.length == 1
         return params[0]

data/lib/queue_classic/queue.rb

@@ -19,6 +19,10 @@ module  QC
       @data.delete(job)
     end
 
+    def delete_all
+      @data.each {|j| delete(j) }
+    end
+
     def length
       @data.count
     end

data/readme.markdown

@@ -1,11 +1,11 @@
 # Queue Classic
-__Beta 0.2.0__
+__Beta 0.2.1__
 
-__Queue Classic 0.2.0 is in Beta.__ I have been using this library with 30-50 Heroku workers and have had great results. However, your mileage may vary.
+__Queue Classic 0.2.1 is in Beta.__ I have been using this library with 30-50 Heroku workers and have had great results. However, your mileage may vary.
 
 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 __asynchronous__ job polling, database maintained locks and
+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

data/test/api_test.rb

@@ -1,14 +1,31 @@
 require File.expand_path("../helper.rb", __FILE__)
 
-class ApiTest < MiniTest::Unit::TestCase
-  include DatabaseHelpers
+context "QC::Api" do
+  setup { clean_database }
 
-  def test_enqueue_takes_a_job
-    clean_database
+  test "enqueue takes a job without params" do
+    QC.enqueue "Notifier.send"
 
-    assert_equal 0, QC.queue_length
-    res = QC.enqueue "Notifier.send", {}
-    assert_equal 1, QC.queue_length
+    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
+
+
 end
 

data/test/durable_array_test.rb

@@ -47,8 +47,10 @@ class DurableArrayTest < MiniTest::Unit::TestCase
     job = array.first
 
     assert_equal( {"job" => "one"}, job.details)
+
+    assert_equal(1,array.count)
     array.delete(job)
-    assert_nil array.first
+    assert_equal(0,array.count)
   end
 
   def test_delete_returns_job_after_delete
@@ -61,7 +63,6 @@ class DurableArrayTest < MiniTest::Unit::TestCase
     assert_equal({"job" => "one"}, job.details)
 
     res = array.delete(job)
-    assert_nil(array.first)
     assert_equal({"job" => "one"}, res.details)
   end
 
@@ -72,7 +73,7 @@ class DurableArrayTest < MiniTest::Unit::TestCase
     array << {"job" => "one"}
     array << {"job" => "two"}
     results = []
-    array.each {|v| results << v}
+    array.each {|v| results << v.details}
     assert_equal([{"job" => "one"},{"job" => "two"}], results)
   end
 

data/test/helper.rb

@@ -16,3 +16,19 @@ def set_data_store(store=nil)
     )
   )
 end
+
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  klass = Class.new(MiniTest::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.setup(&block) define_method(:setup, &block) end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+
+  klass.send :include, DatabaseHelpers
+  klass.class_eval &block
+end

data/test/job_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path("../helper.rb", __FILE__)
+
+context "QC::Job" do
+
+  test "initialize takes details as JSON" do
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => "{\"arg\":1}",
+      "locked_at" => nil
+    )
+    assert_equal({"arg" => 1}, job.details)
+  end
+
+  test "signature returns the class and method" do
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "Class.method", :params => []}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal "Class.method", job.signature
+  end
+
+  test "method returns the class method" do
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "Class.method", :params => []}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal "method", job.method
+  end
+
+  test "klass returns the class" do
+    class WhoHa; end
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "WhoHa.method", :params => []}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal WhoHa, job.klass
+  end
+
+  test "klass returns the class when scoped to module" do
+    module Mod
+      class K
+      end
+    end
+
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "Mod::K.method", :params => []}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal Mod::K, job.klass
+  end
+
+  test "params returns empty array when nil" do
+     job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "Mod::K.method", :params => nil}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal [], job.params
+ end
+
+  test "params returns 1 items when there is 1 param" do
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "Mod::K.method", :params => ["arg"]}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal "arg", job.params
+  end
+
+  test "params retuns many items when there are many params" do
+    job = QC::Job.new(
+      "id" => 1,
+      "details" => {:job => "Mod::K.method", :params => ["arg","arg"]}.to_json,
+      "locked_at" => nil
+    )
+    assert_equal ["arg","arg"], job.params
+  end
+end

data/test/queue_test.rb

@@ -19,4 +19,15 @@ class QueueTest < MiniTest::Unit::TestCase
     assert_equal 1, QC::Queue.instance.length
   end
 
+  def test_queue_delete_all
+    QC::Queue.instance.setup :data_store => []
+
+    QC::Queue.instance.enqueue "job","params"
+    QC::Queue.instance.enqueue "job","params"
+
+    assert_equal 2, QC::Queue.instance.length
+    QC::Queue.instance.delete_all
+    assert_equal 0, QC::Queue.instance.length
+  end
+
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Ryan Smith
@@ -55,7 +55,6 @@ extra_rdoc_files: []
 
 files: 
 - readme.markdown
-- lib/notifier.rb
 - lib/queue_classic/api.rb
 - lib/queue_classic/durable_array.rb
 - lib/queue_classic/job.rb
@@ -67,6 +66,7 @@ files:
 - test/database_helpers.rb
 - test/durable_array_test.rb
 - test/helper.rb
+- test/job_test.rb
 - test/queue_test.rb
 - test/worker_test.rb
 has_rdoc: true
@@ -104,5 +104,6 @@ summary: Queue Classic is an alternative queueing library for Ruby apps (Rails,
 test_files: 
 - test/api_test.rb
 - test/durable_array_test.rb
+- test/job_test.rb
 - test/queue_test.rb
 - test/worker_test.rb

data/lib/notifier.rb

@@ -1,7 +0,0 @@
-class Notifier
-
-  def self.deliver(msg)
-    `say #{msg}`
-  end
-
-end