workhorse 1.2.18 → 1.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec60662cb949157cad7c1c42704bff8299505f75ac993dc3fb4f95e0cb645e6a
-  data.tar.gz: 80d7fff31444778438ebc47c68e54d6a9291f4b7e68f2eaae30dc50d087d4fb2
+  metadata.gz: 4ee79a0aad4b594650de92485a2a0f4d95364042fe1ce8ebd4a2be075827d07d
+  data.tar.gz: a2dcfbdc9e1152513e9fb02613d1f219c3849f85797716e431f0a2fb84fae654
 SHA512:
-  metadata.gz: c9e7940d6d0a38de896ca31a892a5fe4e9d08a607969ff998c916e1688353e4c8264267bc9f45725bfd0a00a5f2b8285748326151b343d24d54e18e20cba0021
-  data.tar.gz: b3c9d6a97f5d90811ea16fe1222b7608feeebefb78d777abd22c831a60fa3a3ec89aed4cbf374779dca959cb3e64a6030802bf909b82125f8db79f2f44d08c4c
+  metadata.gz: 99496e59a85fad0b8ca3fe3d9a24b4fd30fd8be3a9e0a236f584dffc42bfda37ba91a5224dfcd29aee88de72ea1df234df286262b5777daf9edb8cfffa0dc2f8
+  data.tar.gz: 13eee5ce97cfc0e66ef4b99a9132590230cc636d202f6e05e9757288dc0ba05e0fd916052bd3638464d0ecb0fafd868004fdc810c4f45f3d0a79350253a17b75

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Workhorse Changelog
 
+## 1.2.19 - 2024-05-07
+
+* Fix further compatibility issues with `ruby < 2.5`
+
+  Sitrox reference: #124538.
+
 ## 1.2.18 - 2024-05-07
 
 * Fix compatibility with `ruby < 2.5`

data/VERSION

@@ -1 +1 @@
-1.2.18
+1.2.19

data/lib/workhorse/performer.rb

@@ -9,41 +9,45 @@ module Workhorse
     end
 
     def perform
-      fail 'Performer can only run once.' if @started
-      @started = true
-      perform!
-    rescue Exception => e
-      Workhorse.on_exception.call(e)
+      begin
+        fail 'Performer can only run once.' if @started
+        @started = true
+        perform!
+      rescue Exception => e
+        Workhorse.on_exception.call(e)
+      end
     end
 
     private
 
     def perform!
-      Thread.current[:workhorse_current_performer] = self
+      begin
+        Thread.current[:workhorse_current_performer] = self
 
-      ActiveRecord::Base.connection_pool.with_connection do
-        if defined?(Rails) && Rails.respond_to?(:application) && Rails.application && Rails.application.respond_to?(:executor)
-          Rails.application.executor.wrap do
+        ActiveRecord::Base.connection_pool.with_connection do
+          if defined?(Rails) && Rails.respond_to?(:application) && Rails.application && Rails.application.respond_to?(:executor)
+            Rails.application.executor.wrap do
+              perform_wrapped
+            end
+          else
             perform_wrapped
           end
-        else
-          perform_wrapped
         end
