dbq 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 945cacb9b92fb902509f1fcc529711486252c550
+  data.tar.gz: 9c889fab71094d0aacc02d74a391fe786c549379
+SHA512:
+  metadata.gz: ea1df7b2ebe4d1c617fc8069216fd756d82e7e3e7e28093532864a146b98acacf634ddabaeb9426422feb99a820e0120fe230734668e63e94386dca6d4cb2471
+  data.tar.gz: 502452a1f3ac28affe23e61367e2cc9ecbd49ebb7cec6ea5bcb0fd9c965dee06c8014eb163a4bbf81c72c0dc122bf992642bee40193608f0eb7f1143e70a9858

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,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tyler Hartland
+
+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,110 @@
+# DBQ
+
+DuraBle Queues
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dbq'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dbq
+
+## Usage
+
+### Queue
+
+Create a table with the following column and index:
+
+* checked_out_at (timestamp, indexed)
+
+Add any data columns you want.
+
+Create an ActiveRecord model for your table and include DBQ:Queue:
+
+```
+class MyQueue < ActiveRecord::Base
+  include DBQ::Queue
+end
+```
+
+Push some data onto your queue (push is, for now, synonymous with create!):
+
+```MyQueue.push(my_data: 'some data')```
+
+Pop your data back off your queue:
+
+```MyQueue.pop.my_data #=> 'some data'```
+
+### OrderedQueue
+
+Create a table with the following columns:
+
+* checked_out_at (timestamp, indexed)
+* my_ordered_attr1 (any type, indexed)
+* my_ordered_attr2 (any type, indexed)
+* ...
+
+Again, add any data fields you want.
+
+Create an ActiveRecord model for your table and include DBQ:OrderedQueue. Be sure to specify which fields should enforce order (detailed explanation below). I'd recommend validating presence on those fields as well.
+
+```
+class MyOrderedQueue < ActiveRecord::Base
+  include DBQ::OrderedQueue
+  validates :my_ordered_attr1, :my_ordered_attr2, presence: true
+  enforces_order_on :my_ordered_attr1, :my_ordered_attr2
+end
+```
+
+Push some data onto your queue:
+
+```MyOrderedQueue.push(my_ordered_attr1: 'attr1', my_ordered_attr2: 'attr2', my_data 'some data')```
+
+Pop your data back off your queue:
+
+```MyOrderedQueue.pop.my_data #=> 'some data'```
+
+What's the point!?
+
+DBQ::OrderedQueue will enforce processing order for records which have matching ordered_attrs. If a 'sibling' record is checked out, its siblings will not come off the queue until the first sibling's pop is committed. Here's an example:
+
+Two sibling records exist (using one ordered attr for brevity):
+
+```
+MyOrderedQueue.push(ordered: 1, data: 'first item')
+MyOrderedQueue.push(ordered: 1, data: 'second item')
+```
+
+One process/thread pops the first item (in a transaction!):
+
+```do_some_slow_transactional_work(MyOrderedQueue.pop) ```
+
+Before the first transaction commits, DBQ::OrderedQueue restricts access to the sibling item:
+
+```MyOrderedQueue.pop #=> nil```
+
+After the first transaction commits, DBQ::OrderedQueue allows the second item to be popped:
+
+```MyOrderedQueue.pop.data #=> 'second item'```
+
+If the first transaction rolls back, the first item will come off the queue again:
+
+```MyOrderedQueue.pop.data #=> 'first item'```
+
+If the process gets killed or the OS crashes while the first item is checked out, you may need to manually check the item back in by setting checked_out_at to null.
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/dbq/fork )
+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,31 @@
+require "bundler/gem_tasks"
+require 'dbq'
+
+namespace :db do
+  desc "Seed job schedules"
+  namespace :test do
+    task :prepare do
+      puts `dropdb dbq_test -e`
+      puts `createdb dbq_test -e`
+
+      # only testing on postgres for now
+      db = URI.parse('postgres://localhost/dbq_test')
+      DB_NAME = db.path[1..-1]
+
+      ActiveRecord::Base.establish_connection(
+        :adapter  => db.scheme == 'postgres' ? 'postgresql' : db.scheme,
+        :host     => db.host,
+        :port     => db.port,
+        :username => db.user,
+        :password => db.password,
+        :database => DB_NAME,
+        :encoding => 'utf8'
+      )
+
+      Dir['spec/migrate/*.rb'].each { |f| require File.absolute_path(f) }
+      migrations = Migrate.constants.map { |c| Migrate.const_get(c) }
+      ActiveRecord::Migration.run(*migrations)
+    end
+  end
+end
+

