pg_queue 0.0.0a → 0.0.2

data/.rspec

@@ -0,0 +1 @@
+--color

data/lib/pg_queue/job.rb

@@ -1,18 +1,19 @@
+require "multi_json"
+
 module PgQueue
   class Job
     attr_reader :id, :klass, :args
 
     def initialize(attributes)
       @id = attributes["id"]
-      puts "new job #{@id}"
-      @klass = Object.const_get(attributes["klass"])
-      @args = JSON.load(attributes["args"])
+      @klass = Object.const_get(attributes["class_name"])
+      @args = MultiJson.decode(attributes["args"])
     end
 
     def perform
-      puts "performing"
+      PgQueue.logger.debug("performing job #{@id}")
       klass.perform(*args)
-      puts "performed"
+      PgQueue.logger.debug("job #{@id} performed")
     end
   end
 end

data/lib/pg_queue/pg_extensions.rb

@@ -0,0 +1,41 @@
+module PgQueue
+  module PgExtensions
+    def insert(table_name, hash, returning = nil)
+      fields = hash.keys.join(", ")
+      variables = hash.size.times.map { |n| "$#{n+1}" }.join(", ")
+      sql = "INSERT INTO #{table_name} (#{fields}) VALUES (#{variables})"
+      if returning
+        sql << " RETURNING #{returning}"
+        exec(sql, hash.values).getvalue(0, 0)
+      else
+        exec(sql, hash.values)
+      end
+    end
+
+    def delete(table_name, where)
+      i = 0
+      conditions = where.map { |k, v| i += 1; "#{k} = $#{i}" }.join(" AND ")
+      exec("DELETE FROM #{table_name} WHERE #{conditions}", where.values)
+    end
+
+    def first(sql)
+      result = exec(sql)
+      return nil unless result.count > 0
+      result[0]
+    end
+
+    def notify(key, message = nil)
+      sql = "NOTIFY #{key}"
+      sql << ", '#{message}'" if message
+      exec(sql)
+    end
+
+    def listen(key)
+      exec("LISTEN #{key}")
+    end
+
+    def unlisten(key)
+      exec("UNLISTEN #{key}")
+    end
+  end
+end

data/lib/pg_queue/version.rb

@@ -1,3 +1,3 @@
 module PgQueue
-  VERSION = "0.0.0a"
+  VERSION = "0.0.2"
 end

data/lib/pg_queue/worker.rb

@@ -1,47 +1,33 @@
 module PgQueue
   class Worker
-    attr_reader :connection, :interval
-
-    def initialize
-      @connection = new_connection
-      @queue = PgQueue::Queue.new(@connection)
-      @interval = 5
-    end
-
     def start
       @running = true
 
-      listen
+      PgQueue.connection.listen(:pg_queue_jobs)
       while running?
-        job = @queue.dequeue
+        job = PgQueue.dequeue
         if job
           perform(job)
           next
         end
 
-        puts "waiting for jobs"
-        connection.wait_for_notify do |event, pid, payload|
+        PgQueue.logger.debug("waiting for jobs")
+        PgQueue.connection.wait_for_notify do |event, pid, payload|
           if payload == "stop"
-            puts "stop notify received"
+            PgQueue.logger.debug("stop notify received")
             stop
           else
-            puts "let's perform some jobs"
+            PgQueue.logger.debug("let's perform some jobs")
           end
         end
       end
-    end
-
-    def listen
-      connection.exec("LISTEN pg_queue_jobs")
-    end
-
-    def unlisten
-      connection.exec("UNLISTEN pg_queue_jobs")
+      PgQueue.connection.unlisten(:pg_queue_jobs)
     end
 
     def stop
       @running = false
-      new_connection.exec("NOTIFY pg_queue_jobs, 'stop'")
+      PgQueue.connection = nil
+      PgQueue.connection.notify(:pg_queue_jobs, "stop")
     end
 
     def running?
@@ -50,17 +36,13 @@ module PgQueue
 
     protected
 
-    def new_connection
-      PGconn.open(:dbname => 'pg_queue_test')
-    end
-
     def perform(job)
       begin
-        puts job.inspect
+        PgQueue.logger.debug(job.inspect)
         job.perform
       rescue => ex
-        puts ex
-        puts ex.message
+        PgQueue.logger.fatal(ex)
+        PgQueue.logger.fatal(ex.message)
       end
     end
   end

