que-scheduler 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0099d4a7447334aabd3912520a2c7575deac3a05e8b564e3711dcf913235dfd2'
-  data.tar.gz: fb3b867db4ac06c74b81d3ef41a0593dbcf90ac30754ab38746b3a9ef41a17ab
+  metadata.gz: b29b7a589afd759e434332a022ab0af875e23f09fc05494877bcea0cab51b00a
+  data.tar.gz: ab33b4eac4c33b8372be44176036c171c5cd5d0248a741b81d3895edafae383a
 SHA512:
-  metadata.gz: b10b18c7ffb66739556743aec5badbc1f3934edcb0db960c3d3202de327c24495320f73667bc22e207e03ea02fc477c4422f32bd0b0e564400af67185efcc1d2
-  data.tar.gz: 7400225137aa503175f42b26d04d0943f973ffb923e60e92bdf0acbc2a2ac664ef43782f5b61cce6b3b4bb4f9e5c276aa45e7f594aa5bb264ea5fd70188d4a41
+  metadata.gz: bf3a481eae1cfa91ab4743bdc591fbbd7632563dcd16c34353d4663abf99b38e08fedcdb899339f6f6994f7e84d265dc909972ab741c599a91c430455871d71a
+  data.tar.gz: 55b7a0c8a91f8f08129489e0e349524540df8811e4220e70612dbaeec48cf0cdadd6e3622cd1346ca5a0d50562836de7d9027a5f023453835a976f9b9d280c6d

data/README.md

@@ -26,7 +26,11 @@ files, but with additional features.
 1. Add a migration to start the job scheduler.
 
     ```ruby
-    Que::Scheduler::SchedulerJob.enqueue
+    class CreateQueSchedulerSchema < ActiveRecord::Migration
+      def change
+        Que::Scheduler::Migrations.migrate!(version: 2)
+      end
+    end
     ```
     
 ## Schedule configuration
@@ -95,13 +99,18 @@ DailyBatchReport:
 
 A job can have a `schedule_type` assigned to it. Valid values are:
 
-1. `default` - This job will be scheduled when a worker becomes available. If multiple cron times 
-  go by during an extended period of downtime then only one job will be enqueued. This is closer to 
-  how ordinary cron works.
-1. `every_event` - This job will always be scheduled with an ISO8601 time as the first argument. 
-  If multiple cron times go by during an extended period of downtime, then a job will be scheduled 
-  for every one missed. This `schedule_type` should be used for daily batch jobs that need to know 
-  which day they are running a batch for.
+1. `default` - This job will be scheduled in a manner closer to resque-scheduler. If multiple cron
+  times go by during an extended period of downtime (eg a long maintenance window) then only one job
+  will be enqueued when the system starts back up. Multiple missed events are coalesced. This mimics
+  the way resque-scheduler would perform if it were taken down for some time.
+1. `every_event` - Every cron match will result in a job being scheduled. If multiple cron times go 
+  by during an extended period of downtime, then a job will be scheduled for every one missed on 
+  startup. This `schedule_type` should be used for daily batch jobs that need to know which day 
+  they are running a batch for. The job will always be scheduled with an ISO8601 string of the cron 
+  that matched as the first argument. 
+   
+   This feature ensures that jobs which *must run* for a certain cron match will always eventually 
+  execute, even after a total system crash, or even a DB backup restore.
 
 ## Environment Variables
 
@@ -109,6 +118,11 @@ You can configure some aspects of the gem with environment variables.
 
 * `QUE_SCHEDULER_CONFIG_LOCATION` - The location of the schedule configuration (default `config/que_schedule.yml`)
 
+## Scheduler Audit
+
+An audit table _que_scheduler_audit_ is written to by the scheduler to keep a history of what jobs 
+were enqueued when. It is created by the included migration tasks.
+
 ## HA Redundancy and DB restores
 
 Because of the way que-scheduler works, it requires no additional processes. It is, itself, a Que job.
@@ -135,9 +149,12 @@ que-scheduler is a job that reads a config file, enqueues any jobs it determines
 then reschedules itself. The flow is as follows:
 
 1. The que-scheduler job runs for the very first time.
