skiplock 1.0.7 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b5f33c5c4f2f2223b68f6d025989cc3eb6568fb52a7e39ef3bf4c48a1807ec3
-  data.tar.gz: 3839f01f8771b1ec06a0ab33c32555d4aa7ad0a48e142d0224fe46868692bfa5
+  metadata.gz: 2ee6a8ff68af1a1029a26db98867457a798c4fb6aacf0a2a2816efd3ef2b977b
+  data.tar.gz: 2c75fb21c79346f4525b8634b28fb326505acb7ab61795fe7d291c3faa75244f
 SHA512:
-  metadata.gz: 7bf28c36dca7f41518c6d5be2651ff7b40e0f62c526248a478db4a88545b7663260225de5b2c6eacf89e17e34cf24ac2fd38c0bbf95c4cac54a8f57f68fd772a
-  data.tar.gz: 3998b4377bbe2dd0b993ac9abcf848c6164fcb4378387cc8c7187d507c6fc6df1676fdba30ce98e26ac41730d0569a64197317c52447b1e8d6a06c93fb313fa7
+  metadata.gz: c34fa2c27f9fc8bcfbe6c54a30de8645418dfe7c13e8db9ea8c30352f75abd9ab9b04d1a294aea7f2a9f33772d9cc5ed96839bd63d1eacbda17749758b4755b2
+  data.tar.gz: 03cdbef1a70a64fb188258dc44049f9323f53cb9c2e64f8a79a9c8a4a17ca8aea2e7ca718ceb3bc78cc08fd61d6dbd5c3f104f653a9645132ef31f73d22883da

data/README.md

@@ -72,7 +72,7 @@ The library is quite small compared to other PostgreSQL job queues (eg. *delay_j
     - **workers** (*integer*) sets the maximum number of processes when running in standalone mode using the `skiplock` executable; setting this to **0** will enable **async mode**
     
     #### Async mode
-    When **workers** is set to **0** then the jobs will be performed in the web server process using separate threads.  If using multi-worker cluster web server like Puma, then it should be configured as below:
+    When **workers** is set to **0** then the jobs will be performed in the web server process using separate threads.  If using multi-worker cluster mode web server like Puma, then it should be configured as below:
     ```ruby
     # config/puma.rb
     before_fork do
@@ -80,14 +80,10 @@ The library is quite small compared to other PostgreSQL job queues (eg. *delay_j
       Skiplock::Manager.shutdown
     end
 
-    on_worker_boot do
-      # ...
-      Skiplock::Manager.start
-    end
-
-    on_worker_shutdown do
-      # ...
-      Skiplock::Manager.shutdown
+    after_worker_fork do |worker_index|
+      # restarts skiplock after all Puma workers have been started
+      # Skiplock runs in Puma master's process only
+      Skiplock::Manager.start if (worker_index + 1) == @options[:workers]
     end
     ```
 

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

@@ -36,7 +36,7 @@ class CreateSkiplockSchema < ActiveRecord::Migration<%= "[#{ActiveRecord::VERSIO
           ELSE
             record = NEW;
           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 record.scheduled_at) AS FLOAT)::TEXT));
+          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));
           RETURN NULL;
         END;
       $$ LANGUAGE plpgsql

data/lib/skiplock/dispatcher.rb

@@ -9,100 +9,112 @@ module Skiplock
       else
         @worker_num = worker_num
       end
+      @last_dispatch_at = 0
       @next_schedule_at = Time.now.to_f
       @running = true
     end
     
     def run
       Thread.new do
