disquo 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1f9ffa4b76dc43b762c79ff560a981b71d8e6bfb
+  data.tar.gz: 4c320fe08f60dd1d9fc18a190e65ef73d06cff64
+SHA512:
+  metadata.gz: 143053e6aa72ef607a876baa1059457e1db32a75e300448529feb3363ec991919b5c70bae3c147b6ac0b9a3095af862fb4c9dd8962bca0b2702943d650c48984
+  data.tar.gz: ef07e3fe2b6c36d4a759d9564475881b43a9bb9319016440662e49b3e3de5aed64d912c5995a56b08abe4ddeb04d62f2cca09bf3ec3a3e9874e528e36297d7c1

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+before_install:
+  - wget https://github.com/antirez/disque/archive/master.tar.gz -O disque-master.tar.gz
+  - tar xf disque-master.tar.gz && cd disque-master/src/ && make && PREFIX=../ make install && cd -
+before_script:
+  - ./disque-master/bin/disque-server --daemonize yes
+script:
+  - bundle exec rake
+rvm:
+  - 2.4
+  - 2.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    disquo (0.3.0)
+      concurrent-ruby
+      connection_pool
+      disque
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.5)
+    connection_pool (2.2.1)
+    diff-lcs (1.3)
+    disque (0.0.6)
+      redic (~> 1.5.0)
+    hiredis (0.6.1)
+    rake (12.3.0)
+    redic (1.5.0)
+      hiredis
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  disquo!
+  rake
+  rspec
+
+BUNDLED WITH
+   1.16.0

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017 Black Square Media Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,57 @@
+# Disquo
+
+[![Build Status](https://travis-ci.org/bsm/disquo.png?branch=master)](https://travis-ci.org/bsm/disquo)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+Minimalist, threaded high-performance Ruby workers on top of [Disque](https://github.com/antirez/disque).
+
+## Installation
+
+Add this to your Gemfile:
+
+```ruby
+gem 'disquo'
+```
+
+Then execute:
+
+```shell
+$ bundle
+```
+
+## Usage
+
+Define a job:
+
+```ruby
+require 'disquo'
+
+class MyJob
+  include Disquo::Job
+
+  job_options queue: "notdefault", ttl: 3600, async: true
+
+  def perform(msg)
+    $stdout.puts "Hello #{msg}!"
+  end
+end
+
+# Enqueue with override
+MyJob.enqueue ["World"], ttl: 7200
+```
+
+Create a worker config file:
+
+```yaml
+queues: ["default", "notdefault"]
+concurrency: <%= ENV['NUM_THREADS'] || 20 %>
+```
+
+Start a worker:
+
+```shell
+$ RACK_ENV=production disquo -C config/disquo.yaml -r config/environment.rb
+I, [#12581]  INFO -- : Starting worker - queues: ["default", "notdefault"], concurrency: 20
+I, [#12581]  INFO -- : Process {"klass":"MyJob","args":["World"]} - thread: 7807s, job: DI8613f71b34be272dff91e63fa576340076f169bf05a0SQ
+...
+```

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+desc 'Default: run specs.'
+task default: :spec

data/bin/disquo

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+lib_dir = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'disquo/cli'
+
+cli = Disquo::CLI.instance
+begin
+  cli.parse!
+  cli.run!
+rescue ArgumentError => e
+  STDERR.puts " ! #{e.message}\n"
+  STDERR.puts
+  STDERR.puts cli.parser
+  exit 1
+rescue => e
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/disquo.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name        = "disquo"
+  s.version     = "0.3.0"
+  s.platform    = Gem::Platform::RUBY
+
+  s.licenses    = ["Apache-2.0"]
+  s.summary       = "Concurrent background workers on top of Disque"
+  s.description   = "Concurrent background workers on top of Disque"
+
+  s.authors     = ["Dimitrij Denissenko"]
+  s.email       = "dimitrij@blacksquaremedia.com"
+  s.homepage    = "https://github.com/bsm/disquo"
+
+  s.executables   = ['disquo']
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.required_ruby_version = ">= 2.3.0"
+
+  s.add_dependency 'disque'
+  s.add_dependency 'connection_pool'
+  s.add_dependency 'concurrent-ruby'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/lib/disquo/cli.rb

@@ -0,0 +1,109 @@
+require 'singleton'
+require 'optparse'
+require 'yaml'
+require 'erb'
+
+module Disquo
+  class CLI
+    include Singleton
+
+    DEFAULT_OPTIONS = {
+      config:       nil,
+      queues:       ["default"],
+      concurrency:  10,
+      disque_nodes: ["127.0.0.1:7711"],
+      disque_opts:  {},
+      pool_size:    nil, # auto
+      pool_timeout: 1,
+      logfile:      nil, # STDOUT
+      wait_time:    1,
+      wait_count:   100,
+    }
+
+    attr_reader :opts
+
+    def initialize
+      @opts = DEFAULT_OPTIONS.dup
+    end
+
+    def parse!(argv = ARGV)
+      parser.parse!(argv)
+
+      # Check config file
+      if opts[:config] && !File.exist?(opts[:config])
+        raise ArgumentError, "Unable to find config file in #{opts[:config]}"
+      end
+
+      # Load config file
+      if opts[:config]
+        conf = YAML.load(ERB.new(IO.read(opts[:config])).result)
+        unless conf.is_a?(Hash)
+          raise ArgumentError, "File in #{opts[:config]} does not contain a valid configuration"
+        end
+        conf.each do |key, value|
+          opts[key.to_sym] = value
+        end
+      end
+
+      # Set pool size using concurrency
+      opts[:pool_size] ||= opts[:concurrency] + 5
+    end
+
+    def run!
+      return if @worker
+
+      require opts[:require] if opts[:require]
+      require 'disquo/worker'
+
+      Disquo.logger = ::Logger.new(opts[:logfile]) if opts[:logfile]
+      disque = Disquo.connect \
+        nodes: opts[:disque_nodes],
+        opts:  opts[:disque_opts],
+        pool_size:    opts[:pool_size],
+        pool_timeout: opts[:pool_timeout]
+
+      Signal.trap("TERM") { shutdown }
+      Signal.trap("INT")  { shutdown }
+
+      @worker = Disquo::Worker.new disque,
+        queues: opts[:queues],
+        concurrency: opts[:concurrency],
+        wait_time:   opts[:wait_time],
+        wait_count:  opts[:wait_count]
+      @worker.run
+      @worker.wait
+    end
+
+    def shutdown
+      return unless @worker
+
+      @worker.shutdown
+    end
+
+    def parser
+      @parser ||= begin
+        op = OptionParser.new do |o|
+          o.on '-C', '--config FILE', "YAML config file to load" do |v|
+            @opts[:config] = v
+          end
+
+          o.on '-r', '--require [PATH|DIR]', "File to require" do |v|
+            @opts[:require] = v
+          end
+
+          o.on '-L', '--logfile PATH', "path to writable logfile" do |v|
+            @opts[:logfile] = v
+          end
+        end
+
+        op.banner = "disquo [options]"
+        op.on_tail "-h", "--help", "Show help" do
+          $stdout.puts parser
+          exit 1
+        end
+      end
+    end
+
+  end
+end
+

data/lib/disquo/job.rb

@@ -0,0 +1,47 @@
+module Disquo::Job
+  attr_accessor :job_id, :queue, :disque
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # Indicate to disque that this job is still in progress
+  def working!
+    disque.with {|cn| cn.call :working, job_id } if disque && job_id
+  end
+
+  module ClassMethods
+
+    # Configures the Job
+    #
+    # @param [Hash] opts the options to enqueue the message with.
+    # @option opts [String] :queue a specific queue name. Default: "default"
+    # @option opts [Numeric] :timeout number of seconds to wait for server to `:replicate` level (if no `:async` is specified). Default: 10s
+    # @option opts [Integer] :replicate number of nodes the job should be replicated to
+    # @option opts [Integer] :retry seconds after, if no ACK is received, the job is put into the queue again for delivery. Default: 5m
+    # @option opts [Integer] :ttl max job life-time in seconds. Default: 24h
+    # @option opts [Integer] :maxlen specifies that if there are already `maxlen` messages queued for the specified queue name, the message is refused.
+    # @option opts [Boolean] :async asks the server to let the command return ASAP and replicate the job to other nodes in the background.
+    def job_options(opts = {})
+      @job_options ||= {}
+      @job_options.update(opts) unless opts.nil? || opts.empty?
+      @job_options
+    end
+
+    # Enqueues the job
+    # @param [Array] args arguments to pass to #perform
+    # @param [Hash] opts the options to enqueue the message with (see Disquo::Job::ClassMethods.job_options)
+    # @option opts [Interger] :delay is the number of seconds that should elapse before the job is queued by any server
+    def enqueue(args = [], opts = {})
+      opts    = job_options.merge(opts)
+      queue   = opts.delete(:queue) || Disquo::DEFAULT_QUEUE
+      timeout = ((opts.delete(:timeout) || 10).to_f * 1000).to_i
+      payload = Disquo.dump_job(name, args)
+
+      Disquo.disque.with do |conn|
+        conn.push(queue, payload, timeout, opts)
+      end
+    end
+
+  end
+end

data/lib/disquo/worker.rb

@@ -0,0 +1,122 @@
+require 'disquo'
+require 'concurrent'
+require 'concurrent/executor/fixed_thread_pool'
+
+class Disquo::Worker
+  attr_reader :disque, :queues, :wait_time, :wait_count
+
+  # Init a new worker instance
+  # @param [ConnectionPool] disque client connection pool
+  # @param [Hash] options
+  # @option [Array<String>] :queues queues to watch. Default: ["default"]
+  # @option [Integer] :concurrency the number of concurrent threads. Default: 10
+  # @option [Numeric] :wait_time maximum time (in seconds) to block for when retrieving next batch. Default: 1s
+  # @option [Integer] :wait_count the minimum number of jobs to wait for when retrieving next batch. Default: 100
+  def initialize(disque, queues: [Disquo::DEFAULT_QUEUE], concurrency: 10, wait_time: 1, wait_count: 100)
+    @disque     = disque
+    @queues     = Array(queues)
+    @threads    = Concurrent::FixedThreadPool.new(concurrency)
+    @wait_time  = wait_time
+    @wait_count = wait_count
+  end
+
+  # Run starts the worker
+  def run
+    Disquo.logger.info "Starting worker - queues: #{queues.inspect}, concurrency: #{@threads.max_length}"
+
+    begin
+      run_cycle
+    rescue => e
+      handle_exception(e)
+    end until @stopped
+
+    @threads.shutdown
+  end
+
+  # Blocks until worker is stopped
+  def wait(timeout = nil)
+    Disquo.logger.info "Waiting for worker shutdown"
+    @threads.wait_for_termination(timeout)
+    Disquo.logger.info "Shutdown complete"
+  end
+
+  # Stops the worker
+  def shutdown
+    return false if @stopped
+
+    @stopped = true
+  end
+
+  private
+
+    def run_cycle
+      jobs = next_batch
+
+      until @stopped || jobs.empty?
+        job = jobs.shift
+        perform(*job)
+      end
+    ensure
+      requeue(jobs) unless jobs.nil? || jobs.empty?
+    end
+
+    def next_batch
+      jobs = disque.with do |cn|
+        cn.fetch from: queues, timeout: (wait_time*1000).to_i, count: wait_count
+      end
+      @is_down = nil
+      Array(jobs)
+    rescue => e
+      if !@is_down
+        @is_down = true
+        handle_exception(e, message: 'Error retrieving jobs:')
+      end
+      sleep(1)
+      []
+    end
+
+    def perform(queue, job_id, payload)
+      @threads.post do
+        thread_id = Thread.current.object_id.to_s(36)
+        Disquo.logger.info { "Process #{payload} - thread: #{thread_id}, job: #{job_id}" }
+
+        begin
+          class_name, args = Disquo.load_job(payload)
+
+          job = Object.const_get(class_name).new
+          job.disque = disque
+          job.queue  = queue
+          job.job_id = job_id
+          job.perform(*args)
+        rescue => e
+          handle_exception e, message: "Error processing #{payload} - thread: #{thread_id}, job: #{job_id}:"
+
+          disque.with {|cn| cn.call :nack, job_id }
+          return
+        end
+
+        begin
+          disque.with {|cn| cn.call :ackjob, job_id }
+        rescue => e
+          handle_exception e, message: "Error ACKing #{payload} - thread: #{thread_id}, job: #{job_id}:"
+          return
+        end
+      end
+    end
+
+    def requeue(jobs)
+      ids = jobs.map {|_, job_id, _| job_id }
+      disque.with {|cn| cn.call :enqueue, *ids }
+    end
+
+    def handle_exception(e, opts = {})
+      lines = [
+        opts[:message],
+        "#{e.class.name}: #{e.message}",
+        e.backtrace
+      ].compact.flatten
+
+      Disquo.logger.error lines.join("\n")
+    end
+
+end

data/lib/disquo.rb

@@ -0,0 +1,66 @@
+require 'disque'
+require 'connection_pool'
+require 'json'
+require 'logger'
+
+module Disquo
+  DEFAULT_QUEUE = "default".freeze
+
+  # Configure disque with a block.
+  #
+  # @example:
+  #   Disquo.configure do |c|
+  #     c.disque = c.connect(nodes: ["10.0.0.1:7711", "10.0.0.2:7711", "10.0.0.3:7711"])
+  #   end
+  def self.configure(&block)
+    block.call(self)
+  end
+
+  # @option [Array<String>|String] nodes a list of disque nodes. Default: ["127.0.0.1:7711"]
+  # @option [Hash] opts additional disque connection options.
+  # @option [Numeric] pool_timeout disque connection pool timeout in seconds. Default: 1.0
+  # @option [Integer] pool_size the number of slots in the connection pool. Default: 5
+  #
+  # @return [ConnectionPool] disque client connection pool
+  def self.connect(nodes: ["127.0.0.1:7711"], opts: {}, pool_size: 5, pool_timeout: 1)
+    ConnectionPool.new timeout: pool_timeout, size: pool_size do
+      Disque.new(nodes, opts)
+    end
+  end
+
+  # @return [ConnectionPool] disque client connection pool
+  def self.disque
+    @disque ||= connect
+  end
+
+  # @param [ConnectionPool] disque client connection pool
+  def self.disque=(pool)
+    @disque = pool
+  end
+
+  # @return [Logger] returns the logger instance
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  # @param [Logger] log logger instance to use
+  def self.logger=(log)
+    @logger = log
+  end
+
+  # @param [String] payload
+  # @return [Array<Class, Array>] job class and argument
+  def self.load_job(payload)
+    JSON.load(payload).values_at("klass", "args")
+  end
+
+  # @param [String] class_name class name
+  # @param [Array] arguments
+  # @return [String] serialised job
+  def self.dump_job(class_name, args)
+    JSON.dump "klass" => class_name, "args" => Array(args)
+  end
+
+end
+
+require 'disquo/job'

data/spec/disquo/job_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe Disquo::Job do
+
+  it "should enqueue jobs" do
+    jid1 = TestJob.enqueue ["foo", 1]
+    expect(qlen).to eq(1)
+    expect(jid1).to match(/^D\w+/)
+    expect(show(jid1)).to include(
+      "id"    => jid1,
+      "queue" => "__disquo_test__",
+      "nacks" => 0,
+      "delay" => 0,
+      "repl"  => 1,
+      "state" => "queued",
+      "body"  => %({"klass":"TestJob","args":["foo",1]}),
+    )
+
+    jid2 = TestJob.enqueue ["bar"], delay: 600
+    expect(qlen).to eq(1)
+    expect(jid2).to match(/^D\w+/)
+    expect(show(jid2)).to include(
+      "id"    => jid2,
+      "queue" => "__disquo_test__",
+      "nacks" => 0,
+      "delay" => 600,
+      "repl"  => 1,
+      "state" => "active",
+      "body"  => %({"klass":"TestJob","args":["bar"]}),
+    )
+  end
+
+  it "should have instance attributes" do
+    job1, job2 = TestJob.new, TestJob.new
+    job1.job_id = "JOB1"
+    expect(job1.job_id).to eq("JOB1")
+    expect(job2.job_id).to be_nil
+  end
+
+end

data/spec/disquo/worker_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+RSpec.describe Disquo::Worker do
+
+  subject do
+    described_class.new Disquo.connect, wait_time: 0.1, wait_count: 11, queues: Disquo::TEST::QUEUE
+  end
+
+  it "should run/process/shutdown" do
+    runner = Thread.new { subject.run }
+
+    # seed 200 jobs
+    200.times {|n| TestJob.enqueue(n) }
+    wait_for { !qlen.zero? }
+
+    # ensure runner processes them all
+    wait_for { qlen.zero? }
+    expect(runner).to be_alive
+    expect(qlen).to eq(0)
+
+    # ask runner to quit
+    expect(subject.shutdown).to be_truthy
+    expect(subject.shutdown).to be_falsey
+
+    # wait for runner to exit
+    subject.wait
+    expect(runner).not_to be_alive
+
+    # check what's been performed
+    expect(Disquo::TEST::PERFORMED.size).to eq(200)
+    expect(Disquo::TEST::PERFORMED.last).to include(
+      klass: "TestJob",
+      queue: "__disquo_test__",
+    )
+    expect(Disquo::TEST::PERFORMED.last[:job_id]).to match(/^D\w+/)
+  end
+
+  def wait_for
+    20.times do
+      break if yield
+      sleep(0.01)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+require 'rspec'
+require 'disquo'
+require 'disquo/worker'
+
+module Disquo::TEST
+  QUEUE = "__disquo_test__"
+  PERFORMED = []
+end
+
+class TestJob
+  include Disquo::Job
+
+  job_options queue: Disquo::TEST::QUEUE, async: true
+
+  def perform(*args)
+    Disquo::TEST::PERFORMED.push(klass: self.class.name, args: args, queue: queue, job_id: job_id)
+  end
+end
+
+helpers = Module.new do
+
+  def qlen
+    Disquo.disque.with do |conn|
+      conn.call :qlen, Disquo::TEST::QUEUE
+    end
+  end
+
+  def show(job_id)
+    Disquo.disque.with do |conn|
+      pairs = conn.call :show, job_id
+      Hash[*pairs]
+    end
+  end
+
+end
+
+RSpec.configure do |c|
+  c.include helpers
+
+  c.before :each do
+    Disquo.logger = Logger.new(nil)
+  end
+
+  c.after :each do
+    Disquo::TEST::PERFORMED.clear
+    Disquo.disque.with do |conn|
+      _, ids = conn.call :jscan, 0, :count, 10000, :queue, Disquo::TEST::QUEUE
+      conn.call :deljob, *ids unless ids.empty?
+    end
+  end
+
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: disquo
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Dimitrij Denissenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: disque
+  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'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  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'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  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'
+- !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'
+description: Concurrent background workers on top of Disque
+email: dimitrij@blacksquaremedia.com
+executables:
+- disquo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/disquo
+- disquo.gemspec
+- lib/disquo.rb
+- lib/disquo/cli.rb
+- lib/disquo/job.rb
+- lib/disquo/worker.rb
+- spec/disquo/job_spec.rb
+- spec/disquo/worker_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bsm/disquo
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Concurrent background workers on top of Disque
+test_files:
+- spec/disquo/job_spec.rb
+- spec/disquo/worker_spec.rb
+- spec/spec_helper.rb