-1. que-scheduler loads the schedule config file. It will not schedule any other jobs, except itself, as it has never run before.
-1. Some time later it runs again. It knows what jobs it should be monitoring, and notices that some have are due. It enqueues those jobs and then itself. Repeat.
-1. After a deploy that changes the config, the job notices any new jobs to schedule, and knows which ones to forget. It does not need to be re-enqueued or restarted.
+1. que-scheduler loads the schedule config file. It will not schedule any other jobs, except itself, 
+   as it has never run before.
+1. Some time later it runs again. It knows what jobs it should be monitoring, and notices that some 
+   have are due. It enqueues those jobs and then itself. Repeat.
+1. After a deploy that changes the config, the job notices any new jobs to schedule, and knows which
+   ones to forget. It does not need to be re-enqueued or restarted.
 
 ## Inspiration
 

data/lib/que/scheduler/audit.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Que
+  module Scheduler
+    module Audit
+      TABLE_NAME = 'que_scheduler_audit'
+      INSERT_AUDIT = %{
+        INSERT INTO #{TABLE_NAME} (scheduler_job_id, jobs_enqueued, executed_at, next_run_at)
+        VALUES ($1::integer, $2::jsonb, $3::timestamptz, $4::timestamptz)
+        RETURNING *
+      }
+
+      class << self
+        def append(job_id, executed_at, result, next_run_at)
+          json = result.missed_jobs.map { |j| j.to_h.merge(job_class: j.job_class.to_s) }.to_json
+          inserted = ::Que.execute(
+            INSERT_AUDIT, [job_id, json, executed_at, next_run_at]
+          )
+          raise "Cannot save audit row #{job_id} #{executed_at}" if inserted.empty?
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/db.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Que
+  module Scheduler
+    module Db
+      SCHEDULER_COUNT_SQL =
+        "SELECT COUNT(*) FROM que_jobs WHERE job_class = '#{Que::Scheduler::SchedulerJob.name}'"
+      NOW_SQL = 'SELECT now()'
+
+      class << self
+        def count_schedulers
+          Que.execute(SCHEDULER_COUNT_SQL).first.values.first.to_i
+        end
+
+        def now
+          Que.execute(NOW_SQL).first.values.first
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/defined_job.rb

@@ -8,6 +8,7 @@ module Que
     class DefinedJob < Hashie::Dash
       QUE_SCHEDULER_CONFIG_LOCATION =
         ENV.fetch('QUE_SCHEDULER_CONFIG_LOCATION', 'config/que_schedule.yml')
+      ERROR_MESSAGE_SUFFIX = "in que-scheduler config #{QUE_SCHEDULER_CONFIG_LOCATION}".freeze
 
       include Hashie::Extensions::Dash::PropertyTranslation
 
@@ -16,17 +17,14 @@ module Que
         SCHEDULE_TYPE_EVERY_EVENT = :every_event
       ].freeze
 
-      def self.err_field(f, v)
-        suffix = "in que-scheduler config #{QUE_SCHEDULER_CONFIG_LOCATION}"
-        raise "Invalid #{f} '#{v}' #{suffix}"
-      end
-
       property :name, required: true
       property :job_class, required: true, transform_with: lambda { |v|
         job_class = Object.const_get(v)
         job_class < Que::Job ? job_class : err_field(:job_class, v)
       }
-      property :cron, transform_with: ->(v) { Fugit::Cron.parse(v) || err_field(:cron, v) }
+      property :cron, required: true, transform_with: lambda { |v|
+        Fugit::Cron.parse(v) || err_field(:cron, v)
+      }
       property :queue, transform_with: ->(v) { v.is_a?(String) ? v : err_field(:queue, v) }
       property :priority, transform_with: ->(v) { v.is_a?(Integer) ? v : err_field(:priority, v) }
       property :args
@@ -52,7 +50,7 @@ module Que
           last_time = next_run
         end
 
-        generate_required_jobs_list(missed_times)
+        generate_to_enqueue_list(missed_times)
       end
 
       class << self
@@ -66,37 +64,42 @@ module Que
                 args: v['args'],
                 priority: v['priority'],
                 cron: v['cron'],
