skiplock 1.0.12 → 1.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1acb8564f7930a8acbd316ae7ab85064aa3edb29232802d495f6c8261a2dfb72
-  data.tar.gz: c7de58da66f483450fb34680b5e83d37865ce02b9f7e500de386a2ce30c17edb
+  metadata.gz: 89240e4318ca72cf30a3426948d9aa8479f59f85b82e4dca4ef5ee3b449b9894
+  data.tar.gz: b8f6799ccf4ba566379548dc4e9c90b6a1202842139b0ac0a3e0247875be00d9
 SHA512:
-  metadata.gz: 69f54b48dd37b8814ef1bfb046945f4aaf13c996f35f9b297823f980804958d13a897dd1e8f5e28d6514d76867a4bac3a401aee2e682334cbabc2b52d4a36184
-  data.tar.gz: f2fda19cff5a11f6d51c7d2223de5a1251bf6744b86364c82343dafe02807ad59f02b0ad6a4324002e49393f0f87de1356686cda347172e6c947e523fcfe8c92
+  metadata.gz: 3d8ec5ec2c3b0612fd3077fac5d6ff0c6e1b6826ed74b25b640ccc966874461b470f633c582af4f408f547586e30e1fdc5c22f158ca6fdf5c91000ec33c609a2
+  data.tar.gz: 27b6f4746f255777fdb6b3733d08a0592969a45d6d0f315d76231269255e532b51834fa79e1be89a0c18ac62509fe342266c9a8a5c7c038cc2b9e52b120e2469

data/bin/skiplock

@@ -25,4 +25,4 @@ options.transform_keys! { |k| k.to_s.gsub('-', '_').to_sym }
 env = options.delete(:environment)
 ENV['RAILS_ENV'] = env if env
 require File.expand_path("config/environment.rb")
-Skiplock::Manager.new(**options.merge(standalone: true))
+Rails.application.config.skiplock.standalone(**options.merge(standalone: true))

data/lib/active_job/queue_adapters/skiplock_adapter.rb

@@ -2,7 +2,7 @@ module ActiveJob
   module QueueAdapters
     class SkiplockAdapter
       def initialize
-        Rails.application.config.after_initialize { Skiplock::Manager.new }
+        Rails.application.config.after_initialize { Rails.application.config.skiplock = Skiplock::Manager.new }
       end
 
       def enqueue(job)

data/lib/generators/skiplock/templates/migration.rb.erb

@@ -60,7 +60,7 @@ class CreateSkiplockSchema < ActiveRecord::Migration<%= "[#{ActiveRecord::VERSIO
           ELSIF (record.executions IS NOT NULL AND record.scheduled_at IS NOT NULL) THEN
             INSERT INTO skiplock.counters (day,failures) VALUES (NOW(),1) ON CONFLICT (day) DO UPDATE SET failures = skiplock.counters.failures + 1;
           END IF;
-          PERFORM pg_notify('skiplock::jobs', CONCAT(TG_OP,',',record.id::TEXT,',',record.worker_id::TEXT,',',record.queue_name,',',record.running::TEXT,',',CAST(EXTRACT(EPOCH FROM record.expired_at) AS FLOAT)::TEXT,',',CAST(EXTRACT(EPOCH FROM record.finished_at) AS FLOAT)::TEXT,',',CAST(EXTRACT(EPOCH FROM CASE WHEN record.scheduled_at IS NULL THEN record.updated_at ELSE record.scheduled_at END) AS FLOAT)::TEXT));
+          PERFORM pg_notify('skiplock::jobs', CONCAT(TG_OP,',',record.id::TEXT,',',record.worker_id::TEXT,',',record.job_class,',',record.queue_name,',',record.running::TEXT,',',CAST(EXTRACT(EPOCH FROM record.expired_at) AS FLOAT)::TEXT,',',CAST(EXTRACT(EPOCH FROM record.finished_at) AS FLOAT)::TEXT,',',CAST(EXTRACT(EPOCH FROM CASE WHEN record.scheduled_at IS NULL THEN record.updated_at ELSE record.scheduled_at END) AS FLOAT)::TEXT));
           RETURN NULL;
         END;
       $$ LANGUAGE plpgsql

