zboxapi 0.0.7__tar.gz → 0.1.0__tar.gz

zboxapi-0.0.7/README.md → zboxapi-0.1.0/PKG-INFO

@@ -1,3 +1,24 @@
+Metadata-Version: 2.4
+Name: zboxapi
+Version: 0.1.0
+Summary: zPodFactory zBox API: DNS and VLAN management for the zbox VM
+Author: Kelby Valenti, Timo Sugliani
+Author-email: Kelby Valenti <kelby.valenti@gmail.com>, Timo Sugliani <timo.sugliani@gmail.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: FastAPI
+Classifier: Operating System :: POSIX :: Linux
+Requires-Dist: fastapi>=0.118
+Requires-Dist: pydantic>=2.12
+Requires-Dist: uvicorn>=0.37
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
 # zBoxApi
 
 zPodFactory zBox Api
@@ -29,6 +50,14 @@ Complete the following steps to set up zBox Api:
     pipx install zboxapi
     ```
 
+    Or with [uv](https://docs.astral.sh/uv/), which also fetches a suitable Python if needed:
+
+    ```bash
+    uv tool install zboxapi
+    ```
+
+    zBoxApi supports Python 3.10 through 3.14.
+
 1. Set up and start zboxapi.service
 
     ```bash
@@ -112,6 +141,40 @@ curl -X GET "http://127.0.0.1:8000/vlan" \
 For complete VLAN management documentation, see [DOC_VLAN.md](DOC_VLAN.md).
 
 
