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, parent_pid: ::Process.ppid, start_quiet: false) ⇒ ChildBoot

parent_pid is captured by the swarm before it forks (race-free) and threaded through so OrphanGuard can tell "still supervised" from "reparented after the supervisor died". Defaults to the live parent for the non-swarm callers (tests) that construct a ChildBoot directly. start_quiet: — the swarm was TSTP-quieted before this child was forked (respawn/recycle during maintenance); boot the launcher already quieted so the replacement doesn't resume fetching. Delivered as a constructor flag, not a post-fork TSTP, because the signal would race the trap-reset window (default TSTP disposition suspends the child).



36
37
38
39
40
41
42
43
44
 
# File 'lib/wurk/swarm/child_boot.rb', line 36

def initialize(config, slot, index, parent_pid: ::Process.ppid, start_quiet: false)
  @config = config
  @slot = slot
  @index = index
  @parent_pid = parent_pid
  @start_quiet = start_quiet
  @signal_read = nil
  @signal_write = nil
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. Cached per Component instance for LEADER_CACHE_TTL_MS (~5s): cron and the metrics rollups call this every tick, and an uncached GET would double their Redis traffic at short intervals for no benefit — the lock's own renewal cadence (60s+, spec §6.1) easily tolerates a few-second-stale read. 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(idempotent: false) ⇒ Object Originally defined in module Component

#run ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/wurk/swarm/child_boot.rb', line 46

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.

Priority resolution matches Sidekiq (component.rb:44-48): explicit argument, then config.thread_priority, then -1. Ruby's default of 0 buys a 100ms timeslice; each negative step halves it, so -1 keeps a CPU-heavy capsule from starving its siblings for a whole tick.

#tid ⇒ Object Originally defined in module Component

#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.