-      end
-    rescue Exception => e
-      # ---------------------------------------------------------------
-      # Mark job as failed
-      # ---------------------------------------------------------------
-      log %(#{e.message}\n#{e.backtrace.join("\n")}), :error
+      rescue Exception => e
+        # ---------------------------------------------------------------
+        # Mark job as failed
+        # ---------------------------------------------------------------
+        log %(#{e.message}\n#{e.backtrace.join("\n")}), :error
 
-      Workhorse.tx_callback.call do
-        log 'Mark failed', :debug
-        @db_job.mark_failed!(e)
-      end
+        Workhorse.tx_callback.call do
+          log 'Mark failed', :debug
+          @db_job.mark_failed!(e)
+        end
 
-      fail e
-    ensure
-      Thread.current[:workhorse_current_performer] = nil
+        fail e
+      ensure
+        Thread.current[:workhorse_current_performer] = nil
+      end
     end
 
     def perform_wrapped

data/lib/workhorse/poller.rb

@@ -141,60 +141,62 @@ module Workhorse
     end
 
     def with_global_lock(name: :workhorse, timeout: 2, &_block)
-      if @is_oracle
-        result = Workhorse::DbJob.connection.select_all(
-          "SELECT DBMS_LOCK.REQUEST(#{ORACLE_LOCK_HANDLE}, #{ORACLE_LOCK_MODE}, #{timeout}) FROM DUAL"
-        ).first.values.last
+      begin
+        if @is_oracle
+          result = Workhorse::DbJob.connection.select_all(
+            "SELECT DBMS_LOCK.REQUEST(#{ORACLE_LOCK_HANDLE}, #{ORACLE_LOCK_MODE}, #{timeout}) FROM DUAL"
+          ).first.values.last
 
-        success = result == 0
-      else
-        result = Workhorse::DbJob.connection.select_all(
-          "SELECT GET_LOCK(CONCAT(DATABASE(), '_#{name}'), #{timeout})"
-        ).first.values.last
-        success = result == 1
-      end
+          success = result == 0
+        else
+          result = Workhorse::DbJob.connection.select_all(
+            "SELECT GET_LOCK(CONCAT(DATABASE(), '_#{name}'), #{timeout})"
+          ).first.values.last
+          success = result == 1
+        end
 
-      if success
-        @global_lock_fails = 0
-        @max_global_lock_fails_reached = false
-      else
-        @global_lock_fails += 1
+        if success
+          @global_lock_fails = 0
+          @max_global_lock_fails_reached = false
+        else
+          @global_lock_fails += 1
 
-        unless @max_global_lock_fails_reached
-          worker.log 'Could not obtain global lock, retrying with next poll.', :warn
-        end
+          unless @max_global_lock_fails_reached
+            worker.log 'Could not obtain global lock, retrying with next poll.', :warn
+          end
 
-        if @global_lock_fails > Workhorse.max_global_lock_fails && !@max_global_lock_fails_reached
-          @max_global_lock_fails_reached = true
-
-          worker.log 'Could not obtain global lock, retrying with next poll. ' \
-                     'This will be the last such message for this worker until ' \
-                     'the issue is resolved.', :warn
-
-          message = "Worker reached maximum number of consecutive times (#{Workhorse.max_global_lock_fails}) " \
-                    "where the global lock could no be acquired within the specified timeout (#{timeout}). " \
-                    'A worker that obtained this lock may have crashed without ending the database ' \
-                    'connection properly. On MySQL, use "show processlist;" to see which connection(s) ' \
-                    'is / are holding the lock for a long period of time and consider killing them using ' \
-                    "MySQL's \"kill <Id>\" command. This message will be issued only once per worker " \
-                    'and may only be re-triggered if the error happens again *after* the lock has ' \
-                    'been solved in the meantime.'
-
-          worker.log message
-          exception = StandardError.new(message)
-          Workhorse.on_exception.call(exception)
+          if @global_lock_fails > Workhorse.max_global_lock_fails && !@max_global_lock_fails_reached
+            @max_global_lock_fails_reached = true
+
+            worker.log 'Could not obtain global lock, retrying with next poll. ' \
+              'This will be the last such message for this worker until ' \
+              'the issue is resolved.', :warn
+
+            message = "Worker reached maximum number of consecutive times (#{Workhorse.max_global_lock_fails}) " \
+              "where the global lock could no be acquired within the specified timeout (#{timeout}). " \
+              'A worker that obtained this lock may have crashed without ending the database ' \
+              'connection properly. On MySQL, use "show processlist;" to see which connection(s) ' \
+              'is / are holding the lock for a long period of time and consider killing them using ' \
+              "MySQL's \"kill <Id>\" command. This message will be issued only once per worker " \
+              'and may only be re-triggered if the error happens again *after* the lock has ' \
+              'been solved in the meantime.'
+
+            worker.log message
+            exception = StandardError.new(message)
+            Workhorse.on_exception.call(exception)
+          end
         end
-      end
 
-      return unless success
+        return unless success
 
-      yield
-    ensure
-      if success
-        if @is_oracle
-          Workhorse::DbJob.connection.execute("SELECT DBMS_LOCK.RELEASE(#{ORACLE_LOCK_HANDLE}) FROM DUAL")
-        else
-          Workhorse::DbJob.connection.execute("SELECT RELEASE_LOCK(CONCAT(DATABASE(), '_#{name}'))")
+        yield
+      ensure
+        if success
+          if @is_oracle
+            Workhorse::DbJob.connection.execute("SELECT DBMS_LOCK.RELEASE(#{ORACLE_LOCK_HANDLE}) FROM DUAL")
+          else
+            Workhorse::DbJob.connection.execute("SELECT RELEASE_LOCK(CONCAT(DATABASE(), '_#{name}'))")
+          end
         end
       end
     end

data/lib/workhorse/pool.rb

@@ -34,10 +34,12 @@ module Workhorse
         active_threads.increment
 
         @executor.post do
-          yield
-        ensure
-          active_threads.decrement
-          @on_idle.try(:call)
+          begin
+            yield
+          ensure
+            active_threads.decrement
+            @on_idle.try(:call)
+          end
         end
       end
     end

data/lib/workhorse/worker.rb

@@ -144,19 +144,23 @@ module Workhorse
     end
 
     def perform(db_job_id)
-      mutex.synchronize do
-        assert_state! :running
-        log "Posting job #{db_job_id} to thread pool"
-
-        @pool.post do
-          Workhorse::Performer.new(db_job_id, self).perform
-        rescue Exception => e
-          log %(#{e.message}\n#{e.backtrace.join("\n")}), :error
-          Workhorse.on_exception.call(e)
+      begin
+        mutex.synchronize do
+          assert_state! :running
+          log "Posting job #{db_job_id} to thread pool"
+
+          @pool.post do
+            begin
+              Workhorse::Performer.new(db_job_id, self).perform
+            rescue Exception => e
+              log %(#{e.message}\n#{e.backtrace.join("\n")}), :error
+              Workhorse.on_exception.call(e)
+            end
+          end
         end
+      rescue Exception => e
+        Workhorse.on_exception.call(e)
       end
-    rescue Exception => e
-      Workhorse.on_exception.call(e)
     end
 
     private

data/workhorse.gemspec

@@ -1,9 +1,9 @@
 # -*- encoding: utf-8 -*-
-# stub: workhorse 1.2.18 ruby lib
+# stub: workhorse 1.2.19 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "workhorse".freeze
-  s.version = "1.2.18"
+  s.version = "1.2.19"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: workhorse
 version: !ruby/object:Gem::Version
-  version: 1.2.18
+  version: 1.2.19
 platform: ruby
 authors:
 - Sitrox