zboxapi 0.0.6__tar.gz → 0.0.7__tar.gz

zboxapi-0.0.7/PKG-INFO

@@ -0,0 +1,135 @@
+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
+
+## Features
+
+- **DNS Management**: Manage DNS records in `/etc/hosts` with automatic dnsmasq integration
+- **VLAN Management**: Manage VLAN interfaces with automatic network configuration
+
+## Installation
+
+Complete the following steps to set up zBox Api:
+
+1. Install pipx
+
+    ```bash
+    # Install and configure pipx
+    apt update
+    apt install -y pipx
+    pipx ensurepath
+
+    # Reload your profile
+    source ~/.zshrc
+    ```
+
+1. Install zBoxApi:
+
+    ```bash
+    pipx install zboxapi
+    ```
+
+1. Set up and start zboxapi.service
+
+    ```bash
+    cp zboxapi.service /etc/systemd/system
+    systemctl daemon-reload
+    systemctl enable zboxapi.service
+    systemctl start zboxapi.service
+    ```
+
+    **Note**: The service runs on `127.0.0.1:8000` and requires root privileges for network configuration operations.
+
+## Configuration
+
+### VLAN Management
+
+For VLAN management functionality, create a configuration file at `/etc/zboxapi.conf`:
+
+```ini
+[DEFAULT]
+# Base interface name for VLAN management
+interface = eth1
+
+# MTU setting for VLAN interfaces
+mtu = 1700
+
+# System default VLANs that cannot be modified (comma-separated)
+system_vlans_default = 10,20,30
+
+# System zPod VLANs that cannot be modified (comma-separated)
+system_vlans_zpod = 64,128,192
+```
+
+See [DOC_VLAN.md](DOC_VLAN.md) for detailed documentation on VLAN management features.
+
+## API Usage
+
+### Authentication
+
+All API endpoints require authentication using the `access_token` header. The API key is the zPod password which is also the root password of the zbox VM. The password is automatically retrieved from VMware tools:
+
+```bash
+curl -H "access_token: your_zpod_password" http://127.0.0.1:8000/dns
+```
+
+**Note**: The service runs on `127.0.0.1:8000` and requires root privileges for network configuration operations.
+
+### DNS Management
+
+Manage DNS records in `/etc/hosts`:
+
+```bash
+# Add DNS record
+curl -X POST "http://127.0.0.1:8000/dns" \
+     -H "access_token: your_zpod_password" \
+     -H "Content-Type: application/json" \
+     -d '{"ip": "192.168.1.100", "hostname": "example.com"}'
+
+# List all DNS records
+curl -X GET "http://127.0.0.1:8000/dns" \
+     -H "access_token: your_zpod_password"
+```
+
+For complete DNS management documentation, see [DOC_DNS.md](DOC_DNS.md).
+
+### VLAN Management
+
+Manage VLAN interfaces:
+
+```bash
+# Create VLAN interface
+curl -X POST "http://127.0.0.1:8000/vlan" \
+     -H "access_token: your_zpod_password" \
+     -H "Content-Type: application/json" \
+     -d '{"vlan": 2000, "gateway": "192.168.42.129/25"}'
+
+# List all VLAN interfaces
+curl -X GET "http://127.0.0.1:8000/vlan" \
+     -H "access_token: your_zpod_password"
+```
+
+For complete VLAN management documentation, see [DOC_VLAN.md](DOC_VLAN.md).
+
+
+## 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.0.7/README.md