data/lib/skiplock/job.rb

@@ -2,39 +2,6 @@ module Skiplock
   class Job < ActiveRecord::Base
     self.implicit_order_column = 'created_at'
 
-    def self.dispatch(queues_order_query: nil, worker_id: nil, purge_completion: true, max_retries: 20)
-      job = nil
-      self.transaction do
-        job = self.find_by_sql("SELECT id, scheduled_at FROM #{self.table_name} WHERE running = FALSE AND expired_at IS NULL AND finished_at IS NULL ORDER BY scheduled_at ASC NULLS FIRST,#{queues_order_query ? ' CASE ' + queues_order_query + ' ELSE NULL END ASC NULLS LAST,' : ''} priority ASC NULLS LAST, created_at ASC FOR UPDATE SKIP LOCKED LIMIT 1").first
-        return (job ? job.scheduled_at.to_f : Float::INFINITY) if job.nil? || job.scheduled_at.to_f > Time.now.to_f
-        job = Skiplock::Job.find_by_sql("UPDATE #{self.table_name} SET running = TRUE, worker_id = #{self.connection.quote(worker_id)}, updated_at = NOW() WHERE id = '#{job.id}' RETURNING *").first
-      end
-      job.data ||= {}
-      job.exception_executions ||= {}
-      job_data = job.attributes.slice('job_class', 'queue_name', 'locale', 'timezone', 'priority', 'executions', 'exception_executions').merge('job_id' => job.id, 'enqueued_at' => job.updated_at, 'arguments' => (job.data['arguments'] || []))
-      job.executions = (job.executions || 0) + 1
-      Skiplock.logger.info "[Skiplock] Performing #{job.job_class} (#{job.id}) from queue '#{job.queue_name || 'default'}'..."
-      Thread.current[:skiplock_dispatch_job] = job
-      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      begin
-        ActiveJob::Base.execute(job_data)
-      rescue Exception => ex
-        Skiplock.logger.error(ex)
-      end
-      unless ex
-        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        job_name = job.job_class
-        if job.job_class == 'Skiplock::Extension::ProxyJob'
-          target, method_name = ::YAML.load(job.data['arguments'].first)
-          job_name = "'#{target.name}.#{method_name}'"
-        end
-        Skiplock.logger.info "[Skiplock] Performed #{job_name} (#{job.id}) from queue '#{job.queue_name || 'default'}' in #{end_time - start_time} seconds"
-      end
-      job.dispose(ex, purge_completion: purge_completion, max_retries: max_retries)
-    ensure
-      Thread.current[:skiplock_dispatch_job] = nil
-    end
-
     def self.enqueue(activejob)
       self.enqueue_at(activejob, nil)
     end
@@ -48,7 +15,7 @@ module Skiplock
         Thread.current[:skiplock_dispatch_job]
       else
         serialize = activejob.serialize
-        Job.create!(serialize.slice(*self.column_names).merge('id' => serialize['job_id'], 'data' => { 'arguments' => serialize['arguments'] }, 'scheduled_at' => timestamp))
+        self.create!(serialize.slice(*self.column_names).merge('id' => serialize['job_id'], 'data' => { 'arguments' => serialize['arguments'] }, 'scheduled_at' => timestamp))
       end
     end
 
@@ -57,7 +24,7 @@ module Skiplock
     end
 
     def dispose(ex, purge_completion: true, max_retries: 20)
-      dup = self.dup
+      yaml = [self, ex].to_yaml
       self.running = false
       self.worker_id = nil
       self.updated_at = (Time.now > self.updated_at ? Time.now : self.updated_at + 1)
@@ -95,9 +62,41 @@ module Skiplock
       end
       self
     rescue Exception => e
-      Skiplock.logger.error(e)
-      File.write("tmp/skiplock/#{self.id}", [dup, ex].to_yaml)
+      Skiplock.logger.error(e.name)
+      Skiplock.logger.error(e.backtrace.join("\n"))
+      File.write("tmp/skiplock/#{self.id}", yaml)
       nil
     end