-                schedule_type: v['schedule_type'] || DefinedJob::SCHEDULE_TYPE_DEFAULT
+                schedule_type: v['schedule_type'],
               }.compact
             ).freeze
           end
         end
+
+        private
+
+        def err_field(field, value)
+          raise "Invalid #{field} '#{value}' #{ERROR_MESSAGE_SUFFIX}"
+        end
       end
 
       private
 
-      # Given the timestamps of the missed events, generate a list of jobs
-      # that can be enqueued as an array of arrays of args.
-      def generate_required_jobs_list(missed_times)
-        jobs_for_class = []
+      class ToEnqueue < Hashie::Dash
+        property :args, required: true, default: []
+        property :queue
+        property :priority
+        property :job_class, required: true
+      end
 
-        unless missed_times.empty?
-          options = {
-            args: args,
-            queue: queue,
-            priority: priority
-          }.compact
+      def generate_to_enqueue_list(missed_times)
+        [].tap do |jobs_for_class|
+          unless missed_times.empty?
+            options = to_h.slice(:args, :queue, :priority, :job_class).compact
 
-          if schedule_type == DefinedJob::SCHEDULE_TYPE_EVERY_EVENT
-            missed_times.each do |time_missed|
-              jobs_for_class << options.merge(args: [time_missed] + (args || []))
+            if schedule_type == DefinedJob::SCHEDULE_TYPE_EVERY_EVENT
+              missed_times.each do |time_missed|
+                jobs_for_class << ToEnqueue.new(options.merge(args: [time_missed] + (args || [])))
+              end
+            else
+              jobs_for_class << ToEnqueue.new(options)
             end
-          else
-            jobs_for_class << options
           end
-          options.freeze
         end
-        jobs_for_class
       end
     end
   end

data/lib/que/scheduler/enqueueing_calculator.rb

@@ -2,34 +2,32 @@ require 'fugit'
 
 module Que
   module Scheduler
-    class EnqueueingCalculator
-      Result = Struct.new(:missed_jobs, :schedule_dictionary)
+    module EnqueueingCalculator
+      class Result < Hashie::Dash
+        property :missed_jobs, required: true
+        property :job_dictionary, required: true
+      end
 
       class << self
         def parse(scheduler_config, scheduler_job_args)
-          missed_jobs = {}
-          schedule_dictionary = []
+          job_dictionary = []
 
-          # For each scheduled item, we need not schedule a job it if it has no history, as it is
-          # new. Otherwise, check how many times we have missed the job since the last run time.
-          # If it is "every_event" then we schedule all of them, with the missed time as an arg,
-          # otherwise just schedule it once.
-          scheduler_config.each do |desc|
+          # For each scheduled item:
+          # 1) If never seen before, schedule nothing, but add to known list
+          # 2) If seen before, calculate what (if anything) needs to be enqueued.
+          missed_jobs = scheduler_config.map do |desc|
             job_name = desc.name
-            schedule_dictionary << job_name
+            job_dictionary << job_name
 
             # If we have never seen this job before, we don't want to scheduled any jobs for it.
             # But we have added it to the dictionary, so it will be used to enqueue jobs next time.
             next unless scheduler_job_args.job_dictionary.include?(job_name)
 
             # This has been seen before. We should check if we have missed any executions.
-            missed = desc.calculate_missed_runs(
-              scheduler_job_args.last_run_time, scheduler_job_args.as_time
-            )
-            missed_jobs[desc.job_class] = missed unless missed.empty?
-          end
+            desc.calculate_missed_runs(scheduler_job_args.last_run_time, scheduler_job_args.as_time)
+          end.flatten.compact
 
-          Result.new(missed_jobs, schedule_dictionary)
+          Result.new(missed_jobs: missed_jobs, job_dictionary: job_dictionary)
         end
       end
     end

data/lib/que/scheduler/migrations/1/down.sql

@@ -0,0 +1 @@
+DELETE FROM que_jobs WHERE job_class = 'Que::Scheduler::SchedulerJob';

data/lib/que/scheduler/migrations/1/up.sql

@@ -0,0 +1 @@
+-- Do nothing. This is handled by an "enqueue" call.

data/lib/que/scheduler/migrations/2/down.sql

