netboot 0.2.1__tar.gz → 0.2.3__tar.gz

{netboot-0.2.1 → netboot-0.2.3}/CHANGELOG.md

@@ -6,6 +6,40 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.2.3] - 2026-09-23
+
+### Fixed
+- One DHCP server being offline no longer fails `pixie initiate` or
+  `pixie complete`. Arming is meant to be best effort, but since 0.2.0 it
+  stopped at the first failing server and rolled the others back. `initiate`
+  now tries every server in the zone, logs each failure as a warning, and fails
+  only when no server could be armed. `complete` logs a failing server as a
+  warning and still exits 0, so read the log if you need to know every server
+  was disarmed.
+
+## [0.2.2] - 2026-09-21
+
+netboot moves to netimps 0.3.1 and yaconfiglib 0.13. If a plugin, hook or
+template compares `target.mac` with text, read the `MACAddress` entry below.
+
+### Changed
+- Dependencies move to their new series: `netimps>=0.3.1,<0.4` and
+  `yaconfiglib>=0.13.0,<0.14`. The old ceilings made netboot uninstallable
+  beside either release. netimps 0.3.0 is skipped on purpose: it raised from
+  `resolve()` when no resolver was reachable, which would have failed every
+  command at startup, and 0.3.1 answers `[]` again. netboot uses none of the
+  yaconfiglib APIs 0.13.0 removed.
+- **`MACAddress` no longer equals a `str`** (netimps 0.3.0, re-exported as
+  `netboot.utils.net.MACAddress`). `target.mac == "aa:bb:cc:dd:ee:ff"` is now
+  `False` — in a plugin, a hook or a Jinja template alike. Compare with
+  `MACAddress.try_parse(text) == target.mac`. In exchange a MAC is found in a
+  set or dict whichever spelling built it. netboot's own target lookup already
+  compared parsed MACs and is unaffected. A MAC that mixes separators
+  (`00-11:22-33:44-55`) is now rejected, and `aa.bb.cc.dd.ee.ff` is accepted.
+- `resolve()` keeps trying backends after an empty answer, so a hostname
+  target known only to the hosts file or NSS now gets its IP on Windows and
+  macOS. A name that exists nowhere costs two or three lookups instead of one.
+
 ## [0.2.1] - 2026-09-17
 
 netboot ships DHCP backends. Additive: nothing documented changed behaviour,
@@ -520,7 +554,9 @@ First packaged release: the `netboot` library with the `pixie` command line.
   config value construction no longer swallows non-`TypeError` errors; repo
   `joinpath` keeps `.local` a path so chained joins work.
 
-[Unreleased]: https://github.com/jose-pr/netboot/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/jose-pr/netboot/compare/v0.2.3...HEAD
+[0.2.3]: https://github.com/jose-pr/netboot/compare/v0.2.2...v0.2.3
+[0.2.2]: https://github.com/jose-pr/netboot/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/jose-pr/netboot/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/jose-pr/netboot/compare/v0.1.3...v0.2.0
 [0.1.3]: https://github.com/jose-pr/netboot/compare/v0.1.2...v0.1.3

{netboot-0.2.1 → netboot-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: netboot
-Version: 0.2.1
+Version: 0.2.3
 Summary: PXE provisioning management: render netboot artifacts and drive DHCP for targets
 Project-URL: Homepage, https://github.com/jose-pr/netboot/
 Project-URL: Issues, https://github.com/jose-pr/netboot/issues
@@ -27,9 +27,9 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.9
 Requires-Dist: duho<0.6,>=0.5.0
 Requires-Dist: jinja2<4,>=3.0
-Requires-Dist: netimps<0.3,>=0.2.1
+Requires-Dist: netimps<0.4,>=0.3.1
 Requires-Dist: pathlib-next[uri]<0.10,>=0.9.9
-Requires-Dist: yaconfiglib<0.13,>=0.12.0
+Requires-Dist: yaconfiglib<0.14,>=0.13.0
 Provides-Extra: config
 Requires-Dist: pyyaml; extra == 'config'
 Provides-Extra: dev

{netboot-0.2.1 → netboot-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "netboot"
-version = "0.2.1"
+version = "0.2.3"
 authors = [{ name = "Jose A." }]
 description = "PXE provisioning management: render netboot artifacts and drive DHCP for targets"
 readme = "README.md"
@@ -30,10 +30,12 @@ classifiers = [
 ]
 dependencies = [
     "duho>=0.5.0,<0.6",
-    # Above the .0 deliberately: netboot calls netimps' resolve() with no
-    # rdtype, and 0.2.1 is the release that auto-selects it ("ptr" for an
-    # address literal, "a" otherwise). Don't normalize this back to 0.2.0.
-    "netimps>=0.2.1,<0.3",
+    # Above the .0 deliberately: 0.3.0 made resolve() raise ResolutionError
+    # when no backend could even ask (a resolver outage), and 0.3.1 restored
+    # [] as the default (strict=False). PixieTarget and Host.try_ip rely on
+    # that: every target is built at startup, so a raise would fail every
+    # command. Don't normalize this back to 0.3.0.
+    "netimps>=0.3.1,<0.4",
     # Above the .0 deliberately, measured 2026-09-17: recursive `!include`
     # globs (`sub/**/*.yaml`) break on pathlib_next >=0.9.5 unless yaconfiglib
     # is >=0.12.0, and yaconfiglib 0.12.0 itself requires pathlib-next>=0.9.9.
@@ -44,9 +46,7 @@ dependencies = [
     # markupsafe.soft_unicode, removed in MarkupSafe 2.1, so an unpinned
     # resolve can install a jinja2/markupsafe pair that fails on import.
     "jinja2>=3.0,<4",
-    # Above a bare series base for the same measured reason: with the
-    # pathlib-next this project uses, recursive config discovery needs 0.12.0.
-    "yaconfiglib>=0.12.0,<0.13",
+    "yaconfiglib>=0.13.0,<0.14",
 ]
 
 [project.optional-dependencies]

{netboot-0.2.1 → netboot-0.2.3}/src/netboot/AGENTS.md

@@ -110,9 +110,10 @@ is the same object. `netboot.netutils` remains an alias for
   non-MAC `_id` fills `hostname`; then, if `ip` is still unset and a hostname
   is known, **exactly one** forward lookup
   (`netboot.utils.net.resolve`, no reverse lookup) fills it. A name that does
-  not resolve leaves `ip` unset and logs a warning — it is never retried, and
-  never raises. `hostname` is lower-cased. The `dns` extra is optional: without
-  it netimps still resolves through its system/`nslookup` backends.
+  not resolve — including when no resolver is reachable at all — leaves `ip`
+  unset and logs a warning; it is never retried, and never raises. `hostname`
+  is lower-cased. The `dns` extra is optional: without it netimps still
+  resolves through its system/`nslookup` backends.
 
 - **`PixieImage(**kwargs)`** (`content.Resource`) — `template_path`,
   `globals`, plus `Resource`'s `src`/`path`, which address the image's
@@ -149,12 +150,12 @@ is the same object. `netboot.netutils` remains an alias for
     process's working directory; an absolute path or a URI is used as given.
   - **`.pxe_init(netboot) -> Self`** / **`.pxe_complete(netboot) -> Self`** —
     arm/disarm every `dhcpzone.dhcpservers` for this context; called by
-    `Pixie.initialize`/`.complete`, not usually invoked directly. `pxe_init`
-    is **all or nothing**: if a backend raises, the ones already armed are
-    rolled back before the error propagates, so a target is never left armed
-    on some servers and not others. `pxe_complete` is the opposite — every
-    backend is tried even if one fails, and the first error is raised
-    afterwards, because stopping early would leave the rest armed.
+    `Pixie.initialize`/`.complete`, not usually invoked directly. Both try
+    every backend. `pxe_init` logs a backend that raises as a **warning** and
+    carries on; it raises (the first error) only when **no** backend could be
+    armed, and nothing is rolled back, so a target may end up armed on some
+    servers and not others. `pxe_complete` never raises for a backend: each
+    failure is logged as a warning and the rest are still disarmed.
 
 ## DHCP (`netboot.dhcp`)
 
@@ -337,7 +338,8 @@ servers identifies a reservation by it.
 - **`Host(address: str | Host | None = None)`** — a hostname-or-IP repo
   address. **`.try_ip() -> IPAddress | str`** — resolves to an `IPAddress`
   (an IP literal as-is, a hostname through one forward lookup); falls back to
-  the original string on resolution failure. The `dns` extra is optional —
+  the original string on resolution failure, an unreachable resolver
+  included. The `dns` extra is optional —
   without it netimps resolves through its system/`nslookup` backends.
   Equality/hash by `.address`.
 - **`flatten(map, _prefix="") -> dict`** — recursively flattens a
@@ -368,13 +370,18 @@ servers identifies a reservation by it.
   - `parse(value, type, **kw)` raises on bad input; `try_parse(value, type)`
     returns `None` instead; `is_valid(value, type)` returns a bool. Networks
     parse non-strict, so `"10.0.0.5/24"` normalises rather than raising.
-  - `MACAddress` — colon/hyphen/Cisco-dot/bare text, `int` or `bytes`;
-    `.as_str(sep)`, `.packed`, `.oui`, hashable and ordered.
+  - `MACAddress` — colon/hyphen/per-octet-dot/Cisco-dot/bare text (one
+    separator per address), `int` or `bytes`; `.as_str(sep)`, `.packed`,
+    `.oui`, hashable and ordered. It equals only another `MACAddress`, never a
+    `str` — compare text with `MACAddress.try_parse(text) == mac`.
   - `resolve(query, rdtype=None)` → a list of **native** records (`A`/`AAAA`
     are `IPv4Address`/`IPv6Address`, not strings); `[]` on a genuine lookup
     failure, but a malformed query or unknown record type raises `ValueError`
     rather than looking like "no such record". `rdtype=None` auto-selects:
-    `"ptr"` when `query` is an address literal, `"a"` otherwise.
+    `"ptr"` when `query` is an address literal, `"a"` otherwise. Backends are
+    tried until one answers non-empty, so hosts-file and NSS-only names
+    resolve too. An unreachable resolver also answers `[]`; netimps'
+    `strict=True` raises `netimps.ResolutionError` instead.
   - `ping(dst)` → a `PingResult` that is truthy on success and also carries
     `.rtt_ms`/`.ttl`.
   - `get_interfaces()` / `iter_addresses()` — real adapter enumeration with

{netboot-0.2.1 → netboot-0.2.3}/src/netboot/engine.py

@@ -7,6 +7,7 @@ whole implementation.
 
 import datetime
 import enum as _enum
+import logging
 import typing as _ty
 from argparse import Namespace
 from copy import deepcopy
@@ -199,51 +200,49 @@ class PixieContext(Namespace):
         return self.repos.get(resource.src)
 
     def pxe_init(self, config: "Pixie"):
-        """Arm every DHCP backend for this target, all or nothing.
+        """Arm every DHCP backend for this target, succeeding if any one does.
 
-        A target armed on two of three backends is worse than one armed on
-        none: it may boot into an installer from one server while another
-        hands out its normal lease. So a failure rolls the already-armed
-        backends back before re-raising.
+        Every backend is tried. A backend that fails is logged as a warning and
+        skipped, so one server being offline does not block the others; the
+        first error is raised only when no backend could be armed.
         """
-        armed = []
+        first_error = None
+        armed = 0
         for dhcpserver in self.dhcpzone.dhcpservers:
             try:
                 dhcpserver.add_target(self)
-            except Exception:
-                for done in reversed(armed):
-                    try:
-                        done.remove_target(self)
-                    except Exception:  # keep unwinding; report the first cause
-                        LOGGER.exception(
-                            "rollback failed for %s on %s",
-                            self.target._id,
-                            getattr(done, "uri", done),
-                        )
-                raise
-            armed.append(dhcpserver)
+            except Exception as exc:
+                LOGGER.warning(
+                    "could not arm %s on %s: %s",
+                    self.target._id,
+                    getattr(dhcpserver, "uri", dhcpserver),
+                    exc,
+                    exc_info=LOGGER.isEnabledFor(logging.DEBUG),
+                )
+                first_error = first_error or exc
+            else:
+                armed += 1
+        if first_error is not None and not armed:
+            raise first_error
         return self
 
     def pxe_complete(self, config: "Pixie"):
-        """Disarm every DHCP backend, continuing past a failure.
+        """Disarm every DHCP backend; a failure is a warning, never an error.
 
-        Cleanup is the opposite case from arming: stopping at the first error
-        would leave the remaining backends armed, so every backend is tried and
-        the first error is raised once they have all had their turn.
+        Every backend is tried, and one that fails is logged and skipped, so
+        the rest are still disarmed.
         """
-        first_error = None
         for dhcpserver in self.dhcpzone.dhcpservers:
             try:
                 dhcpserver.remove_target(self)
             except Exception as exc:
-                LOGGER.exception(
-                    "could not disarm %s on %s",
+                LOGGER.warning(
+                    "could not disarm %s on %s: %s",
                     self.target._id,
                     getattr(dhcpserver, "uri", dhcpserver),
+                    exc,
+                    exc_info=LOGGER.isEnabledFor(logging.DEBUG),
                 )
-                first_error = first_error or exc
-        if first_error is not None:
-            raise first_error
         return self
 
     def _template_names(self, suffix: Union[list[str], str], **options) -> list[str]:
@@ -706,7 +705,7 @@ class Pixie:
     def initialize(self, target: "PixieTarget"):
         """Arm DHCP for `target` and return its context.
 
-        All or nothing: a backend that fails rolls back the ones already armed.
+        A backend that fails is a warning; it raises only if none could be armed.
         """
         target = self.hook(PixieEvent.StartPixieInitialize, target)
         ctx = self.make_context(target)
@@ -716,7 +715,7 @@ class Pixie:
     def complete(self, target: "PixieTarget"):
         """Disarm DHCP for `target` and return its context.
 
-        Every backend is tried even if one fails; the first error is raised after.
+        Every backend is tried; one that fails is logged as a warning.
         """
         target = self.hook(PixieEvent.StartPixieComplete, target)
         ctx = self.make_context(target, require_image=False)

{netboot-0.2.1 → netboot-0.2.3}/src/netboot/utils/net.py

@@ -3,8 +3,8 @@
 The IP/MAC machinery used to live in an in-tree copy of an earlier version of
 that library. It has since been published, gaining fixes this copy never had --
 real prefix lengths and MTU in interface enumeration, DNS errors that surface
-instead of being swallowed, and a ``ping`` that behaves the same on every
-platform -- so the copy is gone.
+instead of being swallowed, and a ``ping`` that speaks each platform's own
+flags -- so the copy is gone.
 
 This module re-exports netimps under netboot's own name rather than wrapping
 it: the point of adopting a library is to use its vocabulary. Only

{netboot-0.2.1 → netboot-0.2.3}/tests/test_config_discovery.py

@@ -90,3 +90,22 @@ def test_resolve_auto_selects_the_record_type():
         "netimps.resolve no longer defaults rdtype to None (auto-select); "
         "Host.try_ip relies on that, netimps >= 0.2.1"
     )
+
+
+def test_resolve_is_not_strict_by_default():
+    """Guards `netimps>=0.3.1`: a resolver outage answers `[]`, not a raise.
+
+    0.3.0 raised `ResolutionError` from `resolve()` when no backend could even
+    ask; 0.3.1 made that opt-in with `strict=True`. `PixieTarget` handles `[]`
+    with a warning, but a raise would escape its construction -- and every
+    target is built at startup, so one outage would fail every command.
+    """
+    strict = inspect.signature(netutils.resolve).parameters.get("strict")
+    assert strict is not None, (
+        "netimps.resolve has no strict parameter: an unreachable resolver "
+        "raises instead of answering [] (netimps >= 0.3.1)"
+    )
+    assert strict.default is False, (
+        "netimps.resolve is strict by default; PixieTarget relies on [] for "
+        "an unreachable resolver (netimps >= 0.3.1)"
+    )

{netboot-0.2.1 → netboot-0.2.3}/tests/test_engine_robustness.py

@@ -1,7 +1,7 @@
 """Engine behaviour under partly-broken input and partly-failing backends.
 
 Each case here is a crash or a silent wrong answer the 2026-09-17 review
-reproduced: a half-armed target, a retired image blocking cleanup, a global
+reproduced: an offline DHCP server, a retired image blocking cleanup, a global
 that replaced the render context, a zone chosen by declaration order.
 """
 
@@ -61,28 +61,39 @@ class rollback(_Recorder):  # scheme `rollback://`
     pass
 
 
-def test_a_failing_backend_rolls_back_the_ones_already_armed():
+def test_arming_survives_a_failing_backend_with_a_warning(caplog):
     engine = _engine()
     zone = engine.dhcpzones["lan"]
-    zone.dhcpservers[1].fail_on = "add"
-    with pytest.raises(RuntimeError):
+    zone.dhcpservers[0].fail_on = "add"
+    with caplog.at_level(logging.WARNING, logger="netboot"):
         engine.initialize(engine.lookup_target("host1"))
-    # b failed, so a must not be left armed.
-    assert _Recorder.calls == [
-        ("arm", "rollback://a"),
-        ("arm", "rollback://b"),
-        ("disarm", "rollback://a"),
-    ]
+    # a is offline; b is still armed and nothing is rolled back.
+    assert _Recorder.calls == [("arm", "rollback://a"), ("arm", "rollback://b")]
+    assert "could not arm host1 on rollback://a" in caplog.text
 
 
-def test_disarm_continues_past_a_failure_then_raises():
+def test_arming_raises_when_every_backend_fails():
     engine = _engine()
-    zone = engine.dhcpzones["lan"]
-    zone.dhcpservers[0].fail_on = "remove"
-    with pytest.raises(RuntimeError):
+    for server in engine.dhcpzones["lan"].dhcpservers:
+        server.fail_on = "add"
+    with pytest.raises(RuntimeError, match="rollback://a refused to arm"):
+        engine.initialize(engine.lookup_target("host1"))
+    assert _Recorder.calls == [("arm", "rollback://a"), ("arm", "rollback://b")]
+
+
+def test_disarm_failures_are_warnings(caplog):
+    engine = _engine()
+    for server in engine.dhcpzones["lan"].dhcpservers:
+        server.fail_on = "remove"
+    with caplog.at_level(logging.WARNING, logger="netboot"):
         engine.complete(engine.lookup_target("host1"))
-    # The second backend is still disarmed despite the first failing.
-    assert ("disarm", "rollback://b") in _Recorder.calls
+    # Every backend is tried, and none of the failures is raised.
+    assert _Recorder.calls == [
+        ("disarm", "rollback://a"),
+        ("disarm", "rollback://b"),
+    ]
+    assert "could not disarm host1 on rollback://a" in caplog.text
+    assert "could not disarm host1 on rollback://b" in caplog.text
 
 
 def test_complete_works_when_the_image_is_no_longer_configured(caplog):