@@ -0,0 +1,118 @@
+# zBoxApi
+
+zPodFactory zBox Api
+
+## Features
+
+- **DNS Management**: Manage DNS records in `/etc/hosts` with automatic dnsmasq integration
+- **VLAN Management**: Manage VLAN interfaces with automatic network configuration
+
+## Installation
+
+Complete the following steps to set up zBox Api:
+
+1. Install pipx
+
+    ```bash
+    # Install and configure pipx
+    apt update
+    apt install -y pipx
+    pipx ensurepath
+
+    # Reload your profile
+    source ~/.zshrc
+    ```
+
+1. Install zBoxApi:
+
+    ```bash
+    pipx install zboxapi
+    ```
+
+1. Set up and start zboxapi.service
+
+    ```bash
+    cp zboxapi.service /etc/systemd/system
+    systemctl daemon-reload
+    systemctl enable zboxapi.service
+    systemctl start zboxapi.service
+    ```
+
+    **Note**: The service runs on `127.0.0.1:8000` and requires root privileges for network configuration operations.
+
+## Configuration
+
+### VLAN Management
+
+For VLAN management functionality, create a configuration file at `/etc/zboxapi.conf`:
+
+```ini
+[DEFAULT]
+# Base interface name for VLAN management
+interface = eth1
+
+# MTU setting for VLAN interfaces
+mtu = 1700
+
+# System default VLANs that cannot be modified (comma-separated)
+system_vlans_default = 10,20,30
+
+# System zPod VLANs that cannot be modified (comma-separated)
+system_vlans_zpod = 64,128,192
+```
+
+See [DOC_VLAN.md](DOC_VLAN.md) for detailed documentation on VLAN management features.
+
+## API Usage
+
+### Authentication
+
+All API endpoints require authentication using the `access_token` header. The API key is the zPod password which is also the root password of the zbox VM. The password is automatically retrieved from VMware tools:
+
+```bash
+curl -H "access_token: your_zpod_password" http://127.0.0.1:8000/dns
+```
+
+**Note**: The service runs on `127.0.0.1:8000` and requires root privileges for network configuration operations.
+
+### DNS Management
+
+Manage DNS records in `/etc/hosts`:
+
+```bash
+# Add DNS record
+curl -X POST "http://127.0.0.1:8000/dns" \
+     -H "access_token: your_zpod_password" \
+     -H "Content-Type: application/json" \
+     -d '{"ip": "192.168.1.100", "hostname": "example.com"}'
+
+# List all DNS records
+curl -X GET "http://127.0.0.1:8000/dns" \
+     -H "access_token: your_zpod_password"
+```
+
+For complete DNS management documentation, see [DOC_DNS.md](DOC_DNS.md).
+
+### VLAN Management
+
+Manage VLAN interfaces:
+
+```bash
+# Create VLAN interface
+curl -X POST "http://127.0.0.1:8000/vlan" \
+     -H "access_token: your_zpod_password" \
+     -H "Content-Type: application/json" \
+     -d '{"vlan": 2000, "gateway": "192.168.42.129/25"}'
+
+# List all VLAN interfaces
+curl -X GET "http://127.0.0.1:8000/vlan" \
+     -H "access_token: your_zpod_password"
+```
+
+For complete VLAN management documentation, see [DOC_VLAN.md](DOC_VLAN.md).
+
+
+## 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.0.6 → zboxapi-0.0.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zboxapi"
-version = "0.0.6"
+version = "0.0.7"
 description = ""
 authors = ["Kelby Valenti <kelby.valenti@gmail.com>", "Timo Sugliani <timo.sugliani@gmail.com>"]
 readme = "README.md"

zboxapi-0.0.7/src/zboxapi/__init__.py

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

zboxapi-0.0.6/src/zboxapi/main.py → zboxapi-0.0.7/src/zboxapi/dns.py

@@ -1,6 +1,5 @@
 import contextlib
 import fcntl
-import os
 import re
 import socket
 import subprocess
@@ -9,20 +8,14 @@ from ipaddress import IPv4Address
 from pathlib import Path
 from typing import IO, Annotated
 
-import uvicorn
-from fastapi import APIRouter, Depends, FastAPI, HTTPException, Security, status
-from fastapi.routing import APIRoute
-from fastapi.security.api_key import APIKey, APIKeyHeader
+from fastapi import APIRouter, HTTPException, status
 from pydantic import AfterValidator, BaseModel
 from pydantic_core import PydanticCustomError
 
-from zboxapi import __version__
-
-api_key_header = APIKeyHeader(name="access_token", auto_error=False)
-
 
 @contextlib.contextmanager
 def get_hosts_file_object():
+    """Context manager for safely handling /etc/hosts file"""
     pfile = Path("/etc/hosts")
     if not pfile.is_file():
         pfile.write_text("")
@@ -44,6 +37,7 @@ def get_hosts_file_object():
 
 
 def get_hosts_lines(hosts_fo: IO) -> list[dict[str, str]]:
+    """Parse hosts file and return list of IP-hostname mappings"""
     lines = []
     for line in hosts_fo.read().splitlines():
         line = line.strip()
@@ -62,6 +56,7 @@ def filter_hosts_file(
     ip: IPv4Address | None = None,
     hostname: str | None = None,
 ):
+    """Filter hosts file lines by IP and/or hostname"""
     return [
         line
         for line in lines
@@ -71,33 +66,15 @@ def filter_hosts_file(
 
 
 def write_hosts_file(hosts_fo: IO, lines: list[dict[str, str]]):
+    """Write hosts file lines back to file"""
     lines.sort(key=sort_hosts_lines)
     hosts_fo.seek(0)
     hosts_fo.truncate()
     hosts_fo.writelines([f"{line['ip']}\t{line['hostname']}\n" for line in lines])
 
 
-def validate_api_key(api_key: Annotated[APIKey, Security(api_key_header)]):
-    if api_key != ZPOD_PASSWORD:
-        raise HTTPException(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail="Invalid access_token",
-        )
-
-
-def get_zpod_password():
-    ovfenv = subprocess.run(
-        ["vmtoolsd", "--cmd", "info-get guestinfo.ovfenv"],
-        capture_output=True,
-        text=True,
-    )
-    pw_re = re.compile(r'<Property oe:key="guestinfo.password" oe:value="([^"]*)"/>')
-    if item := re.search(pw_re, ovfenv.stdout):
-        return item[1]
-    raise Exception("Unable to retrieve zpod password")
-
-
 def dnsmasq_sighup():
+    """Send SIGHUP to dnsmasq to reload configuration"""
     print("Send SIGHUP to dnsmasq...")
     subprocess.call(["pkill", "-SIGHUP", "dnsmasq"])
 
@@ -111,18 +88,8 @@ def sort_hosts_lines(item: dict):
     )
 
 
-def simplify_operation_ids(api: FastAPI) -> None:
-    """
-    Update operation IDs so that generated API clients have simpler function
-    names.
-    """
-    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}"
-
-
 def RecordNotFound(ip, hostname):
