skiplock 1.0.13 → 1.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89240e4318ca72cf30a3426948d9aa8479f59f85b82e4dca4ef5ee3b449b9894
-  data.tar.gz: b8f6799ccf4ba566379548dc4e9c90b6a1202842139b0ac0a3e0247875be00d9
+  metadata.gz: 55c98833e2792a216b6389d399e992aae9660f23ea076fcf852fb164cbc32d55
+  data.tar.gz: 43c8c2f90ee55ec423242042d1ab2986c0cb9f70fcc04db56aaf2c566bbb0382
 SHA512:
-  metadata.gz: 3d8ec5ec2c3b0612fd3077fac5d6ff0c6e1b6826ed74b25b640ccc966874461b470f633c582af4f408f547586e30e1fdc5c22f158ca6fdf5c91000ec33c609a2
-  data.tar.gz: 27b6f4746f255777fdb6b3733d08a0592969a45d6d0f315d76231269255e532b51834fa79e1be89a0c18ac62509fe342266c9a8a5c7c038cc2b9e52b120e2469
+  metadata.gz: 873492b815e6b5fc653630fed3bc64c5a363339551bbad304ecbad9453ea3738c24f3f0b874f4d6fe47cd4cc0ea5d46fb61b4c0dc322814d08dbc11002c24443
+  data.tar.gz: e84f7081e07ba0aff19834251de09e08df573d45ff159299fe08baf621b76845cd2fdf0461229da77b07cf707f151e7d8fc00d97b19a9bf30f1129376c2dd053

data/lib/skiplock/job.rb

@@ -2,6 +2,16 @@ module Skiplock
   class Job < ActiveRecord::Base
     self.implicit_order_column = 'created_at'
 
+    def self.dispatch(worker_id: nil, purge_completion: true, max_retries: 20)
+      job = nil
+      self.connection.transaction do
+        job = self.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, priority ASC NULLS LAST, created_at ASC FOR UPDATE SKIP LOCKED LIMIT 1").first
+        return if job.nil? || job.scheduled_at.to_f > Time.now.to_f
+        job = self.find_by_sql("UPDATE skiplock.jobs SET running = TRUE, worker_id = #{self.connection.quote(worker_id)}, updated_at = NOW() WHERE id = '#{job.id}' RETURNING *").first
+      end
+      self.dispatch(worker_id: worker_id, purge_completion: purge_completion, max_retries: max_retries) if job.execute(purge_completion: purge_completion, max_retries: max_retries)
+    end
+
     def self.enqueue(activejob)
       self.enqueue_at(activejob, nil)
     end
@@ -50,7 +60,7 @@ module Skiplock
           self.scheduled_at = Time.at(next_cron_at)
           self.save!
         else
-          Skiplock.logger.error "[Skiplock] ERROR: Invalid CRON '#{self.cron}' for Job #{self.job_class}"
+          Skiplock.logger.error("[Skiplock] ERROR: Invalid CRON '#{self.cron}' for Job #{self.job_class}") if Skiplock.logger
           self.delete
         end
       elsif purge_completion
@@ -62,14 +72,16 @@ module Skiplock
       end
       self
     rescue Exception => e
-      Skiplock.logger.error(e.name)
-      Skiplock.logger.error(e.backtrace.join("\n"))
-      File.write("tmp/skiplock/#{self.id}", yaml)
+      if Skiplock.logger
+        Skiplock.logger.error(e.to_s)
+        Skiplock.logger.error(e.backtrace.join("\n"))
+        File.write("tmp/skiplock/#{self.id}", yaml)
+      end
       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'}'..."
+      Skiplock.logger.info("[Skiplock] Performing #{self.job_class} (#{self.id}) from queue '#{self.queue_name || 'default'}'...") if Skiplock.logger
       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'] || []))
@@ -81,20 +93,22 @@ module Skiplock
         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}'"
+      if Skiplock.logger
+        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.to_s)
+            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
-        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

data/lib/skiplock/manager.rb