+## Development
+
+The project is managed with [uv](https://docs.astral.sh/uv/). Clone the repository, then:
+
+```bash
+uv sync                 # create .venv with the project and dev dependencies
+uv run pytest           # run the unit tests (no root, /etc or network access needed)
+uv run pytest --cov     # same, with a coverage report
+uv run ruff check src tests && uv run ruff format --check src tests
+```
+
+A `justfile` wraps the same commands (`just test`, `just lint`, `just format`).
+
+### Releasing
+
+Every change gets a line under `[Unreleased]` in [CHANGELOG.md](CHANGELOG.md). A release is
+one command:
+
+```bash
+python3 tools/release.py 0.2.0 --push      # or: just release 0.2.0
+```
+
+It turns `[Unreleased]` into a dated `[0.2.0]` section, bumps `pyproject.toml` and `uv.lock`,
+runs the tests, commits, tags `v0.2.0` and pushes. The tag then runs
+`.github/workflows/release.yml`, which publishes the changelog section as the GitHub release
+note, builds the package with `uv build`, publishes it to PyPI with `uv publish` and attaches
+the wheel and sdist to the release. See [tools/README.md](tools/README.md) for the details,
+including the one-time PyPI setup (an API token secret or trusted publishing).
+
+The test suite exercises every endpoint through FastAPI's `TestClient`. The hosts file,
+`/etc/zboxapi.conf`, `/etc/network/interfaces.d/` and the `vmtoolsd` password lookup are
+redirected to temporary locations, and the `ip`, `ifup`, `ifdown` and `pkill` commands are
+replaced by an in-memory fake, so the tests can run on any machine.
+
 ## Documentation
 
 - [DOC_DNS.md](DOC_DNS.md) - Complete guide to DNS management features

zboxapi-0.0.7/PKG-INFO → zboxapi-0.1.0/README.md

@@ -1,19 +1,3 @@
-Metadata-Version: 2.1
-Name: zboxapi
-Version: 0.0.7
-Summary: 
-Author: Kelby Valenti
-Author-email: kelby.valenti@gmail.com
-Requires-Python: >=3.10
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: fastapi (==0.111.0)
-Requires-Dist: ipython (>=8.24.0,<9.0.0)
-Requires-Dist: uvicorn (==0.29.0)
-Description-Content-Type: text/markdown
-
 # zBoxApi
 
 zPodFactory zBox Api
@@ -45,6 +29,14 @@ Complete the following steps to set up zBox Api:
     pipx install zboxapi
     ```
 
+    Or with [uv](https://docs.astral.sh/uv/), which also fetches a suitable Python if needed:
+
+    ```bash
+    uv tool install zboxapi
+    ```
+
+    zBoxApi supports Python 3.10 through 3.14.
+
 1. Set up and start zboxapi.service
 
     ```bash
@@ -128,8 +120,41 @@ curl -X GET "http://127.0.0.1:8000/vlan" \
 For complete VLAN management documentation, see [DOC_VLAN.md](DOC_VLAN.md).
 
 
+## Development
+
+The project is managed with [uv](https://docs.astral.sh/uv/). Clone the repository, then:
+
+```bash
+uv sync                 # create .venv with the project and dev dependencies
+uv run pytest           # run the unit tests (no root, /etc or network access needed)
+uv run pytest --cov     # same, with a coverage report
+uv run ruff check src tests && uv run ruff format --check src tests
+```
+
+A `justfile` wraps the same commands (`just test`, `just lint`, `just format`).
+
+### Releasing
+
+Every change gets a line under `[Unreleased]` in [CHANGELOG.md](CHANGELOG.md). A release is
+one command:
+
+```bash
+python3 tools/release.py 0.2.0 --push      # or: just release 0.2.0
+```
+
+It turns `[Unreleased]` into a dated `[0.2.0]` section, bumps `pyproject.toml` and `uv.lock`,
+runs the tests, commits, tags `v0.2.0` and pushes. The tag then runs
+`.github/workflows/release.yml`, which publishes the changelog section as the GitHub release
+note, builds the package with `uv build`, publishes it to PyPI with `uv publish` and attaches
+the wheel and sdist to the release. See [tools/README.md](tools/README.md) for the details,
+including the one-time PyPI setup (an API token secret or trusted publishing).
+
+The test suite exercises every endpoint through FastAPI's `TestClient`. The hosts file,
+`/etc/zboxapi.conf`, `/etc/network/interfaces.d/` and the `vmtoolsd` password lookup are
+redirected to temporary locations, and the `ip`, `ifup`, `ifdown` and `pkill` commands are
+replaced by an in-memory fake, so the tests can run on any machine.
+
 ## Documentation
 
 - [DOC_DNS.md](DOC_DNS.md) - Complete guide to DNS management features
 - [DOC_VLAN.md](DOC_VLAN.md) - Complete guide to VLAN management features
-

zboxapi-0.1.0/pyproject.toml

@@ -0,0 +1,72 @@
+[project]
+name = "zboxapi"
+version = "0.1.0"
+description = "zPodFactory zBox API: DNS and VLAN management for the zbox VM"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Framework :: FastAPI",
+    "Operating System :: POSIX :: Linux",
+]
+dependencies = [
+    "fastapi>=0.118",
+    "pydantic>=2.12",
+    "uvicorn>=0.37",
+]
+
+[[project.authors]]
+name = "Kelby Valenti"
+email = "kelby.valenti@gmail.com"
+
+[[project.authors]]
+name = "Timo Sugliani"
+email = "timo.sugliani@gmail.com"
+
+[project.scripts]
+zboxapi = "zboxapi.main:launch"
+
+[dependency-groups]
+dev = [
+    "httpx2>=0.1",
+    "ipython>=8.24",
+    "pytest>=8.3",
+    "pytest-cov>=6.0",
+    "ruff>=0.13",
+]
+
+[build-system]
+requires = ["uv_build>=0.9,<1"]
+build-backend = "uv_build"
+
+[tool.uv]
+required-version = ">=0.9"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.coverage.run]
+source = ["zboxapi"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "W",
+    "F",
+    "I",
+    "C",
+    "B",
+    "UP",
+]
+ignore = ["B008"]

zboxapi-0.1.0/pyproject.toml.orig

