good_job 3.12.5 → 3.12.6

data/app/controllers/good_job/assets_controller.rb

@@ -1,47 +1,45 @@
 # frozen_string_literal: true
 module GoodJob
   class AssetsController < ActionController::Base # rubocop:disable Rails/ApplicationController
-    skip_before_action :verify_authenticity_token, raise: false
+    skip_after_action :verify_same_origin_request
+
+    STATIC_ASSETS = {
+      css: {
+        bootstrap: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "bootstrap", "bootstrap.min.css"),
+        style: GoodJob::Engine.root.join("app", "assets", "good_job", "style.css"),
+      },
+      js: {
+        bootstrap: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "bootstrap", "bootstrap.bundle.min.js"),
+        chartjs: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "chartjs", "chart.min.js"),
+        es_module_shims: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "es_module_shims.js"),
+        rails_ujs: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "rails_ujs.js"),
+      },
+    }.freeze
+
+    MODULE_OVERRIDES = {
+      application: GoodJob::Engine.root.join("app", "assets", "good_job", "application.js"),
+      stimulus: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "stimulus.js"),
+    }.freeze
 
     def self.js_modules
       @_js_modules ||= GoodJob::Engine.root.join("app", "assets", "good_job", "modules").children.select(&:file?).each_with_object({}) do |file, modules|
         key = File.basename(file.basename.to_s, ".js").to_sym
         modules[key] = file
-      end
+      end.merge(MODULE_OVERRIDES)
     end
 
     before_action do
       expires_in 1.year, public: true
     end
 
-    def es_module_shims_js
-      render file: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "es_module_shims.js")
+    def static
+      render file: STATIC_ASSETS.dig(params[:format].to_sym, params[:name].to_sym) || raise(ActionController::RoutingError, 'Not Found')
     end
 
-    def bootstrap_css
-      render file: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "bootstrap", "bootstrap.min.css")
-    end
-
-    def bootstrap_js
-      render file: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "bootstrap", "bootstrap.bundle.min.js")
-    end
-
-    def chartjs_js
-      render file: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "chartjs", "chart.min.js")
-    end
-
-    def rails_ujs_js
-      render file: GoodJob::Engine.root.join("app", "assets", "good_job", "vendor", "rails_ujs.js")
-    end
-
-    def style_css
-      render file: GoodJob::Engine.root.join("app", "assets", "good_job", "style.css")
-    end
+    def module
+      raise(ActionController::RoutingError, 'Not Found') if params[:format] != "js"
 
-    def modules_js
-      module_name = params[:module].to_sym
-      module_file = self.class.js_modules.fetch(module_name) { raise ActionController::RoutingError, 'Not Found' }
-      render file: module_file
+      render file: self.class.js_modules[params[:name].to_sym] || raise(ActionController::RoutingError, 'Not Found')
     end
   end
 end

data/app/views/layouts/good_job/application.html.erb

@@ -8,16 +8,16 @@
   <%= csp_meta_tag %>
 
   <%# Do not use asset tag helpers to avoid paths being overriden by config.asset_host %>
