boneio 1.6.0.dev3__tar.gz → 1.6.0.dev5__tar.gz

{boneio-1.6.0.dev3/boneio.egg-info → boneio-1.6.0.dev5}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.6.0.dev3
+Version: 1.6.0.dev5
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
 Project-URL: Homepage, https://boneio.eu
-Project-URL: Repository, https://github.com/boneIO-eu/app_bbb
+Project-URL: Repository, https://github.com/boneIO-eu/app_black
 Project-URL: Documentation, https://boneio.eu/docs/intro/
-Project-URL: Changelog, https://github.com/boneIO-eu/app_bbb/releases
+Project-URL: Changelog, https://github.com/boneIO-eu/app_black/releases
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE

boneio-1.6.0.dev5/boneio/core/cloud/__init__.py

@@ -0,0 +1,5 @@
+"""Cloud registration module for boneIO Black PWA support."""
+
+from boneio.core.cloud.registration import CloudRegistration, set_enabled
+
+__all__ = ["CloudRegistration", "set_enabled"]

{boneio-1.6.0.dev3/boneio/migrations/assets/docker/nodered → boneio-1.6.0.dev5/boneio/core/cloud/data}/docker-compose-cloud.yaml

@@ -20,6 +20,10 @@ services:
       - "${HTTPS_PORT:-8443}:443"
     environment:
       - HOST_HOSTNAME=${HOSTNAME}
+      # The port the host publishes 443 on. Caddy only sees 443 from
+      # inside the container, so a redirect built from what it sees
+      # would send browsers to a port nothing listens on.
+      - PUBLIC_HTTPS_PORT=${HTTPS_PORT:-8443}
     volumes:
       - ./caddy/502.html:/srv/502.html:ro
       - ./caddy/init-certs-cloud.sh:/init-certs-cloud.sh:ro

{boneio-1.6.0.dev3/boneio/migrations/assets/docker/nodered → boneio-1.6.0.dev5/boneio/core/cloud/data}/docker-compose.yaml

@@ -25,6 +25,10 @@ services:
       - "${HTTPS_PORT:-8443}:443"
     environment:
       - HOST_HOSTNAME=${HOSTNAME:-boneio}
+      # The port the host publishes 443 on. Caddy only sees 443 from
+      # inside the container, so a redirect built from what it sees
+      # would send browsers to a port nothing listens on.
+      - PUBLIC_HTTPS_PORT=${HTTPS_PORT:-8443}
     volumes:
       - ./caddy/502.html:/srv/502.html:ro
       - ./caddy/init-certs.sh:/init-certs.sh:ro

{boneio-1.6.0.dev3 → boneio-1.6.0.dev5}/boneio/core/cloud/data/init-certs-cloud.sh

