zboxapi 0.0.4__tar.gz → 0.0.6__tar.gz

{zboxapi-0.0.4 → zboxapi-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zboxapi
-Version: 0.0.4
+Version: 0.0.6
 Summary: 
 Author: Kelby Valenti
 Author-email: kelby.valenti@gmail.com

{zboxapi-0.0.4 → zboxapi-0.0.6}/pyproject.toml

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

zboxapi-0.0.6/src/zboxapi/__init__.py

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

{zboxapi-0.0.4 → zboxapi-0.0.6}/src/zboxapi/main.py

@@ -3,8 +3,6 @@ import fcntl
 import os
 import re
 import socket
-
-# import ssl
 import subprocess
 import time
 from ipaddress import IPv4Address
@@ -18,6 +16,8 @@ from fastapi.security.api_key import APIKey, APIKeyHeader
 from pydantic import AfterValidator, BaseModel
 from pydantic_core import PydanticCustomError
 
+from zboxapi import __version__
+
 api_key_header = APIKeyHeader(name="access_token", auto_error=False)
 
 
@@ -49,9 +49,10 @@ def get_hosts_lines(hosts_fo: IO) -> list[dict[str, str]]:
         line = line.strip()
         if not line or line.startswith("#"):
             continue
-        line_ip, *line_fqdns = line.split()
+        line_ip, *line_hostnames = line.split()
         lines.extend(
-            {"ip": IPv4Address(line_ip), "fqdn": line_fqdn} for line_fqdn in line_fqdns
+            {"ip": IPv4Address(line_ip), "hostname": line_hostname}
+            for line_hostname in line_hostnames
         )
     return sorted(lines, key=sort_hosts_lines)
 
@@ -59,12 +60,13 @@ def get_hosts_lines(hosts_fo: IO) -> list[dict[str, str]]:
 def filter_hosts_file(
     lines: list[dict[str, str]],
     ip: IPv4Address | None = None,
-    fqdn: str | None = None,
+    hostname: str | None = None,
 ):
     return [
         line
         for line in lines
-        if (not ip or ip == line["ip"]) and (not fqdn or fqdn == line["fqdn"])
+        if (not ip or ip == line["ip"])
+        and (not hostname or hostname == line["hostname"])
     ]
 
 
@@ -72,7 +74,7 @@ def write_hosts_file(hosts_fo: IO, lines: list[dict[str, str]]):
     lines.sort(key=sort_hosts_lines)
     hosts_fo.seek(0)
     hosts_fo.truncate()
-    hosts_fo.writelines([f"{line['ip']}\t{line['fqdn']}\n" for line in lines])
+    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)]):
@@ -101,11 +103,11 @@ def dnsmasq_sighup():
 
 
 def sort_hosts_lines(item: dict):
-    """Sort list by loopback first, ip second, fqdn third"""
+    """Sort list by loopback first, ip second, hostname third"""
     return (
         not item["ip"].is_loopback,
         socket.inet_aton(str(item["ip"])),
-        item["fqdn"],
+        item["hostname"],
     )
 
 
@@ -120,135 +122,125 @@ def simplify_operation_ids(api: FastAPI) -> None:
             route.operation_id = f"{tag}_{route.name}"
 
 
-def make_list(obj):
-    return obj if isinstance(obj, list) else [obj]
-
-
-def ip_fqdn_str(obj, ip_key="ip", fqdn_key="fqdn"):
-    return f"ip={getattr(obj, ip_key)}, fqdn={getattr(obj, fqdn_key)}"
-
-
-def ip_fqdn_dict(obj, ip_key="ip", fqdn_key="fqdn"):
-    return {"ip": getattr(obj, ip_key), "fqdn": getattr(obj, fqdn_key)}
-
-
-def RecordNotFound(obj, ip_key="ip", fqdn_key="fqdn"):
+def RecordNotFound(ip, hostname):
     return HTTPException(
-        status_code=status.HTTP_406_NOT_ACCEPTABLE,
-        detail=f"Record not found: {ip_fqdn_str(obj, ip_key, fqdn_key)}",
+        status_code=status.HTTP_404_NOT_FOUND,
+        detail=f"DNS record not found: ip={ip}, hostname={hostname}",
     )
 
 
-def RecordAlreadyPresent(obj, ip_key="ip", fqdn_key="fqdn"):
+def RecordAlreadyPresent(ip, hostname):
     return HTTPException(
         status_code=status.HTTP_406_NOT_ACCEPTABLE,
-        detail=f"Record already present: {ip_fqdn_str(obj, ip_key, fqdn_key)}",
+        detail=f"DNS record already present: ip={ip}, hostname={hostname}",
     )
 
 
-def validate_fqdn(value: str):
-    """
-    https://en.m.wikipedia.org/wiki/Fully_qualified_domain_name
-    """
-
-    if not 1 < len(value) < 253:
-        raise PydanticCustomError("value_error", "Invalid fqdn length")
-
-    # Remove trailing dot
-    if value[-1] == ".":
-        value = value[:-1]
-
-    #  Split hostname into list of DNS labels
-    labels = value.split(".")
+def validate_hostname(value: str):
+    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
-    fqdn = re.compile(r"^[a-z0-9]([a-z-0-9-]{0,61}[a-z0-9])?$", re.IGNORECASE)
+    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 all(fqdn.match(label) for label in labels):
-        raise PydanticCustomError("value_error", "Invalid fqdn")
+    if not hostname_re.match(value):
+        raise PydanticCustomError("value_error", "Invalid hostname")
     return value
 
 
