delayed-threaded 0.16.0 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32e63adc06acd90d954baed1e872c113239941d9
-  data.tar.gz: bb4d43d6376e85f84efe0945c14149143ca59140
+  metadata.gz: ce6a3948e6a0ceea302b0645c284c392dae15b19
+  data.tar.gz: 6fe497718a6c6cc06b010e13e8a1c477ded4b228
 SHA512:
-  metadata.gz: 46418908010e3463ca50d1c6a17d069670869b40cb220f2c3729b6924b89b99006ddf07a1e0259f7b2429b5d01e690be9bf8bd9692494c6c39cb3848f9a92403
-  data.tar.gz: f50279911f6e6024570079a3f6715a72136d9853e53949ebad1f62591422656881b0eee64fd1db29ab505d2bdfb0d68d46c55f77e9393b3ddeac4bfc9a769db2
+  metadata.gz: 1dd596551baf39bb987209f5b136c5d34a55a6deec73206c441175a2d8034e9c5b44a80bb44b1d1d3649a808223596a3e460c0f4c3b0a64e92026223aaa5ae8b
+  data.tar.gz: 18dc0ba741a33056f789f03b79c7b972647ae4945bbf00c94e671ddcece7196aa56f1ade89b3c0341b24a8b425b50fbb55b66b26c72ac415c958750e114a5ed6

data/.travis.yml

@@ -9,7 +9,7 @@ before_install: gem install bundler -v 1.16.1
 env:
   - delayed_job="~>4.1.5" activerecord="~>4.2"
   - delayed_job="~>4.0.6" activerecord="~>4.2"
-  - delayed_job="~>3.0" # activerecord="~>3.2"
+  - delayed_job="~>3.0" activerecord="~>3.2.22"
   - delayed_job="~>4.1" activerecord="~>4.2.6"
 matrix:
   allow_failures:

data/Gemfile

@@ -23,7 +23,7 @@ end
 
 if ENV['activerecord']
   gem 'activerecord', version = ENV['activerecord'], :require => nil
-  if version =~ /~?\s?4\.[12]/
+  if version =~ /~?\s?[34]\.[012]/
     gem 'activerecord-jdbc-adapter', '~> 1.3.20', :require => nil, :platform => :jruby
   else
     gem 'activerecord-jdbc-adapter', :require => nil, :platform => :jruby

data/README.md

@@ -20,10 +20,6 @@ and `bundle` or install it yourself as `gem install delayed-threaded`.
 ```ruby
 def start_worker
   options = { :quiet => true }
-  options[:queues] = (ENV['QUEUES'] || ENV['QUEUE'] || '').split(',')
-  options[:min_priority] = ENV['MIN_PRIORITY']
-  options[:max_priority] = ENV['MAX_PRIORITY']
-  # beyond `rake delayed:work` compatibility :
   if read_ahead = ENV['READ_AHEAD'] # DEFAULT_READ_AHEAD = 5
     options[:read_ahead] = read_ahead.to_i
   end
@@ -31,6 +27,7 @@ def start_worker
     options[:sleep_delay] = sleep_delay.to_f
   end
 
+  # some options are set to work per-thread (as a thread-local).
   worker = Delayed::Threaded::Worker.new(options)
   worker.start
 rescue Exception => e
@@ -41,9 +38,23 @@ rescue Exception => e
   STDERR.puts(msg)
 end
 
+# while other options are global and do not make sense to be set per-thread
+Delayed::Worker.queues = (ENV['QUEUES'] || ENV['QUEUE'] || '').split(',')
+Delayed::Worker.min_priority = ENV['MIN_PRIORITY'] if ENV['MIN_PRIORITY']
+Delayed::Worker.max_priority = ENV['MAX_PRIORITY'] if ENV['MAX_PRIORITY']
+
 Thread.new { start_worker }
 ```
 
+### ActiveRecord
+
+There's an optional integration with the [ActiveRecord][2] backend, to clear
+the connections after work (as the worker sleeps), setup as a plugin using :
+
+```ruby
+require 'delayed/active_record/release_connection_plugin.rb'
+````
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies.
@@ -59,3 +70,4 @@ See LICENSE (http://en.wikipedia.org/wiki/MIT_License) for details.
 
 [0]: https://github.com/collectiveidea/delayed_job
 [1]: https://github.com/kares/jruby-rack-worker
+[2]: https://github.com/collectiveidea/delayed_job_active_record

data/lib/delayed/active_record/release_connection_plugin.rb

@@ -0,0 +1,4 @@
+require 'delayed/worker'
+
+require 'delayed/backend/active_record/release_connection'
+Delayed::Worker.plugins << Delayed::Backend::ActiveRecord::ReleaseConnection

data/lib/delayed/backend/active_record/release_connection.rb

@@ -0,0 +1,30 @@
+module Delayed
+  module Backend
+    module ActiveRecord
+
+      # Plugin responsible for releasing ActiveRecord connections.
+      # Connection (mapped to the current worker thread) gets cleared
+      # as the worker finishes a 'work' iteration and goes to sleep.
+      # Expected to be compatibile with AR versions 4.x/5.x.
+      #
+      # `Delayed::Worker.plugins << Delayed::Backend::ActiveRecord::ReleaseConnection`
+      #
+      # @note Should be the last one in the plugin list.
+      # @note `require 'delayed/active_record/release_connection_plugin.rb'`
+      #
+      class ReleaseConnection < Delayed::Plugin
+
+        def self.call(_)
+          ::ActiveRecord::Base.clear_active_connections!
+          # ~ connection_pool_list.each(&:release_connection)
+        end
+
+        callbacks do |lifecycle|
+          lifecycle.after(:loop, &method(:call)) # (worker) work loop
+          lifecycle.after(:execute, &method(:call)) # once as (worker) stops
+        end
+
+      end
+    end
+  end
+end

data/lib/delayed/threaded/sleep_calculator.rb

@@ -24,7 +24,7 @@ module Delayed
         # (now - last) * 0.001 < opt_pause ? ( time + time / 11.1 ) : time
       end
 
-      def thread_count
+      def thread_count # TODO gross jruby-rack-worker heritage
         $worker_manager ? $worker_manager.thread_count : false
       end
 

data/lib/delayed/threaded/version.rb

@@ -1,5 +1,5 @@
 module Delayed
   module Threaded
-    VERSION = '0.16.0'
+    VERSION = '0.17.1'
   end
 end

data/lib/delayed/threaded/worker.rb

@@ -35,18 +35,24 @@ module Delayed::Threaded
     # @patch make sure concurrent worker threads do not cause multiple initializations
     Delayed::Worker.extend SyncLifecycle if Delayed.const_defined? :Lifecycle
 
-    THREAD_LOCAL_ACCESSORS = [
-      :min_priority, :max_priority, :sleep_delay, :read_ahead, :queues, :exit_on_complete
-    ]
+    THREAD_LOCAL_ACCESSORS = [ :sleep_delay, :read_ahead, :exit_on_complete,
+                               :delay_jobs, :max_attempts, :default_log_level ]
     private_constant :THREAD_LOCAL_ACCESSORS if respond_to?(:private_constant)
+    #
     # due Delayed::Worker#initialize(options = {}) :
     #
     # [:min_priority, :max_priority, :sleep_delay, :read_ahead, :queues, :exit_on_complete].each do |option|
     #   self.class.send("#{option}=", options[option]) if options.key?(option)
     # end
+    #
+    # :min_priority, :max_priority, :queues, :max_run_time, :destroy_failed_jobs
+    #  ... are "always" global (accessed in backend)
+
+    # NOTE: should we warn when 'global' options are being passed in, so that users prefer (realize)
+    # they need to be setting the cattr instead e.g. `Delayed::Worker.queues = [ 'my_queue' ]` ... ?
 
     class Config
-      attr_accessor *THREAD_LOCAL_ACCESSORS
+      attr_accessor(*THREAD_LOCAL_ACCESSORS)
       def key?(name); ! instance_variable_get(:"@#{name}").nil? end
     end
 
@@ -62,19 +68,25 @@ module Delayed::Threaded
             superclass.#{name}
           end
         end
+        # and re-def instance accessors setup by cattr_accessor (from superclass) :        
+        def #{name}=(val); self.class.#{name} = val end
       EOS
+      unless [:max_attempts, :max_run_time].include?(name) # DJ::Worker#max_run_time(job)
+        # re-def instance accessors setup by cattr_accessor (from superclass)
+        class_eval("def #{name}; self.class.#{name} end", __FILE__, __LINE__)
+      end
     end
     # e.g. :
     #
-    #  def self.min_priority=(value)
-    #    (Thread.current[:delayed_jruby_worker_config] ||= Config.new).min_priority = value
+    #  def self.sleep_delay=(value)
+    #    (Thread.current[:delayed_threaded_worker_config] ||= Config.new).sleep_delay = value
     #  end
     #
     #  def self.min_priority
-    #    if (config = Thread.current[:delayed_jruby_worker_config]) && config.key?(:min_priority)
-    #      config.min_priority
+    #    if (config = Thread.current[:delayed_threaded_worker_config]) && config.key?(:sleep_delay)
+    #      config.sleep_delay
     #    else
-    #      Worker.min_priority
+    #      superclass.sleep_delay # Delayed::Worker.sleep_delay
     #    end
     #  end
 
@@ -92,14 +104,26 @@ module Delayed::Threaded
 
     def to_s; name; end
 
-    def thread_id
-      # NOTE: JRuby might set a bit long name for Thread.new { ... } code e.g.
-      # RubyThread-1: /home/[...]/src/test/ruby/delayed/jruby_worker_test.rb:163
-      if name = java.lang.Thread.currentThread.getName
-        if name.size > 100 && match = name.match(/(.*?)\:\s.*?[\/\\]+/)
-          match[1]
-        else
-          name
+    if defined? Thread.current.name
+      def thread_id
+        if ( name = Thread.current.name || '' ).empty?
+          name = java.lang.Thread.currentThread.getName
+          if name.size > 100 && match = name.match(/(.*?)\:\s.*?[\/\\]+/)
+            name = match[1]
+          end
+        end
+        name
+      end
+    else
+      def thread_id
+        # NOTE: JRuby might set a bit long name for Thread.new { ... } code e.g.
+        # RubyThread-1: /home/[...]/src/test/ruby/delayed/jruby_worker_test.rb:163
+        if name = java.lang.Thread.currentThread.getName
+          if name.size > 100 && match = name.match(/(.*?)\:\s.*?[\/\\]+/)
+            match[1]
+          else
+            name
+          end
         end
       end
     end

data/lib/delayed/threaded.rb

@@ -1,5 +1,3 @@
 require 'delayed/threaded/version'
 
 require 'delayed/threaded/worker'
-
-require 'delayed/threaded/compat'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed-threaded
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.17.1
 platform: ruby
 authors:
 - Karol Bucek
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2018-05-02 00:00:00.000000000 Z
+date: 2018-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -116,8 +116,9 @@ files:
 - bin/console
 - bin/setup
 - delayed-threaded.gemspec
+- lib/delayed/active_record/release_connection_plugin.rb
+- lib/delayed/backend/active_record/release_connection.rb
 - lib/delayed/threaded.rb
-- lib/delayed/threaded/compat.rb
 - lib/delayed/threaded/sleep_calculator.rb
 - lib/delayed/threaded/sync_lifecycle.rb
 - lib/delayed/threaded/version.rb

data/lib/delayed/threaded/compat.rb

@@ -1,4 +0,0 @@
-module Delayed
-  # @deprecated
-  JRubyWorker = Threaded::Worker
-end