data/lib/pg_queue.rb

@@ -1,8 +1,45 @@
 require "pg_queue/version"
 require "pg"
+require "logger"
+require "multi_json"
 
 module PgQueue
   autoload :Worker, "pg_queue/worker"
-  autoload :Queue, "pg_queue/queue"
   autoload :Job, "pg_queue/job"
+  autoload :PgExtensions, "pg_queue/pg_extensions"
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.logger=(object)
+    @logger = object
+  end
+
+  def self.connection
+    @connection ||= begin
+      conn = PGconn.open(:dbname => 'pg_queue_test')
+      conn.extend(PgQueue::PgExtensions)
+    end
+  end
+
+  def self.connection=(object)
+    @connection = object
+  end
+
+  def self.enqueue(klass, *args)
+    id = connection.insert(:pg_queue_jobs, { :class_name => klass.name, :args => MultiJson.encode(args) }, "id")
+    logger.debug("enqueued #{id}")
+    connection.notify(:pg_queue_jobs)
+  end
+
+  def self.dequeue
+    result = connection.first("SELECT id, class_name, args FROM pg_queue_jobs LIMIT 1")
+    return nil unless result
+
+    PgQueue::Job.new(result).tap do |job|
+      PgQueue.logger.debug("dequeued #{job.id}")
+      connection.delete(:pg_queue_jobs, :id => job.id)
+    end
+  end
 end

data/pg_queue.gemspec

@@ -16,4 +16,7 @@ Gem::Specification.new do |gem|
   gem.version       = PgQueue::VERSION
 
   gem.add_dependency "pg", "~> 0.12.2"
+  gem.add_dependency "multi_json", "~> 1.0.4"
+
+  gem.add_development_dependency "rspec", "~> 2.8.0"
 end

data/spec/pg_queue/job_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+class MyQueue; end
+
+describe PgQueue::Job do
+  subject do
+    described_class.new(
+      "id" => 1,
+      "class_name" => "MyQueue",
+      "args" => MultiJson.encode([1, "two"])
+    )
+  end
+
+  its(:id) { should == 1 }
+  its(:klass) { should == MyQueue }
+  its(:args) { should == [1, "two"] }
+
+  it "performs the job" do
+    subject.klass.should_receive(:perform)
+    subject.perform
+  end
+end

data/spec/pg_queue/worker_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe PgQueue::Worker do
+  subject { described_class.new }
+  before do
+    PgQueue.connection = double("connection").as_null_object
+  end
+
+  context "starting" do
+    before do
+      PgQueue.connection.should_receive(:listen).with(:pg_queue_jobs)
+      [true, false].each { |ret| subject.should_receive(:running?).and_return(ret) }
+      PgQueue.connection.should_receive(:unlisten).with(:pg_queue_jobs)
+    end
+
+    context "with jobs pending" do
+      let(:job) { double("job") }
+
+      it "performs the job" do
+        PgQueue.should_receive(:dequeue).and_return(job)
+        job.should_receive(:perform)
+
+        subject.start
+      end
+    end
+
+    context "with no jobs pending" do
+      it "waits for notifies" do
+        PgQueue.should_receive(:dequeue).and_return(nil)
+        PgQueue.connection.should_receive(:wait_for_notify).and_yield("pg_queue_jobs", "12345", nil)
+
+        subject.start
+      end
+    end
+  end
+
+  context "stoping" do
+    let(:connection) { double("connection") }
+
+    before do
+      subject.instance_variable_set(:@running, true)
+    end
+
+    it "notifies worker to stop" do
+      PgQueue.should_receive(:connection=).with(nil)
+      PgQueue.should_receive(:connection).and_return(connection)
+      connection.should_receive(:notify).with(:pg_queue_jobs, "stop")
+
+      subject.should be_running
+      subject.stop
+      subject.should_not be_running
+    end
+  end
+end