+
+    def execute(purge_completion: true, max_retries: 20)
+      Skiplock.logger.info "[Skiplock] Performing #{self.job_class} (#{self.id}) from queue '#{self.queue_name || 'default'}'..."
+      self.data ||= {}
+      self.exception_executions ||= {}
+      job_data = self.attributes.slice('job_class', 'queue_name', 'locale', 'timezone', 'priority', 'executions', 'exception_executions').merge('job_id' => self.id, 'enqueued_at' => self.updated_at, 'arguments' => (self.data['arguments'] || []))
+      self.executions = (self.executions || 0) + 1
+      Thread.current[:skiplock_dispatch_job] = self
+      activejob = ActiveJob::Base.deserialize(job_data)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        activejob.perform_now
+      rescue Exception => ex
+      end
+      if ex || self.exception_executions.key?('activejob_retry')
+        Skiplock.logger.error("[Skiplock] Job #{self.job_class} (#{self.id}) was interrupted by an exception#{ ' (rescued and retried by ActiveJob)' if self.exception_executions.key?('activejob_retry') }")
+        if ex
+          Skiplock.logger.error(ex)
+          Skiplock.logger.error(ex.backtrace.join("\n"))
+        end
+      else
+        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        job_name = self.job_class
+        if self.job_class == 'Skiplock::Extension::ProxyJob'
+          target, method_name = ::YAML.load(self.data['arguments'].first)
+          job_name = "'#{target.name}.#{method_name}'"
+        end
+        Skiplock.logger.info "[Skiplock] Performed #{job_name} (#{self.id}) from queue '#{self.queue_name || 'default'}' in #{end_time - start_time} seconds"
+      end
+      self.dispose(ex, purge_completion: purge_completion, max_retries: max_retries)
+    end
   end
 end

data/lib/skiplock/manager.rb

@@ -6,30 +6,65 @@ module Skiplock
       @config.symbolize_keys!
       @config.transform_values! {|v| v.is_a?(String) ? v.downcase : v}
       @config.merge!(config)
-      Module.__send__(:include, Skiplock::Extension) if @config[:extensions] == true
-      return unless @config[:standalone] || (caller.any?{ |l| l =~ %r{/rack/} } && (@config[:workers] == 0 || Rails.env.development?))
       @config[:hostname] = `hostname -f`.strip
-      do_config
-      banner if @config[:standalone]
-      cleanup_workers
-      create_worker
-      ActiveJob::Base.logger = nil
-      if @config[:standalone]
-        standalone
-      else
-        dispatcher = Dispatcher.new(worker: @worker, **@config)
-        thread = dispatcher.run
+      configure
+      Module.__send__(:include, Skiplock::Extension) if @config[:extensions] == true
+      if (caller.any?{ |l| l =~ %r{/rack/} } && (@config[:workers] == 0 || Rails.env.development?))
+        cleanup_workers
+        @worker = create_worker
+        @thread = @worker.run(**@config)
         at_exit do
-          dispatcher.shutdown
-          thread.join(@config[:graceful_shutdown])
+          @worker.shutdown
+          @thread.join(@config[:graceful_shutdown])
           @worker.delete
         end
       end
     rescue Exception => ex
-      @logger.error(ex)
+      @logger.error(ex.name)
+      @logger.error(ex.backtrace.join("\n"))
+    end
+
+    def standalone(**options)
+      @config.merge!(options)
+      Rails.logger.reopen('/dev/null')
+      Rails.logger.extend(ActiveSupport::Logger.broadcast(@logger))
+      @config[:workers] = 1 if @config[:workers] <= 0
+      banner
+      cleanup_workers
+      @worker = create_worker
+      @parent_id = Process.pid
+      @shutdown = false
+      Signal.trap("INT") { @shutdown = true }
+      Signal.trap("TERM") { @shutdown = true }
+      (@config[:workers] - 1).times do |n|
+        fork do
+          sleep 1
+          worker = create_worker(master: false)
+          thread = worker.run(worker_num: n + 1, **@config)
+          loop do
+            sleep 0.5
+            break if @shutdown || Process.ppid != @parent_id
+          end
+          worker.shutdown
+          thread.join(@config[:graceful_shutdown])
+          worker.delete
+          exit
+        end
+      end
+      @thread = @worker.run(**@config)
+      loop do
+        sleep 0.5
+        break if @shutdown
+      end
+      @logger.info "[Skiplock] Terminating signal... Waiting for jobs to finish (up to #{@config[:graceful_shutdown]} seconds)..." if @config[:graceful_shutdown]
+      Process.waitall
+      @worker.shutdown
+      @thread.join(@config[:graceful_shutdown])
+      @worker.delete
+      @logger.info "[Skiplock] Shutdown completed."
     end
 