+    """Return HTTPException for DNS record not found"""
     return HTTPException(
         status_code=status.HTTP_404_NOT_FOUND,
         detail=f"DNS record not found: ip={ip}, hostname={hostname}",
@@ -130,6 +97,7 @@ def RecordNotFound(ip, hostname):
 
 
 def RecordAlreadyPresent(ip, hostname):
+    """Return HTTPException for DNS record already present"""
     return HTTPException(
         status_code=status.HTTP_406_NOT_ACCEPTABLE,
         detail=f"DNS record already present: ip={ip}, hostname={hostname}",
@@ -137,7 +105,8 @@ def RecordAlreadyPresent(ip, hostname):
 
 
 def validate_hostname(value: str):
-    if not 1 < len(value) < 64:
+    """Validate hostname format"""
+    if not 1 <= len(value) < 64:
         raise PydanticCustomError("value_error", "Invalid hostname length")
 
     #  Define pattern of DNS label
@@ -156,40 +125,44 @@ HOSTNAME = Annotated[str, AfterValidator(validate_hostname)]
 
 
 class DnsCreate(BaseModel):
-    ip: IPv4Address
-    hostname: HOSTNAME
+    """Model for creating DNS records"""
 
-
-class DnsDelete(BaseModel):
     ip: IPv4Address
     hostname: HOSTNAME
 
 
 class DnsUpdate(BaseModel):
+    """Model for updating DNS records"""
+
     ip: IPv4Address
     hostname: HOSTNAME
 
 
 class DnsView(BaseModel):
+    """Model for viewing DNS records"""
+
     ip: IPv4Address
     hostname: str
 
 
+# API Router
 dns_router = APIRouter(prefix="/dns", tags=["dns"])
 
 
-@dns_router.get("")
+@dns_router.get("", response_model=list[DnsView])
 def dns_get_all() -> list[DnsView]:
+    """Get all DNS records"""
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
     return hosts_lines
 
 
-@dns_router.get("/{ip}/{hostname}")
+@dns_router.get("/{ip}/{hostname}", response_model=DnsView)
 def dns_get(
     ip: IPv4Address,
     hostname: HOSTNAME,
 ) -> DnsView:
+    """Get specific DNS record"""
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
         hosts_lines = filter_hosts_file(hosts_lines, ip, hostname)
@@ -198,10 +171,11 @@ def dns_get(
     return hosts_lines[0]
 
 
-@dns_router.post("")
+@dns_router.post("", response_model=list[DnsView])
 def dns_add(
     dns_in: DnsCreate,
 ) -> list[DnsView]:
+    """Add DNS record"""
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
         if filter_hosts_file(hosts_lines, dns_in.ip, dns_in.hostname):
@@ -212,12 +186,13 @@ def dns_add(
     return hosts_lines
 
 
-@dns_router.put("/{ip}/{hostname}")
+@dns_router.put("/{ip}/{hostname}", response_model=list[DnsView])
 def dns_update(
     ip: IPv4Address,
     hostname: HOSTNAME,
     dns_in: DnsUpdate,
 ) -> list[DnsView]:
+    """Update DNS record"""
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
         key = {"ip": ip, "hostname": hostname}
@@ -230,11 +205,12 @@ def dns_update(
     return hosts_lines
 
 
-@dns_router.delete("/{ip}/{hostname}")
+@dns_router.delete("/{ip}/{hostname}", response_model=list[DnsView])
 def dns_delete(
     ip: IPv4Address,
     hostname: HOSTNAME,
 ) -> list[DnsView]:
+    """Delete DNS record"""
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
         key = {"ip": ip, "hostname": hostname}
@@ -244,29 +220,3 @@ def dns_delete(
         write_hosts_file(hosts_fo, hosts_lines)
     dnsmasq_sighup()
     return hosts_lines
-
-
-zboxapi_root_path = os.getenv("ZBOXAPI_ROOT_PATH", None)
-
-app = FastAPI(
-    title="zBox API",
-    root_path=zboxapi_root_path,
-    dependencies=[Depends(validate_api_key)],
-    version=__version__,
-)
-app.include_router(dns_router)
-simplify_operation_ids(app)
-
-ZPOD_PASSWORD = get_zpod_password()
-
-
-def launch():
-    uvicorn.run(
-        app,
-        host="127.0.0.1",
-        port=8000,
-    )
-
-
-if __name__ == "__main__":
-    launch()

zboxapi-0.0.7/src/zboxapi/main.py

@@ -0,0 +1,83 @@
+import os
+import re
+import subprocess
+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 zboxapi import __version__
+from zboxapi.dns import dns_router
+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"""
+    ovfenv = subprocess.run(
+        ["vmtoolsd", "--cmd", "info-get guestinfo.ovfenv"],
+        capture_output=True,
+        text=True,
+    )
+    pw_re = re.compile(r'<Property oe:key="guestinfo.password" oe:value="([^"]*)"/>')
+    if item := re.search(pw_re, ovfenv.stdout):
+        return item[1]
+    raise Exception("Unable to retrieve zpod password")
+
+
+def simplify_operation_ids(api: FastAPI) -> None:
+    """
+    Update operation IDs so that generated API clients have simpler function
+    names.
+    """
+    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}"
+
+
+# Get zpod password for authentication
+ZPOD_PASSWORD = get_zpod_password()
+
+# Get root path from environment
+zboxapi_root_path = os.getenv("ZBOXAPI_ROOT_PATH", None)
+
+# Create FastAPI application
+app = FastAPI(
+    title="zBox API",
+    root_path=zboxapi_root_path,
+    dependencies=[Depends(validate_api_key)],
+    version=__version__,
+)
+
+# 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"""
+    uvicorn.run(
+        app,
+        host="127.0.0.1",
+        port=8000,
+    )
+
+
+if __name__ == "__main__":
+    launch()

zboxapi-0.0.7/src/zboxapi/vlan.py

@@ -0,0 +1,709 @@
+import configparser
+import contextlib
+import fcntl
+import ipaddress
+import re
+import subprocess
+import time
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, status
+from pydantic import AfterValidator, BaseModel, Field
+from pydantic_core import PydanticCustomError
+
+
+class ConfigError(Exception):
+    """Configuration error"""
+
+    pass
+
+
+class NetworkError(Exception):
+    """Network configuration error"""
+
+    pass
+
+
+def load_config() -> configparser.ConfigParser:
+    """Load configuration from /etc/zboxapi.conf"""
+    config = configparser.ConfigParser()
+    config_path = Path("/etc/zboxapi.conf")
+
+    if not config_path.exists():
+        raise ConfigError("Configuration file /etc/zboxapi.conf not found")
+
+    config.read(config_path)
+    return config
+
+
+def get_config_value(
+    config: configparser.ConfigParser, section: str, key: str, default: str = None
+) -> str:
+    """Get configuration value with optional default"""
+    try:
+        return config.get(section, key)
+    except (configparser.NoSectionError, configparser.NoOptionError):
+        if default is not None:
+            return default
+        raise ConfigError(f"Configuration missing: [{section}] {key}") from None
+
+
+def get_system_vlans_default() -> list[int]:
+    """Get system default VLANs from configuration"""
+    config = load_config()
+    system_vlans_str = get_config_value(
+        config, "DEFAULT", "system_vlans_default", "10,20,30"
+    )
+    try:
+        return [int(v.strip()) for v in system_vlans_str.split(",")]
+    except ValueError as e:
+        raise ConfigError("Invalid system_vlans_default configuration") from e
+
+
+def get_system_vlans_zpod() -> list[int]:
+    """Get system zPod VLANs from configuration"""
+    config = load_config()
+    system_vlans_str = get_config_value(
+        config, "DEFAULT", "system_vlans_zpod", "64,128,192"
+    )
+    try:
+        return [int(v.strip()) for v in system_vlans_str.split(",")]
+    except ValueError as e:
+        raise ConfigError("Invalid system_vlans_zpod configuration") from e
+
+
+def get_interface_name() -> str:
+    """Get interface name from configuration"""
+    config = load_config()
+    return get_config_value(config, "DEFAULT", "interface", "eth1")
+
+
+def get_mtu() -> int:
+    """Get MTU from configuration"""
+    config = load_config()
+    try:
+        return int(get_config_value(config, "DEFAULT", "mtu", "1700"))
+    except ValueError as e:
+        raise ConfigError("Invalid MTU configuration") from e
+
+
+def validate_vlan_id(vlan_id: int) -> int:
+    """Validate VLAN ID is in valid range and not a system VLAN"""
+    if not 1 <= vlan_id <= 4094:
+        raise PydanticCustomError("value_error", "VLAN ID must be between 1 and 4094")
+
+    system_vlans_default = get_system_vlans_default()
+    system_vlans_zpod = get_system_vlans_zpod()
+
+    if vlan_id in system_vlans_default:
+        raise PydanticCustomError(
+            "value_error",
+            f"VLAN {vlan_id} is a system default VLAN and cannot be modified",
+        )
+
+    if vlan_id in system_vlans_zpod:
+        raise PydanticCustomError(
+            "value_error",
+            f"VLAN {vlan_id} is a system zPod VLAN and cannot be modified",
+        )
+
+    return vlan_id
+
+
+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)
+        # But return the original input, not the normalized network
+        return cidr
+    except ValueError as e:
+        raise PydanticCustomError("value_error", f"Invalid CIDR: {e}") from e
+
+
+def check_no_overlap(cidrs):
+    """
+    Check a list of CIDR networks for overlaps.
+    Raises ValueError if any two networks overlap.
+
+    Args:
+        cidrs (list[str]): List of CIDR notation strings (e.g., "192.168.0.0/24").
+
+    Returns:
+        bool: True if no overlaps are found.
+
+    Raises:
+        ValueError: If any two networks overlap.
+    """
+    # Parse strings into IPv4Network/IPv6Network objects with strict=False
+    # This allows host addresses like 172.16.10.1/24 to be converted to 172.16.10.0/24
+    networks = [ipaddress.ip_network(cidr, strict=False) for cidr in cidrs]
+
+    # Compare each pair for overlap
+    for i, net1 in enumerate(networks):
+        for net2 in networks[i + 1 :]:
+            if net1.overlaps(net2):
+                raise ValueError(f"Networks {net1} and {net2} overlap")
+
+    # No overlaps detected
+    return True
+
+
+def validate_vlan_networks(new_gateway: str, exclude_vlan_id: int = None) -> None:
+    """Validate that a new gateway doesn't overlap with existing VLAN networks"""
+    # Get all existing VLAN gateways
+    existing_vlans = get_existing_vlans()
+    all_gateways = [new_gateway]  # Include the new gateway
+
+    for vlan in existing_vlans:
+        # 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
+        all_gateways.append(vlan.gateway)
+
+    # Check for overlaps
+    try:
+        check_no_overlap(all_gateways)
+    except ValueError as e:
+        raise NetworkError(f"Network overlap detected: {e}") from e
+
+
+VLAN_ID = Annotated[int, AfterValidator(validate_vlan_id)]
+CIDR = Annotated[str, AfterValidator(validate_cidr)]
+
+
+class VlanCreate(BaseModel):
+    vlan: VLAN_ID = Field(..., description="VLAN ID (1-4094, excluding system VLANs)")
+    gateway: CIDR = Field(..., description="Gateway IP address in CIDR notation")
+
+
+class VlanUpdate(BaseModel):
+    gateway: CIDR = Field(..., description="Gateway IP address in CIDR notation")
+
+
+class VlanView(BaseModel):
+    vlan: int
+    gateway: str
+    interface: str
+    status: str
+    owner: str
+
+
+@contextlib.contextmanager
+def get_vlan_config_file_object(vlan_id: int):
+    """Context manager for safely handling VLAN configuration files in /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"
+
+    # Ensure the directory exists
+    config_dir.mkdir(mode=0o755, exist_ok=True)
+
+    while True:
+        try:
+            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:
+            time.sleep(0.1)
+
+    try:
+        yield file_handle
+    finally:
+        fcntl.flock(file_handle, fcntl.LOCK_UN)
+        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")
+
+    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}"
+
+        # 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",
+            )
+        )
+
+    # 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
+
+        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",
+            )
+        )
+
+    # Add user-configured VLANs from /etc/network/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"):
+            match = re.match(vlan_pattern, config_file.name)
+            if not match:
+                continue
+
+            vlan_id = int(match.group(1))
+
+            # Skip if this is a system VLAN (already added above)
+            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
+
+    return sorted(vlans, key=lambda x: x.vlan)
+
+
+def add_vlan_interface(vlan_id: int, gateway: str) -> None:
+    """Add VLAN interface configuration to /etc/network/interfaces.d/"""
+    interface_name = get_interface_name()
+    mtu = get_mtu()
+
+    # Validate inputs - check for overlaps and gateway uniqueness
+    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"
+
+    if config_file.exists():
+        raise NetworkError(f"VLAN interface {interface_name}.{vlan_id} already exists")
+
+    # Create VLAN configuration
+    vlan_config = f"""auto {interface_name}.{vlan_id}
+iface {interface_name}.{vlan_id} inet static
+    address {gateway}
+    mtu {mtu}
+"""
+
+    # Write to dedicated configuration file
+    with get_vlan_config_file_object(vlan_id) as f:
+        f.write(vlan_config)
+
+
+def update_vlan_interface(vlan_id: int, gateway: str) -> None:
+    """Update VLAN interface configuration in /etc/network/interfaces.d/"""
+    interface_name = get_interface_name()
+    mtu = get_mtu()
+
+    # Validate inputs - check for overlaps and gateway uniqueness, excluding current VLAN
+    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"
+
+    if not config_file.exists():
+        raise NetworkError(f"VLAN interface {interface_name}.{vlan_id} does not exist")
+
+    # Create updated VLAN configuration
+    vlan_config = f"""auto {interface_name}.{vlan_id}
+iface {interface_name}.{vlan_id} inet static
+    address {gateway}
+    mtu {mtu}
+"""
+
+    # Write updated configuration to file
+    with get_vlan_config_file_object(vlan_id) as f:
+        f.write(vlan_config)
+
+
+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"
+
+    if not config_file.exists():
+        raise NetworkError(f"VLAN interface {interface_name}.{vlan_id} does not exist")
+
+    interface_name_full = f"{interface_name}.{vlan_id}"
+
+    # Step 1: Bring interface down
+    try:
+        bring_interface_down(interface_name_full)
+        print(f"Interface {interface_name_full} brought down")
+    except Exception as e:
+        print(f"Warning: Could not bring down interface {interface_name_full}: {e}")
+        # Continue with deletion even if interface is already down
+
+    # Step 2: Delete the configuration file
+    try:
+        config_file.unlink()
+        print(f"Configuration file {config_file} deleted")
+    except Exception as e:
+        raise NetworkError(f"Failed to delete VLAN configuration file: {e}") from e
+
+
+def bring_interface_up(interface_name: str) -> None:
+    """Bring up a network interface"""
+    try:
+        subprocess.run(
+            ["ifup", interface_name], check=True, capture_output=True, text=True
+        )
+    except subprocess.CalledProcessError as e:
+        raise NetworkError(
+            f"Failed to bring up interface {interface_name}: {e.stderr}"
+        ) from e
+
+
+def bring_interface_down(interface_name: str) -> None:
+    """Bring down a network interface"""
+    try:
+        subprocess.run(
+            ["ifdown", interface_name], check=True, capture_output=True, text=True
+        )
+    except subprocess.CalledProcessError as e:
+        raise NetworkError(
+            f"Failed to bring down interface {interface_name}: {e.stderr}"
+        ) from e
+
+
+# API Router
+vlan_router = APIRouter(prefix="/vlan", tags=["vlan"])
+
+
+@vlan_router.get("", response_model=list[VlanView])
+def vlan_get_all() -> list[VlanView]:
+    """Get all VLAN interfaces"""
+    try:
+        return get_existing_vlans()
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get VLAN interfaces: {str(e)}",
+        ) from e
+
+
+@vlan_router.get("/{vlan_id}", response_model=VlanView)
+def vlan_get(vlan_id: int) -> VlanView:
+    """Get specific VLAN interface"""
+    try:
+        vlans = get_existing_vlans()
+        for vlan in vlans:
+            if vlan.vlan == vlan_id:
+                return vlan
+
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail=f"VLAN {vlan_id} not found"
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to get VLAN {vlan_id}: {str(e)}",
+        ) from e
+
+
+@vlan_router.post("", response_model=VlanView)
+def vlan_create(vlan_in: VlanCreate) -> VlanView:
+    """Create a new VLAN interface"""
+    try:
+        # Validate VLAN ID
+        validate_vlan_id(vlan_in.vlan)
+
+        # Add VLAN interface configuration
+        add_vlan_interface(vlan_in.vlan, vlan_in.gateway)
+
+        # Bring up the interface
+        interface_name = get_interface_name()
+        vlan_interface = f"{interface_name}.{vlan_in.vlan}"
+        bring_interface_up(vlan_interface)
+
+        # Return the created VLAN
+        return VlanView(
+            vlan=vlan_in.vlan,
+            gateway=vlan_in.gateway,
+            interface=vlan_interface,
+            status="up",
+            owner="user-defined",
+        )
+    except (ConfigError, NetworkError) as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to create VLAN: {str(e)}",
+        ) from e
+
+
+@vlan_router.put("/{vlan_id}", response_model=VlanView)
+def vlan_update(vlan_id: int, vlan_in: VlanUpdate) -> VlanView:
+    """Update a VLAN interface"""
+    try:
+        # Validate VLAN ID
+        validate_vlan_id(vlan_id)
+
+        # Update VLAN interface configuration
+        update_vlan_interface(vlan_id, vlan_in.gateway)
+
+        # Restart the interface
+        interface_name = get_interface_name()
+        vlan_interface = f"{interface_name}.{vlan_id}"
+        bring_interface_down(vlan_interface)
+        bring_interface_up(vlan_interface)
+
+        # Return the updated VLAN
+        return VlanView(
+            vlan=vlan_id,
+            gateway=vlan_in.gateway,
+            interface=vlan_interface,
+            status="up",
+            owner="user-defined",
+        )
+    except (ConfigError, NetworkError) as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to update VLAN {vlan_id}: {str(e)}",
+        ) from e
+
+
+@vlan_router.delete("/{vlan_id}")
+def vlan_delete(vlan_id: int) -> dict:
+    """Delete a VLAN interface"""
+    try:
+        # Validate VLAN ID
+        validate_vlan_id(vlan_id)
+
+        # Delete VLAN interface configuration (includes bringing down and deleting interface)
+        delete_vlan_interface(vlan_id)
+
+        return {"message": f"VLAN {vlan_id} deleted successfully"}
+    except (ConfigError, NetworkError) as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to delete VLAN {vlan_id}: {str(e)}",
+        ) from e
+
+
+@vlan_router.put("/{vlan_id}/enable")
+def vlan_enable(vlan_id: int) -> dict:
+    """Enable a VLAN interface (bring it up)"""
+    try:
+        # Validate VLAN ID
+        validate_vlan_id(vlan_id)
+
+        interface_name = get_interface_name()
+        vlan_interface = f"{interface_name}.{vlan_id}"
+
+        # Check if interface exists
+        result = subprocess.run(
+            ["ip", "link", "show", vlan_interface],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"VLAN interface {vlan_interface} does not exist",
+            )
+
+        # Bring interface up
+        result = subprocess.run(
+            ["ip", "link", "set", vlan_interface, "up"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise NetworkError(
+                f"Failed to enable interface {vlan_interface}: {result.stderr}"
+            )
+
+        return {"message": f"VLAN {vlan_id} enabled 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 HTTPException:
+        raise
+    except (ConfigError, NetworkError) as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to enable VLAN {vlan_id}: {str(e)}",
+        ) from e
+
+
+@vlan_router.put("/{vlan_id}/disable")
+def vlan_disable(vlan_id: int) -> dict:
+    """Disable a VLAN interface (bring it down)"""
+    try:
+        # Validate VLAN ID
+        validate_vlan_id(vlan_id)
+
+        interface_name = get_interface_name()
+        vlan_interface = f"{interface_name}.{vlan_id}"
+
+        # Check if interface exists
+        result = subprocess.run(
+            ["ip", "link", "show", vlan_interface],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND,
+                detail=f"VLAN interface {vlan_interface} does not exist",
+            )
+
+        # Bring interface down
+        result = subprocess.run(
+            ["ip", "link", "set", vlan_interface, "down"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise NetworkError(
+                f"Failed to disable interface {vlan_interface}: {result.stderr}"
+            )
+
+        return {"message": f"VLAN {vlan_id} disabled 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 HTTPException:
+        raise
+    except (ConfigError, NetworkError) as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=f"Failed to disable VLAN {vlan_id}: {str(e)}",
+        ) from e

zboxapi-0.0.6/PKG-INFO

@@ -1,51 +0,0 @@
-Metadata-Version: 2.1
-Name: zboxapi
-Version: 0.0.6
-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
-
-## Installation
-
-Complete the following steps to set up zBox Api:
-
-1. Install pipx
-
-    ```bash
-    # Install and configure pipx
-    apt update
-    apt install -y pipx
-    pipx ensurepath
-
-    # Reload your profile
-    source ~/.zshrc
-    ```
-
-1. Install zBoxApi:
-
-    ```bash
-    pipx install zboxapi
-    ```
-
-1. Set up and start zboxapi.service
-
-    ```bash
-    cp zboxapi.service /etc/systemd/system
-    systemctl daemon-reload
-    systemctl enable zboxapi.service
-    systemctl start zboxapi.service
-    ```
-

zboxapi-0.0.6/README.md

@@ -1,34 +0,0 @@
-# zBoxApi
-
-zPodFactory zBox Api
-
-## Installation
-
-Complete the following steps to set up zBox Api:
-
-1. Install pipx
-
-    ```bash
-    # Install and configure pipx
-    apt update
-    apt install -y pipx
-    pipx ensurepath
-
-    # Reload your profile
-    source ~/.zshrc
-    ```
-
-1. Install zBoxApi:
-
-    ```bash
-    pipx install zboxapi
-    ```
-
-1. Set up and start zboxapi.service
-
-    ```bash
-    cp zboxapi.service /etc/systemd/system
-    systemctl daemon-reload
-    systemctl enable zboxapi.service
-    systemctl start zboxapi.service
-    ```

zboxapi-0.0.6/src/zboxapi/__init__.py

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