@@ -0,0 +1,70 @@
+[project]
+name = "zboxapi"
+version = "0.1.0"
+description = "zPodFactory zBox API: DNS and VLAN management for the zbox VM"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Kelby Valenti", email = "kelby.valenti@gmail.com" },
+    { name = "Timo Sugliani", email = "timo.sugliani@gmail.com" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Framework :: FastAPI",
+    "Operating System :: POSIX :: Linux",
+]
+dependencies = [
+    "fastapi>=0.118",
+    "pydantic>=2.12",
+    "uvicorn>=0.37",
+]
+
+[project.scripts]
+zboxapi = "zboxapi.main:launch"
+
+[dependency-groups]
+dev = [
+    "httpx2>=0.1",
+    "ipython>=8.24",
+    "pytest>=8.3",
+    "pytest-cov>=6.0",
+    "ruff>=0.13",
+]
+
+[build-system]
+requires = ["uv_build>=0.9,<1"]
+build-backend = "uv_build"
+
+[tool.uv]
+required-version = ">=0.9"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.coverage.run]
+source = ["zboxapi"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+
+[tool.ruff.lint]
+select = [
+    "E",  # pycodestyle errors
+    "W",  # pycodestyle warnings
+    "F",  # pyflakes
+    "I",  # isort
+    "C",  # flake8-comprehensions
+    "B",  # flake8-bugbear
+    "UP",  # pyupgrade
+]
+ignore = [
+    "B008",
+]

zboxapi-0.1.0/src/zboxapi/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("zboxapi")
+except PackageNotFoundError:  # pragma: no cover - running from a bare checkout
+    __version__ = "0.0.0"

{zboxapi-0.0.7 → zboxapi-0.1.0}/src/zboxapi/dns.py

@@ -12,11 +12,14 @@ from fastapi import APIRouter, HTTPException, status
 from pydantic import AfterValidator, BaseModel
 from pydantic_core import PydanticCustomError
 
+# Path of the hosts file managed by this API (module-level so tests can override)
+HOSTS_FILE = Path("/etc/hosts")
+
 
 @contextlib.contextmanager
 def get_hosts_file_object():
-    """Context manager for safely handling /etc/hosts file"""
-    pfile = Path("/etc/hosts")
+    """Context manager for safely handling the hosts file"""
+    pfile = HOSTS_FILE
     if not pfile.is_file():
         pfile.write_text("")
 
@@ -25,7 +28,7 @@ def get_hosts_file_object():
             file_handle = pfile.open("r+")
             fcntl.flock(file_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
             break
-        except IOError:  # noqa: UP024
+        except OSError:
             # File is locked, wait for a while and try again
             time.sleep(0.1)
 
@@ -105,19 +108,37 @@ def RecordAlreadyPresent(ip, hostname):
 
 
 def validate_hostname(value: str):
-    """Validate hostname format"""
-    if not 1 <= len(value) < 64:
-        raise PydanticCustomError("value_error", "Invalid hostname length")
-
-    #  Define pattern of DNS label
-    #  Can begin and end with a number or letter only
-    #  Can contain hyphens, a-z, A-Z, 0-9
-    #  1 - 63 chars allowed
-    hostname_re = re.compile(r"^[a-z0-9]([a-z-0-9-]{0,61}[a-z0-9])?$", re.IGNORECASE)
-
-    # Check that all labels match that pattern.
-    if not hostname_re.match(value):
-        raise PydanticCustomError("value_error", "Invalid hostname")
+    """Validate hostname format according to DNS standards"""
+    # Check total FQDN length (1-253 characters)
+    if not 1 <= len(value) <= 253:
+        raise PydanticCustomError(
+            "value_error",
+            f"Invalid hostname length: {len(value)} characters (must be 1-253)",
+        )
+
+    # Define pattern for individual DNS labels
+    # Each label: 1-63 chars, alphanumeric + hyphens, can't start/end with hyphen
+    label_re = re.compile(r"^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$", re.IGNORECASE)
+
+    # Check that all labels match the pattern and length requirements
+    for label in value.split("."):
+        if not label:  # Empty label (leading/trailing/consecutive dots)
+            raise PydanticCustomError("value_error", "Invalid hostname: empty label")
+
+        # Check individual label length (1-63 characters)
+        if len(label) > 63:
+            raise PydanticCustomError(
+                "value_error",
+                f"Invalid label length: '{label}' is {len(label)} characters "
+                "(must be 1-63)",
+            )
+
+        # Check label format (alphanumeric + hyphens, can't start/end with hyphen)
+        if not label_re.match(label):
+            raise PydanticCustomError(
+                "value_error", f"Invalid hostname label: '{label}'"
+            )
+
     return value
 
 

{zboxapi-0.0.7 → zboxapi-0.1.0}/src/zboxapi/main.py

@@ -1,12 +1,15 @@
+import functools
 import os
 import re
 import subprocess
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 from typing import Annotated
 
 import uvicorn
 from fastapi import Depends, FastAPI, HTTPException, Security, status
 from fastapi.routing import APIRoute
-from fastapi.security.api_key import APIKey, APIKeyHeader
+from fastapi.security.api_key import APIKeyHeader
 
 from zboxapi import __version__
 from zboxapi.dns import dns_router
@@ -15,17 +18,9 @@ from zboxapi.vlan import vlan_router
 api_key_header = APIKeyHeader(name="access_token", auto_error=False)
 
 
-def validate_api_key(api_key: Annotated[APIKey, Security(api_key_header)]):
-    """Validate API key for authentication"""
-    if api_key != ZPOD_PASSWORD:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Invalid access_token",
-        )
-
-
-def get_zpod_password():
-    """Retrieve zpod password from VMware tools"""
+@functools.cache
+def get_zpod_password() -> str:
+    """Retrieve zpod password from VMware tools (cached after first lookup)"""
     ovfenv = subprocess.run(
         ["vmtoolsd", "--cmd", "info-get guestinfo.ovfenv"],
         capture_output=True,
@@ -37,19 +32,30 @@ def get_zpod_password():
     raise Exception("Unable to retrieve zpod password")
 
 
-def simplify_operation_ids(api: FastAPI) -> None:
+def validate_api_key(api_key: Annotated[str | None, Security(api_key_header)]):
+    """Validate API key for authentication"""
+    if api_key != get_zpod_password():
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Invalid access_token",
+        )
+
+
+def generate_operation_id(route: APIRoute) -> str:
     """
-    Update operation IDs so that generated API clients have simpler function
-    names.
+    Build operation IDs as "<tag>_<function name>" so that generated API
+    clients have simpler function names (e.g. dns_dns_get_all).
     """
-    for route in api.routes:
-        if isinstance(route, APIRoute) and not route.operation_id:
-            tag = route.tags[0] if route.tags else "default"
-            route.operation_id = f"{tag}_{route.name}"
+    tag = route.tags[0] if route.tags else "default"
+    return f"{tag}_{route.name}"
 
 
-# Get zpod password for authentication
-ZPOD_PASSWORD = get_zpod_password()
+@asynccontextmanager
+async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+    """Resolve the zpod password at startup so a broken VM env fails fast"""
+    get_zpod_password()
+    yield
+
 
 # Get root path from environment
 zboxapi_root_path = os.getenv("ZBOXAPI_ROOT_PATH", None)
@@ -60,15 +66,14 @@ app = FastAPI(
     root_path=zboxapi_root_path,
     dependencies=[Depends(validate_api_key)],
     version=__version__,
+    lifespan=lifespan,
+    generate_unique_id_function=generate_operation_id,
 )
 
 # Include routers
 app.include_router(dns_router)
 app.include_router(vlan_router)
 
-# Simplify operation IDs
-simplify_operation_ids(app)
-
 
 def launch():
     """Launch the FastAPI application with uvicorn"""

{zboxapi-0.0.7 → zboxapi-0.1.0}/src/zboxapi/vlan.py

@@ -12,6 +12,10 @@ from fastapi import APIRouter, HTTPException, status
 from pydantic import AfterValidator, BaseModel, Field
 from pydantic_core import PydanticCustomError
 
+# Paths managed by this API (module-level so tests can override)
+CONFIG_FILE = Path("/etc/zboxapi.conf")
+INTERFACES_DIR = Path("/etc/network/interfaces.d")
+
 
 class ConfigError(Exception):
     """Configuration error"""
@@ -28,17 +32,20 @@ class NetworkError(Exception):
 def load_config() -> configparser.ConfigParser:
     """Load configuration from /etc/zboxapi.conf"""
     config = configparser.ConfigParser()
-    config_path = Path("/etc/zboxapi.conf")
+    config_path = CONFIG_FILE
 
     if not config_path.exists():
-        raise ConfigError("Configuration file /etc/zboxapi.conf not found")
+        raise ConfigError(f"Configuration file {config_path} not found")
 
     config.read(config_path)
     return config
 
 
 def get_config_value(
-    config: configparser.ConfigParser, section: str, key: str, default: str = None
+    config: configparser.ConfigParser,
+    section: str,
+    key: str,
+    default: str | None = None,
 ) -> str:
     """Get configuration value with optional default"""
     try:
@@ -115,7 +122,7 @@ def validate_cidr(cidr: str) -> str:
     """Validate CIDR notation, but preserve the original input."""
     try:
         # Parse the CIDR to validate it's correct
-        network = ipaddress.IPv4Network(cidr, strict=False)
+        ipaddress.IPv4Network(cidr, strict=False)
         # But return the original input, not the normalized network
         return cidr
     except ValueError as e:
@@ -150,7 +157,9 @@ def check_no_overlap(cidrs):
     return True
 
 
-def validate_vlan_networks(new_gateway: str, exclude_vlan_id: int = None) -> None:
+def validate_vlan_networks(
+    new_gateway: str, exclude_vlan_id: int | None = None
+) -> None:
     """Validate that a new gateway doesn't overlap with existing VLAN networks"""
     # Get all existing VLAN gateways
     existing_vlans = get_existing_vlans()
@@ -160,6 +169,13 @@ def validate_vlan_networks(new_gateway: str, exclude_vlan_id: int = None) -> Non
         # Skip the VLAN we're updating (if this is an update operation)
         if exclude_vlan_id is not None and vlan.vlan == exclude_vlan_id:
             continue
+        # System VLANs whose interface has no address carry a placeholder
+        # ("system-default" / "system-zpod") instead of a CIDR: nothing to
+        # compare against, so leave them out of the overlap check.
+        try:
+            ipaddress.ip_network(vlan.gateway, strict=False)
+        except ValueError:
+            continue
         all_gateways.append(vlan.gateway)
 
     # Check for overlaps
@@ -192,9 +208,9 @@ class VlanView(BaseModel):
 
 @contextlib.contextmanager
 def get_vlan_config_file_object(vlan_id: int):
-    """Context manager for safely handling VLAN configuration files in /etc/network/interfaces.d/"""
+    """Context manager for safely handling VLAN config files in interfaces.d/"""
     interface_name = get_interface_name()
-    config_dir = Path("/etc/network/interfaces.d")
+    config_dir = INTERFACES_DIR
     config_file = config_dir / f"{interface_name}.{vlan_id}.cfg"
 
     # Ensure the directory exists
@@ -205,7 +221,7 @@ def get_vlan_config_file_object(vlan_id: int):
             file_handle = config_file.open("w")  # Use write mode for individual files
             fcntl.flock(file_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
             break
-        except IOError:
+        except OSError:
             time.sleep(0.1)
 
     try:
@@ -215,108 +231,95 @@ def get_vlan_config_file_object(vlan_id: int):
         file_handle.close()
 
 
-def get_existing_vlans() -> list[VlanView]:
-    """Get all existing VLAN configurations from /etc/network/interfaces.d/ and system VLANs"""
-    interface_name = get_interface_name()
-    config_dir = Path("/etc/network/interfaces.d")
+def get_interface_status(interface_name_full: str) -> str:
+    """Return up if the interface exists and is up, otherwise down"""
+    try:
+        result = subprocess.run(
+            ["ip", "link", "show", interface_name_full],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0 and "UP" in result.stdout:
+            return "up"
+    except Exception:
+        pass
+    return "down"
 
-    vlans = []
 
-    # Add system default VLANs
-    system_vlans_default = get_system_vlans_default()
-    for vlan_id in system_vlans_default:
-        # Try to get actual gateway from ip addr command
-        gateway = "system-default"
-        interface_name_full = f"{interface_name}.{vlan_id}"
+def get_interface_gateway(interface_name_full: str) -> str | None:
+    """Return the first inet address (CIDR) of an interface, if any"""
+    try:
+        result = subprocess.run(
+            ["ip", "addr", "show", interface_name_full],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            ip_match = re.search(r"inet\s+(\d+\.\d+\.\d+\.\d+/\d+)", result.stdout)
+            if ip_match:
+                return ip_match.group(1)
+    except Exception:
+        pass
+    return None
 
-        # Check if interface is currently up
-        status = "down"
-        try:
-            result = subprocess.run(
-                ["ip", "link", "show", interface_name_full],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode == 0 and "UP" in result.stdout:
-                status = "up"
-        except Exception:
-            pass
 
-        try:
-            result = subprocess.run(
-                ["ip", "addr", "show", interface_name_full],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode == 0:
-                # Extract IP address from ip addr output
-                ip_match = re.search(r"inet\s+(\d+\.\d+\.\d+\.\d+/\d+)", result.stdout)
-                if ip_match:
-                    gateway = ip_match.group(1)
-        except Exception:
-            pass
-
-        vlans.append(
-            VlanView(
-                vlan=vlan_id,
-                gateway=gateway,
-                interface=interface_name_full,
-                status=status,
-                owner="system-default",
-            )
-        )
+def get_system_vlan_view(interface_name: str, vlan_id: int, owner: str) -> VlanView:
+    """Build the view of a system VLAN from the live interface state"""
+    interface_name_full = f"{interface_name}.{vlan_id}"
+    return VlanView(
+        vlan=vlan_id,
+        gateway=get_interface_gateway(interface_name_full) or owner,
+        interface=interface_name_full,
+        status=get_interface_status(interface_name_full),
+        owner=owner,
+    )
 
-    # Add system zPod VLANs
-    system_vlans_zpod = get_system_vlans_zpod()
-    for vlan_id in system_vlans_zpod:
-        # Try to get actual gateway from ip addr command
-        gateway = "system-zpod"
-        interface_name_full = f"{interface_name}.{vlan_id}"
 
-        # Check if interface is currently up
-        status = "down"
-        try:
-            result = subprocess.run(
-                ["ip", "link", "show", interface_name_full],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode == 0 and "UP" in result.stdout:
-                status = "up"
-        except Exception:
-            pass
+def get_user_vlan_view(
+    interface_name: str, vlan_id: int, config_file: Path
+) -> VlanView | None:
+    """Build the view of a user-defined VLAN from its interfaces.d config file"""
+    try:
+        content = config_file.read_text()
+    except OSError:
+        return None
 
-        try:
-            result = subprocess.run(
-                ["ip", "addr", "show", interface_name_full],
-                capture_output=True,
-                text=True,
-                check=False,
-            )
-            if result.returncode == 0:
-                # Extract IP address from ip addr output
-                ip_match = re.search(r"inet\s+(\d+\.\d+\.\d+\.\d+/\d+)", result.stdout)
-                if ip_match:
-                    gateway = ip_match.group(1)
-        except Exception:
-            pass
-
-        vlans.append(
-            VlanView(
-                vlan=vlan_id,
-                gateway=gateway,
-                interface=interface_name_full,
-                status=status,
-                owner="system-zpod",
-            )
-        )
+    # Extract gateway from the configuration
+    gateway_match = re.search(r"address\s+(\d+\.\d+\.\d+\.\d+/\d+)", content)
+    if not gateway_match:
+        return None
+
+    interface_name_full = f"{interface_name}.{vlan_id}"
+    return VlanView(
+        vlan=vlan_id,
+        gateway=gateway_match.group(1),
+        interface=interface_name_full,
+        status=get_interface_status(interface_name_full),
+        owner="user-defined",
+    )
 
-    # Add user-configured VLANs from /etc/network/interfaces.d/
+
+def get_existing_vlans() -> list[VlanView]:
+    """Get all VLANs: system VLANs from config plus user VLANs from interfaces.d/"""
+    interface_name = get_interface_name()
+    config_dir = INTERFACES_DIR
+
+    system_vlans_default = get_system_vlans_default()
+    system_vlans_zpod = get_system_vlans_zpod()
+
+    vlans = [
+        get_system_vlan_view(interface_name, vlan_id, "system-default")
+        for vlan_id in system_vlans_default
+    ]
+    vlans.extend(
+        get_system_vlan_view(interface_name, vlan_id, "system-zpod")
+        for vlan_id in system_vlans_zpod
+    )
+
+    # Add user-configured VLANs from interfaces.d/
     if config_dir.exists():
-        # Find all VLAN configuration files
         vlan_pattern = rf"{re.escape(interface_name)}\.(\d+)\.cfg$"
 
         for config_file in config_dir.glob(f"{interface_name}.*.cfg"):
@@ -330,44 +333,8 @@ def get_existing_vlans() -> list[VlanView]:
             if vlan_id in system_vlans_default or vlan_id in system_vlans_zpod:
                 continue
 
-            try:
-                with open(config_file, "r") as f:
-                    content = f.read()
-
-                # Extract gateway from the configuration
-                gateway_match = re.search(
-                    r"address\s+(\d+\.\d+\.\d+\.\d+/\d+)", content
-                )
-                if not gateway_match:
-                    continue
-
-                gateway = gateway_match.group(1)
-
-                # Check if interface is currently up
-                status = "down"
-                try:
-                    result = subprocess.run(
-                        ["ip", "link", "show", f"{interface_name}.{vlan_id}"],
-                        capture_output=True,
-                        text=True,
-                        check=False,
-                    )
-                    if result.returncode == 0 and "UP" in result.stdout:
-                        status = "up"
-                except Exception:
-                    pass
-
-                vlans.append(
-                    VlanView(
-                        vlan=vlan_id,
-                        gateway=gateway,
-                        interface=f"{interface_name}.{vlan_id}",
-                        status=status,
-                        owner="user-defined",
-                    )
-                )
-            except Exception:
-                continue  # Skip files that can't be read or parsed
+            if view := get_user_vlan_view(interface_name, vlan_id, config_file):
+                vlans.append(view)
 
     return sorted(vlans, key=lambda x: x.vlan)
 
@@ -381,8 +348,7 @@ def add_vlan_interface(vlan_id: int, gateway: str) -> None:
     validate_vlan_networks(gateway)
 
     # Check if VLAN configuration file already exists
-    config_dir = Path("/etc/network/interfaces.d")
-    config_file = config_dir / f"{interface_name}.{vlan_id}.cfg"
+    config_file = INTERFACES_DIR / f"{interface_name}.{vlan_id}.cfg"
 
     if config_file.exists():
         raise NetworkError(f"VLAN interface {interface_name}.{vlan_id} already exists")
@@ -404,12 +370,11 @@ def update_vlan_interface(vlan_id: int, gateway: str) -> None:
     interface_name = get_interface_name()
     mtu = get_mtu()
 
-    # Validate inputs - check for overlaps and gateway uniqueness, excluding current VLAN
+    # Validate inputs - check for overlaps, excluding the VLAN being updated
     validate_vlan_networks(gateway, exclude_vlan_id=vlan_id)
 
     # Check if VLAN configuration file exists
-    config_dir = Path("/etc/network/interfaces.d")
-    config_file = config_dir / f"{interface_name}.{vlan_id}.cfg"
+    config_file = INTERFACES_DIR / f"{interface_name}.{vlan_id}.cfg"
 
     if not config_file.exists():
         raise NetworkError(f"VLAN interface {interface_name}.{vlan_id} does not exist")
@@ -429,8 +394,7 @@ iface {interface_name}.{vlan_id} inet static
 def delete_vlan_interface(vlan_id: int) -> None:
     """Delete VLAN interface configuration from /etc/network/interfaces.d/"""
     interface_name = get_interface_name()
-    config_dir = Path("/etc/network/interfaces.d")
-    config_file = config_dir / f"{interface_name}.{vlan_id}.cfg"
+    config_file = INTERFACES_DIR / f"{interface_name}.{vlan_id}.cfg"
 
     if not config_file.exists():
         raise NetworkError(f"VLAN interface {interface_name}.{vlan_id} does not exist")
@@ -572,6 +536,9 @@ def vlan_update(vlan_id: int, vlan_in: VlanUpdate) -> VlanView:
             status="up",
             owner="user-defined",
         )
+    except PydanticCustomError as e:
+        # System VLANs are forbidden from modification
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(e)) from e
     except (ConfigError, NetworkError) as e:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
@@ -590,10 +557,13 @@ def vlan_delete(vlan_id: int) -> dict:
         # Validate VLAN ID
         validate_vlan_id(vlan_id)
 
-        # Delete VLAN interface configuration (includes bringing down and deleting interface)
+        # Delete VLAN configuration (brings the interface down first)
         delete_vlan_interface(vlan_id)
 
         return {"message": f"VLAN {vlan_id} deleted successfully"}
+    except PydanticCustomError as e:
+        # System VLANs are forbidden from modification
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=str(e)) from e
     except (ConfigError, NetworkError) as e:
         raise HTTPException(
             status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)

zboxapi-0.0.7/pyproject.toml

@@ -1,43 +0,0 @@
-[tool.poetry]
-name = "zboxapi"
-version = "0.0.7"
-description = ""
-authors = ["Kelby Valenti <kelby.valenti@gmail.com>", "Timo Sugliani <timo.sugliani@gmail.com>"]
-readme = "README.md"
-
-[tool.poetry.scripts]
-zboxapi = "zboxapi.main:launch"
-
-[tool.poetry.dependencies]
-fastapi = "0.111.0"
-python = ">=3.10"
-uvicorn = "0.29.0"
-ipython = "^8.24.0"
-
-[tool.poetry.group.dev.dependencies]
-ruff = "^0.4"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"
-
-[tool.ruff.lint]
-select = [
-    "E",  # pycodestyle errors
-    "W",  # pycodestyle warnings
-    "F",  # pyflakes
-    "I",  # isort
-    "C",  # flake8-comprehensions
-    "B",  # flake8-bugbear
-    "UP",  # pyupgrade
-]
-ignore = [
-    "B008",
-]
-
-[[tool.poetry_bumpversion.replacements]]
-files = [
-    "src/zboxapi/__init__.py",
-]
-search = '__version__ = "{current_version}"'
-replace = '__version__ = "{new_version}"'

zboxapi-0.0.7/src/zboxapi/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.7"