data/dbq.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dbq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dbq"
+  spec.version       = DBQ::VERSION
+  spec.authors       = ["TH"]
+  spec.email         = ["tyler.hartland@code42.com"]
+  spec.summary       = %q{Durable queues which commit with database transactions.}
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pg"
+
+  spec.add_runtime_dependency 'activerecord'
+end

data/lib/dbq.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require 'active_support/inflector'
+
+Gem.find_files("dbq/**/*.rb").each { |path| require path }
+
+module DBQ
+  class Error < StandardError; end
+end

data/lib/dbq/basic_queue.rb

@@ -0,0 +1,44 @@
+module DBQ
+  module BasicQueue
+    def self.included(receiver)
+      receiver.after_rollback :check_in!
+      receiver.extend ClassMethods
+    end
+
+    module ClassMethods
+      def pop
+        item = check_out_item
+        item.try(:destroy)
+        item
+      end
+
+      def push(opts)
+        create!(opts)
+      end
+
+      private
+
+      def check_out_item
+        raise 'Do not include BasicQueue directly. Maybe you wanted DBQ::Queue?'
+      end
+    end
+
+    def check_out!
+      self.update_attributes(checked_out_at: Time.now)
+    end
+
+    def check_in!
+      # necessary if we were frozen by a rolled back destroy call
+      self.class.update(id, checked_out_at: nil)
+    end
+
+    def data=(new_data)
+      self.wrapped_data ||= {}
+      wrapped_data['data'] = new_data
+    end
+
+    def data
+      wrapped_data['data'] if wrapped_data
+    end
+  end
+end

data/lib/dbq/ordered_queue.rb

@@ -0,0 +1,63 @@
+module DBQ
+  module OrderedQueue
+    def self.included(receiver)
+      receiver.include BasicQueue
+      receiver.extend ClassMethods
+    end
+
+    module ClassMethods
+      def enforces_order_on(*attrs)
+        @check_out_query = nil
+        @enforce_order_on = attrs
+        # check indexes and warn if they do not exist?
+      end
+
+      private
+
+      def check_out_item
+        # a separate thread means a separate connection/transaction/commit
+        thread = Thread.new do
+          item = nil
+          connection_pool.with_connection do
+            transaction do
+              item = find_by_sql(check_out_query).first
+              item.try(:check_out!)
+            end
+          end
+          item
+        end
+        thread.abort_on_exception = true
+        thread.value
+      end
+
+      def check_out_query
+        @check_out_query ||= <<-SQL
+          select * from #{table_name}
+          where #{table_name}.id not in (
+            select #{table_name}.id
+            from #{table_name}
+            inner join #{table_name} as self_join on
+              #{join_clause}
+            where self_join.checked_out_at is not null
+          )
+          and #{table_name}.checked_out_at is null
+          order by #{table_name}.id asc
+          limit 1
+          for update;
+        SQL
+      end
+
+      # possibly add check/warn for recommended indexes
+      # def indexes
+      #   connection.indexes(self)
+      # end
+
+      def join_clause
+        @enforce_order_on.inject([]) do |items, ordered_attr|
+          items << "#{table_name}.#{ordered_attr} = self_join.#{ordered_attr}"
+          items
+        end.join(' and ')
+      end
+    end
+  end
+end

data/lib/dbq/queue.rb

@@ -0,0 +1,28 @@
+module DBQ
+  module Queue
+    def self.included(receiver)
+      receiver.include BasicQueue
+      receiver.extend ClassMethods
+    end
+
+    module ClassMethods
+      private
+
+      def check_out_item
+        thread = Thread.new do
+          item = nil
+          connection_pool.with_connection do
+            transaction do
+              item = where(checked_out_at: nil)
+              .order(id: :asc).limit(1).lock(true).first
+              item.try(:check_out!)
+            end
+          end
+          item
+        end
+        thread.abort_on_exception = true
+        thread.value
+      end
+    end
+  end
+end

data/lib/dbq/version.rb

@@ -0,0 +1,3 @@
+module DBQ
+  VERSION = "1.0.0"
+end

data/spec/integration/postgres/connnected_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe 'a database connection exists' do
+  it 'does not raise an error' do
+    expect { ActiveRecord::Base.connection.execute('select 1') }.not_to raise_error
+  end
+end

