fleiss 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '0786905f08fa028fa92f0d422db3d26acc173b57dbf403b5fe1b20dc2bfb8e73'
+  data.tar.gz: f6f13c6d6c86e456a7779bc06119b2d4e7ed61daa1bbd9438014a0e356daedd0
+SHA512:
+  metadata.gz: 67ae6d5b939e7c83cfa69bba4d0ecbacabbed12a0c474289a9162a82928a2aea78aaaa6d96bf66700f10e06c548ac10fbe3008b7562be1133ed09bfdc33b3713
+  data.tar.gz: 609b536863e02bc91eb093b839f64ec518090bd722eaffa163162cccff537d3cd87f5991c0a366abd403a5a3fb701d1a581830d3d820439d0d74d80e30638812

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,2 @@
+.rubocop-*
+pkg/

data/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_from:
+  - https://storage.googleapis.com/bsm-misc/rubocop.yml
+
+Security/Open:
+  Exclude:
+    - "core/lib/bfs/bucket/abstract.rb"
+    - "core/lib/bfs/blob.rb"
+Metrics/BlockLength:
+  Exclude:
+    - "**/spec/**/*"

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,82 @@
+PATH
+  remote: .
+  specs:
+    fleiss (0.1.0)
+      activejob (>= 5.0)
+      activerecord (>= 5.0)
+      concurrent-ruby
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activejob (5.2.1)
+      activesupport (= 5.2.1)
+      globalid (>= 0.3.6)
+    activemodel (5.2.1)
+      activesupport (= 5.2.1)
+    activerecord (5.2.1)
+      activemodel (= 5.2.1)
+      activesupport (= 5.2.1)
+      arel (>= 9.0)
+    activesupport (5.2.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    ast (2.4.0)
+    concurrent-ruby (1.1.3)
+    diff-lcs (1.3)
+    globalid (0.4.1)
+      activesupport (>= 4.2.0)
+    i18n (1.1.1)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.1)
+    minitest (5.11.3)
+    parallel (1.12.1)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    rainbow (3.0.0)
+    rake (12.3.1)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.60.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    ruby-progressbar (1.10.0)
+    sqlite3 (1.3.13)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  fleiss!
+  rake
+  rspec
+  rubocop
+  sqlite3
+
+BUNDLED WITH
+   1.16.4

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2018 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,62 @@
+# Fleiss
+
+[![Build Status](https://travis-ci.org/bsm/fleiss.png?branch=master)](https://travis-ci.org/bsm/fleiss)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+Minimialist background jobs backed by ActiveJob and ActiveRecord.
+
+## Usage
+
+Define your active jobs, as usual:
+
+```ruby
+class SimpleJob < ActiveJob::Base
+  queue_as :default
+
+  def perform(*args)
+    # Perform Job
+  end
+end
+```
+
+Allow jobs to expire job by specifying an optional TTL:
+
+```ruby
+class ExpringJob < ActiveJob::Base
+  queue_as :default
+  retry_on SomeError, attempts: 1_000_000
+
+  def perform(*args)
+    # Perform Job
+  end
+
+  # This will cause the job to retry up-to 1M times
+  # until the 72h TTL is reached.
+  def ttl
+    72.hours
+  end
+end
+```
+
+Include the data migration:
+
+```ruby
+# db/migrate/20182412102030_create_fleiss_jobs.rb
+require 'fleiss/backend/active_record/migration'
+
+class CreateFleissJobs < ActiveRecord::Migration[5.2]
+  def up
+    Fleiss::Backend::ActiveRecord::Migration.migrate(:up)
+  end
+
+  def down
+    Fleiss::Backend::ActiveRecord::Migration.migrate(:down)
+  end
+end
+```
+
+Run the worker:
+
+```ruby
+bundle exec fleiss -I . -r config/environment
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[spec rubocop]

data/bin/fleiss

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

data/fleiss.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |s|
+  s.name          = 'fleiss'
+  s.version       = '0.1.0'
+  s.authors       = ['Black Square Media Ltd']
+  s.email         = ['info@blacksquaremedia.com']
+  s.summary       = %(Minimialist background jobs backed by ActiveJob and ActiveRecord.)
+  s.description   = %(Run background jobs with your favourite stack.)
+  s.homepage      = 'https://github.com/bsm/fleiss'
+  s.license       = 'Apache-2.0'
+
+  s.executables   = ['fleiss']
+  s.files         = `git ls-files -z`.split("\x0").reject {|f| f.match(%r{^spec/}) }
+  s.test_files    = `git ls-files -z -- spec/*`.split("\x0")
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 2.2'
+
+  s.add_dependency 'activejob', '>= 5.0'
+  s.add_dependency 'activerecord', '>= 5.0'
+  s.add_dependency 'concurrent-ruby'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'sqlite3'
+end

data/lib/active_job/queue_adapters/fleiss_adapter.rb

@@ -0,0 +1,17 @@
+require 'fleiss'
+
+module ActiveJob
+  module QueueAdapters
+    class FleissAdapter
+      def enqueue(job) #:nodoc:
+        enqueue_at(job, nil)
+      end
+
+      def enqueue_at(job, scheduled_at) #:nodoc:
+        job_id = Fleiss.backend.enqueue(job, scheduled_at: scheduled_at)
+        job.provider_job_id = job_id
+        job_id
+      end
+    end
+  end
+end

data/lib/fleiss/backend/active_record/concern.rb

@@ -0,0 +1,88 @@
+module Fleiss
+  module Backend
+    class ActiveRecord
+      module Concern
+        extend ActiveSupport::Concern
+
+        included do
+          scope :in_queue, ->(qs) { where(queue_name: Array.wrap(qs)) }
+          scope :not_finished, -> { where(finished_at: nil) }
+          scope :not_expired,  ->(now=Time.zone.now) { where(arel_table[:expires_at].eq(nil).or(arel_table[:expires_at].gt(now))) }
+          scope :started,      -> { where(arel_table[:started_at].not_eq(nil)) }
+          scope :not_started,  -> { where(arel_table[:started_at].eq(nil)) }
+          scope :scheduled,    ->(now=Time.zone.now) { where(arel_table[:scheduled_at].gt(now)) }
+        end
+
+        module ClassMethods
+          # @return [ActiveRecord::Relation] pending scope
+          def pending(now=Time.zone.now)
+            not_finished
+              .not_expired(now)
+              .not_started
+              .where(arel_table[:scheduled_at].lteq(now))
+              .order(priority: :desc)
+              .order(scheduled_at: :asc)
+          end
+
+          # @return [ActiveRecord::Relation] in-progress scope
+          def in_progress(owner)
+            started.not_finished.where(owner: owner)
+          end
+
+          # Reschedules jobs to run again.
+          def reschedule_all(at=Time.zone.now)
+            update_all(
+              started_at: nil,
+              owner: nil,
+              scheduled_at: at,
+            )
+          end
+
+          # @param [ActiveJob::Base] job the job instance
+          # @option [Time] :scheduled_at schedule job at
+          def enqueue(job, scheduled_at: nil)
+            scheduled_at = scheduled_at ? Time.zone.at(scheduled_at) : Time.zone.now
+            expires_at = scheduled_at + job.ttl.seconds if job.respond_to?(:ttl)
+
+            create!(
+              payload: JSON.dump(job.serialize),
+              queue_name: job.queue_name,
+              priority: job.priority.to_i,
+              scheduled_at: scheduled_at,
+              expires_at: expires_at,
+            ).id
+          end
+        end
+
+        # @return [Hash] serialized job data
+        def job_data
+          @job_data ||= JSON.parse(payload)
+        end
+
+        # @return [String] the ActiveJob ID
+        def job_id
+          job_data['job_id']
+        end
+
+        # Acquires a lock and starts the job.
+        # @param [String] owner
+        # @return [Boolean] true if job was started.
+        def start(owner, now: Time.zone.now)
+          self.class.pending(now)
+              .where(id: id)
+              .update_all(started_at: now, owner: owner) == 1
+        end
+
+        # Marks a job as finished.
+        # @param [String] owner
+        # @return [Boolean] true if successful.
+        def finish(owner, now: Time.zone.now)
+          self.class
+              .in_progress(owner)
+              .where(id: id)
+              .update_all(finished_at: now) == 1
+        end
+      end
+    end
+  end
+end

data/lib/fleiss/backend/active_record/migration.rb

@@ -0,0 +1,29 @@
+require 'fleiss/backend/active_record'
+
+module Fleiss
+  module Backend
+    class ActiveRecord
+      class Migration < ::ActiveRecord::Migration[5.0]
+        def change
+          create_table :fleiss_jobs do |t|
+            t.string :queue_name, limit: 50, null: false
+            t.integer :priority, limit: 2, null: false, default: 10
+            t.text :payload, null: false
+            t.timestamp :scheduled_at, null: false
+            t.timestamp :started_at
+            t.timestamp :finished_at
+            t.timestamp :expires_at
+            t.string :owner, limit: 100
+
+            t.index :queue_name
+            t.index :priority
+            t.index :scheduled_at
+            t.index :finished_at
+            t.index :expires_at
+            t.index :owner
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fleiss/backend/active_record.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+
+module Fleiss
+  module Backend
+    class ActiveRecord < ::ActiveRecord::Base
+      self.table_name = 'fleiss_jobs'
+
+      require 'fleiss/backend/active_record/concern'
+      include self::Concern
+    end
+  end
+end

data/lib/fleiss/backend.rb

@@ -0,0 +1,5 @@
+module Fleiss
+  module Backend
+  end
+end
+require 'fleiss/backend/active_record'

data/lib/fleiss/cli.rb

@@ -0,0 +1,95 @@
+require 'singleton'
+require 'optparse'
+require 'yaml'
+require 'erb'
+require 'logger'
+
+module Fleiss
+  class CLI
+    include Singleton
+
+    DEFAULT_OPTIONS = {
+      config: nil,
+      queues: ['default'],
+      include: [],
+      require: [],
+      concurrency: 10,
+      wait_time: 1.0,
+      logfile: STDOUT,
+    }.freeze
+
+    attr_reader :opts
+
+    def initialize
+      @opts = DEFAULT_OPTIONS.dup
+    end
+
+    def parse!(argv=ARGV)
+      parser.parse!(argv)
+
+      # Check config file
+      raise ArgumentError, "Unable to find config file in #{opts[:config]}" if opts[:config] && !File.exist?(opts[:config])
+
+      return unless opts[:config]
+
+      # Load config file
+      conf = YAML.safe_load(ERB.new(IO.read(opts[:config])).result)
+      raise ArgumentError, "File in #{opts[:config]} does not contain a valid configuration" unless conf.is_a?(Hash)
+
+      conf.each do |key, value|
+        opts[key.to_sym] = value
+      end
+    end
+
+    def run!
+      return if @worker
+
+      $LOAD_PATH.concat opts[:include]
+      opts[:require].each {|n| require n }
+      require 'fleiss/worker'
+
+      Signal.trap('TERM') { shutdown }
+      Signal.trap('INT')  { shutdown }
+
+      @worker = Fleiss::Worker.new \
+        queues: opts[:queues],
+        concurrency: opts[:concurrency],
+        wait_time: opts[:wait_time],
+        logger: Logger.new(opts[:logfile])
+      @worker.run
+      @worker.wait
+    end
+
+    def shutdown
+      @worker.shutdown if @worker
+    end
+
+    def parser # rubocop:disable Metrics/MethodLength
+      @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 '-I [DIR]', 'Specify an additional $LOAD_PATH directory' do |v|
+            @opts[:include].push(v)
+          end
+
+          o.on '-r', '--require [PATH|DIR]', 'File to require' do |v|
+            @opts[:require].push(v)
+          end
+
+          o.on '-L', '--logfile PATH', 'path to writable logfile' do |v|
+            @opts[:logfile] = v
+          end
+        end
+
+        op.banner = 'fleiss [options]'
+        op.on_tail '-h', '--help', 'Show help' do
+          $stdout.puts parser
+          exit 1
+        end
+      end
+    end
+  end
+end

data/lib/fleiss/worker.rb

@@ -0,0 +1,107 @@
+require 'fleiss'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/atomic/atomic_fixnum'
+require 'logger'
+require 'securerandom'
+
+class Fleiss::Worker
+  attr_reader :queues, :uuid, :wait_time, :logger
+
+  # 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 pool. Default: 10
+  # @option [Numeric] :wait_time maximum time (in seconds) to wait for jobs when retrieving next batch. Default: 1s.
+  # @option [Logger] :logger optional logger.
+  def initialize(queues: [Fleiss::DEFAULT_QUEUE], concurrency: 10, wait_time: 1, logger: nil)
+    @uuid      = SecureRandom.uuid
+    @queues    = Array(queues)
+    @pool      = Concurrent::FixedThreadPool.new(concurrency, fallback_policy: :discard)
+    @wait_time = wait_time
+    @logger    = logger || Logger.new(nil)
+  end
+
+  # Run starts the worker
+  def run
+    logger.info "Worker #{uuid} starting - queues: #{queues.inspect}, concurrency: #{@pool.max_length}"
+    loop do
+      run_cycle
+      break if @stopped
+
+      sleep @wait_time
+    end
+    logger.info "Worker #{uuid} shutting down"
+  end
+
+  # Blocks until worker until it's stopped.
+  def wait
+    @pool.shutdown
+    @pool.wait_for_termination(1)
+
+    Fleiss.backend
+          .in_queue(queues)
+          .in_progress(uuid)
+          .reschedule_all(10.seconds.from_now)
+    @pool.wait_for_termination
+    logger.info "Worker #{uuid} shutdown complete"
+  rescue StandardError => e
+    handle_exception e, 'shutdown'
+  end
+
+  # Initiates the shutdown process
+  def shutdown
+    @stopped = true
+  end
+
+  private
+
+  def run_cycle
+    jobs = next_batch
+    while !@stopped && capacity.positive? && !jobs.empty?
+      job = jobs.shift
+      @pool.post { perform(job) }
+    end
+  rescue StandardError => e
+    handle_exception e, 'running cycle'
+  end
+
+  def capacity
+    num = @pool.max_length - @pool.scheduled_task_count + @pool.completed_task_count
+    num.positive? ? num : 0
+  end
+
+  def next_batch
+    slots = capacity
+    return [] if slots.zero?
+
+    Fleiss.backend
+          .in_queue(queues)
+          .pending
+          .limit(slots)
+          .to_a
+  end
+
+  def perform(job)
+    return unless job.start(uuid)
+
+    thread_id = Thread.current.object_id.to_s(36)
+    logger.info { "Worker #{uuid} execute job ##{job.id} by thread #{thread_id}" }
+
+    ActiveJob::Base.execute job.job_data
+  rescue StandardError => e
+    handle_exception e, "processing job ##{job.id} (by thread #{thread_id})"
+  ensure
+    job.finish(uuid)
+  end
+
+  def handle_exception(err, intro)
+    lines = [
+      "Worker #{uuid} error on #{intro}:",
+      "#{err.class.name}: #{err.message}",
+      err.backtrace,
+    ].compact.flatten
+
+    logger.error lines.join("\n")
+  end
+end

data/lib/fleiss.rb

@@ -0,0 +1,9 @@
+module Fleiss
+  DEFAULT_QUEUE = 'default'.freeze
+
+  def self.backend
+    self::Backend::ActiveRecord
+  end
+end
+
+require 'fleiss/backend'

data/spec/fleiss/backend/active_record_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+RSpec.describe Fleiss::Backend::ActiveRecord do
+  def retrieve(job)
+    described_class.find(job.provider_job_id)
+  end
+
+  it 'should persist jobs' do
+    job = TestJob.perform_later
+    rec = retrieve(job)
+
+    expect(rec.attributes).to include(
+      'queue_name'  => 'test-queue',
+      'owner'       => nil,
+      'started_at'  => nil,
+      'finished_at' => nil,
+    )
+    expect(rec.scheduled_at).to be_within(2.seconds).of(Time.zone.now)
+    expect(rec.expires_at).to be_within(2.seconds).of(3.days.from_now)
+    expect(rec.job_data).to include(
+      'job_class'       => 'TestJob',
+      'arguments'       => [],
+      'executions'      => 0,
+      'locale'          => 'en',
+      'priority'        => nil,
+      'provider_job_id' => nil,
+      'queue_name'      => 'test-queue',
+    )
+  end
+
+  it 'should enqueue with delay' do
+    job = TestJob.set(wait: 1.day).perform_later
+    rec = retrieve(job)
+    expect(rec.scheduled_at).to be_within(2.seconds).of(1.day.from_now)
+  end
+
+  it 'should enqueue with priority' do
+    job = TestJob.set(priority: 8).perform_later
+    rec = retrieve(job)
+    expect(rec.priority).to eq(8)
+  end
+
+  it 'should expose active job ID' do
+    job = TestJob.perform_later
+    rec = retrieve(job)
+    expect(rec.job_id.size).to eq(36)
+  end
+
+  it 'should reschedule' do
+    job = TestJob.perform_later
+    described_class.reschedule_all(1.hour.from_now)
+    rec = retrieve(job)
+    expect(rec.scheduled_at).to be_within(2.seconds).of(1.hour.from_now)
+  end
+
+  it 'should scope pending' do
+    j1 = TestJob.perform_later
+    expect(retrieve(j1).start('owner')).to be_truthy
+    expect(retrieve(j1).finish('owner')).to be_truthy
+
+    j2 = TestJob.perform_later
+    _j3 = TestJob.set(wait: 1.hour).perform_later
+    j4 = TestJob.set(priority: 2).perform_later
+
+    expect(described_class.pending.ids).to eq [j4.provider_job_id, j2.provider_job_id]
+  end
+
+  it 'should scope in_progress' do
+    _j1 = TestJob.perform_later
+    j2 = TestJob.perform_later
+    expect(retrieve(j2).start('owner')).to be_truthy
+
+    j3 = TestJob.perform_later
+    expect(retrieve(j3).start('owner')).to be_truthy
+    expect(described_class.in_progress('owner').ids).to match_array [j2.provider_job_id, j3.provider_job_id]
+    expect(described_class.in_progress('other').ids).to be_empty
+
+    expect(retrieve(j3).finish('owner')).to be_truthy
+    expect(described_class.in_progress('owner').ids).to eq [j2.provider_job_id]
+  end
+
+  it 'should scope by queue' do
+    j1 = TestJob.perform_later
+    j2 = TestJob.set(queue: 'other').perform_later
+    expect(described_class.in_queue('test-queue').ids).to eq [j1.provider_job_id]
+    expect(described_class.in_queue('other').ids).to eq [j2.provider_job_id]
+  end
+
+  it 'should start' do
+    job = TestJob.perform_later
+    rec = retrieve(job)
+    expect(rec.start('owner')).to be_truthy
+    expect(rec.start('other')).to be_falsey
+    expect(rec.reload.owner).to eq('owner')
+    expect(rec.started_at).to be_within(2.seconds).of(Time.zone.now)
+  end
+
+  it 'should finish' do
+    job = TestJob.perform_later
+    rec = retrieve(job)
+    expect(rec.finish('owner')).to be_falsey
+    expect(rec.start('owner')).to be_truthy
+    expect(rec.finish('other')).to be_falsey
+    expect(rec.finish('owner')).to be_truthy
+    expect(rec.reload.owner).to eq('owner')
+    expect(rec.started_at).to be_within(2.seconds).of(Time.zone.now)
+    expect(rec.finished_at).to be_within(2.seconds).of(Time.zone.now)
+  end
+end

data/spec/fleiss/worker_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'fleiss/worker'
+
+RSpec.describe Fleiss::Worker do
+  subject do
+    described_class.new queues: TestJob.queue_name, wait_time: 0.01
+  end
+
+  let! :runner do
+    t = Thread.new { subject.run }
+    t.abort_on_exception = true
+    t
+  end
+
+  after do
+    subject.shutdown
+    subject.wait
+  end
+
+  def wait_for
+    200.times do
+      break if yield
+
+      sleep(0.1)
+    end
+    expect(yield).to be_truthy
+  end
+
+  it 'should run/process/shutdown' do
+    # seed 50 jobs
+    50.times {|n| TestJob.perform_later(n) }
+    wait_for { Fleiss.backend.not_finished.count > 0 }
+
+    # ensure runner processes them all
+    wait_for { Fleiss.backend.not_finished.count.zero? }
+
+    # check what's been performed
+    expect(TestJob.performed.size).to eq(50)
+    expect(TestJob.performed).to match_array(0..49)
+  end
+
+  it 'should handle failing jobs' do
+    TestJob.perform_later('raise')
+    wait_for { Fleiss.backend.not_finished.count.zero? }
+    expect(Fleiss.backend.count).to eq(1)
+  end
+end

data/spec/fleiss_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe Fleiss do
+  it 'should have a backend' do
+    expect(described_class.backend).to eq(Fleiss::Backend::ActiveRecord)
+  end
+
+  it 'should enqueue' do
+    expect do
+      TestJob.set(wait: 1.week).perform_later
+    end.to change { described_class.backend.count }.by(1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+ENV['RACK_ENV'] ||= 'test'
+
+require 'rspec'
+require 'fleiss'
+require 'fleiss/backend/active_record/migration'
+require 'active_job'
+require 'active_job/queue_adapters/fleiss_adapter'
+require 'tempfile'
+
+ActiveJob::Base.queue_adapter = :fleiss
+ActiveJob::Base.logger = Logger.new(nil)
+
+Time.zone_default = Time.find_zone!('UTC')
+
+ActiveRecord::Base.configurations['test'] = {
+  'adapter'  => 'sqlite3',
+  'database' => Tempfile.new(['fleiss-test', '.sqlite3']).path,
+  'pool'     => 20,
+}
+ActiveRecord::Base.establish_connection :test
+ActiveRecord::Migration.suppress_messages do
+  Fleiss::Backend::ActiveRecord::Migration.migrate(:up)
+end
+
+class TestJob < ActiveJob::Base
+  queue_as 'test-queue'
+
+  def self.performed
+    @performed ||= []
+  end
+
+  def ttl
+    72.hours
+  end
+
+  def perform(msg=nil)
+    raise 'Failing' if msg == 'raise'
+
+    self.class.performed.push(msg)
+  end
+end
+
+RSpec.configure do |c|
+  c.after :each do
+    TestJob.performed.clear
+    Fleiss.backend.delete_all
+  end
+end

metadata

@@ -0,0 +1,183 @@
+--- !ruby/object:Gem::Specification
+name: fleiss
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Black Square Media Ltd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.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: bundler
+  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: 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: rubocop
+  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: sqlite3
+  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: Run background jobs with your favourite stack.
+email:
+- info@blacksquaremedia.com
+executables:
+- fleiss
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/fleiss
+- fleiss.gemspec
+- lib/active_job/queue_adapters/fleiss_adapter.rb
+- lib/fleiss.rb
+- lib/fleiss/backend.rb
+- lib/fleiss/backend/active_record.rb
+- lib/fleiss/backend/active_record/concern.rb
+- lib/fleiss/backend/active_record/migration.rb
+- lib/fleiss/cli.rb
+- lib/fleiss/worker.rb
+- spec/fleiss/backend/active_record_spec.rb
+- spec/fleiss/worker_spec.rb
+- spec/fleiss_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bsm/fleiss
+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.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Minimialist background jobs backed by ActiveJob and ActiveRecord.
+test_files:
+- spec/fleiss/backend/active_record_spec.rb
+- spec/fleiss/worker_spec.rb
+- spec/fleiss_spec.rb
+- spec/spec_helper.rb