-  <%= tag.link rel: "stylesheet", media: "screen", href: bootstrap_path(format: :css, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
-  <%= tag.link rel: "stylesheet", media: "screen", href: style_path(format: :css, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
+  <%= tag.link rel: "stylesheet", href: static_asset_path(:bootstrap, format: :css, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
+  <%= tag.link rel: "stylesheet", href: static_asset_path(:style, format: :css, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
 
-  <%= tag.script "", src: bootstrap_path(format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
-  <%= tag.script "", src: chartjs_path(format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
-  <%= tag.script "", src: rails_ujs_path(format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
+  <%= tag.script "", src: static_asset_path(:bootstrap, format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
+  <%= tag.script "", src: static_asset_path(:chartjs, format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
+  <%= tag.script "", src: static_asset_path(:rails_ujs, format: :js, v: GoodJob::VERSION, locale: nil), nonce: content_security_policy_nonce %>
 
-  <%= tag.script "", src: es_module_shims_path(format: :js, v: GoodJob::VERSION, locale: nil), async: true, nonce: content_security_policy_nonce %>
-  <% importmaps = { imports: GoodJob::AssetsController.js_modules.keys.index_with { |module_name| modules_path(module_name, format: :js, locale: nil, v: GoodJob::VERSION) } } %>
-  <%= tag.script importmaps.to_json.html_safe, type: "importmap", nonce: content_security_policy_nonce %>
+  <%= tag.script "", src: static_asset_path(:es_module_shims, format: :js, v: GoodJob::VERSION, locale: nil), async: true, nonce: content_security_policy_nonce %>
+  <% importmaps = GoodJob::AssetsController.js_modules.keys.index_with { |module_name| module_asset_path(module_name, format: :js, locale: nil, v: GoodJob::VERSION) } %>
+  <%= tag.script({ imports: importmaps }.to_json.html_safe, type: "importmap", nonce: content_security_policy_nonce) %>
   <%= tag.script "", type: "module", nonce: content_security_policy_nonce do %> import "application"; <% end %>
 </head>
 <body>

data/config/routes.rb

@@ -28,17 +28,7 @@ GoodJob::Engine.routes.draw do
   resources :processes, only: %i[index]
 
   scope :assets, controller: :assets do
-    constraints(format: :css) do
-      get :bootstrap, action: :bootstrap_css
-      get :style, action: :style_css
-    end
-
-    constraints(format: :js) do
-      get :bootstrap, action: :bootstrap_js
-      get :chartjs, action: :chartjs_js
-      get :rails_ujs, action: :rails_ujs_js
-      get :es_module_shims, action: :es_module_shims_js
-      get "modules/:module", action: :modules_js, as: :modules
-    end
+    get "modules/:name", action: :module, as: :module_asset, constraints: { format: 'js' }
+    get "static/:name", action: :static, as: :static_asset, constraints: { format: %w[css js] }
   end
 end

data/lib/good_job/adapter.rb

@@ -24,9 +24,10 @@ module GoodJob
     #   -+test+: +:inline+
     #  - +production+ and all other environments: +:external+
     #
-    def initialize(execution_mode: nil)
+    def initialize(execution_mode: nil, _capsule: GoodJob.capsule) # rubocop:disable Lint/UnderscorePrefixedVariableName
       @_execution_mode_override = execution_mode
       GoodJob::Configuration.validate_execution_mode(@_execution_mode_override) if @_execution_mode_override
+      @capsule = _capsule
 
       self.class.instances << self
       start_async if GoodJob.async_ready?
@@ -98,7 +99,7 @@ module GoodJob
             state = { queue_name: queue_name, count: executions_by_queue_and_scheduled_at.size }
             state[:scheduled_at] = scheduled_at if scheduled_at
 
-            executed_locally = execute_async? && @scheduler&.create_thread(state)
+            executed_locally = execute_async? && @capsule&.create_thread(state)
             unless executed_locally
               state[:count] = job_id_to_active_jobs.values_at(*executions_by_queue_and_scheduled_at.map(&:active_job_id)).count { |active_job| send_notify?(active_job) }
               Notifier.notify(state) unless state[:count].zero?
@@ -141,7 +142,7 @@ module GoodJob
         job_state = { queue_name: execution.queue_name }
         job_state[:scheduled_at] = execution.scheduled_at if execution.scheduled_at
 
-        executed_locally = execute_async? && @scheduler&.create_thread(job_state)
+        executed_locally = execute_async? && @capsule&.create_thread(job_state)
         Notifier.notify(job_state) if !executed_locally && send_notify?(active_job)
       end
 
@@ -150,20 +151,13 @@ module GoodJob
 
     # Shut down the thread pool executors.
     # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads.
-    #   * +nil+, the scheduler will trigger a shutdown but not wait for it to complete.
-    #   * +-1+, the scheduler will wait until the shutdown is complete.
-    #   * +0+, the scheduler will immediately shutdown and stop any threads.
+    #   * +nil+ trigger a shutdown but not wait for it to complete.
+    #   * +-1+ wait until the shutdown is complete.
+    #   * +0+ immediately shutdown and stop any threads.
     #   * A positive number will wait that many seconds before stopping any remaining active threads.
     # @return [void]
     def shutdown(timeout: :default)
-      timeout = if timeout == :default
-                  GoodJob.configuration.shutdown_timeout
-                else
-                  timeout
-                end
-
-      executables = [@notifier, @poller, @scheduler].compact
-      GoodJob._shutdown_all(executables, timeout: timeout)
+      @capsule&.shutdown(timeout: timeout)
       @_async_started = false
     end
 
@@ -199,14 +193,7 @@ module GoodJob
     def start_async
       return unless execute_async?
 
-      @notifier = GoodJob::Notifier.new(enable_listening: GoodJob.configuration.enable_listen_notify)
-      @poller = GoodJob::Poller.new(poll_interval: GoodJob.configuration.poll_interval)
-      @scheduler = GoodJob::Scheduler.from_configuration(GoodJob.configuration, warm_cache_on_initialize: true)
-      @notifier.recipients << [@scheduler, :create_thread]
-      @poller.recipients << [@scheduler, :create_thread]
-
-      @cron_manager = GoodJob::CronManager.new(GoodJob.configuration.cron_entries, start_on_initialize: true) if GoodJob.configuration.enable_cron?
-
+      @capsule.start
       @_async_started = true
     end
 

data/lib/good_job/capsule.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module GoodJob
+  # A GoodJob::Capsule contains the resources necessary to execute jobs, including
+  # a {GoodJob::Scheduler}, {GoodJob::Poller}, {GoodJob::Notifier}, and {GoodJob::CronManager}.
+  # GoodJob creates a default capsule on initialization.
+  class Capsule
+    # @!attribute [r] instances
+    #   @!scope class
+    #   List of all instantiated Capsules in the current process.
+    #   @return [Array<GoodJob::Capsule>, nil]
+    cattr_reader :instances, default: [], instance_reader: false
+
+    # @param configuration [GoodJob::Configuration] Configuration to use for this capsule.
+    def initialize(configuration: GoodJob.configuration)
+      self.class.instances << self
+      @configuration = configuration
+
+      @autostart = true
+      @running = false
+      @mutex = Mutex.new
+    end
+
+    # Start executing jobs (if not already running).
+    def start
+      return if @running
+
+      @mutex.synchronize do
+        return if @running
+
+        @notifier = GoodJob::Notifier.new(enable_listening: @configuration.enable_listen_notify)
+        @poller = GoodJob::Poller.new(poll_interval: @configuration.poll_interval)
+        @scheduler = GoodJob::Scheduler.from_configuration(@configuration, warm_cache_on_initialize: true)
+        @notifier.recipients << [@scheduler, :create_thread]
+        @poller.recipients << [@scheduler, :create_thread]
+
+        @cron_manager = GoodJob::CronManager.new(@configuration.cron_entries, start_on_initialize: true) if @configuration.enable_cron?
+
+        @autostart = false
+        @running = true
+      end
+    end
+
+    # Shut down the thread pool executors.
+    # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads.
+    #   * +-1+ will wait for all active threads to complete.
+    #   * +0+ will interrupt active threads.
+    #   * +N+ will wait at most N seconds and then interrupt active threads.
+    #   * +nil+ will trigger a shutdown but not wait for it to complete.
+    # @return [void]
+    def shutdown(timeout: :default)
+      timeout = timeout == :default ? @configuration.shutdown_timeout : timeout
+      GoodJob._shutdown_all([@notifier, @poller, @scheduler, @cron_manager].compact, timeout: timeout)
+      @autostart = false
+      @running = false
+    end
+
+    # Shutdown and then start the capsule again.
+    # @param timeout [nil, Numeric, Symbol] Seconds to wait for active threads.
+    # @return [void]
+    def restart(timeout: :default)
+      shutdown(timeout: timeout)
+      start
+    end
+
+    # @return [Boolean] Whether the capsule is currently running.
+    def running?
+      @running
+    end
+
+    # @return [Boolean] Whether the capsule has been shutdown.
+    def shutdown?
+      [@notifier, @poller, @scheduler, @cron_manager].compact.all?(&:shutdown?)
+    end
+
+    # Creates an execution thread(s) with the given attributes.
+    # @param job_state [Hash, nil] See {GoodJob::Scheduler#create_thread}.
+    # @return [Boolean, nil] Whether work was started.
+    def create_thread(job_state = nil)
+      start if !running? && @autostart
+      @scheduler&.create_thread(job_state)
+    end
+  end
+end

data/lib/good_job/cli.rb

@@ -95,13 +95,8 @@ module GoodJob
 
       Daemon.new(pidfile: configuration.pidfile).daemonize if configuration.daemonize?
 
-      notifier = GoodJob::Notifier.new(enable_listening: GoodJob.configuration.enable_listen_notify)
-      poller = GoodJob::Poller.new(poll_interval: configuration.poll_interval)
-      scheduler = GoodJob::Scheduler.from_configuration(configuration, warm_cache_on_initialize: true)
-      notifier.recipients << [scheduler, :create_thread]
-      poller.recipients << [scheduler, :create_thread]
-
-      cron_manager = GoodJob::CronManager.new(configuration.cron_entries, start_on_initialize: true) if configuration.enable_cron?
+      capsule = GoodJob::Capsule.new
+      capsule.start
 
       if configuration.probe_port
         probe_server = GoodJob::ProbeServer.new(port: configuration.probe_port)
@@ -115,11 +110,10 @@ module GoodJob
 
       Kernel.loop do
         sleep 0.1
-        break if @stop_good_job_executable || scheduler.shutdown? || notifier.shutdown?
+        break if @stop_good_job_executable || capsule.shutdown?
       end
 
-      executors = [notifier, poller, cron_manager, scheduler].compact
-      GoodJob._shutdown_all(executors, timeout: configuration.shutdown_timeout)
+      capsule.shutdown(timeout: configuration.shutdown_timeout)
       probe_server&.stop
     end
 

data/lib/good_job/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module GoodJob
   # GoodJob gem version.
-  VERSION = '3.12.5'
+  VERSION = '3.12.6'
 end

data/lib/good_job.rb

@@ -15,6 +15,7 @@ require "good_job/active_job_extensions/notify_options"
 
 require "good_job/assignable_connection"
 require "good_job/bulk"
+require "good_job/capsule"
 require "good_job/cleanup_tracker"
 require "good_job/cli"
 require "good_job/configuration"
@@ -91,6 +92,12 @@ module GoodJob
   #   @return [GoodJob::Configuration, nil]
   mattr_accessor :configuration, default: GoodJob::Configuration.new({})
 
+  # @!attribute [rw] capsule
+  #   @!scope class
+  #   Global/default execution capsule for GoodJob.
+  #   @return [GoodJob::Capsule, nil]
+  mattr_accessor :capsule, default: GoodJob::Capsule.new(configuration: configuration)
+
   # Called with exception when a GoodJob thread raises an exception
   # @param exception [Exception] Exception that was raised
   # @return [void]
@@ -108,16 +115,15 @@ module GoodJob
   #   * +-1+, the scheduler will wait until the shutdown is complete.
   #   * +0+, the scheduler will immediately shutdown and stop any active tasks.
   #   * +1..+, the scheduler will wait that many seconds before stopping any remaining active tasks.
-  # @param wait [Boolean] whether to wait for shutdown
   # @return [void]
   def self.shutdown(timeout: -1)
-    _shutdown_all(_executables, timeout: timeout)
+    _shutdown_all(Capsule.instances, timeout: timeout)
   end
 
   # Tests whether jobs have stopped executing.
   # @return [Boolean] whether background threads are shut down
   def self.shutdown?
-    _executables.all?(&:shutdown?)
+    Capsule.instances.all?(&:shutdown?)
   end
 
   # Stops and restarts executing jobs.
@@ -128,7 +134,7 @@ module GoodJob
   # @param timeout [Numeric, nil] Seconds to wait for active threads to finish.
   # @return [void]
   def self.restart(timeout: -1)
-    _shutdown_all(_executables, :restart, timeout: timeout)
+    _shutdown_all(Capsule.instances, :restart, timeout: timeout)
   end
 
   # Sends +#shutdown+ or +#restart+ to executable objects ({GoodJob::Notifier}, {GoodJob::Poller}, {GoodJob::Scheduler}, {GoodJob::MultiScheduler}, {GoodJob::CronManager})
@@ -154,7 +160,7 @@ module GoodJob
   # analyze or inspect job performance.
   # If you are preserving job records this way, use this method regularly to
   # destroy old records and preserve space in your database.
-  # @params older_than [nil,Numeric,ActiveSupport::Duration] Jobs older than this will be destroyed (default: +86400+).
+  # @param older_than [nil,Numeric,ActiveSupport::Duration] Jobs older than this will be destroyed (default: +86400+).
   # @return [Integer] Number of job execution records and batches that were destroyed.
   def self.cleanup_preserved_jobs(older_than: nil)
     older_than ||= GoodJob.configuration.cleanup_preserved_jobs_before_seconds_ago
@@ -194,14 +200,5 @@ module GoodJob
     end
   end
 
-  def self._executables
-    [].concat(
-      CronManager.instances,
-      Notifier.instances,
-      Poller.instances,
-      Scheduler.instances
-    )
-  end
-
   ActiveSupport.run_load_hooks(:good_job, self)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: good_job
 version: !ruby/object:Gem::Version
-  version: 3.12.5
+  version: 3.12.6
 platform: ruby
 authors:
 - Ben Sheldon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-24 00:00:00.000000000 Z
+date: 2023-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -318,7 +318,7 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
-- app/assets/good_job/modules/application.js
+- app/assets/good_job/application.js
 - app/assets/good_job/modules/charts.js
 - app/assets/good_job/modules/checkbox_toggle.js
 - app/assets/good_job/modules/document_ready.js
@@ -331,6 +331,7 @@ files:
 - app/assets/good_job/vendor/chartjs/chart.min.js
 - app/assets/good_job/vendor/es_module_shims.js
 - app/assets/good_job/vendor/rails_ujs.js
+- app/assets/good_job/vendor/stimulus.js
 - app/charts/good_job/scheduled_by_queue_chart.rb
 - app/controllers/good_job/application_controller.rb
 - app/controllers/good_job/assets_controller.rb
@@ -408,6 +409,7 @@ files:
 - lib/good_job/adapter.rb
 - lib/good_job/assignable_connection.rb
 - lib/good_job/bulk.rb
+- lib/good_job/capsule.rb
 - lib/good_job/cleanup_tracker.rb
 - lib/good_job/cli.rb
 - lib/good_job/configuration.rb