data/spec/integration/postgres/ordered_queue_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+
+class TestOrderedQueue < ActiveRecord::Base
+  include DBQ::OrderedQueue
+  enforces_order_on :fk1, :fk2
+end
+
+describe TestOrderedQueue do
+  let(:klass) { TestOrderedQueue }
+
+  before do
+    # klass.logger = Logger.new(STDOUT)
+    klass.delete_all
+  end
+
+  after do
+    klass.delete_all
+  end
+
+  context 'a single item exists' do
+    let(:value) { {'expected' => 'changed_attrs'} }
+
+    before do
+      klass.push(data: value)
+    end
+
+    it 'can pop the item back out' do
+      expect(klass.pop.data).to eq value
+    end
+
+    it 'destroys the item' do
+      expect { klass.pop }.to change { klass.count }.from(1).to(0)
+    end
+
+    context 'the transaction is rolled back' do
+      it 'does not destroy the item' do
+        expect {
+          klass.transaction { klass.pop; raise ActiveRecord::Rollback }
+        }.not_to change {
+          klass.count
+        }.from(1)
+      end
+
+      it 'resets checked_out_at to nil' do
+        expect {
+          klass.transaction { klass.pop; raise ActiveRecord::Rollback }
+        }.not_to change {
+          klass.first.checked_out_at
+        }.from(nil)
+      end
+    end
+  end
+
+  context 'items are not order constrained' do
+    before do
+      klass.push(data: 1)
+      klass.push(data: 2)
+      klass.push(data: 3)
+    end
+
+    context 'multiple items are popped simultaneously' do
+      it 'only pops each item once' do
+        result_threads = [
+          simultaneous_pop,
+          simultaneous_pop,
+          simultaneous_pop
+        ]
+        values = result_threads.map(&:value)
+        data = values.map(&:data)
+        expect(data.sort).to eq [ 1, 2, 3 ]
+      end
+    end
+
+  end
+
+  context 'order enforcement matches partially' do
+    before do
+      klass.push(fk1: 1, fk2: 1, data: 1)
+      klass.push(fk1: 1, fk2: 2, data: 2)
+      klass.push(fk1: 1, fk2: 3, data: 3)
+    end
+
+    context 'multiple items are popped simultaneously' do
+      it 'only pops each item once' do
+        result_threads = [
+          simultaneous_pop,
+          simultaneous_pop,
+          simultaneous_pop
+        ]
+        values = result_threads.map(&:value)
+        data = values.map(&:data)
+        expect(data.sort).to eq [ 1, 2, 3 ]
+      end
+    end
+  end
+
+  context 'order enforcement matches' do
+    before do
+      klass.push(fk1: 1, fk2: 1, data: 1)
+      klass.push(fk1: 1, fk2: 1, data: 2)
+      klass.push(fk1: 1, fk2: 1, data: 3)
+    end
+
+    it 'pops items in order' do
+      expect([klass.pop.data, klass.pop.data, klass.pop.data]).to eq [ 1, 2, 3 ]
+    end
+
+    context 'multiple items are popped simultaneously' do
+      it 'only pops each item once' do
+        result_threads = [
+          simultaneous_pop,
+          simultaneous_pop,
+          simultaneous_pop
+        ]
+        values = result_threads.map(&:value).compact.sort
+        # ids = values.map(&:id)
+        expect(values.uniq).to eq values
+      end
+    end
+
+    context 'an item is being processed' do
+      it 'does not return order-enfoced items' do
+        thread = slow_threaded_pop # work on an item
+        sleep 0.05 # wait for threaded pop to go first
+        begin
+          expect(klass.count).to eq 3
+          expect(klass.first.checked_out_at).not_to be_nil
+          expect(klass.last.checked_out_at).to be_nil
+          expect(klass.pop).to be_nil
+        ensure
+          thread.kill
+        end
+      end
+      context 'a non-order-enforced item also exists' do
+        before do
+          klass.push(fk1: 1, fk2: 4, data: 4)
+        end
+
+        it 'returns the non-order-enforced item' do
+          thread = slow_threaded_pop # work on an item
+          sleep 0.05 # wait for threaded pop to go first
+          begin
+            expect(klass.count).to eq 4
+            expect(klass.first.checked_out_at).not_to be_nil
+            expect(klass.last.checked_out_at).to be_nil
+            expect(klass.pop.data).to eq 4
+          ensure
+            thread.kill
+          end
+        end
+      end
+    end
+
+  end
+end
+
+def simultaneous_pop(at=Time.now + 0.1)
+  thread = Thread.new do
+    result = nil
+    klass.connection_pool.with_connection do
+      klass.transaction do
+        sleep_for = at - Time.now
+        sleep sleep_for if sleep_for > 0
+        result = klass.pop
+      end
+    end
+    result
+  end
+  thread.abort_on_exception = true
+  thread
+end
+
+def slow_threaded_pop
+  thread = Thread.new do
+    klass.connection_pool.with_connection do
+      klass.transaction do
+        klass.pop
+        sleep 2
+      end
+    end
+  end
+  thread.abort_on_exception = true
+  thread
+end

