Class: Wurk::Swarm::ChildBoot

Inherits:
Object
  • Object
show all
Includes:
Component
Defined in:
lib/wurk/swarm/child_boot.rb

Overview

Step 5 of the boot ordering. Runs inside each forked child:

* reset signal traps inherited from the parent,
* reconnect ActiveRecord (if loaded) + open a fresh Redis pool,
* apply the slot's queues + concurrency to the default capsule,
* install child signal handlers (TERM/INT drain, TSTP quiet,
USR2 reopen logs),
* launch the Wurk::Launcher and block until shutdown.

Kept separate from Wurk::Swarm so the parent supervisor stays focused on PID supervision (SRP).

Constant Summary collapse

CHILD_SIGNALS = 
{ 'TERM' => :term, 'INT' => :term, 'TSTP' => :tstp, 'USR2' => :usr2 }.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config, slot, index) ⇒ ChildBoot

Returns a new instance of ChildBoot.



24
25
26
27
28
29
 
# File 'lib/wurk/swarm/child_boot.rb', line 24

def initialize(config, slot, index)
  @config = config
  @slot = slot
  @index = index
  @signal_queue = ::Thread::Queue.new
end

Instance Attribute Details

#config ⇒ Object (readonly) Originally defined in module Component

Returns the value of attribute config.

Instance Method Details

#default_tag(dir = Dir.pwd) ⇒ Object Originally defined in module Component

#fire_event(event, oneshot: true, reverse: false, reraise: false) ⇒ Object Originally defined in module Component

Invokes lifecycle hooks for event. Hooks run in registration order (or LIFO when reverse: true, used for teardown). A raise in one hook is reported via handle_exception and does NOT stop the next hook unless reraise: true (used in tests / fail-fast boot). oneshot: true clears the bucket after dispatch so the event can't fire twice.

#handle_exception(ex, ctx = {}) ⇒ Object Originally defined in module Component

#hostname ⇒ Object Originally defined in module Component

#identity ⇒ Object Originally defined in module Component

#leader? ⇒ Boolean Originally defined in module Component

True iff this process currently holds the cluster dear-leader lock. Per spec, the check is performed at call time (Wurk does not cache); callers must not poll faster than the 60s follower cadence. Returns false unconditionally when WURK_LEADER=false (or SIDEKIQ_LEADER=false) is set on the process (opt-out hot-standby). Any Redis error is swallowed → false, so a transient partition can't propagate as an exception into user code.

Spec: docs/target/sidekiq-ent.md §6.1.

Returns:

  • (Boolean)

#logger ⇒ Object Originally defined in module Component

--- delegated to config -------------------------------------------

#mono_ms ⇒ Object Originally defined in module Component

#process_nonce ⇒ Object Originally defined in module Component

#real_ms ⇒ Object Originally defined in module Component

--- clocks ---------------------------------------------------------

#redis ⇒ Object Originally defined in module Component

#run ⇒ Object 



31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/wurk/swarm/child_boot.rb', line 31

def run
  reset_inherited_signals
  reconnect_after_fork
  Wurk.server = true
  # :fork runs in each child after our internal AR/Redis reconnect and
  # before fetching, so apps can reopen sockets / restart threads /
  # reconnect non-fork-safe libs (Ent §7.4). It never fires in the parent
  # (which only forks + supervises). Like :startup, the child's forked
  # copy of the bucket is cleared after dispatch, so siblings fire theirs.
  fire_event(:fork)
  apply_slot_to_config
  # :startup must fire in each worker child before its managers spin up
  # (Sidekiq contract, reraise: true). The parent supervisor never runs
  # jobs, so the non-swarm CLI path fires it once per process — for the
  # swarm, each child fires it here. Its own forked copy of the bucket is
  # cleared after, so siblings still fire their own.
  fire_event(:startup, reraise: true)
  run_launcher
  exit 0
rescue StandardError, ::Wurk::Shutdown => e
  @config.logger.error { "swarm child ##{@index} (#{::Process.pid}) crashed: #{e.class}: #{e.message}" }
  exit 1
end

#safe_thread(name, priority: nil, &block) ⇒ Object Originally defined in module Component

Spawns a named thread that runs block under watchdog(name). The parent must retain the returned Thread; otherwise GC may not, but report_on_exception is disabled so we don't double-log on death.

#tid ⇒ Object Originally defined in module Component

--- identity -------------------------------------------------------

#watchdog(last_words) ⇒ Object Originally defined in module Component

Wraps a block at a thread boundary: any unhandled exception is reported via handle_exception (so it lands in error_handlers / the log) and then re-raised. last_words is the component label included in the context.