-  private
+    private
 
     def banner
       title = "Skiplock #{Skiplock::VERSION} (Rails #{Rails::VERSION::STRING} | Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL})"
@@ -58,19 +93,17 @@ module Skiplock
         sid = Process.getsid(worker.pid) rescue nil
         delete_ids << worker.id if worker.sid != sid || worker.updated_at < 30.minutes.ago
       end
-      if delete_ids.count > 0
-        Job.where(running: true, worker_id: delete_ids).update_all(running: false, worker_id: nil)
-        Worker.where(id: delete_ids).delete_all
-      end
+      Worker.where(id: delete_ids).delete_all if delete_ids.count > 0
+      Job.where(running: true).where.not(worker_id: Worker.ids).update_all(running: false, worker_id: nil)
     end
 
-    def create_worker(pid: Process.pid, sid: Process.getsid(), master: true)
-      @worker = Worker.create!(pid: pid, sid: sid, master: master, hostname: @config[:hostname], capacity: @config[:max_threads])
+    def create_worker(master: true)
+      Worker.create!(pid: Process.pid, sid: Process.getsid(), master: master, hostname: @config[:hostname], capacity: @config[:max_threads])
     rescue
-      @worker = Worker.create!(pid: pid, sid: sid, master: false, hostname: @config[:hostname], capacity: @config[:max_threads])
+      Worker.create!(pid: Process.pid, sid: Process.getsid(), master: false, hostname: @config[:hostname], capacity: @config[:max_threads])
     end
 
-    def do_config
+    def configure
       @config[:loglevel] = 'info' unless ['debug','info','warn','error','fatal','unknown'].include?(@config[:loglevel].to_s)
       @config[:graceful_shutdown] = 300 if @config[:graceful_shutdown] > 300
       @config[:graceful_shutdown] = nil if @config[:graceful_shutdown] < 0
@@ -80,7 +113,6 @@ module Skiplock
       @config[:max_threads] = 20 if @config[:max_threads] > 20
       @config[:min_threads] = 0 if @config[:min_threads] < 0
       @config[:workers] = 0 if @config[:workers] < 0
-      @config[:workers] = 1 if @config[:standalone] && @config[:workers] <= 0
       @logger = ActiveSupport::Logger.new(STDOUT)
       @logger.level = @config[:loglevel].to_sym
       Skiplock.logger = @logger
@@ -88,10 +120,7 @@ module Skiplock
       @config[:logfile] = nil if @config[:logfile].to_s.length == 0
       if @config[:logfile]
         @logger.extend(ActiveSupport::Logger.broadcast(::Logger.new(@config[:logfile])))
-        if @config[:standalone]
-          Rails.logger.reopen('/dev/null')
-          Rails.logger.extend(ActiveSupport::Logger.broadcast(@logger))
-        end
+        ActiveJob::Base.logger = nil
       end
       @config[:queues].values.each { |v| raise 'Queue value must be an integer' unless v.is_a?(Integer) } if @config[:queues].is_a?(Hash)
       if @config[:notification] == 'auto'
@@ -126,40 +155,5 @@ module Skiplock
       end
       Skiplock.on_errors.freeze unless Skiplock.on_errors.frozen?
     end