data/spec/pg_queue_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+class MyLogger; end
+class MyDbConnection; end
+class MyQueue; end
+
+describe PgQueue do
+  context "logging" do
+    its(:logger) { should be_instance_of(Logger) }
+
+    it "defines a new logger" do
+      described_class.logger = MyLogger.new
+      described_class.logger.should be_instance_of(MyLogger)
+    end
+
+    after do
+      described_class.logger = nil
+    end
+  end
+
+  context "database connection" do
+    its(:connection) { should be_instance_of(PGconn) }
+
+    context "extensions" do
+      subject { described_class.connection }
+      it { should respond_to(:insert) }
+      it { should respond_to(:notify) }
+      it { should respond_to(:delete) }
+      it { should respond_to(:first) }
+      it { should respond_to(:listen) }
+      it { should respond_to(:unlisten) }
+    end
+
+    it "defines a new connection" do
+      described_class.connection = MyDbConnection.new
+      described_class.connection.should be_instance_of(MyDbConnection)
+    end
+
+    after do
+      described_class.connection = nil
+    end
+  end
+
+  context "enqueuing/dequeuing" do
+    let(:connection) { described_class.connection }
+    let(:result) { double("result") }
+
+    it "enqueues a job" do
+      connection.should_receive(:insert).with(:pg_queue_jobs, instance_of(Hash), "id").and_return("1")
+      connection.should_receive(:notify).with(:pg_queue_jobs)
+
+      described_class.enqueue(MyQueue, 1, "two")
+    end
+
+    it "dequeues a job" do
+      connection.should_receive(:first).with(/LIMIT 1/).and_return(result)
+      result.should_receive(:[]).with("id").and_return("1")
+      result.should_receive(:[]).with("class_name").and_return("MyQueue")
+      result.should_receive(:[]).with("args").and_return("[1, \"two\"]")
+      connection.should_receive(:delete).with(:pg_queue_jobs, :id => "1")
+
+      subject.dequeue.should be_instance_of(PgQueue::Job)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "pg_queue"
+
+PgQueue.logger = Logger.new("/dev/null")

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: pg_queue
 version: !ruby/object:Gem::Version
-  version: 0.0.0a
-  prerelease: 5
+  version: 0.0.2
+  prerelease: 
 platform: ruby
 authors:
 - Rafael Souza
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-26 00:00:00.000000000 Z
+date: 2012-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &70283076765840 !ruby/object:Gem::Requirement
+  requirement: &70278043238320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,29 @@ dependencies:
         version: 0.12.2
   type: :runtime
   prerelease: false
-  version_requirements: *70283076765840
+  version_requirements: *70278043238320
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70278043237820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70278043237820
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70278043237360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70278043237360
 description: Some experimentations with LISTEN/NOTIFY for background jobs
 email:
 - me@rafaelss.com
@@ -31,6 +53,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE
 - README.md
@@ -38,10 +61,14 @@ files:
 - bin/queue_worker
 - lib/pg_queue.rb
 - lib/pg_queue/job.rb
-- lib/pg_queue/queue.rb
+- lib/pg_queue/pg_extensions.rb
 - lib/pg_queue/version.rb
 - lib/pg_queue/worker.rb
 - pg_queue.gemspec
+- spec/pg_queue/job_spec.rb
+- spec/pg_queue/worker_spec.rb
+- spec/pg_queue_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/rafaelss/pg_queue
 licenses: []
 post_install_message: 
@@ -57,13 +84,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Background jobs using PostgreSQL's LISTEN/NOTIFY
-test_files: []
+test_files:
+- spec/pg_queue/job_spec.rb
+- spec/pg_queue/worker_spec.rb
+- spec/pg_queue_spec.rb
+- spec/spec_helper.rb

data/lib/pg_queue/queue.rb

@@ -1,26 +0,0 @@
-require "json"
-
-module PgQueue
-  class Queue
-    attr_reader :connection
-
-    def initialize(connection)
-      @connection = connection
-    end
-
-    def enqueue(klass, *args)
-      sql = "INSERT INTO pg_queue_jobs (klass, args) VALUES ($1, $2) RETURNING id"
-      id = connection.exec(sql, [klass.name, JSON.dump(args)]).getvalue(0, 0)
-      puts "enqueued #{id}"
-      connection.exec("NOTIFY pg_queue_jobs")
-    end
-
-    def dequeue
-      result = connection.exec("SELECT id, klass, args FROM pg_queue_jobs LIMIT 1")
-      return nil unless result.count == 1
-      PgQueue::Job.new(result[0]).tap do |job|
-        connection.exec("DELETE FROM pg_queue_jobs WHERE id = $1", [job.id])
-      end
-    end
-  end
-end