@@ -0,0 +1 @@
+DROP TABLE que_scheduler_audit;

data/lib/que/scheduler/migrations/2/up.sql

@@ -0,0 +1,9 @@
+CREATE TABLE que_scheduler_audit (
+  scheduler_job_id integer     NOT NULL,
+  executed_at      timestamptz NOT NULL,
+  next_run_at      timestamptz NOT NULL,
+  jobs_enqueued    jsonb       NOT NULL
+);
+
+CREATE UNIQUE INDEX index_que_scheduler_audit_on_scheduler_job_id ON que_scheduler_audit USING btree (scheduler_job_id);
+CREATE INDEX index_que_scheduler_audit_on_jobs_enqueued ON que_scheduler_audit USING btree (jobs_enqueued);

data/lib/que/scheduler/migrations.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Que
+  module Scheduler
+    module Migrations
+      AUDIT_TABLE_NAME = Que::Scheduler::Audit::TABLE_NAME
+      TABLE_COMMENT = %(
+        SELECT description FROM pg_class
+        LEFT JOIN pg_description ON pg_description.objoid = pg_class.oid
+        WHERE relname = '#{AUDIT_TABLE_NAME}'
+      )
+      MAX_VERSION = Dir.glob("#{__dir__}/migrations/*").map { |d| File.basename(d) }.map(&:to_i).max
+
+      class << self
+        def migrate!(version:)
+          ::Que.transaction do
+            current = db_version
+            if current < version
+              migrate_up(current, version)
+            elsif current > version
+              migrate_down(current, version)
+            end
+          end
+        end
+
+        def db_version
+          return 0 if Que::Scheduler::Db.count_schedulers.zero?
+          return 1 unless ActiveRecord::Base.connection.table_exists?(AUDIT_TABLE_NAME)
+          Que.execute(TABLE_COMMENT).first[:description].to_i
+        end
+
+        private
+
+        def migrate_up(current, version)
+          Que::Scheduler::SchedulerJob.enqueue if current.zero? # Version 1 does not use SQL
+          execute_step((current += 1), :up) until current == version
+        end
+
+        def migrate_down(current, version)
+          current += 1
+          execute_step((current -= 1), :down) until current == version + 1
+        end
+
+        def execute_step(number, direction)
+          Que.execute(IO.read("#{__dir__}/migrations/#{number}/#{direction}.sql"))
+          return unless number >= (direction == :up ? 2 : 3)
+          Que.execute "COMMENT ON TABLE que_scheduler_audit IS '#{number}'"
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/scheduler_job.rb

@@ -4,6 +4,8 @@ require_relative 'defined_job'
 require_relative 'enqueueing_calculator'
 require_relative 'scheduler_job_args'
 
+# The main job that runs every minute, determining what needs to be enqueued, enqueues the required
+# jobs, then re-enqueues itself.
 module Que
   module Scheduler
     class SchedulerJob < Que::Job
@@ -13,83 +15,51 @@ module Que
       @priority = 0
 
       def run(options = nil)
-        ::Que::Scheduler::Adapters::Orm.instance.transaction do
+        ::Que.transaction do
           assert_one_scheduler_job
           scheduler_job_args = SchedulerJobArgs.build(options)
           logs = ["que-scheduler last ran at #{scheduler_job_args.last_run_time}."]
 
-          # It's possible the DB time has been changed manaully to an earlier time than it was
-          # before. Whether this was a small amount of time (eg clock drift correction), or a major
-          # change like timezone, the business schedule semantics of this are unknowable, so log and
-          # rescheduled with the same last run at.
-          if scheduler_job_args.as_time < scheduler_job_args.last_run_time
-            handle_db_clock_change_backwards(scheduler_job_args, logs)
-          else
-            # Otherwise, run as normal
-            handle_normal_call(scheduler_job_args, logs)
-          end
+          result = EnqueueingCalculator.parse(DefinedJob.defined_jobs, scheduler_job_args)
+          enqueue_required_jobs(result, logs)
+          enqueue_self_again(scheduler_job_args, scheduler_job_args.as_time, result)
 
           # Only now we're sure nothing errored, log the results