data/spec/integration/postgres/queue_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+class TestQueue < ActiveRecord::Base
+  include DBQ::Queue
+end
+
+describe TestQueue do
+  let(:klass) { TestQueue }
+
+  before do
+    klass.connection_pool.with_connection do
+      klass.delete_all
+    end
+  end
+
+  after do
+    klass.connection_pool.with_connection do
+      klass.delete_all
+    end
+  end
+
+  context 'a single item exists' do
+    let(:value) { {'expected' => 'changed_attrs'} }
+
+    before do
+      klass.push(data: value)
+    end
+
+    it 'can pop the item back out' do
+      expect(klass.pop.data).to eq value
+    end
+
+    it 'destroys the item' do
+      expect { klass.pop.data }.to change { klass.count }.from(1).to(0)
+    end
+
+    context 'the transaction is rolled back' do
+      it 'does not destroy the item' do
+        expect {
+          klass.transaction { klass.pop; raise ActiveRecord::Rollback }
+        }.not_to change {
+          klass.count
+        }.from(1)
+      end
+
+      it 'resets checked_out_at to nil' do
+        expect {
+          klass.transaction { klass.pop; raise ActiveRecord::Rollback }
+        }.not_to change {
+          klass.first.checked_out_at
+        }.from(nil)
+      end
+    end
+  end
+
+  context 'multiple items are popped simultaneously' do
+    before do
+      klass.push(data: 1)
+      klass.push(data: 2)
+      klass.push(data: 3)
+    end
+
+    it 'only pops each item once' do
+      result_threads = [
+        simultaneous_pop,
+        simultaneous_pop,
+        simultaneous_pop
+      ]
+      results = result_threads.map(&:value).map(&:data)
+      expect(results.sort).to eq [ 1, 2, 3 ]
+    end
+  end
+end
+
+def simultaneous_pop(at=Time.now + 0.1)
+  thread = Thread.new do
+    result = nil
+    klass.connection_pool.with_connection do
+      klass.transaction do
+        sleep_for = at - Time.now
+        sleep sleep_for if sleep_for > 0
+        result = klass.pop
+      end
+    end
+    result
+  end
+  thread.abort_on_exception = true
+  thread
+end

data/spec/lib/dbq/queue_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe DBQ::Queue do
+  # tested in integration
+end

data/spec/lib/dbq/version_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe DBQ::VERSION do
+  # it exists
+end

data/spec/migrate/create_test_ordered_queues.rb

@@ -0,0 +1,13 @@
+module Migrate
+  class CreateTestOrderedQueues < ActiveRecord::Migration
+    def change
+      create_table :test_ordered_queues do |t|
+        t.json :wrapped_data
+        t.timestamp :checked_out_at
+
+        t.integer :fk1
+        t.integer :fk2
+      end
+    end
+  end
+end

data/spec/migrate/create_test_queues.rb

@@ -0,0 +1,10 @@
+module Migrate
+  class CreateTestQueues < ActiveRecord::Migration
+    def change
+      create_table :test_queues do |t|
+        t.json :wrapped_data
+        t.timestamp :checked_out_at
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'dbq'
+require 'pg'
+
+RSpec.configure do |config|
+  config.order = 'random'
+end
+
+# only testing on postgres for now
+db = URI.parse('postgres://localhost/dbq_test')
+DB_NAME = db.path[1..-1]
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => db.scheme == 'postgres' ? 'postgresql' : db.scheme,
+  :host     => db.host,
+  :port     => db.port,
+  :username => db.user,
+  :password => db.password,
+  :database => DB_NAME,
+  :encoding => 'utf8'
+)

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: dbq
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TH
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: '0'
+  type: :development
+  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: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: 
+email:
+- tyler.hartland@code42.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dbq.gemspec
+- lib/dbq.rb
+- lib/dbq/basic_queue.rb
+- lib/dbq/ordered_queue.rb
+- lib/dbq/queue.rb
+- lib/dbq/version.rb
+- spec/integration/postgres/connnected_spec.rb
+- spec/integration/postgres/ordered_queue_spec.rb
+- spec/integration/postgres/queue_spec.rb
+- spec/lib/dbq/queue_spec.rb
+- spec/lib/dbq/version_spec.rb
+- spec/migrate/create_test_ordered_queues.rb
+- spec/migrate/create_test_queues.rb
+- spec/spec_helper.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.11
+signing_key: 
+specification_version: 4
+summary: Durable queues which commit with database transactions.
+test_files:
+- spec/integration/postgres/connnected_spec.rb
+- spec/integration/postgres/ordered_queue_spec.rb
+- spec/integration/postgres/queue_spec.rb
+- spec/lib/dbq/queue_spec.rb
+- spec/lib/dbq/version_spec.rb
+- spec/migrate/create_test_ordered_queues.rb
+- spec/migrate/create_test_queues.rb
+- spec/spec_helper.rb
+has_rdoc: