delayed_job_master 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 548efefc42b3ecd02bcb85da66da4a8e001376057a54ee7a636adf5177346923
-  data.tar.gz: 6c83c6a641d334f262bb191f68649c90cfa083ede76ace8e960c9b7a1ce99b9d
+  metadata.gz: 90f6ec1ebe00243f5d69adf6a92a6e2716772b7a9af68b7301220bae2cfc55d7
+  data.tar.gz: 30db6bc4a8183622514a9e4fcad3f5130e3061cff0bb973b834e5e0c9db5ffb0
 SHA512:
-  metadata.gz: 81b40df17053df90e59c84c3e53bbc854ba0e623cc8185811725673867532f68525a65a86d732914f117f56788ebee607466d469e546f3be4332e2935ff17b60
-  data.tar.gz: c77e25e5aa04b6f4c11c3e7c630c3c8dcd45f691c5088cac3a8f07bb6980317419c1b5a45149c2154c4982991593f67f06bebef32dc27915e4d4958a05590981
+  metadata.gz: 6958a025ee232142b6a3049b25ea62075a08dea1446ddc0b29ee3f26d5ef1dd9351e6df46a2ad2a8d8068238e44a84bce6140639ff62aa8a0c8f2ad0ba43c2fe
+  data.tar.gz: c863131bde412c128fc3f144fd5ba1bb472cd8850a0c31a32d0500e043572e389ce7184c6a98a0b57de31bd5c434601c5641c64ea00b7a7db1a41bd11095f4dc

data/.gitignore

@@ -1,19 +1,11 @@
 /.bundle/
-/.yardoc
 /.project
 /Gemfile.lock
-/gemfiles/.bundle
-/gemfiles/vendor
 /gemfiles/*gemfile.lock
-/_yardoc/
-/bin/
 /coverage/
-/doc/
 /pkg/
-/log/
-/tmp/
 /spec/reports/
 /spec/**/db/*.sqlite3
 /spec/**/log/*.log
-/spec/**/tmp/pids/*.pid
+/spec/**/tmp/*
 /vendor/

data/.travis.yml

@@ -1,16 +1,23 @@
 language: ruby
-services:
-  - mongodb
 rvm:
   - 2.3
   - 2.4
   - 2.5
   - 2.6
 gemfile:
-  - gemfiles/active_record.gemfile
-  - gemfiles/mongoid.gemfile
+  - gemfiles/rails50.gemfile
+  - gemfiles/rails51.gemfile
+  - gemfiles/rails52.gemfile
+  - gemfiles/rails60.gemfile
+matrix:
+  exclude:
+  - rvm: 2.3
+    gemfile: gemfiles/rails60.gemfile
+  - rvm: 2.4
+    gemfile: gemfiles/rails60.gemfile
 before_script:
   - cd spec/dummy
-  - bundle exec rake db:migrate RAILS_ENV=test
+  - bundle exec rake dbs:migrate RAILS_ENV=test
   - cd ../..
-script: bundle exec rspec
+script:
+  - bundle exec rspec

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## 2.0.0
+
+* Support multiple databases.
+* Logging memory usage.
+* Remove static worker support.
+* Remove mongoid support.
+
 ## 1.2.0
 
 * Add destroy_failed_jobs for worker.

data/README.md

@@ -5,11 +5,9 @@ A simple delayed_job master process to control multiple workers.
 ## Features
 
 * Preload application and fork workers fastly.
-* Monitor workers and fork new workers if necessary.
-* Restart workers with memory limitation.
-* Trap USR1 signal to reopen log files.
-* Trap USR2 signal to restart master and workers.
-* Auto-scale worker processes.
+* Monitor job queues and fork new workers on demand.
+* Trap signals to restart / reopen log files.
+* Support multiple databases.
 
 ## Dependencies
 
@@ -19,7 +17,6 @@ A simple delayed_job master process to control multiple workers.
 ## Supported delayed_job backends
 
 * delayed_job_active_record 4.1
-* delayed_job_mongoid 2.3
 
 ## Installation
 
@@ -33,11 +30,11 @@ And then execute:
 
     $ bundle
 
-Create config files:
+## Generate files
 
-    $ rails generate delayed_job_master:config
+Generate `bin/delayed_job_master` and `config/delayed_job_master.rb`:
 
-This command creates `bin/delayed_job_master` and `config/delayed_job_master.rb`.
+    $ rails generate delayed_job_master:config
 
 ## Configuration
 
@@ -59,14 +56,14 @@ log_file "#{Dir.pwd}/log/delayed_job_master.log"
 # log level
 log_level :info
 
+# databases for checking queued jobs if you have multiple databases
+# databases [:production]
+
 # worker1
 add_worker do |worker|
   # queue name for the worker
   worker.queues %w(queue1)
 
-  # worker control (:static or :dynamic)
-  worker.control :static
-
   # worker count
   worker.count 1
 
@@ -86,7 +83,6 @@ end
 # worker2
 add_worker do |worker|
   worker.queues %w(queue2)
-  worker.control :dynamic
   worker.count 2
 end
 
@@ -146,19 +142,19 @@ Workers handle each signal as follows:
 
 ```
 $ ps aux
-... delayed_job.0 (queue1) [BUSY]  # BUSY process is currently proceeding some jobs
+... delayed_job.0: worker[0] (queue1) [BUSY]  # BUSY process is currently proceeding some jobs
 ```
 
 After graceful restart, you may find OLD process.
 
 ```
 $ ps aux
-... delayed_job.0 (queue1) [BUSY] [OLD]  # OLD process will stop after finishing current jobs.
+... delayed_job.0: worker[0] (queue1) [BUSY] [OLD]  # OLD process will stop after finishing current jobs.
 ```
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/kanety/delayed_job_master. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/kanety/delayed_job_master.
 
 ## License
 

data/delayed_job_master.gemspec

@@ -8,7 +8,6 @@ Gem::Specification.new do |spec|
   spec.version       = Delayed::Master::VERSION
   spec.authors       = ["Yoshikazu Kaneta"]
   spec.email         = ["kaneta@sitebridge.co.jp"]
-
   spec.summary       = %q{A simple delayed_job master process to control multiple workers}
   spec.description   = %q{A simple delayed_job master process to control multiple workers}
   spec.homepage      = "https://github.com/kanety/delayed_job_master"
@@ -29,6 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec-rails"
   spec.add_development_dependency "simplecov"
   spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "delayed_job_mongoid", ">= 2.3"
   spec.add_development_dependency "delayed_job_active_record", ">= 4.1"
 end

data/gemfiles/{mongoid.gemfile → rails50.gemfile}

@@ -1,7 +1,7 @@
 source 'https://rubygems.org'
 
-gem "delayed_job_mongoid", "~> 2.3.0"
-gem "rails", "~> 5.2.0"
+gem "delayed_job_active_record", "~> 4.1.0"
+gem "rails", "~> 5.0.0"
 gem "sqlite3", "~> 1.3.6"
 
 gemspec path: "../"

data/gemfiles/rails51.gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem "delayed_job_active_record", "~> 4.1.0"
+gem "rails", "~> 5.1.0"
+gem "sqlite3", "~> 1.3.6"
+
+gemspec path: "../"

data/gemfiles/rails60.gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem "delayed_job_active_record", "~> 4.1.0"
+gem "rails", "~> 6.0.0"
+
+gemspec path: "../"

data/lib/delayed/master.rb

@@ -2,10 +2,9 @@ require 'fileutils'
 require 'logger'
 require_relative 'master/version'
 require_relative 'master/command'
-require_relative 'master/callback'
 require_relative 'master/worker'
-require_relative 'master/worker_pool'
-require_relative 'master/signal_handler'
+require_relative 'master/monitoring'
+require_relative 'master/signaler'
 require_relative 'master/util/file_reopener'
 
 module Delayed
@@ -17,79 +16,74 @@ module Delayed
       @logger = setup_logger(@config.log_file, @config.log_level)
       @workers = []
 
-      @signal_handler = SignalHandler.new(self)
-      @worker_pool = WorkerPool.new(self, @config)
+      @signaler = Signaler.new(self)
+      @monitoring = Monitoring.new(self)
     end
 
     def run
-      load_app
-      show_config
+      print_config
       daemonize if @config.daemon
 
-      create_pid_file
-      @logger.info "started master #{Process.pid}"
+      @logger.info "started master #{Process.pid}".tap { |msg| puts msg }
 
-      @signal_handler.register
-      @worker_pool.init
-      @worker_pool.monitor_while { stop? }
+      handle_pid_file do
+        @signaler.register
+        @prepared = true
+        @monitoring.monitor_while { stop? }
+      end
 
-      remove_pid_file
       @logger.info "shut down master"
     end
 
-    def load_app
-      require File.join(@config.working_directory, 'config', 'environment')
-      require_relative 'master/job_counter'
-      require_relative 'worker/extension'
-    end
-
     def prepared?
-      @worker_pool.prepared?
+      @prepared
     end
 
     def quit
-      kill_workers
+      @signaler.dispatch(:KILL)
       @stop = true
     end
 
     def stop
-      @signal_handler.dispatch('TERM')
+      @signaler.dispatch(:TERM)
       @stop = true
     end
 
     def stop?
-      @stop
+      @stop == true
     end
 
     def reopen_files
-      @signal_handler.dispatch('USR1')
+      @signaler.dispatch(:USR1)
       @logger.info "reopening files..."
       Util::FileReopener.reopen
       @logger.info "reopened"
     end
 
     def restart
-      @signal_handler.dispatch('USR2')
+      @signaler.dispatch(:USR2)
       @logger.info "restarting master..."
       exec(*([$0] + ARGV))
     end
 
-    def kill_workers
-      @signal_handler.dispatch('KILL')
-    end
-
-    def wait_workers
-      Process.waitall
-    end
-
     private
 
     def setup_logger(log_file, log_level)
-      FileUtils.mkdir_p(File.dirname(log_file))
+      FileUtils.mkdir_p(File.dirname(log_file)) if log_file.is_a?(String)
       logger = Logger.new(log_file)
       logger.level = log_level
       logger
     end
+  
+    def daemonize
+      Process.daemon(true)
+    end
+
+    def handle_pid_file
+      create_pid_file
+      yield
+      remove_pid_file
+    end
 
     def create_pid_file
       FileUtils.mkdir_p(File.dirname(@config.pid_file))
@@ -100,13 +94,12 @@ module Delayed
       File.delete(@config.pid_file) if File.exist?(@config.pid_file)
     end
 
-    def daemonize
-      Process.daemon(true)
-    end
-
-    def show_config
-      @config.workers.each do |setting|
-        puts "#{setting.count} worker for '#{setting.queues.join(',')}' under #{setting.control} control"
+    def print_config
+      @logger.info "databases: #{@config.databases.join(', ')}" if @config.databases
+      @config.worker_settings.each do |setting|
+        message = "worker[#{setting.id}]: #{setting.count} processes"
+        message << " (#{setting.queues.join(', ')})" if setting.queues.respond_to?(:join)
+        @logger.info message
       end
     end
   end

data/lib/delayed/master/config.rb

@@ -1,7 +1,7 @@
 module Delayed
   class Master
     class Config
-      SIMPLE_CONFIGS   = [:working_directory, :log_file, :log_level, :pid_file, :monitor_wait, :daemon]
+      SIMPLE_CONFIGS   = [:working_directory, :log_file, :log_level, :pid_file, :monitor_wait, :daemon, :databases]
       CALLBACK_CONFIGS = [:before_fork, :after_fork, :before_monitor, :after_monitor]
 
       attr_reader :data, :workers
@@ -12,14 +12,17 @@ module Delayed
         read(file) if file
       end
 
+      def worker_settings
+        @workers
+      end
+
       def read(file)
-        instance_eval(File.read(file))
+        instance_eval(File.read(file), file)
       end
 
       def add_worker
-        worker = WorkerSetting.new(control: :static, count: 1)
+        worker = WorkerSetting.new(id: @workers.size, count: 1, exit_on_complete: true)
         yield worker
-        worker.exit_on_complete(true) if worker.control == :dynamic
         @workers << worker
       end
 
@@ -27,6 +30,10 @@ module Delayed
         @data.select { |k, _| CALLBACK_CONFIGS.include?(k) }
       end
 
+      def run_callback(key, *args)
+        @data[key].call(*args)
+      end
+
       SIMPLE_CONFIGS.each do |key|
         define_method(key) do |value = nil|
           if value
@@ -48,7 +55,7 @@ module Delayed
       end
 
       class WorkerSetting
-        SIMPLE_CONFIGS = [:control, :count, :max_memory,
+        SIMPLE_CONFIGS = [:id, :count, :max_memory,
                           :min_priority, :max_priority, :sleep_delay, :read_ahead, :exit_on_complete,
                           :max_attempts, :max_run_time, :destroy_failed_jobs]
         ARRAY_CONFIGS  = [:queues]
@@ -59,6 +66,10 @@ module Delayed
           @data = default
         end
 
+        def control(value = nil)
+          puts "DEPRECATION WARNING: deprecated control setting is called from #{caller(1, 1).first}. Remove it from your config file."
+        end
+
         SIMPLE_CONFIGS.each do |key|
           define_method(key) do |value = nil|
             if value

data/lib/delayed/master/forker.rb

@@ -0,0 +1,49 @@
+module Delayed
+  class Master
+    class Forker
+      def initialize(master)
+        @master = master
+        @config = master.config
+      end
+
+      def new_worker(worker)
+        @master.logger.info "forking #{worker.name}..."
+        fork_worker(worker)
+        @master.logger.info "forked #{worker.name} with pid #{worker.pid}"
+
+        @master.workers << worker
+      end
+
+      private
+
+      def fork_worker(worker)
+        @config.run_callback(:before_fork, @master, worker)
+        worker.pid = fork do
+          worker.pid = Process.pid
+          worker.instance = create_instance(worker)
+          @config.run_callback(:after_fork, @master, worker)
+          $0 = worker.process_title
+          worker.instance.start
+        end
+      end
+
+      def create_instance(worker)
+        require_relative 'worker_extension'
+
+        instance = Delayed::Worker.new(worker.setting.data)
+        [:max_run_time, :max_attempts, :destroy_failed_jobs].each do |key|
+          if (value = worker.setting.send(key))
+            Delayed::Worker.send("#{key}=", value)
+          end
+        end
+        [:max_memory].each do |key|
+          if (value = worker.setting.send(key))
+            instance.send("#{key}=", value)
+          end
+        end
+        instance.master_logger = @master.logger
+        instance
+      end
+    end
+  end
+end

data/lib/delayed/master/job_checker.rb

@@ -0,0 +1,98 @@
+require_relative 'job_counter'
+
+module Delayed
+  class Master
+    class JobChecker
+      def initialize(master)
+        @master = master
+        @config = master.config
+        @spec_names = target_spec_names
+
+        define_models
+        extend_after_fork_callback
+      end
+
+      def check
+        workers = []
+        mon = Monitor.new
+
+        threads = @spec_names.map do |spec_name|
+          Thread.new(spec_name) do |spec_name|
+            find_jobs_in_db(spec_name) do |setting|
+              mon.synchronize do
+                workers << Worker.new(index: @master.workers.size + workers.size, database: spec_name, setting: setting)
+              end
+            end
+          end
+        end
+
+        threads.each(&:join)
+
+        workers
+      end
+
+      private
+
+      def define_models
+        @spec_names.each do |spec_name|
+          klass = Class.new(Delayed::Job)
+          klass_name = "DelayedJob#{spec_name.capitalize}"
+          unless Delayed::Master.const_defined?(klass_name)
+            Delayed::Master.const_set(klass_name, klass)
+            Delayed::Master.const_get(klass_name).establish_connection(spec_name)
+          end
+        end
+      end
+
+      def model_for(spec_name)
+        Delayed::Master.const_get("DelayedJob#{spec_name.capitalize}")
+      end
+
+      def extend_after_fork_callback
+        prc = @config.after_fork
+        @config.after_fork do |master, worker|
+          prc.call(master, worker)
+          if worker.database && ActiveRecord::Base.connection_pool.spec.name != worker.database.to_s
+            ActiveRecord::Base.establish_connection(worker.database)
+          end
+        end
+      end
+
+      def target_spec_names
+        if @config.databases.nil? || @config.databases.empty?
+          load_spec_names.select { |spec_name| has_delayed_job_table?(spec_name) }
+        else
+          @config.databases
+        end
+      end
+
+      def load_spec_names
+        if Rails::VERSION::MAJOR >= 6
+          configs = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env)
+          configs.reject(&:replica?).map { |c| c.spec_name.to_sym }
+        else
+          [Rails.env.to_sym]
+        end
+      end
+
+      def has_delayed_job_table?(spec_name)
+        ActiveRecord::Base.establish_connection(spec_name)
+        ActiveRecord::Base.connection.tables.include?('delayed_jobs')
+      end
+
+      def find_jobs_in_db(spec_name)
+        counter = JobCounter.new(model_for(spec_name))
+
+        @config.worker_settings.each do |setting|
+          count = @master.workers.count { |worker| worker.setting.queues == setting.queues }
+          slot = setting.count - count
+          if slot > 0 && (job_count = counter.count(setting)) > 0
+            [slot, job_count].min.times do
+              yield setting
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed/master/job_counter.rb

@@ -1,8 +1,26 @@
-case Delayed::Worker.backend.to_s
-when 'Delayed::Backend::ActiveRecord::Job'
-  require_relative 'job_counter/active_record'
-when 'Delayed::Backend::Mongoid::Job'
-  require_relative 'job_counter/mongoid'
-else
-  raise "Unsupported backend: #{Delayed::Worker.backend}"
+# JobCounter depends on delayed_job_active_record.
+# See https://github.com/collectiveidea/delayed_job_active_record/blob/master/lib/delayed/backend/active_record.rb
+module Delayed
+  class Master
+    class JobCounter
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def count(setting)
+        jobs = ready_to_run(setting.max_run_time || Delayed::Worker::DEFAULT_MAX_RUN_TIME)
+        jobs.where!("priority >= ?", setting.min_priority) if setting.min_priority
+        jobs.where!("priority <= ?", setting.max_priority) if setting.max_priority
+        jobs.where!(queue: setting.queues) if setting.queues.any?
+        jobs.count
+      end
+
+      private
+
+      def ready_to_run(max_run_time)
+        db_time_now = @klass.db_time_now
+        @klass.where("(run_at <= ? AND (locked_at IS NULL OR locked_at < ?)) AND failed_at IS NULL", db_time_now, db_time_now - max_run_time)
+      end
+    end
+  end
 end

data/lib/delayed/master/monitoring.rb

@@ -0,0 +1,59 @@
+require_relative 'forker'
+require_relative 'job_checker' if defined?(Delayed::Backend::ActiveRecord)
+
+module Delayed
+  class Master
+    class Monitoring
+      def initialize(master)
+        @master = master
+        @config = master.config
+        @forker = Forker.new(master)
+        @job_checker = JobChecker.new(master)
+      end
+
+      def monitor_while(&block)
+        loop do
+          break if block.call
+          monitor do
+            check_terminated
+            check_queued_jobs
+          end
+          sleep @config.monitor_wait.to_i
+        end
+      end
+
+      private
+
+      def monitor
+        @config.run_callback(:before_monitor, @master)
+        yield
+        @config.run_callback(:after_monitor, @master)
+      rescue Exception => e
+        @master.logger.warn "#{e.class}: #{e.message} at #{__FILE__}: #{__LINE__}"
+      end
+
+      def check_terminated
+        if (pid = terminated_pid)
+          @master.logger.debug "found terminated pid: #{pid}"
+          @master.workers.reject! { |worker| worker.pid == pid }
+        end
+      end
+
+      def terminated_pid
+        Process.waitpid(-1, Process::WNOHANG)
+      rescue Errno::ECHILD
+        nil
+      end
+
+      def check_queued_jobs
+        @master.logger.debug "checking jobs..."
+
+        new_workers = @job_checker.check
+        new_workers.each do |worker|
+          @master.logger.info "found jobs for #{worker.info}"
+          @forker.new_worker(worker)
+        end
+      end
+    end
+  end
+end

data/lib/delayed/master/plugins/memory_checker.rb

@@ -0,0 +1,24 @@
+require 'get_process_mem'
+
+module Delayed
+  class Master
+    module Plugins
+      class MemoryChecker < Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.before(:perform) do |worker, job|
+            mem = GetProcessMem.new
+            worker.master_logger.info "performing #{job.name}, memory: #{mem.mb.to_i} MB"
+          end
+          lifecycle.after(:perform) do |worker, job|
+            mem = GetProcessMem.new
+            worker.master_logger.info "performed #{job.name}, memory: #{mem.mb.to_i} MB"
+            if worker.max_memory && mem.mb > worker.max_memory
+              worker.master_logger.info "shutting down worker #{Process.pid} because it consumes large memory..."
+              worker.stop
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed/master/plugins/signal_handler.rb

@@ -0,0 +1,31 @@
+module Delayed
+  class Master
+    module Plugins
+      class SignalHandler < Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.before(:execute) do |worker|
+            worker.instance_eval do
+              trap(:USR1) do
+                Thread.new do
+                  master_logger.info "reopening files..."
+                  Delayed::Master::Util::FileReopener.reopen
+                  master_logger.info "reopened"
+                end
+              end
+              trap(:USR2) do
+                Thread.new do
+                  $0 = "#{$0} [OLD]"
+                  master_logger.info "shutting down worker #{Process.pid}..."
+                  stop
+                end
+              end
+            end
+          end
+          lifecycle.after(:execute) do |worker|
+            worker.master_logger.info "shut down worker #{Process.pid}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed/master/plugins/status_notifier.rb

@@ -0,0 +1,17 @@
+module Delayed
+  class Master
+    module Plugins
+      class StatusNotifier < Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:perform) do |worker, job, &block|
+            title = $0
+            $0 = "#{title} [BUSY]"
+            ret = block.call
+            $0 = title
+            ret
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delayed/master/signaler.rb

@@ -0,0 +1,41 @@
+module Delayed
+  class Master
+    class Signaler
+      def initialize(master)
+        @master = master
+      end
+
+      def register
+        signals = [[:TERM, :stop], [:INT, :stop], [:QUIT, :quit], [:USR1, :reopen_files], [:USR2, :restart]]
+        signals.each do |signal, method|
+          register_signal(signal, method)
+        end
+      end
+
+      def dispatch(signal)
+        @master.workers.each do |worker|
+          next unless worker.pid
+          dispatch_to(signal, worker.pid)
+        end
+      end
+
+      private
+
+      def register_signal(signal, method)
+        trap(signal) do
+          Thread.new do
+            @master.logger.info "received #{signal} signal"
+            @master.public_send(method)
+          end
+        end
+      end
+
+      def dispatch_to(signal, pid)
+        Process.kill(signal, pid)
+        @master.logger.info "sent #{signal} signal to worker #{pid}"
+      rescue
+        @master.logger.error "failed to send #{signal} signal to worker #{pid}"
+      end
+    end
+  end
+end

data/lib/delayed/master/version.rb

@@ -1,5 +1,5 @@
 module Delayed
   class Master
-    VERSION = "1.2.0"
+    VERSION = "2.0.0"
   end
 end

data/lib/delayed/master/worker.rb

@@ -1,18 +1,28 @@
 module Delayed
   class Master
     class Worker
-      attr_reader :index, :setting
+      attr_accessor :index, :setting, :database
       attr_accessor :pid, :instance
 
-      def initialize(index, setting)
-        @index = index
-        @setting = setting
+      def initialize(attrs = {})
+        attrs.each do |k, v|
+          send("#{k}=", v)
+        end
       end
 
-      def title
-        titles = ["delayed_job.#{@index}"]
-        titles << "(#{@setting.queues.join(',')})" if @setting.queues
-        titles.join(' ')
+      def name
+        "worker[#{@setting.id}]"
+      end
+
+      def info
+        str = name
+        str << " @#{@database}" if @database
+        str << " (#{@setting.queues.join(', ')})" if @setting.queues.respond_to?(:join)
+        str
+      end
+
+      def process_title
+        "delayed_job.#{@index}: #{info}"
       end
     end
   end

data/lib/delayed/master/worker_extension.rb

@@ -0,0 +1,19 @@
+module Delayed
+  class Worker
+    attr_accessor :master_logger, :max_memory
+  end
+end
+
+require_relative 'plugins/memory_checker'
+require_relative 'plugins/signal_handler'
+require_relative 'plugins/status_notifier'
+
+[
+  Delayed::Master::Plugins::MemoryChecker,
+  Delayed::Master::Plugins::SignalHandler,
+  Delayed::Master::Plugins::StatusNotifier
+].each do |plugin|
+  unless Delayed::Worker.plugins.include?(plugin)
+    Delayed::Worker.plugins << plugin
+  end
+end

data/lib/delayed_job_master.rb

@@ -0,0 +1 @@
+require 'delayed/master'

data/lib/generators/delayed_job_master/templates/config.rb

@@ -18,9 +18,6 @@ add_worker do |worker|
   # queue name for the worker
   worker.queues %w(queue1)
 
-  # worker control (:static or :dynamic)
-  worker.control :static
-
   # worker count
   worker.count 1
 
@@ -40,7 +37,6 @@ end
 # worker2
 add_worker do |worker|
   worker.queues %w(queue2)
-  worker.control :dynamic
   worker.count 2
 end
 

data/lib/generators/delayed_job_master/templates/script

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup'
-require 'delayed/master'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'config', 'environment'))
+require 'delayed_job_master'
+
 Delayed::Master.new(ARGV).run

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed_job_master
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-04-01 00:00:00.000000000 Z
+date: 2019-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -108,20 +108,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: delayed_job_mongoid
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: delayed_job_active_record
   requirement: !ruby/object:Gem::Requirement
@@ -153,24 +139,26 @@ files:
 - README.md
 - Rakefile
 - delayed_job_master.gemspec
-- gemfiles/active_record.gemfile
-- gemfiles/mongoid.gemfile
+- gemfiles/rails50.gemfile
+- gemfiles/rails51.gemfile
+- gemfiles/rails52.gemfile
+- gemfiles/rails60.gemfile
 - lib/delayed/master.rb
-- lib/delayed/master/callback.rb
 - lib/delayed/master/command.rb
 - lib/delayed/master/config.rb
+- lib/delayed/master/forker.rb
+- lib/delayed/master/job_checker.rb
 - lib/delayed/master/job_counter.rb
-- lib/delayed/master/job_counter/active_record.rb
-- lib/delayed/master/job_counter/mongoid.rb
-- lib/delayed/master/signal_handler.rb
+- lib/delayed/master/monitoring.rb
+- lib/delayed/master/plugins/memory_checker.rb
+- lib/delayed/master/plugins/signal_handler.rb
+- lib/delayed/master/plugins/status_notifier.rb
+- lib/delayed/master/signaler.rb
 - lib/delayed/master/util/file_reopener.rb
 - lib/delayed/master/version.rb
 - lib/delayed/master/worker.rb
-- lib/delayed/master/worker_pool.rb
-- lib/delayed/worker/extension.rb
-- lib/delayed/worker/plugins/memory_checker.rb
-- lib/delayed/worker/plugins/signal_handler.rb
-- lib/delayed/worker/plugins/status_notifier.rb
+- lib/delayed/master/worker_extension.rb
+- lib/delayed_job_master.rb
 - lib/generators/delayed_job_master/config_generator.rb
 - lib/generators/delayed_job_master/templates/config.rb
 - lib/generators/delayed_job_master/templates/script

data/lib/delayed/master/callback.rb

@@ -1,13 +0,0 @@
-module Delayed
-  class Master
-    class Callback
-      def initialize(config)
-        @callbacks = config.callbacks
-      end
-
-      def run(name, *args)
-        @callbacks[name].call(*args) if @callbacks[name]
-      end
-    end
-  end
-end

data/lib/delayed/master/job_counter/active_record.rb

@@ -1,24 +0,0 @@
-# JobCounter depends on delayed_job_active_record.
-# See https://github.com/collectiveidea/delayed_job_active_record/blob/master/lib/delayed/backend/active_record.rb
-module Delayed
-  class Master
-    class JobCounter
-      class << self
-        def count(setting)
-          jobs = ready_to_run(setting.max_run_time || Delayed::Worker::DEFAULT_MAX_RUN_TIME)
-          jobs.where!("priority >= ?", setting.min_priority) if setting.min_priority
-          jobs.where!("priority <= ?", setting.max_priority) if setting.max_priority
-          jobs.where!(queue: setting.queues) if setting.queues.any?
-          jobs.count
-        end
-
-        private
-
-        def ready_to_run(max_run_time)
-          db_time_now = Delayed::Job.db_time_now
-          Delayed::Job.where("(run_at <= ? AND (locked_at IS NULL OR locked_at < ?)) AND failed_at IS NULL", db_time_now, db_time_now - max_run_time)
-        end
-      end
-    end
-  end
-end

data/lib/delayed/master/job_counter/mongoid.rb

@@ -1,32 +0,0 @@
-# JobCounter depends on delayed_job_mongoid.
-# See https://github.com/collectiveidea/delayed_job_mongoid/blob/master/lib/delayed/backend/mongoid.rb
-module Delayed
-  class Master
-    class JobCounter
-      class << self
-        def count(setting)
-          right_now = Delayed::Job.db_time_now
-          jobs = reservation_criteria(right_now, setting.max_run_time || Delayed::Worker::DEFAULT_MAX_RUN_TIME)
-          jobs = jobs.gte(priority: setting.min_priority.to_i) if setting.min_priority
-          jobs = jobs.lte(priority: setting.max_priority.to_i) if setting.max_priority
-          jobs = jobs.any_in(queue: setting.queues) if setting.queues.any?
-          jobs.count
-        end
-
-        private
-
-        def reservation_criteria(right_now, max_run_time)
-          criteria = Delayed::Job.where(
-            run_at: { '$lte' => right_now },
-            failed_at: nil
-          ).any_of(
-            { locked_at: nil },
-            locked_at: { '$lt' => (right_now - max_run_time) }
-          )
-
-          criteria
-        end
-      end
-    end
-  end
-end

data/lib/delayed/master/signal_handler.rb

@@ -1,47 +0,0 @@
-module Delayed
-  class Master
-    class SignalHandler
-      def initialize(master)
-        @master = master
-        @logger = master.logger
-        @workers = master.workers
-      end
-
-      def register
-        %w(TERM INT QUIT USR1 USR2).each do |signal|
-          trap(signal) do
-            Thread.new do
-              @logger.info "received #{signal} signal"
-              case signal
-              when 'TERM', 'INT'
-                @master.stop
-              when 'QUIT'
-                @master.quit
-              when 'USR1'
-                @master.reopen_files
-              when 'USR2'
-                @master.restart
-              end
-            end
-          end
-        end
-      end
-
-      def dispatch(signal)
-        @workers.each do |worker|
-          next unless worker.pid
-          dispatch_to(signal, worker.pid)
-        end
-      end
-
-      private
-
-      def dispatch_to(signal, pid)
-        Process.kill signal, pid
-        @logger.info "sent #{signal} signal to worker #{pid}"
-      rescue
-        @logger.error "failed to send #{signal} signal to worker #{pid}"
-      end
-    end
-  end
-end

data/lib/delayed/master/worker_pool.rb

@@ -1,141 +0,0 @@
-module Delayed
-  class Master
-    class WorkerPool
-      def initialize(master, config)
-        @master = master
-        @config = config
-
-        @logger = master.logger
-        @workers = master.workers
-
-        @static_settings, @dynamic_settings = config.workers.partition { |conf| conf.control == :static }
-        @callback = Delayed::Master::Callback.new(config)
-      end
-
-      def init
-        @static_settings.each_with_index do |setting, i|
-          worker = Delayed::Master::Worker.new(i, setting)
-          @workers << worker
-          fork_worker(worker)
-          @logger.info "started worker #{worker.pid}"
-        end
-
-        @prepared = true
-        print_workers
-      end
-
-      def monitor_while(&block)
-        loop do
-          break if block.call
-          monitor do
-            check_pid
-            check_dynamic_worker
-          end
-          sleep @config.monitor_wait.to_i
-        end
-      end
-
-      def prepared?
-        @prepared
-      end
-
-      private
-
-      def fork_worker(worker)
-        @callback.run(:before_fork, @master, worker)
-        worker.pid = fork do
-          worker.pid = Process.pid
-          worker.instance = create_instance(worker)
-          @callback.run(:after_fork, @master, worker)
-          $0 = worker.title
-          worker.instance.start
-        end
-      end
-
-      def create_instance(worker)
-        instance = Delayed::Worker.new(worker.setting.data)
-        [:max_run_time, :max_attempts, :destroy_failed_jobs].each do |key|
-          if (value = worker.setting.send(key))
-            Delayed::Worker.send("#{key}=", value)
-          end
-        end
-        [:max_memory].each do |key|
-          if (value = worker.setting.send(key))
-            instance.send("#{key}=", value)
-          end
-        end
-        instance.master_logger = @logger
-        instance
-      end
-
-      def monitor
-        @callback.run(:before_monitor, @master)
-        yield
-        @callback.run(:after_monitor, @master)
-      rescue Exception => e
-        @logger.warn "#{e.class}: #{e.message} at #{__FILE__}: #{__LINE__}"
-      end
-
-      def check_pid
-        pid = wait_pid
-        return unless pid
-        worker = @workers.detect { |worker| worker.pid == pid }
-        return unless worker
-
-        case worker.setting.control
-        when :static
-          fork_alt_worker(worker)
-        when :dynamic
-          @workers.delete(worker)
-        end
-      end
-
-      def wait_pid
-        Process.waitpid(-1, Process::WNOHANG)
-      rescue Errno::ECHILD
-        nil
-      end
-
-      def check_dynamic_worker
-        @dynamic_settings.each do |setting|
-          current_count = @workers.count { |worker| worker.setting.queues == setting.queues }
-          remaining_count = setting.count - current_count
-          if remaining_count > 0 && (job_count = count_job(setting)) > 0
-            [remaining_count, job_count].min.times do
-              fork_dynamic_worker(setting)
-            end
-          end
-        end
-      end
-
-      def count_job(setting)
-        Delayed::Master::JobCounter.count(setting)
-      end
-
-      def fork_dynamic_worker(setting)
-        worker = Delayed::Master::Worker.new(@workers.size, setting)
-        @workers << worker
-
-        @logger.info "forking dynamic worker..."
-        fork_worker(worker)
-        @logger.info "forked worker #{worker.pid}"
-
-        print_workers
-      end
-
-      def fork_alt_worker(worker)
-        @logger.info "worker #{worker.pid} seems to be killed, forking alternative worker..."
-        fork_worker(worker)
-        @logger.info "forked worker #{worker.pid}"
-
-        print_workers
-      end
-
-      def print_workers
-        @workers.each do |worker|
-          @logger.debug "#{worker.pid}: #{worker.title}"
-        end
-      end
-    end
-  end
-end

data/lib/delayed/worker/extension.rb

@@ -1,9 +0,0 @@
-require_relative 'plugins/memory_checker'
-require_relative 'plugins/signal_handler'
-require_relative 'plugins/status_notifier'
-
-module Delayed
-  class Worker
-    attr_accessor :master_logger, :max_memory
-  end
-end

data/lib/delayed/worker/plugins/memory_checker.rb

@@ -1,20 +0,0 @@
-require 'get_process_mem'
-
-module Delayed
-  module Plugins
-    class WorkerMemoryChecker < Delayed::Plugin
-      callbacks do |lifecycle|
-        lifecycle.after(:perform) do |worker, job|
-          next unless worker.max_memory
-          mem = GetProcessMem.new
-          if mem.mb > worker.max_memory
-            worker.master_logger.info "shutting down worker #{Process.pid} because it consumes large memory #{mem.mb.to_i} MB..."
-            worker.stop
-          end
-        end
-      end
-    end
-  end
-end
-
-Delayed::Worker.plugins << Delayed::Plugins::WorkerMemoryChecker

data/lib/delayed/worker/plugins/signal_handler.rb

@@ -1,31 +0,0 @@
-module Delayed
-  module Plugins
-    class SignalHandler < Delayed::Plugin
-      callbacks do |lifecycle|
-        lifecycle.before(:execute) do |worker|
-          worker.instance_eval do
-            trap('USR1') do
-              Thread.new do
-                master_logger.info "reopening files..."
-                Delayed::Master::Util::FileReopener.reopen
-                master_logger.info "reopened"
-              end
-            end
-            trap('USR2') do
-              Thread.new do
-                $0 = "#{$0} [OLD]"
-                master_logger.info "shutting down worker #{Process.pid}..."
-                stop
-              end
-            end
-          end
-        end
-        lifecycle.after(:execute) do |worker|
-          worker.master_logger.info "shut down worker #{Process.pid}"
-        end
-      end
-    end
-  end
-end
-
-Delayed::Worker.plugins << Delayed::Plugins::SignalHandler

data/lib/delayed/worker/plugins/status_notifier.rb

@@ -1,17 +0,0 @@
-module Delayed
-  module Plugins
-    class StatusNotifier < Delayed::Plugin
-      callbacks do |lifecycle|
-        lifecycle.around(:perform) do |worker, job, &block|
-          title = $0
-          $0 = "#{title} [BUSY]"
-          ret = block.call
-          $0 = title
-          ret
-        end
-      end
-    end
-  end
-end
-
-Delayed::Worker.plugins << Delayed::Plugins::StatusNotifier