@@ -9,18 +9,14 @@ module Skiplock
       @config[:hostname] = `hostname -f`.strip
       configure
       Module.__send__(:include, Skiplock::Extension) if @config[:extensions] == true
-      if (caller.any?{ |l| l =~ %r{/rack/} } && (@config[:workers] == 0 || Rails.env.development?))
+      if (caller.any?{ |l| l =~ %r{/rack/} } && @config[:workers] == 0)
         cleanup_workers
         @worker = create_worker
-        @thread = @worker.run(**@config)
-        at_exit do
-          @worker.shutdown
-          @thread.join(@config[:graceful_shutdown])
-          @worker.delete
-        end
+        @worker.start(**@config)
+        at_exit { @worker.shutdown }
       end
     rescue Exception => ex
-      @logger.error(ex.name)
+      @logger.error(ex.to_s)
       @logger.error(ex.backtrace.join("\n"))
     end
 
@@ -40,18 +36,15 @@ module Skiplock
         fork do
           sleep 1
           worker = create_worker(master: false)
-          thread = worker.run(worker_num: n + 1, **@config)
+          worker.start(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)
+      @worker.start(**@config)
       loop do
         sleep 0.5
         break if @shutdown
@@ -59,8 +52,6 @@ module Skiplock
       @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
 

data/lib/skiplock/version.rb

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

data/lib/skiplock/worker.rb

@@ -2,116 +2,120 @@ module Skiplock
   class Worker < ActiveRecord::Base
     self.implicit_order_column = 'created_at'
 
-    def run(worker_num: 0, **config)
+    def start(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)
+      @executor = Concurrent::ThreadPoolExecutor.new(min_threads: @config[:min_threads] + 1, max_threads: @config[:max_threads] + 1, 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])
+      Process.setproctitle("skiplock-#{self.master ? 'master[0]' : 'worker[' + worker_num.to_s + ']'}") if @config[:standalone]
+      @executor.post do
+        Rails.application.reloader.wrap { run }
       end
     end
 
     def shutdown
       @running = false
+      @executor.shutdown
+      @executor.kill unless @executor.wait_for_termination(@config[:graceful_shutdown])
+      self.delete
     end
 
     private
 
     def check_sync_errors
-      # get performed jobs that could not sync with database
+      # get executed 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])
+          disposed = job.dispose(ex, purge_completion: @config[:purge_completion], max_retries: @config[:max_retries]) if job
         end
         File.delete(f) if disposed
       end
     end
 
-    def dispatch_job
+    def get_next_available_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
+        if job && job.scheduled_at.to_f <= Time.now.to_f
+          job = Job.find_by_sql("UPDATE skiplock.jobs SET running = TRUE, worker_id = '#{self.id}', updated_at = NOW() WHERE id = '#{job.id}' RETURNING *").first
+        end
+        job
+      end
+    end
+
+    def run
+      @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
+            if Time.now.to_f >= @next_schedule_at && @executor.remaining_capacity > 0
+              job = get_next_available_job
+              if job.try(:running)
+                @executor.post do
+                  Rails.application.executor.wrap do
+                    ActiveSupport::Dependencies.interlock.permit_concurrent_loads { job.execute(purge_completion: @config[:purge_completion], max_retries: @config[:max_retries]) }
+                  end
+                end
+              else
+                @next_schedule_at = (job ? job.scheduled_at.to_f : Float::INFINITY)
+              end
+            end
+            job_notifications = []
+            @connection.raw_connection.wait_for_notify(0.4) 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
+                @next_schedule_at = scheduled_at.to_f if scheduled_at.to_f < @next_schedule_at
+              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.to_s)
+            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.3)
+        end
       end
+      @connection.exec_query('UNLISTEN *')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skiplock
 version: !ruby/object:Gem::Version
-  version: 1.0.13
+  version: 1.0.14
 platform: ruby
 authors:
 - Tin Vo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-04 00:00:00.000000000 Z
+date: 2021-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob