netboot 0.2.2__tar.gz → 0.2.3__tar.gz

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

@@ -6,6 +6,17 @@ 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
@@ -543,7 +554,8 @@ 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.2...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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: netboot
-Version: 0.2.2
+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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "netboot"
-version = "0.2.2"
+version = "0.2.3"
 authors = [{ name = "Jose A." }]
 description = "PXE provisioning management: render netboot artifacts and drive DHCP for targets"
 readme = "README.md"

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

@@ -150,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`)
 

{netboot-0.2.2 → 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.2 → 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):