mirror of
https://github.com/kevinveenbirkenbach/computer-playbook.git
synced 2026-11-08 11:46:35 +00:00
kevinveenbirkenbachandClaude Opus 5
3c2666f262
Ansible's Linux hardware collector reads /sys/block/<dev>/size without a None guard, and that read runs before the CPU facts in the same collector. One unreadable block device therefore drops every hardware fact at once and without a warning. Seven expressions across four files dereferenced processor_vcpus or memtotal_mb directly and died on the first render. Measured on the interpreter the deploy actually uses, gather_subset=all returns none of those facts. plugins/lookup/resource.py now measures and computes every host-resource constant. The two measured inputs resolve as an inventory override, then the host's own hardware facts, then a probe of the machine the plugin runs on. The probe applies only to a target reached over the local connection, because a lookup executes on the Ansible controller and would otherwise report the controller's hardware for a remote host. No value is ever substituted. What that abort may interrupt depends on context. A play carries inventory_hostname and has to stop, while the inventory generator and the lint suite render the same applications payload with no host and must not fail over a value they never read. The first case raises UnresolvableValueError, the one class the best-effort render layers re-raise instead of swallowing; the second raises an ordinary AnsibleError that they absorb, exactly as the missing fact did before. The meta files of web-app-nextcloud and svc-opt-swapfile call the lookup directly rather than through a group_var. _render_with_templar replaces the templar's variables with a flat dict, which drops the lazy resolution a play uses to expand a variable that itself holds a lookup, so the indirection renders 0M there while the same expression yields 2133M in a play. The container count is computed only for the keys that divide by it. Reading applications pulls the payload back through the templar while it is still being produced, and those meta files sit in that payload. utils/cache/errors.py lives in the cache package rather than at the top of utils/: ansible.cfg exposes ./utils as module_utils, so a top-level errors.py becomes ansible.module_utils.errors and shadows the real one inside every module payload zip, which broke uri and get_url with an ImportError pointing into a temporary zip. A lint now guards that class of collision. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
40 lines
1.5 KiB
Python
40 lines
1.5 KiB
Python
"""Errors that MUST survive a best-effort render.
|
|
|
|
`utils.cache.base._render_with_templar` and the two templar helpers behind it
|
|
swallow every exception on purpose: a meta payload renders in rounds, and an
|
|
expression that cannot resolve yet has to come back unchanged rather than abort
|
|
the round.
|
|
|
|
That contract is wrong for one class of failure. When a value could not be
|
|
measured and substituting one would be a guess, silence turns a loud stop into
|
|
a wrong number nobody sees. Such a failure raises from here and every render
|
|
layer re-raises it untouched.
|
|
|
|
No ansible import: `utils.cache.base` deliberately carries none, and the env
|
|
generator imports parts of `utils` on hosts that have no ansible installed.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
|
|
class UnresolvableValueError(Exception):
|
|
"""A value could not be determined and MUST NOT be substituted."""
|
|
|
|
|
|
def is_unresolvable(exc: BaseException | None) -> bool:
|
|
"""True when `exc` is, or was caused by, an `UnresolvableValueError`.
|
|
|
|
Ansible wraps an exception raised inside a lookup into its own error type,
|
|
so the original is reachable only through the `__cause__` / `__context__`
|
|
chain. The walk is cycle-guarded because a re-raise can make that chain
|
|
point back at itself.
|
|
"""
|
|
seen: set[int] = set()
|
|
current = exc
|
|
while current is not None and id(current) not in seen:
|
|
if isinstance(current, UnresolvableValueError):
|
|
return True
|
|
seen.add(id(current))
|
|
current = current.__cause__ or current.__context__
|
|
return False
|