@@ -79,34 +79,12 @@ cat > /tmp/Caddyfile << EOF
 
 # HTTP - serve directly
 :80 {
-        handle_errors {
-                @502-504 expression {err.status_code} >= 502 && {err.status_code} <= 504
-                handle @502-504 {
-                        root * /srv
-                        rewrite * /502.html
-                        file_server
-                }
-        }
-
-        handle /nodered-status {
-                header Content-Type application/json
-                header X-NodeRed-Available "true"
-                header Access-Control-Expose-Headers "X-NodeRed-Available"
-                respond \`{"available": true}\` 200
-        }
-
-        handle /nodered/* {
-                reverse_proxy node-red:1880 {
-                        header_up X-Forwarded-Proto {scheme}
-                        header_down X-NodeRed-Available "true"
-                }
-        }
-
-        handle {
-                reverse_proxy host.docker.internal:8090 {
-                        header_up X-Forwarded-Proto {scheme}
-                }
-        }
+        # Redirect to HTTPS. This port used to serve the panel in the clear —
+        # the login form, the token it hands back, and a configuration carrying
+        # passwords. The port is substituted by this shell as the file is
+        # written: Caddy only sees 443 from inside the container, while the
+        # host publishes it as 8443.
+        redir https://{host}:${PUBLIC_HTTPS_PORT:-8443}{uri}
 }
 
 ${CLOUD_BLOCK}

{boneio-1.6.0.dev3 → boneio-1.6.0.dev5}/boneio/core/cloud/registration.py

@@ -41,9 +41,11 @@ KEY_FILE = CERT_DIR / "privkey.pem"
 
 # Caddy configuration paths
 CADDY_CONFIG_DIR = _DOCKER_DIR / "caddy"
-CADDY_DEFAULT_CONFIG = CADDY_CONFIG_DIR / "Caddyfile"
-CADDY_CLOUD_CONFIG = CADDY_CONFIG_DIR / "Caddyfile.cloud"
-CADDY_ACTIVE_CONFIG = CADDY_CONFIG_DIR / "Caddyfile"
+# No Caddyfile constants here on purpose. Caddy's configuration is not a file
+# in this directory — init-certs.sh (or init-certs-cloud.sh) writes it to
+# /tmp/Caddyfile inside the container on every start. Switching between local
+# and cloud mode swaps the compose file, and with it which of those two scripts
+# runs; there is no Caddyfile to copy over another.
 
 # Registration interval (1 hour)
 REGISTRATION_INTERVAL = 3600
@@ -637,3 +639,76 @@ class CloudRegistration:
             return "init-certs-cloud.sh" in content
         except Exception:
             return False
+
+
+async def set_enabled(config_helper, enabled: bool, local_ip: str | None = None) -> str:
+    """Turn cloud registration on or off on a running device.
+
+    Registration used to begin only in :mod:`boneio.runner`, so switching it on
+    from the panel wrote a line to config.yaml and asked for a restart —
+    on a controller whose whole point is that it is running. Everything the
+    change needs is already here: :meth:`CloudRegistration.start` does no more
+    than launch the loop that registers the name, fetches the certificate,
+    swaps the compose template and recreates Caddy.
+
+    Idempotent in both directions, because the panel can be open twice and a
+    save can be repeated.
+
+    Args:
+        config_helper: The live :class:`ConfigHelper`.
+        enabled: The state asked for.
+        local_ip: This device's address on the LAN. Read from the system when
+            not given.
+
+    Returns:
+        A short word for what happened: ``started``, ``stopped``, ``unchanged``
+        or ``unavailable``.
+    """
+    existing = getattr(config_helper, "_cloud_reg", None)
+
+    if not enabled:
+        config_helper._cloud_registration = False
+        if existing is None:
+            return "unchanged"
+        try:
+            await existing.stop()
+            # Put the plain template back, or Caddy keeps trying to serve a
+            # certificate for a name that is no longer being renewed.
+            await existing._restore_local_config()
+        except Exception as err:  # noqa: BLE001
+            _LOGGER.warning("Could not stop cloud registration cleanly: %s", err)
+        config_helper._cloud_reg = None
+        _LOGGER.info("Cloud registration stopped on request")
+        return "stopped"
+
+    if existing is not None:
+        config_helper._cloud_registration = True
+        return "unchanged"
+
+    serial = getattr(config_helper, "serial_number", None)
+    if not local_ip:
+        try:
+            from boneio.core.system.monitor import get_network_info
+
+            local_ip = (get_network_info() or {}).get("ip", "")
+        except Exception as err:  # noqa: BLE001
+            _LOGGER.warning("Could not read this device's address: %s", err)
+            local_ip = ""
+
+    if not serial or not local_ip:
+        # The setting is saved either way; the next start picks it up. Saying
+        # so is better than reporting success for a service that did not begin.
+        _LOGGER.warning(
+            "Cloud registration is enabled but %s is not known yet; it will "
+            "start on the next boot.",
+            "the serial number" if not serial else "this device's address",
+        )
+        config_helper._cloud_registration = True
+        return "unavailable"
+
+    registration = CloudRegistration(serial_number=serial, local_ip=local_ip)
+    await registration.start()
+    config_helper._cloud_reg = registration
+    config_helper._cloud_registration = True
+    _LOGGER.info("Cloud registration started for %s (IP: %s)", serial, local_ip)
+    return "started"

boneio-1.6.0.dev5/boneio/core/config/provenance.py

@@ -0,0 +1,114 @@
+"""Tell a freshly flashed controller from one that has been in service.
+
+The first-run wizard has two steps that are only appropriate on a blank
+device. The import step offers to restore a configuration, which on a device
+that already has one reads as "yours is gone". The devices step is worse than
+misleading: it replaces the whole ``event`` section, so a controller with fifty
+configured inputs loses them to a wizard its owner opened only to create an
+account.
+
+So the question has to be answered before those steps are offered, and the two
+ways of getting it wrong are not equally bad:
+
+  * Treating an upgraded device as fresh costs the owner their configuration.
+  * Treating a fresh device as upgraded costs them a step in a wizard; they
+    can still import and bind inputs from the normal interface afterwards.
+
+This module is therefore written to answer "is it fresh" and to say no when it
+cannot tell. Freshness has to be demonstrated, not assumed.
+
+The demonstration is that the configuration is still the factory one. The image
+copies a variant out of ``~/.cache/boneio_configs/<variant>/`` verbatim, and
+per-device work touches only ``mqtt.yaml`` (the broker password), so a
+controller nobody has configured yet still has a ``config.yaml`` byte-identical
+to its template.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+
+_LOGGER = logging.getLogger(__name__)
+
+#: Where the image leaves the per-variant templates it seeded the device from.
+FACTORY_TEMPLATE_DIR = Path.home() / ".cache" / "boneio_configs"
+
+
+def _digest(path: Path) -> bytes | None:
+    """Read a file for comparison.
+
+    Args:
+        path: File to read.
+
+    Returns:
+        Its contents, or None when it cannot be read.
+    """
+    try:
+        return path.read_bytes()
+    except OSError:
+        return None
+
+
+def looks_factory_fresh(
+    config_path: str | os.PathLike[str],
+    template_dir: str | os.PathLike[str] | None = None,
+) -> bool:
+    """Whether this device still carries an untouched factory configuration.
+
+    Args:
+        config_path: The device's ``config.yaml``.
+        template_dir: Where the per-variant templates live. Defaults to
+            :data:`FACTORY_TEMPLATE_DIR`.
+
+    Returns:
+        True only when freshness can be positively shown: there is no
+        configuration at all, or the configuration is identical to one of the
+        templates the image ships. False whenever the answer is not certain.
+    """
+    config = Path(config_path)
+    current = _digest(config)
+    if current is None:
+        # Nothing to lose, and nothing that an import could overwrite.
+        _LOGGER.debug("No configuration at %s — treating the device as fresh", config)
+        return True
+
+    root = Path(template_dir) if template_dir is not None else FACTORY_TEMPLATE_DIR
+    try:
+        variants = sorted(p for p in root.iterdir() if p.is_dir())
+    except OSError:
+        # No templates to compare against: the honest answer is "cannot tell",
+        # and the safe reading of that is "assume it has been configured".
+        _LOGGER.debug("No factory templates under %s — assuming configured", root)
+        return False
+
+    for variant in variants:
+        if current == _digest(variant / "config.yaml"):
+            _LOGGER.debug("Configuration matches the %s template", variant.name)
+            return True
+
+    return False
+
+
+def was_configured_before(
+    config_path: str | os.PathLike[str],
+    had_legacy_auth: bool = False,
+    template_dir: str | os.PathLike[str] | None = None,
+) -> bool:
+    """Whether the wizard should skip the steps that assume a blank device.
+
+    Args:
+        config_path: The device's ``config.yaml``.
+        had_legacy_auth: Whether a pre-1.6 ``web.auth`` block was found. It
+            proves the device is not fresh, but its absence proves nothing —
+            most 1.5.x controllers never had web authentication at all, which
+            is exactly the case this used to get wrong.
+        template_dir: Passed through to :func:`looks_factory_fresh`.
+
+    Returns:
+        True when the device already has a configuration of its own.
+    """
+    if had_legacy_auth:
+        return True
+    return not looks_factory_fresh(config_path, template_dir)

{boneio-1.6.0.dev3 → boneio-1.6.0.dev5}/boneio/core/config/yaml_patch.py

@@ -260,3 +260,124 @@ def ensure_section(config_file: str | Path, path: tuple[str, ...]) -> bool:
     file_path.write_text("".join(lines), encoding="utf-8")
     _LOGGER.info("Created section '%s' in %s", ".".join(path), file_path)
     return True
+
+
+def _find_section_line(lines: list[str], path: tuple[str, ...]) -> int | None:
+    """Index of the line declaring a nested key, or None if it is not there.
+
+    Args:
+        lines: File lines.
+        path: Section path, outermost first.
+
+    Returns:
+        The index of the key's own line, or None.
+    """
+    depth = 0
+    for index, line in enumerate(lines):
+        parsed = _line_key(line)
+        if parsed is None:
+            continue
+        key, indent, _ = parsed
+        if depth and indent <= (depth - 1) * len(INDENT):
+            return None
+        if key == path[depth] and indent == depth * len(INDENT):
+            depth += 1
+            if depth == len(path):
+                return index
+    return None
+
+
+def has_section(config_file: str | Path, path: tuple[str, ...]) -> bool:
+    """Whether a nested key is present in the file.
+
+    Separate from :func:`remove_section` so a caller can find out before doing
+    anything irreversible — such as writing a backup copy over the one it made
+    the last time it was asked.
+
+    Args:
+        config_file: Path to config.yaml.
+        path: Section path, outermost first.
+
+    Returns:
+        True when the key is there.
+
+    Raises:
+        YamlPatchError: If the path is empty.
+    """
+    if not path:
+        raise YamlPatchError("No section path given.")
+    lines = Path(config_file).read_text(encoding="utf-8").splitlines(keepends=True)
+    return _find_section_line(lines, path) is not None
+
+
+def remove_section(config_file: str | Path, path: tuple[str, ...]) -> bool:
+    """Delete a nested mapping key and everything under it.
+
+    Written for one job: taking the pre-1.6 ``web.auth`` block out of a
+    configuration after its account has been migrated into the hashed store.
+    Nothing reads it any more, and it still holds the owner's password in
+    plain text — in the file, and in every backup and diagnostic bundle made
+    since.
+
+    Line-based rather than a parse-and-dump, for the usual reason: the file
+    belongs to the owner, and round-tripping it through a YAML library would
+    return their comments, ordering and ``!include`` directives as something
+    they did not write.
+
+    Comment lines immediately above the key are removed with it. They describe
+    the block, and leaving them behind stranded over an unrelated setting is
+    worse than taking one comment too many.
+
+    Args:
+        config_file: Path to config.yaml.
+        path: Section path, outermost first, e.g. ``("web", "auth")``.
+
+    Returns:
+        True if something was removed, False if the key was not there.
+
+    Raises:
+        YamlPatchError: If the path is empty.
+    """
+    if not path:
+        raise YamlPatchError("No section path given.")
+
+    file_path = Path(config_file)
+    lines = file_path.read_text(encoding="utf-8").splitlines(keepends=True)
+
+    start = _find_section_line(lines, path)
+    if start is None:
+        return False
+    key_indent = len(lines[start]) - len(lines[start].lstrip())
+
+    # Everything indented under the key belongs to it, blank lines included
+    # while more indented content follows.
+    end = start + 1
+    while end < len(lines):
+        line = lines[end]
+        if not line.strip():
+            following = next(
+                (i for i in range(end + 1, len(lines)) if lines[i].strip()), None
+            )
+            if following is None:
+                break
+            next_indent = len(lines[following]) - len(lines[following].lstrip())
+            if next_indent <= key_indent:
+                break
+            end += 1
+            continue
+        indent = len(line) - len(line.lstrip())
+        if indent <= key_indent:
+            break
+        end += 1
+
+    # Take the comment block sitting directly on top of it.
+    while start > 0:
+        above = lines[start - 1].strip()
+        if above.startswith("#"):
+            start -= 1
+            continue
+        break
+
+    del lines[start:end]
+    file_path.write_text("".join(lines), encoding="utf-8")
+    return True

{boneio-1.6.0.dev3 → boneio-1.6.0.dev5}/boneio/core/containers.py

@@ -55,7 +55,12 @@ _FALLBACK: dict[str, list[str]] = {
     "restart-caddy": ["docker", "compose", "restart", CADDY_SERVICE],
     "reload-caddy": [
         "docker", "compose", "exec", CADDY_SERVICE,
-        "caddy", "reload", "--config", "/etc/caddy/Caddyfile",
+        # /tmp/Caddyfile, not /etc/caddy/Caddyfile: the container runs the
+        # file init-certs.sh writes on every start. /etc/caddy/Caddyfile is the
+        # stock config baked into the image, and reloading that swaps the
+        # working proxy for Caddy's welcome page — HTTPS goes down and stays
+        # down until the container is restarted.
+        "caddy", "reload", "--config", "/tmp/Caddyfile",
     ],
 }