-          logs.each { |str| Que.log(message: str) }
+          logs.each { |str| ::Que.log(message: str) }
           destroy
         end
       end
 
       def enqueue_required_jobs(result, logs)
-        result.missed_jobs.each do |job_class, options_array|
-          options_array.each do |options|
-            enqueue_new_job(job_class, options.dup, logs)
+        result.missed_jobs.each do |to_enqueue|
+          job_class = to_enqueue.job_class
+          args = to_enqueue.args
+          remaining_hash = to_enqueue.except(:job_class, :args)
+          if args.is_a?(Hash)
+            job_class.enqueue(args.merge(remaining_hash))
+          else
+            job_class.enqueue(*args, remaining_hash)
           end
+          logs << "que-scheduler enqueueing #{job_class} with: #{to_enqueue}"
         end
-        result.schedule_dictionary
       end
 
       private
 
       def assert_one_scheduler_job
-        schedulers = ::Que::Scheduler::Adapters::Orm.instance.count_schedulers
+        schedulers = Que::Scheduler::Db.count_schedulers
         return if schedulers == 1
         raise "Only one #{self.class.name} should be enqueued. #{schedulers} were found."
       end
 
-      def handle_normal_call(scheduler_job_args, logs)
-        # Obtain the hash of missed jobs. Keys are the job classes, and the values are arrays
-        # each containing params to enqueue.
-        result = EnqueueingCalculator.parse(DefinedJob.defined_jobs, scheduler_job_args)
-        new_job_dictionary = enqueue_required_jobs(result, logs)
-        enqueue_self_again(
-          scheduler_job_args.as_time,
-          scheduler_job_args.as_time,
-          new_job_dictionary
-        )
-      end
-
-      def enqueue_new_job(job_class, options, logs)
-        logs << "que-scheduler enqueueing #{job_class} with options: #{options}"
-        args = options.delete(:args)
-        if args.is_a?(Hash)
-          job_class.enqueue(args.merge(options))
-        else
-          job_class.enqueue(*args, options)
-        end
-      end
-
-      def handle_db_clock_change_backwards(scheduler_job_args, logs)
-        logs << 'que-scheduler detected the DB time is further back than the last run. ' \
-                'Rescheduling self again without enqueueing jobs to wait for the clock to catch up.'
-        enqueue_self_again(
-          scheduler_job_args.last_run_time,
-          scheduler_job_args.as_time,
-          scheduler_job_args.job_dictionary
-        )
-      end
-
-      def enqueue_self_again(last_full_execution, this_run_time, new_job_dictionary)
+      def enqueue_self_again(scheduler_job_args, last_full_execution, result)
+        next_run_at = scheduler_job_args.as_time.beginning_of_minute + SCHEDULER_FREQUENCY
         SchedulerJob.enqueue(
           last_run_time: last_full_execution.iso8601,
-          job_dictionary: new_job_dictionary,
-          run_at: this_run_time.beginning_of_minute + SCHEDULER_FREQUENCY
+          job_dictionary: result.job_dictionary,
+          run_at: next_run_at
         )
+        Audit.append(attrs[:job_id], scheduler_job_args.as_time, result, next_run_at)
       end
     end
   end

data/lib/que/scheduler/scheduler_job_args.rb

@@ -11,19 +11,19 @@ module Que
       property :as_time, required: true
 
       def self.build(options)
-        now = ::Que::Scheduler::Adapters::Orm.instance.now
+        now = Que::Scheduler::Db.now
         parsed =
           if options.nil?
-            # First ever run, there is nothing to do but reschedule self.
+            # First ever run, there is nothing to do but reschedule self to run on the next minute.
             {
               last_run_time: now,
-              job_dictionary: []
+              job_dictionary: [],
             }
           else
             options = options.symbolize_keys
             {
               last_run_time: Time.zone.parse(options.fetch(:last_run_time)),
-              job_dictionary: options.fetch(:job_dictionary)
+              job_dictionary: options.fetch(:job_dictionary),
             }
           end
         SchedulerJobArgs.new(parsed.merge(as_time: now))

data/lib/que/scheduler/version.rb

@@ -1,5 +1,5 @@
 module Que
   module Scheduler