-FQDN = Annotated[str, AfterValidator(validate_fqdn)]
+HOSTNAME = Annotated[str, AfterValidator(validate_hostname)]
 
 
-class HostsCreate(BaseModel):
+class DnsCreate(BaseModel):
     ip: IPv4Address
-    fqdn: FQDN
+    hostname: HOSTNAME
 
 
-class HostsDelete(BaseModel):
+class DnsDelete(BaseModel):
     ip: IPv4Address
-    fqdn: FQDN
+    hostname: HOSTNAME
 
 
-class HostsUpdate(BaseModel):
+class DnsUpdate(BaseModel):
     ip: IPv4Address
-    fqdn: FQDN
-    new_ip: IPv4Address
-    new_fqdn: FQDN
+    hostname: HOSTNAME
 
 
-class HostsView(BaseModel):
+class DnsView(BaseModel):
     ip: IPv4Address
-    fqdn: str
+    hostname: str
 
 
-hosts_router = APIRouter(prefix="/hosts", tags=["hosts"])
+dns_router = APIRouter(prefix="/dns", tags=["dns"])
 
 
-@hosts_router.get("")
-def get_hosts(
-    ip: IPv4Address | None = None,
-    fqdn: str | None = None,
-) -> list[HostsView]:
+@dns_router.get("")
+def dns_get_all() -> list[DnsView]:
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
-        hosts_lines = filter_hosts_file(hosts_lines, ip, fqdn)
     return hosts_lines
 
 
-@hosts_router.post("")
-def add_hosts(lines_in: list[HostsCreate] | HostsCreate) -> list[HostsView]:
+@dns_router.get("/{ip}/{hostname}")
+def dns_get(
+    ip: IPv4Address,
+    hostname: HOSTNAME,
+) -> DnsView:
+    with get_hosts_file_object() as hosts_fo:
+        hosts_lines = get_hosts_lines(hosts_fo)
+        hosts_lines = filter_hosts_file(hosts_lines, ip, hostname)
+    if not hosts_lines:
+        raise RecordNotFound(ip, hostname)
+    return hosts_lines[0]
+
+
+@dns_router.post("")
+def dns_add(
+    dns_in: DnsCreate,
+) -> list[DnsView]:
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
-        for line in make_list(lines_in):
-            if filter_hosts_file(hosts_lines, line.ip, line.fqdn):
-                raise RecordAlreadyPresent(line)
-            hosts_lines.append(ip_fqdn_dict(line))
+        if filter_hosts_file(hosts_lines, dns_in.ip, dns_in.hostname):
+            raise RecordAlreadyPresent(dns_in.ip, dns_in.hostname)
+        hosts_lines.append({"ip": dns_in.ip, "hostname": dns_in.hostname})
         write_hosts_file(hosts_fo, hosts_lines)
     dnsmasq_sighup()
     return hosts_lines
 
 
-@hosts_router.put("")
-def update_hosts(lines_in: list[HostsUpdate] | HostsUpdate) -> list[HostsView]:
+@dns_router.put("/{ip}/{hostname}")
+def dns_update(
+    ip: IPv4Address,
+    hostname: HOSTNAME,
+    dns_in: DnsUpdate,
+) -> list[DnsView]:
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
-        for line in make_list(lines_in):
-            key = ip_fqdn_dict(line)
-            if key not in hosts_lines:
-                raise RecordNotFound(line)
-            ix = hosts_lines.index(key)
-            hosts_lines[ix] = ip_fqdn_dict(line, "new_ip", "new_fqdn")
+        key = {"ip": ip, "hostname": hostname}
+        if key not in hosts_lines:
+            raise RecordNotFound(ip, hostname)
+        ix = hosts_lines.index(key)
+        hosts_lines[ix] = {"ip": dns_in.ip, "hostname": dns_in.hostname}
         write_hosts_file(hosts_fo, hosts_lines)
     dnsmasq_sighup()
     return hosts_lines
 
 
-@hosts_router.delete("")
-def delete_hosts(lines_in: list[HostsDelete] | HostsDelete) -> list[HostsView]:
+@dns_router.delete("/{ip}/{hostname}")
+def dns_delete(
+    ip: IPv4Address,
+    hostname: HOSTNAME,
+) -> list[DnsView]:
     with get_hosts_file_object() as hosts_fo:
         hosts_lines = get_hosts_lines(hosts_fo)
-        for line in make_list(lines_in):
-            key = ip_fqdn_dict(line)
-            if key not in hosts_lines:
-                raise RecordNotFound(line)
-            hosts_lines.remove(key)
+        key = {"ip": ip, "hostname": hostname}
+        if key not in hosts_lines:
+            raise RecordNotFound(ip, hostname)
+        hosts_lines.remove(key)
         write_hosts_file(hosts_fo, hosts_lines)
     dnsmasq_sighup()
     return hosts_lines
@@ -260,8 +252,9 @@ app = FastAPI(
     title="zBox API",
     root_path=zboxapi_root_path,
     dependencies=[Depends(validate_api_key)],
+    version=__version__,
 )
-app.include_router(hosts_router)
+app.include_router(dns_router)
 simplify_operation_ids(app)
 
 ZPOD_PASSWORD = get_zpod_password()

zboxapi-0.0.4/src/zboxapi/__init__.py

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