smq 0.1.1

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Tim Blair <tim@bla.ir>
+ 
+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.markdown

@@ -0,0 +1,88 @@
+# Simple Message Queue (SMQ)
+
+SMQ is a database-backed, JSON-based message queue and worker platform.
+
+## Description
+
+SMQ uses ActiveRecord to provide a database-agnositc, JSON-based [message queue](http://en.wikipedia.org/wiki/Message_queue) and worker platform; this is not to be confused with [job queues](http://en.wikipedia.org/wiki/Job_queue) such as [Resque](http://github.com/defunkt/resque) or [Delayed::Job](http://github.com/tobi/delayed_job).
+
+Other simple message queue systems exist, but these generally either use Marshal'd ruby objects which are not transferable to other platforms, or are run as a separate server daemon.  SMQ uses a simple database table for persisting message queues and JSON encoding for message payloads to enable use cross-platform.
+
+## Installation
+
+SMQ is provided as a gem courtesy of Gemcutter:
+
+	gem install smq
+
+Once you've established your ActiveRecord connection, you'll need to initialise the (single) database table:
+
+	SMQ.load_schema!
+
+## Queues
+
+Creating a queue is as simple as:
+
+	queue = SMQ::Queue.new("queue_name")
+
+A "queue" doesn't exist as a persisted entity: it's effectively just a tag applied to a message; pushing a message onto a queue simply saves the Message with the queue name assigned.
+
+## Adding Messages to a Queue
+
+A message's payload can be any data structure that can be serialised to JSON.  There are three ways that a message can be added to a queue (here we're assuming that `msg_data` already exists):
+
+	queue.enqueue(msg_data)
+
+	# or
+
+	queue.push(SMQ::Message.build(msg_data))
+
+	# or
+
+	SMQ::Message.build(msg_data, "queue_name").save
+
+The first two methods are effectively simplified abstractions of the third.  Note that a single message can only be added to one queue; to push to multiple queues, additional instances of the message must be created.
+
+### Non-Ruby Messages
+
+Adding to a queue from outside a ruby environment is as simple as `INSERT`ing a JSON-encoded packet into the queue table:
+
+	INSERT INTO smq_messages (queue, payload, created_at) VALUES (
+		'queue_name',
+		'{"json":"encoded stuff"}',
+		NOW()
+	)
+
+## Workers
+
+A worker is an instance of `SMQ::Worker` bound to a single named queue.  The `Worker#work` method takes care of reserving `Message`s and then passing them back to the given block:
+
+	SMQ::Worker.new("queue_name").work do |msg|
+	  puts msg.data.inspect
+	  msg.ack!
+	end
+
+When a worker has finished with a `Message`, it should either call `Message#ack!` to acknowledge receipt of that message, or `Message#fail` followed by `Message#save` to mark the message as failed.  In addition, if a message should fail for a transient reason, it can be pushed back into the queue by calling `Message#retry!`.  A message will be retried up to 5 times before automatically being marked as failed.
+
+`Worker#work` takes a single optional argument (in addition to the callback block): `until_empty`.  If `true`, the worker will stop when the queue is empty (but see detail on locking below); if `false` the worker will continue to look for new jobs indefinitely (or until `Worker#stop!` is called), waiting 1 second between queue polls.
+
+### Locking Strategy
+
+To facilitate the locking ("delivery") of individual messages, the following strategy is used:
+
+1. Find the next 5 messages in the queue;
+2. Randomise these messages;
+3. Attempt to `UPDATE` each message based on the message ID, lock status and last updated stamp;
+4. When the `UPDATE` returns a row change count of 1, that message has been locked and can be passed off to be processed;
+5. If a lock isn't aquired for any of the 5 messages, either wait for 1 second and then start the process again or, if `until_empty` is `true`, end the processing loop and stop the worker.
+
+The effect of this is that, although multiple workers can be employed on a single queue, the increase in throughput is not linear as may be expected.  In fact, if you increase the number of workers on queue past 5, throughput may actually diminish due to the extra time spent attempting to aquire a message lock.
+
+This process, although heavy on `SELECT`s, results in a minimum of table locking which would actually slow the lock process down.  For example, by using an `UPDATE` with a `LIMIT` of `1` when the queue size is more than a couple of hundred results in a noticible slow down in lock aquisition.
+
+These limitations are deemed acceptable due to the simple nature of this queueing system.
+
+## Licensing and Attribution
+
+SMQ is released under the MIT license as detailed in the LICENSE file that should be distributed with this library; the source code is [freely available](http://github.com/timblair/smq).
+
+SMQ was developed by [Tim Blair](http://tim.bla.ir/) during work on [White Label Dating](http://www.whitelabeldating.com/), while employed by [Global Personals Ltd](http://www.globalpersonals.co.uk).  Global Personals Ltd have kindly agreed to the extraction and release of this software under the license terms above.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "smq"
+    gem.summary = %Q{Simple Message Queue}
+    gem.description = %Q{A simple database-backed, JSON-based message queue and worker base}
+    gem.email = "tim@bla.ir"
+    gem.homepage = "http://github.com/timblair/smq"
+    gem.authors = ["Tim Blair"]
+    gem.add_dependency 'activerecord'
+    gem.add_dependency 'yajl-ruby'
+    gem.add_development_dependency 'sqlite3-ruby'
+  end
+  Jeweler::GemcutterTasks.new
+  task :test => :check_dependencies
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "smq #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/examples/database.yml

@@ -0,0 +1,3 @@
+development:
+  adapter: sqlite3
+  database: /tmp/smq-dev.sqlite

data/examples/worker.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+
+begin
+  require 'smq'
+rescue LoadError
+  $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+  require 'smq'
+end
+
+ActiveRecord::Base.configurations = YAML.load_file(File.dirname(__FILE__) + '/database.yml')
+ActiveRecord::Base.establish_connection 'development'
+
+SMQ::load_schema!
+
+worker = SMQ::Worker.new("queue_name")
+100.times { |i| worker.queue.enqueue(i+1) }
+
+count = 0
+worker.work(true) do |msg|
+  count += 1
+  puts msg.inspect
+  msg.ack!
+end
+
+puts "Handled: #{count}"

data/lib/smq.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'active_record'
+require 'yajl'
+
+require File.dirname(__FILE__) + '/smq/worker'
+require File.dirname(__FILE__) + '/smq/message'
+require File.dirname(__FILE__) + '/smq/queue'
+
+module SMQ
+
+  def self.now
+    (ActiveRecord::Base.default_timezone == :utc) ? Time.now.utc : Time.now
+  end
+
+  def self.encode(object)
+    Yajl::Encoder.encode(object)
+  end
+
+  def self.decode(object)
+    return unless object
+    Yajl::Parser.parse(object, :check_utf8 => false)
+  end
+
+  def self.load_schema!(force = false)
+    return if !force && ActiveRecord::Base.connection.tables.include?(SMQ::Message.table_name)
+    ActiveRecord::Schema.define do
+      create_table :smq_messages, :force => force do |t|
+        t.string     :queue, :limit => 30, :null => false
+        t.text       :payload
+        t.datetime   :locked_at
+        t.string     :locked_by, :limit => 50
+        t.integer    :attempts, :limit => 2, :default => 0
+        t.datetime   :failed_at
+        t.datetime   :completed_at
+        t.timestamps
+      end
+      if ActiveRecord::Base.connection.instance_variable_get(:@config)[:adapter] == 'mysql'
+        execute "ALTER TABLE `smq_messages` MODIFY COLUMN `updated_at` TIMESTAMP"
+      end
+      add_index "smq_messages", ["queue", "completed_at", "locked_by"], :name => "idx_smq_available"
+      add_index "smq_messages", ["id", "updated_at", "locked_by", "completed_at"], :name => "idx_smq_unlocked"
+    end
+  end
+
+  def self.flush_all_queues!
+    # yes, not the most efficient, but *should* only be called during testing
+    # so it's not that much of a concern
+    SMQ::Message.delete_all
+  end
+
+end

data/lib/smq/message.rb

@@ -0,0 +1,66 @@
+module SMQ
+
+  class Message < ActiveRecord::Base
+    set_table_name :smq_messages
+    validates_presence_of :queue
+    MAX_ATTEMPTS = 5
+
+    def self.build(payload, queue = nil)
+      msg = self.new
+      msg.payload = SMQ.encode(payload)
+      msg.queue = queue
+      msg
+    end
+
+    def data
+      SMQ.decode(payload)
+    end
+    def data=(object)
+      self.payload = SMQ.encode(object)
+    end
+
+    def retry!
+      self.locked_by = nil
+      self.locked_at = nil
+      fail if self.attempts >= MAX_ATTEMPTS
+      save!
+    end
+
+    def lock!(worker)
+      rows = self.class.update_all(
+        ["updated_at = ?, locked_at = ?, locked_by = ?, attempts = (attempts+1)", SMQ.now, SMQ.now, worker.name],
+        ["id = ? AND updated_at = ? AND locked_by IS NULL AND completed_at IS NULL", self.id, self.updated_at]
+      )
+      if rows == 1
+        self.reload
+        return self
+      end
+      nil
+    end
+
+    def locked?
+      !self.locked_by.nil?
+    end
+    def failed?
+      !self.failed_at.nil?
+    end
+    def completed?
+      !self.completed_at.nil?
+    end
+
+    def complete
+      self.completed_at = SMQ.now
+    end
+    def fail
+      self.failed_at = SMQ.now
+      complete
+    end
+
+    def ack!
+      complete
+      save!
+    end
+
+  end
+
+end

data/lib/smq/queue.rb

@@ -0,0 +1,65 @@
+module SMQ
+
+  class Queue
+
+    attr_accessor :name
+    attr_accessor :batch_size
+
+    def initialize(name, batch_size = 5)
+      @name = name
+      @batch_size = batch_size
+    end
+
+    def to_s
+      @name
+    end
+
+    def push(msg)
+      msg.queue = @name
+      msg.save!
+      msg
+    end
+
+    def enqueue(payload)
+      push SMQ::Message.build(payload)
+    end
+
+    def reserve(worker)
+      find_available.each do |msg|
+        m = msg.lock!(worker)
+        return m unless m == nil
+      end
+      nil
+    end
+
+    def find_available
+      SMQ::Message.find(:all, :select => 'id, updated_at', :conditions => ["queue = ? AND completed_at IS NULL AND locked_by IS NULL", @name], :order => "id ASC", :limit => @batch_size).sort_by { rand() }
+    end
+
+    def length
+      SMQ::Message.count(:conditions => ["queue = ? AND completed_at IS NULL", @name])
+    end
+
+    def flush!
+      delete_queue_items
+    end
+
+    def clear_completed!
+      delete_queue_items "completed_at IS NOT NULL"
+    end
+    def clear_successful!
+      delete_queue_items "completed_at IS NOT NULL AND failed_at IS NULL"
+    end
+    def clear_failed!
+      delete_queue_items "completed_at IS NOT NULL AND failed_at IS NOT NULL"
+    end
+
+    private
+
+    def delete_queue_items(where = nil)
+      SMQ::Message.delete_all(["queue = ? #{where ? 'AND ' + where : ''}", @name])
+    end
+
+  end
+
+end

data/lib/smq/worker.rb

@@ -0,0 +1,58 @@
+require "socket"
+
+module SMQ
+
+  class Worker
+
+    attr_accessor :name
+    attr_accessor :queue
+
+    @working = false
+    @stopping = false
+
+    def initialize(queue)
+      self.name = "#{Socket.gethostname}:#{Process.pid}" rescue "pid:#{Process.pid}"
+      self.queue = queue.instance_of?(SMQ::Queue) ? queue : SMQ::Queue.new(queue)
+    end
+
+    def to_s
+      self.name
+    end
+
+    def work(until_empty = false, &block)
+      @working = true
+      empty = false
+      empty_for = 0
+      while(!empty && !@stopping) do
+        if work_one_message(&block).nil?
+          empty = true if until_empty
+          sleep 1 unless (empty && (empty_for += 1) >= 10)
+        else
+          empty_for = 0
+        end
+      end
+      @stopping = false
+      @working = false
+    end
+
+    def work_one_message
+      msg = self.queue.reserve(self)
+      yield msg if !msg.nil? && block_given?
+      msg
+    end
+
+    def stop!
+      @stopping = true
+    end
+
+    def is_working?
+      @working
+    end
+
+    def is_stopping?
+      @stopping
+    end
+
+  end
+
+end

data/test/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter: sqlite3
+  database: /tmp/smq-test.sqlite

data/test/helper.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'test/unit'
+begin; require 'redgreen'; rescue LoadError; end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'smq'
+
+ActiveRecord::Base.configurations = YAML.load_file(File.dirname(__FILE__) + '/database.yml')
+ActiveRecord::Base.establish_connection 'test'
+
+SMQ::load_schema!       # will check if table already exists
+SMQ::flush_all_queues!  # clear out old test data
+
+class Test::Unit::TestCase
+
+  def populate_queue(queue, msgs = 5)
+    msgs.times { |i| SMQ::Message.build(i, queue.to_s).save! }
+  end
+
+end

data/test/test_message.rb

@@ -0,0 +1,112 @@
+require 'helper'
+
+class MessageTest < Test::Unit::TestCase
+
+  def setup
+    @simple_value  = "string"
+    @complex_value = SMQ::decode(SMQ::encode({ :a => 1, :b => 2, :c => [1,2,3] })) # JSON-ifying muddles things around
+    @msg = SMQ::Message.build(@simple_value, "test_queue")
+    @worker = SMQ::Worker.new("test_queue")
+  end
+
+  def teardown
+    SMQ.flush_all_queues!
+  end
+
+  def test_builing_message_returns_instance_of_message
+    assert_instance_of SMQ::Message, @msg
+  end
+
+  def test_building_message_correctly_encodes_payload_for_simple_value
+    assert_equal @msg.payload, SMQ::encode(@simple_value)
+  end
+
+  def test_building_message_correctly_encodes_payload_for_complex_value
+    msg = SMQ::Message.build(@complex_value)
+    assert_equal msg.payload, SMQ::encode(@complex_value)
+  end
+
+  def test_data_is_decoded_payload_for_simple_value
+    assert_equal @msg.data, @simple_value
+  end
+
+  def test_data_is_decoded_payload_for_complex_value
+    msg = SMQ::Message.build(@complex_value)
+    assert_equal msg.data, @complex_value
+  end
+
+  def test_setting_data_correctly_serialises_to_payload
+    @msg.data = @complex_value
+    assert_equal @msg.data, @complex_value
+    assert_equal @msg.payload, SMQ::encode(@complex_value)
+  end
+
+  def test_complete_sets_completed_at_timestamp
+    @msg.complete
+    assert_not_nil @msg.completed_at
+  end
+
+  def test_fail_sets_completed_and_fail_at_timestamps
+    @msg.fail
+    assert_not_nil @msg.completed_at
+    assert_not_nil @msg.failed_at
+  end
+
+  def test_message_should_not_save_without_a_queue_name
+    @msg.queue = nil
+    assert_raise ActiveRecord::RecordInvalid do
+      @msg.save!
+    end
+  end
+
+  def test_ack_marks_message_as_complete_and_saves
+    @msg.ack!
+    assert_not_nil @msg.completed_at
+    assert_not_nil @msg.id
+  end
+
+  def test_should_lock_an_unlocked_message
+    @msg.save!
+    msg = @msg.lock!(@worker)
+    assert_equal msg.id, @msg.id
+    assert_not_nil @msg.locked_at
+    assert_equal @msg.locked_by, @worker.name
+  end
+
+  def test_should_return_nil_when_locking_a_completed_message
+    @msg.ack!
+    assert_nil @msg.lock!(@worker)
+  end
+
+  def test_should_return_nil_when_locking_a_locked_message_locked_by_someone_else
+    @msg.locked_by = 'random_worker'
+    @msg.save!
+    assert_nil @msg.lock!(@worker)
+  end
+
+  def test_locking_a_message_increments_the_attempts_count
+    @msg.save!
+    assert_equal @msg.attempts + 1, @msg.lock!(SMQ::Worker.new("test_queue")).attempts
+  end
+
+  def test_message_should_report_as_locked
+    @msg.save!
+    assert !@msg.locked?, "Message locked"
+    @msg.lock!(@worker)
+    assert @msg.locked?, "Message not locked"
+  end
+
+  def test_message_should_report_as_failed
+    assert !@msg.failed?, "Message failed"
+    @msg.fail
+    @msg.save!
+    assert @msg.failed?, "Message not failed"
+  end
+
+  def test_message_should_report_as_completed
+    assert !@msg.completed?, "Message completed"
+    @msg.ack!
+    assert @msg.completed?, "Message not completed"
+  end
+
+end

data/test/test_queue.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+class QueueTest < Test::Unit::TestCase
+
+  def setup
+    @queue = SMQ::Queue.new("test_queue")
+    @worker = SMQ::Worker.new(@queue.name)
+  end
+
+  def teardown
+    SMQ.flush_all_queues!
+  end
+
+  def test_pushing_a_message_should_add_it_to_the_queue
+    msg = SMQ::Message.build("payload")
+    @queue.push(msg)
+    assert_equal 1, @queue.length
+  end
+
+  def test_enqueueing_a_payload_should_create_a_message_and_add_it_to_the_queue
+    msg = @queue.enqueue("payload")
+    assert_instance_of SMQ::Message, msg
+    assert_equal 1, @queue.length
+  end
+
+  def test_should_reserve_a_message_when_one_is_available
+    populate_queue(@queue, 1)
+    assert_instance_of SMQ::Message, @queue.reserve(@worker)
+  end
+
+  def test_reserve_should_return_nil_when_no_message_to_reserve
+    assert_nil @queue.reserve(@worker)
+  end
+
+  def test_find_available_should_return_up_to_batch_size_queued_messages
+    populate_queue(@queue, 10)
+    @queue.batch_size = 3
+    assert_equal @queue.batch_size, @queue.find_available.length
+  end
+
+  def test_flush_should_clear_all_messages_from_the_queue
+    populate_queue(@queue, 5)
+    @queue.flush!
+    assert_equal 0, @queue.length
+  end
+
+  def test_clearing_completed_should_not_touch_incomplete_messages
+    populate_queue(@queue, 5)
+    SMQ::Message.find(:first).ack!
+    @queue.clear_completed!
+    assert_equal 4, @queue.length
+  end
+
+  def test_clearing_successful_should_not_touch_failed_messages
+    populate_and_ack_all_but_fail_one
+    @queue.clear_successful!
+    assert_equal 1, SMQ::Message.count(:conditions => ["queue = ?", @queue.name])
+  end
+
+  def test_clearing_failures_should_not_touch_successful_messages
+    populate_and_ack_all_but_fail_one
+    @queue.clear_failed!
+    assert_equal 4, SMQ::Message.count(:conditions => ["queue = ?", @queue.name])
+  end
+
+  def test_clearing_one_queue_should_not_affect_another
+    @other_queue = SMQ::Queue.new("other_queue")
+    populate_queue(@queue, 5)
+    populate_queue(@other_queue, 5)
+    @queue.flush!
+    assert_equal 5, @other_queue.length
+  end
+
+  def test_should_return_correct_queue_size
+    populate_queue(@queue, 5)
+    assert_equal 5, @queue.length
+  end
+
+  private
+
+  def populate_and_ack_all_but_fail_one
+    populate_queue(@queue, 5)
+    msg = SMQ::Message.find(:first)
+    msg.fail
+    msg.save!
+    @worker.work(true) { |m| m.ack! }
+  end
+
+end

data/test/test_worker.rb

@@ -0,0 +1,60 @@
+require 'helper'
+
+class WorkerTest < Test::Unit::TestCase
+
+  def setup
+    @worker = SMQ::Worker.new("test_queue")
+  end
+
+  def teardown
+    SMQ.flush_all_queues!
+  end
+
+  def test_new_worker_should_have_correctly_named_queue
+    assert_equal "test_queue", @worker.queue.name
+  end
+
+  def test_can_init_worker_with_queue_instance
+    worker = SMQ::Worker.new(@worker.queue)
+    assert_instance_of SMQ::Queue, worker.queue
+    assert_equal @worker.queue.name, worker.queue.name
+  end
+
+  def test_working_should_yield_a_message_when_one_is_available
+    SMQ::Message.build("string", @worker.queue.name).save!
+    yielded_msg = nil
+    @worker.work_one_message { |m| yielded_msg = m }
+    assert_instance_of SMQ::Message, yielded_msg
+  end
+
+  def test_working_should_return_message_locked_to_correct_worker
+    SMQ::Message.build("string", @worker.queue.name).save!
+    assert_equal @worker.work_one_message.locked_by, @worker.name
+  end
+
+  def test_working_should_return_nil_when_none_are_available
+    assert_nil @worker.work_one_message
+  end
+
+  def test_working_an_empty_queue_until_empty_should_do_nothing
+    block_calls = 0
+    @worker.work(true) { block_calls += 1 }
+    assert_equal 0, block_calls
+  end
+
+  def test_working_a_populated_queue_until_empty_should_work_all_jobs
+    populate_queue(@worker.queue.name, 5)
+    block_calls = 0
+    @worker.work(true) { block_calls += 1 }
+    assert_equal 5, block_calls
+  end
+
+  def test_working_continues_until_told_to_stop
+    t = Thread.new { @worker.work }
+    assert @worker.is_working?, "Not working"
+    @worker.stop!
+    sleep 2
+    assert !@worker.is_working?, "Working and should have stopped"
+  end
+
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: smq
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Tim Blair
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-10 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A simple database-backed, JSON-based message queue and worker base
+email: tim@bla.ir
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- examples/database.yml
+- examples/worker.rb
+- lib/smq.rb
+- lib/smq/message.rb
+- lib/smq/queue.rb
+- lib/smq/worker.rb
+- test/database.yml
+- test/helper.rb
+- test/test_message.rb
+- test/test_queue.rb
+- test/test_worker.rb
+has_rdoc: true
+homepage: http://github.com/timblair/smq
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Simple Message Queue
+test_files: 
+- test/helper.rb
+- test/test_message.rb
+- test/test_queue.rb
+- test/test_worker.rb
+- examples/worker.rb