-    VERSION = '1.2.0'.freeze
+    VERSION = '2.0.0'.freeze
   end
 end

data/lib/que/scheduler.rb

@@ -1,6 +1,8 @@
 require 'que/scheduler/version'
 require 'que/scheduler/scheduler_job'
-require 'que/scheduler/adapters/orm'
+require 'que/scheduler/db'
+require 'que/scheduler/audit'
+require 'que/scheduler/migrations'
 # rubocop:disable Style/PreferredHashMethods
 require 'que/scheduler/engine' if Gem.loaded_specs.has_key?('railties')
 # rubocop:enable Style/PreferredHashMethods

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: que-scheduler
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Harry Lascelles
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-29 00:00:00.000000000 Z
+date: 2018-04-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
-  name: que
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -81,35 +81,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: que
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
+        version: '0.10'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: combustion
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: combustion
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,7 +137,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -151,7 +151,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: que-testing
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -224,30 +224,16 @@ dependencies:
   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: sequel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 0.54.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: 0.54.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -299,17 +285,28 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/que/scheduler.rb
-- lib/que/scheduler/adapters/orm.rb
+- lib/que/scheduler/audit.rb
+- lib/que/scheduler/db.rb
 - lib/que/scheduler/defined_job.rb
 - lib/que/scheduler/engine.rb
 - lib/que/scheduler/enqueueing_calculator.rb
+- lib/que/scheduler/migrations.rb
+- lib/que/scheduler/migrations/1/down.sql
+- lib/que/scheduler/migrations/1/up.sql
+- lib/que/scheduler/migrations/2/down.sql
+- lib/que/scheduler/migrations/2/up.sql
 - lib/que/scheduler/scheduler_job.rb
 - lib/que/scheduler/scheduler_job_args.rb
 - lib/que/scheduler/version.rb
 homepage: https://github.com/hlascelles/que-scheduler
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/hlascelles/que-scheduler
+  documentation_uri: https://github.com/hlascelles/que-scheduler
+  changelog_uri: https://github.com/hlascelles/que-scheduler/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/hlascelles/que-scheduler/
+  bug_tracker_uri: https://github.com/hlascelles/que-scheduler/issues
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/que/scheduler/adapters/orm.rb

@@ -1,74 +0,0 @@
-module Que
-  module Scheduler
-    module Adapters
-      module Orm
-        class AdapterBase
-          SCHEDULER_COUNT_SQL =
-            'SELECT COUNT(*) FROM que_jobs WHERE job_class = ' \
-            "'#{Que::Scheduler::SchedulerJob.name}'".freeze
-          NOW_SQL = 'SELECT now()'.freeze
-
-          def transaction
-            transaction_base.transaction do
-              yield
-            end
-          end
-
-          def count_schedulers
-            dml(SCHEDULER_COUNT_SQL).first.values.first.to_i
-          end
-
-          def now
-            Time.zone.parse(dml(NOW_SQL).first.values.first)
-          end
-        end
-
-        class ActiveRecordAdapter < AdapterBase
-          def transaction_base
-            ::ActiveRecord::Base
-          end
-
-          def dml(sql)
-            ::ActiveRecord::Base.connection.execute(sql)
-          end
-
-          def ddl(sql)
-            dml(sql)
-          end
-        end
-
-        class SequelAdapter < AdapterBase
-          def transaction_base
-            ::DB
-          end
-
-          def dml(sql)
-            ::DB.fetch(sql)
-          end
-
-          def ddl(sql)
-            ::DB.run(sql)
-          end
-        end
-
-        class << self
-          # The exposed mutator method here allows any future orm adapters to be tested.
-          attr_writer :instance
-
-          def instance
-            # rubocop:disable Style/PreferredHashMethods
-            @instance ||=
-              if Gem.loaded_specs.has_key?('activerecord')
-                ActiveRecordAdapter.new
-              elsif Gem.loaded_specs.has_key?('sequel')
-                SequelAdapter.new
-              else
-                raise 'No known ORM adapter is available for que-scheduler'
-              end
-            # rubocop:enable Style/PreferredHashMethods
-          end
-        end
-      end
-    end
-  end
-end