-        Rails.application.reloader.wrap do
-          sleep(0.1) while @running && !Rails.application.initialized?
-          Process.setproctitle("skiplock-#{@master ? 'master[0]' : 'worker[' + @worker_num.to_s + ']'}") if Settings['workers'] > 0
-          ActiveRecord::Base.connection_pool.with_connection do |connection|
-            connection.exec_query('LISTEN "skiplock::jobs"')
-            hostname = `hostname -f`.strip
-            @worker = Worker.create!(pid: Process.pid, ppid: (@master ? nil : Process.ppid), capacity: Settings['max_threads'], hostname: hostname)
-            if @master
-              if File.exists?('tmp/cache/skiplock')
-                # get performed jobs that could not sync with database
-                job_ids = File.read('tmp/cache/skiplock').split("\n")
-                if Settings['purge_completion']
-                  Job.where(id: job_ids, running: true).delete_all
-                else
-                  Job.where(id: job_ids, running: true).update_all(running: false, finished_at: File.mtime('tmp/cache/skiplock'))
-                end
-                File.delete('tmp/cache/skiplock')
+        sleep(1) while @running && !Rails.application.initialized?
+        Process.setproctitle("skiplock-#{@master ? 'master[0]' : 'worker[' + @worker_num.to_s + ']'}") if Settings['workers'] > 0
+        ActiveRecord::Base.connection_pool.with_connection do |connection|
+          connection.exec_query('LISTEN "skiplock::jobs"')
+          hostname = `hostname -f`.strip
+          @worker = Worker.create!(pid: Process.pid, ppid: (@master ? nil : Process.ppid), capacity: Settings['max_threads'], hostname: hostname)
+          if @master
+            connection.exec_query('LISTEN "skiplock::workers"')
+            if File.exists?('tmp/cache/skiplock')
+              # get performed jobs that could not sync with database
+              job_ids = File.read('tmp/cache/skiplock').split("\n")
+              if Settings['purge_completion']
+                Job.where(id: job_ids).delete_all
+              else
+                Job.where(id: job_ids).update_all(running: false, finished_at: File.mtime('tmp/cache/skiplock'), updated_at: Time.now)
               end
-              # get current worker ids
-              worker_ids = Worker.where(hostname: hostname, pid: @worker_pids).ids
+              File.delete('tmp/cache/skiplock')
+            end
+            # get dead worker ids
+            dead_worker_ids = Worker.where(hostname: hostname).where.not(pid: @worker_pids).ids
+            if dead_worker_ids.count > 0
               # reset orphaned jobs of the dead worker ids for retry
-              Job.where(running: true).where.not(worker_id: worker_ids).update_all(running: false, worker_id: nil)
-              # remove workers that were not shutdown properly on the host
-              Worker.where(hostname: hostname).where.not(pid: @worker_pids).delete_all
-              # reset retries schedules on startup
-              Job.where('scheduled_at > NOW() AND executions IS NOT NULL AND expired_at IS NULL AND finished_at IS NULL').update_all(scheduled_at: nil, updated_at: Time.now)
-              Cron.setup
+              Job.where(running: true).where(worker_id: dead_worker_ids).update_all(running: false, worker_id: nil)
+              # remove dead workers
+              Worker.where(id: dead_worker_ids).delete_all
             end
-            error = false
-            while @running
-              begin
-                if error
-                  unless connection.active?
-                    connection.reconnect!
-                    sleep(0.5)
-                    connection.exec_query('LISTEN "skiplock::jobs"')
-                    @next_schedule_at = Time.now
-                  end
-                  error = false
+            # reset retries schedules on startup
+            Job.where('scheduled_at > NOW() AND executions IS NOT NULL AND expired_at IS NULL AND finished_at IS NULL').update_all(scheduled_at: nil, updated_at: Time.now)
+            Cron.setup
+          end
+          error = false
+          while @running
+            begin
+              if error
+                unless connection.active?
+                  connection.reconnect!
+                  sleep(0.5)
+                  connection.exec_query('LISTEN "skiplock::jobs"')
+                  connection.exec_query('LISTEN "skiplock::workers"') if @master
+                  @next_schedule_at = Time.now.to_f
                 end
-                if Job::Errors.keys.count > 0
-                  completed_ids = Job::Errors.keys.map { |k| k if Job::Errors[k] }.compact
-                  if Settings['purge_completion'] && completed_ids.count > 0
-                    Job.where(id: completed_ids, running: true).delete_all
-                  elsif completed_ids.count > 0
-                    Job.where(id: completed_ids, running: true).update_all(running: false, finished_at: Time.now)
-                  end
-                  orphaned_ids = Job::Errors.keys.map { |k| k unless Job::Errors[k] }.compact
-                  Job.where(id: orphaned_ids, running: true).update_all(running: false, worker_id: nil, scheduled_at: (Time.now + 10)) if orphaned_ids.count > 0
-                  Job::Errors.clear
+                error = false
+              end
+              if Job::Errors.keys.count > 0
+                completed_ids = Job::Errors.keys.map { |k| k if Job::Errors[k] }.compact
+                if Settings['purge_completion'] && completed_ids.count > 0
+                  Job.where(id: completed_ids, running: true).delete_all
+                elsif completed_ids.count > 0
+                  Job.where(id: completed_ids, running: true).update_all(running: false, finished_at: Time.now, updated_at: Time.now)
                 end