-
-    def standalone
-      parent_id = Process.pid
-      shutdown = false
-      Signal.trap("INT") { shutdown = true }
-      Signal.trap("TERM") { shutdown = true }
-      (@config[:workers] - 1).times do |n|
-        fork do
-          sleep 1
-          worker = create_worker(master: false)
-          dispatcher = Dispatcher.new(worker: worker, worker_num: n + 1, **@config)
-          thread = dispatcher.run
-          loop do
-            sleep 0.5
-            break if shutdown || Process.ppid != parent_id
-          end
-          dispatcher.shutdown
-          thread.join(@config[:graceful_shutdown])
-          worker.delete
-          exit
-        end
-      end
-      dispatcher = Dispatcher.new(worker: @worker, **@config)
-      thread = dispatcher.run
-      loop do
-        sleep 0.5
-        break if shutdown
-      end
-      @logger.info "[Skiplock] Terminating signal... Waiting for jobs to finish (up to #{@config[:graceful_shutdown]} seconds)..." if @config[:graceful_shutdown]
-      Process.waitall
-      dispatcher.shutdown
-      thread.join(@config[:graceful_shutdown])
-      @worker.delete
-      @logger.info "[Skiplock] Shutdown completed."
-    end
   end
 end

data/lib/skiplock/version.rb

@@ -1,4 +1,4 @@
 module Skiplock
-  VERSION = Version = '1.0.12'
+  VERSION = Version = '1.0.13'
 end
 

data/lib/skiplock/worker.rb

@@ -1,5 +1,117 @@
 module Skiplock
   class Worker < ActiveRecord::Base
     self.implicit_order_column = 'created_at'
+
+    def run(worker_num: 0, **config)
+      @config = config
+      @worker_num = worker_num
+      @queues_order_query = @config[:queues].map { |q,v| "WHEN queue_name = '#{q}' THEN #{v}" }.join(' ') if @config[:queues].is_a?(Hash) && @config[:queues].count > 0
+      @next_schedule_at = Time.now.to_f
+      @executor = Concurrent::ThreadPoolExecutor.new(min_threads: @config[:min_threads], max_threads: @config[:max_threads], max_queue: @config[:max_threads], idletime: 60, auto_terminate: true, fallback_policy: :discard)
+      @running = true
+      Process.setproctitle("skiplock-#{self.master ? 'master[0]' : 'worker[' + @worker_num.to_s + ']'}") if @config[:standalone]
+      Thread.new do
+        @connection = self.class.connection
+        @connection.exec_query('LISTEN "skiplock::jobs"')
+        if self.master
+          Dir.mkdir('tmp/skiplock') unless Dir.exist?('tmp/skiplock')
+          check_sync_errors
+          Cron.setup
+        end
+        error = false
+        timestamp = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        while @running
+          Rails.application.reloader.wrap do
+            begin
+              if error
+                unless @connection.active?
+                  @connection.reconnect!
+                  sleep(0.5)
+                  @connection.exec_query('LISTEN "skiplock::jobs"')
+                  @next_schedule_at = Time.now.to_f
+                end
+                check_sync_errors if self.master
+                error = false
+              end
+              job_notifications = []
+              @connection.raw_connection.wait_for_notify(0.1) do |channel, pid, payload|
+                job_notifications << payload if payload
+                loop do
+                  payload = @connection.raw_connection.notifies
+                  break unless @running && payload
+                  job_notifications << payload[:extra]
+                end
+                job_notifications.each do |n|
+                  op, id, worker_id, job_class, queue_name, running, expired_at, finished_at, scheduled_at = n.split(',')
+                  next if op == 'DELETE' || running == 'true' || expired_at.to_f > 0 || finished_at.to_f > 0
+                  if scheduled_at.to_f <= Time.now.to_f
+                    @next_schedule_at = Time.now.to_f
+                  elsif scheduled_at.to_f < @next_schedule_at
+                    @next_schedule_at = scheduled_at.to_f
+                  end
+                end
+              end
+              if Time.now.to_f >= @next_schedule_at && @executor.remaining_capacity > 0
+                job = dispatch_job
+                if job.is_a?(Job)
+                  @executor.post(job, @config[:purge_completion], @config[:max_retries]) do |job, purge_completion, max_retries|
+                    job.execute(purge_completion: purge_completion, max_retries: max_retries)
+                  end
+                else
+                  @next_schedule_at = job
+                end
+              end
+              if Process.clock_gettime(Process::CLOCK_MONOTONIC) - timestamp > 60
+                self.touch
+                timestamp = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              end
+            rescue Exception => ex
+              # most likely error with database connection
+              Skiplock.logger.error(ex.name)
+              Skiplock.logger.error(ex.backtrace.join("\n"))
+              Skiplock.on_errors.each { |p| p.call(ex, @last_exception) }
+              error = true
+              t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              while @running
+                sleep(0.5)
+                break if Process.clock_gettime(Process::CLOCK_MONOTONIC) - t > 5
+              end
+              @last_exception = ex
+            end
+            sleep(0.2)
+          end
+        end
+        @connection.exec_query('UNLISTEN *')
+        @executor.shutdown
+        @executor.kill unless @executor.wait_for_termination(@config[:graceful_shutdown])
+      end
+    end
+
+    def shutdown
+      @running = false
+    end
+
+    private
+
+    def check_sync_errors
+      # get performed jobs that could not sync with database
+      Dir.glob('tmp/skiplock/*').each do |f|
+        job_from_db = Job.find_by(id: File.basename(f), running: true)
+        disposed = true
+        if job_from_db
+          job, ex = YAML.load_file(f) rescue nil
+          disposed = job.dispose(ex, purge_completion: @config[:purge_completion], max_retries: @config[:max_retries])
+        end
+        File.delete(f) if disposed
+      end
+    end
+
+    def dispatch_job
+      @connection.transaction do
+        job = Job.find_by_sql("SELECT id, scheduled_at FROM skiplock.jobs WHERE running = FALSE AND expired_at IS NULL AND finished_at IS NULL ORDER BY scheduled_at ASC NULLS FIRST,#{@queues_order_query ? ' CASE ' + @queues_order_query + ' ELSE NULL END ASC NULLS LAST,' : ''} priority ASC NULLS LAST, created_at ASC FOR UPDATE SKIP LOCKED LIMIT 1").first
+        return (job ? job.scheduled_at.to_f : Float::INFINITY) if job.nil? || job.scheduled_at.to_f > Time.now.to_f
+        Job.find_by_sql("UPDATE skiplock.jobs SET running = TRUE, worker_id = '#{self.id}', updated_at = NOW() WHERE id = '#{job.id}' RETURNING *").first
+      end
+    end
   end
 end

data/lib/skiplock.rb

@@ -3,7 +3,6 @@ require 'active_job/queue_adapters/skiplock_adapter'
 require 'active_record'
 require 'skiplock/counter'
 require 'skiplock/cron'
-require 'skiplock/dispatcher'
 require 'skiplock/extension'
 require 'skiplock/job'
 require 'skiplock/manager'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skiplock
 version: !ruby/object:Gem::Version
-  version: 1.0.12
+  version: 1.0.13
 platform: ruby
 authors:
 - Tin Vo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-30 00:00:00.000000000 Z
+date: 2021-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -84,7 +84,6 @@ files:
 - lib/skiplock.rb
 - lib/skiplock/counter.rb
 - lib/skiplock/cron.rb
-- lib/skiplock/dispatcher.rb
 - lib/skiplock/extension.rb
 - lib/skiplock/job.rb
 - lib/skiplock/manager.rb

data/lib/skiplock/dispatcher.rb

@@ -1,116 +0,0 @@
-module Skiplock
-  class Dispatcher
-    def initialize(worker:, worker_num: nil, **config)
-      @config = config
-      @worker = worker
-      @queues_order_query = @config[:queues].map { |q,v| "WHEN queue_name = '#{q}' THEN #{v}" }.join(' ') if @config[:queues].is_a?(Hash) && @config[:queues].count > 0
-      @executor = Concurrent::ThreadPoolExecutor.new(min_threads: @config[:min_threads], max_threads: @config[:max_threads], max_queue: @config[:max_threads], idletime: 60, auto_terminate: true, fallback_policy: :discard)
-      @last_dispatch_at = 0
-      @next_schedule_at = Time.now.to_f
-      Process.setproctitle("skiplock-#{@worker.master ? 'master[0]' : 'worker[' + worker_num.to_s + ']'}") if @config[:standalone]
-    end
-    
-    def run
-      @running = true
-      Thread.new do
-        ActiveRecord::Base.connection_pool.with_connection do |connection|
-          connection.exec_query('LISTEN "skiplock::jobs"')
-          if @worker.master
-            Dir.mkdir('tmp/skiplock') unless Dir.exist?('tmp/skiplock')
-            check_sync_errors
-            Cron.setup
-          end
-          error = false
-          timestamp = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          while @running
-            begin
-              if error
-                unless connection.active?
-                  connection.reconnect!
-                  sleep(0.5)
-                  connection.exec_query('LISTEN "skiplock::jobs"')
-                  @next_schedule_at = Time.now.to_f
-                end
-                check_sync_errors
-                error = false
-              end
-              job_notifications = []
-              connection.raw_connection.wait_for_notify(0.1) do |channel, pid, payload|
-                job_notifications << payload if payload
-                loop do
-                  payload = connection.raw_connection.notifies
-                  break unless @running && payload
-                  job_notifications << payload[:extra]
-                end
-                job_notifications.each do |n|
-                  op, id, worker_id, queue_name, running, expired_at, finished_at, scheduled_at = n.split(',')
-                  next if op == 'DELETE' || running == 'true' || expired_at.to_f > 0 || finished_at.to_f > 0  || scheduled_at.to_f < @last_dispatch_at
-                  if scheduled_at.to_f <= Time.now.to_f
-                    @next_schedule_at = Time.now.to_f
-                  elsif scheduled_at.to_f < @next_schedule_at
-                    @next_schedule_at = scheduled_at.to_f
-                  end
-                end
-              end
-              if Time.now.to_f >= @next_schedule_at && @executor.remaining_capacity > 0
-                @executor.post { do_work }
-              end
-              if Process.clock_gettime(Process::CLOCK_MONOTONIC) - timestamp > 60
-                @worker.touch
-                timestamp = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-              end
-            rescue Exception => ex
-              # most likely error with database connection
-              Skiplock.logger.error(ex)
-              Skiplock.on_errors.each { |p| p.call(ex, @last_exception) }
-              error = true
-              t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-              while @running
-                sleep(0.5)
-                break if Process.clock_gettime(Process::CLOCK_MONOTONIC) - t > 5
-              end
-              @last_exception = ex
-            end
-            sleep(0.2)
-          end
-          connection.exec_query('UNLISTEN *')
-          @executor.shutdown
-          @executor.kill unless @executor.wait_for_termination(@config[:graceful_shutdown])
-        end
-      end
-    end
-
-    def shutdown
-      @running = false
-    end
-
-    private
-
-    def check_sync_errors
-      # get performed jobs that could not sync with database
-      Dir.glob('tmp/skiplock/*').each do |f|
-        job_from_db = Job.find_by(id: File.basename(f), running: true)
-        disposed = true
-        if job_from_db
-          job, ex = YAML.load_file(f) rescue nil
-          disposed = job.dispose(ex, purge_completion: @config[:purge_completion], max_retries: @config[:max_retries])
-        end
-        File.delete(f) if disposed
-      end
-    end
-
-    def do_work
-      while @running
-        @last_dispatch_at = Time.now.to_f - 1  # 1 second allowance for time drift
-        result = Job.dispatch(queues_order_query: @queues_order_query, worker_id: @worker.id, purge_completion: @config[:purge_completion], max_retries: @config[:max_retries])
-        next if result.is_a?(Job) && Time.now.to_f >= @next_schedule_at
-        @next_schedule_at = result if result.is_a?(Float)
-        break
-      end
-    rescue Exception => ex
-      Skiplock.logger.error(ex)
-      Skiplock.on_errors.each { |p| p.call(ex, @last_exception) }
-      @last_exception = ex
-    end
-  end
-end