-                if Time.now.to_f >= @next_schedule_at && @executor.remaining_capacity > 0
-                  @executor.post { do_work }
+                orphaned_ids = Job::Errors.keys.map { |k| k unless Job::Errors[k] }.compact
+                Job.where(id: orphaned_ids, running: true).update_all(running: false, worker_id: nil, scheduled_at: (Time.now + 10), updated_at: Time.now) if orphaned_ids.count > 0
+                Job::Errors.clear
+              end
+              notifications = { 'skiplock::jobs' => [], 'skiplock::workers' => [] }
+              connection.raw_connection.wait_for_notify(0.1) do |channel, pid, payload|
+                notifications[channel] << payload if payload
+                loop do
+                  payload = connection.raw_connection.notifies
+                  break unless @running && payload
+                  notifications[payload[:relname]] << payload[:extra]
                 end
-                notifications = []
-                connection.raw_connection.wait_for_notify(0.1) do |channel, pid, payload|
-                  notifications << payload if payload
-                  loop do
-                    payload = connection.raw_connection.notifies
-                    break unless @running && payload
-                    notifications << payload[:extra]
+                notifications['skiplock::jobs'].each do |n|
+                  op, id, worker_id, queue_name, running, expired_at, finished_at, scheduled_at = n.split(',')
+                  if @master
+                    # TODO: report job status to action cable
                   end
-                  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_s.length > 0 || finished_at.to_s.length > 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
+                  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
-              rescue Exception => ex
-                STDERR.puts ex.message
-                STDERR.puts ex.backtrace
-                Skiplock.on_error.call(ex, @last_exception) if Skiplock.on_error.is_a?(Proc)
-                error = true
-                t = Time.now
-                while @running
-                  sleep(0.5)
-                  break if Time.now - t > 5
-                end              
-                @last_exception = ex
+                if @master
+                  # TODO: report worker status to action cable
+                  notifications['skiplock::workers'].each do |n|
+                  end
+                end
+              end
+              if Time.now.to_f >= @next_schedule_at && @executor.remaining_capacity > 0
+                @executor.post { do_work }
+              end
+            rescue Exception => ex
+              # most likely error with database connection
+              STDERR.puts ex.message
+              STDERR.puts ex.backtrace
+              Skiplock.on_error.call(ex, @last_exception) if Skiplock.on_error.is_a?(Proc)
+              error = true
+              t = Time.now
+              while @running
+                sleep(0.5)
+                break if Time.now - t > 5
               end
-              sleep(0.2)
+              @last_exception = ex
             end
-            connection.exec_query('UNLISTEN *')
+            sleep(0.2)
           end
+          connection.exec_query('UNLISTEN *')
         end
       end
     end
@@ -118,6 +130,7 @@ module Skiplock
 
     def do_work
       while @running
+        @last_dispatch_at = Time.now.to_f
         result = Job.dispatch(queues_order_query: @queues_order_query, worker_id: @worker.id)
         next if result.is_a?(Job)
         @next_schedule_at = result if result.is_a?(Float)

data/lib/skiplock/manager.rb

@@ -1,6 +1,6 @@
 module Skiplock
   class Manager
-    def self.start(standalone: false, workers: nil, max_retries: nil, max_threads: nil, min_threads: nil, logging: nil)
+    def self.start(standalone: false, restart: false, workers: nil, max_retries: nil, max_threads: nil, min_threads: nil, logging: nil)
       unless Settings.frozen?
         load_settings
         Settings['logging'] = logging if logging
@@ -16,7 +16,7 @@ module Skiplock
         Settings['workers'] = 0 if Settings['workers'] < 0
         Settings.freeze
       end
-      return unless standalone || (caller.any?{|l| l =~ %r{/rack/}} && (Settings['workers'] == 0 || Rails.env.development?))
+      return unless standalone || restart || (caller.any?{|l| l =~ %r{/rack/}} && (Settings['workers'] == 0 || Rails.env.development?))
       if standalone
         self.standalone
       else
@@ -24,12 +24,15 @@ module Skiplock
         @thread = @dispatcher.run
         at_exit { self.shutdown }
       end
+      ActiveJob::Base.logger = nil
     end
     
     def self.shutdown(wait: true)
       if @dispatcher && @thread
         @dispatcher.shutdown(wait: wait)
         @thread.join
+        @dispatcher = nil
+        @thread = nil
       end
     end
 

data/lib/skiplock/version.rb

@@ -1,4 +1,4 @@
 module Skiplock
-  VERSION = Version = '1.0.7'
+  VERSION = Version = '1.0.8'
 end
 

metadata

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