Sergey Antropoff
0773f721ea
- Scale small/large/big seeds (3×50 / 10×1000 / 20×2000) with proportional backups, snapshots, HA, replication, Ceph capacity, and OSD totals (10 / 100 / 500) plus matching node disks and crush/pg metadata - Enrich handler responses for apt, certificates, qemu/lxc status, storage, SDN, metrics export, and related cluster/node dumps - Flatten nested body_example fields into PARAMS and sync the request body via dotted paths (oVirt-style) - Restyle DATA controls as size cards with full-width Reset to minimal / Refresh stats; unload reloads the minimal cluster
426 lines
18 KiB
Python
426 lines
18 KiB
Python
"""Node-level operational handlers (apt, network, disks, services)."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, cast
|
|
|
|
from fastapi import Request
|
|
|
|
from app.api.errors import ApiError
|
|
from app.api.registry import HandlerRegistry
|
|
from app.handlers.common import (
|
|
database,
|
|
node_metadata,
|
|
require_node,
|
|
save_node_metadata,
|
|
subdirs,
|
|
values,
|
|
)
|
|
from app.tasks.repository import TaskRepository
|
|
from app.tasks.upid import Upid
|
|
|
|
|
|
async def load_node_ops(request: Request, node: str) -> dict[str, Any]:
|
|
metadata = await node_metadata(request, node)
|
|
ops = metadata.get("ops")
|
|
if isinstance(ops, dict):
|
|
return ops
|
|
return {}
|
|
|
|
|
|
async def save_node_ops(request: Request, node: str, ops: dict[str, Any]) -> None:
|
|
metadata = await node_metadata(request, node)
|
|
metadata["ops"] = ops
|
|
await save_node_metadata(request, node, metadata)
|
|
|
|
|
|
def register_node_ops_handlers(registry: HandlerRegistry) -> None:
|
|
async def apt_index(request: Request, inputs: dict[str, Any]) -> list[dict[str, str]]:
|
|
await require_node(request, str(values(inputs)["node"]))
|
|
return subdirs("changelog", "repositories", "update", "versions")
|
|
|
|
async def apt_versions(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
node = str(values(inputs)["node"])
|
|
ops = await load_node_ops(request, node)
|
|
packages = ops.get("apt", {}).get("packages", [])
|
|
if not isinstance(packages, list):
|
|
return []
|
|
result: list[dict[str, Any]] = []
|
|
for item in packages:
|
|
if not isinstance(item, dict):
|
|
continue
|
|
entry = dict(item)
|
|
status = str(entry.pop("Status", entry.get("CurrentState", "Installed")))
|
|
if status.lower() == "upgradable":
|
|
entry["CurrentState"] = "Installed"
|
|
entry.setdefault("OldVersion", entry.get("Version", ""))
|
|
else:
|
|
entry["CurrentState"] = "Installed" if status.lower() == "installed" else status
|
|
entry.setdefault("Package", entry.get("Package") or "unknown")
|
|
entry.setdefault("Version", entry.get("Version") or "")
|
|
entry.setdefault("Arch", "amd64")
|
|
entry.setdefault("Origin", "Proxmox")
|
|
result.append(entry)
|
|
return result
|
|
|
|
async def apt_repositories(request: Request, inputs: dict[str, Any]) -> dict[str, Any]:
|
|
node = str(values(inputs)["node"])
|
|
ops = await load_node_ops(request, node)
|
|
repositories = ops.get("apt", {}).get("repositories")
|
|
if isinstance(repositories, dict) and "files" in repositories:
|
|
return {
|
|
"digest": str(repositories.get("digest") or "seedapt"),
|
|
"files": list(repositories.get("files") or []),
|
|
"errors": list(repositories.get("errors") or []),
|
|
"infos": list(repositories.get("infos") or []),
|
|
"standard-repos": list(repositories.get("standard-repos") or []),
|
|
}
|
|
legacy = list(repositories) if isinstance(repositories, list) else []
|
|
return {
|
|
"digest": "seedapt",
|
|
"files": [
|
|
{
|
|
"path": "/etc/apt/sources.list.d/pve-enterprise.list",
|
|
"file-type": "list",
|
|
"digest": "seedapt-file0",
|
|
"repositories": legacy,
|
|
}
|
|
],
|
|
"errors": [],
|
|
"infos": [],
|
|
"standard-repos": [
|
|
{
|
|
"handle": "no-subscription",
|
|
"name": "Proxmox VE No-Subscription Repository",
|
|
"status": 1,
|
|
}
|
|
],
|
|
}
|
|
|
|
async def apt_changelog(request: Request, inputs: dict[str, Any]) -> str:
|
|
node = str(values(inputs)["node"])
|
|
name = str(values(inputs).get("name") or "pve-manager")
|
|
ops = await load_node_ops(request, node)
|
|
apt = ops.get("apt")
|
|
changelogs = apt.get("changelogs") if isinstance(apt, dict) else None
|
|
if not isinstance(changelogs, dict):
|
|
return ""
|
|
return str(changelogs.get(name) or "")
|
|
|
|
async def apt_update_status(request: Request, inputs: dict[str, Any]) -> dict[str, Any]:
|
|
node = str(values(inputs)["node"])
|
|
ops = await load_node_ops(request, node)
|
|
apt = ops.get("apt")
|
|
update = apt.get("update") if isinstance(apt, dict) else None
|
|
return dict(update) if isinstance(update, dict) else {}
|
|
|
|
async def apt_update_start(request: Request, inputs: dict[str, Any]) -> str:
|
|
node = str(values(inputs)["node"])
|
|
ops = await load_node_ops(request, node)
|
|
apt = ops.setdefault("apt", {})
|
|
apt["update"] = {"status": "running", "exitstatus": ""}
|
|
await save_node_ops(request, node, ops)
|
|
return await _node_task(request, node=node, task_type="aptupdate", worker="aptupdate")
|
|
|
|
async def network_list(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
node = str(values(inputs)["node"])
|
|
ops = await load_node_ops(request, node)
|
|
network = ops.get("network", [])
|
|
return [dict(item) for item in network] if isinstance(network, list) else []
|
|
|
|
async def network_get(request: Request, inputs: dict[str, Any]) -> dict[str, Any]:
|
|
iface = str(values(inputs)["iface"])
|
|
for item in await network_list(request, inputs):
|
|
if item.get("iface") == iface:
|
|
return item
|
|
raise ApiError(404, "interface does not exist")
|
|
|
|
async def network_mutate(request: Request, inputs: dict[str, Any]) -> str | None:
|
|
node = str(values(inputs)["node"])
|
|
payload = values(inputs)
|
|
ops = await load_node_ops(request, node)
|
|
network = list(ops.get("network") or [])
|
|
iface = payload.get("iface")
|
|
method = request.method.upper()
|
|
if method == "DELETE":
|
|
target = str(iface or "")
|
|
if not any(item.get("iface") == target for item in network):
|
|
raise ApiError(404, "interface does not exist")
|
|
ops["network"] = [item for item in network if item.get("iface") != target]
|
|
elif method == "POST":
|
|
name = str(iface or payload.get("iface") or "")
|
|
if not name:
|
|
raise ApiError(400, "parameter verification failed - 'iface' missing")
|
|
if any(item.get("iface") == name for item in network):
|
|
raise ApiError(400, f"interface '{name}' already exists")
|
|
entry = {
|
|
key: value
|
|
for key, value in payload.items()
|
|
if key not in {"node", "delete", "digest"}
|
|
}
|
|
entry["iface"] = name
|
|
entry.setdefault("type", "bridge")
|
|
entry.setdefault("active", 1)
|
|
network.append(entry)
|
|
ops["network"] = network
|
|
elif method == "PUT" and iface is not None:
|
|
name = str(iface)
|
|
found = False
|
|
updated: list[dict[str, Any]] = []
|
|
for item in network:
|
|
if item.get("iface") != name:
|
|
updated.append(item)
|
|
continue
|
|
found = True
|
|
merged = {
|
|
**item,
|
|
**{
|
|
key: value
|
|
for key, value in payload.items()
|
|
if key not in {"node", "iface", "delete", "digest"}
|
|
},
|
|
}
|
|
merged["iface"] = name
|
|
updated.append(merged)
|
|
if not found:
|
|
raise ApiError(404, "interface does not exist")
|
|
ops["network"] = updated
|
|
else:
|
|
# PUT /nodes/{node}/network without iface → reload (returns UPID string).
|
|
ops["network_applied"] = True
|
|
await save_node_ops(request, node, ops)
|
|
return await _node_task(
|
|
request, node=node, task_type="network-reload", worker="srvreload"
|
|
)
|
|
await save_node_ops(request, node, ops)
|
|
return None
|
|
|
|
async def disks_index(request: Request, inputs: dict[str, Any]) -> list[dict[str, str]]:
|
|
await require_node(request, str(values(inputs)["node"]))
|
|
return subdirs("directory", "list", "lvm", "lvmthin", "smart", "zfs")
|
|
|
|
async def _disks(request: Request, node: str) -> dict[str, Any]:
|
|
ops = await load_node_ops(request, node)
|
|
disks = ops.get("disks")
|
|
if not isinstance(disks, dict):
|
|
return {}
|
|
return cast(dict[str, Any], disks)
|
|
|
|
async def disks_list(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
node = str(values(inputs)["node"])
|
|
disks = await _disks(request, node)
|
|
items = disks.get("list", [])
|
|
return [dict(item) for item in items] if isinstance(items, list) else []
|
|
|
|
async def disks_smart(request: Request, inputs: dict[str, Any]) -> dict[str, Any]:
|
|
node = str(values(inputs)["node"])
|
|
disk = str(values(inputs).get("disk") or "/dev/sda")
|
|
disks = await _disks(request, node)
|
|
smart = disks.get("smart")
|
|
if not isinstance(smart, dict) or disk not in smart:
|
|
return {}
|
|
return dict(smart[disk])
|
|
|
|
async def disks_collection(
|
|
request: Request, inputs: dict[str, Any], key: str
|
|
) -> list[dict[str, Any]]:
|
|
node = str(values(inputs)["node"])
|
|
disks = await _disks(request, node)
|
|
items = disks.get(key, [])
|
|
return [dict(item) for item in items] if isinstance(items, list) else []
|
|
|
|
async def disks_directory(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
return await disks_collection(request, inputs, "directory")
|
|
|
|
async def disks_lvm(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
return await disks_collection(request, inputs, "lvm")
|
|
|
|
async def disks_lvmthin(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
return await disks_collection(request, inputs, "lvmthin")
|
|
|
|
async def disks_zfs(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
return await disks_collection(request, inputs, "zfs")
|
|
|
|
async def disks_initgpt(request: Request, inputs: dict[str, Any]) -> str:
|
|
node = str(values(inputs)["node"])
|
|
disk = str(values(inputs).get("disk") or values(inputs).get("device") or "")
|
|
if not disk:
|
|
raise ApiError(400, "parameter verification failed - 'disk' missing")
|
|
ops = await load_node_ops(request, node)
|
|
disks = ops.get("disks")
|
|
if not isinstance(disks, dict):
|
|
disks = {}
|
|
ops["disks"] = disks
|
|
items = list(disks.get("list") or [])
|
|
found = False
|
|
for item in items:
|
|
if item.get("devpath") == disk:
|
|
item["gpt"] = 1
|
|
found = True
|
|
break
|
|
if not found:
|
|
items.append(
|
|
{
|
|
"devpath": disk,
|
|
"size": 0,
|
|
"model": "SIM-DISK",
|
|
"serial": disk,
|
|
"gpt": 1,
|
|
}
|
|
)
|
|
disks["list"] = items
|
|
ops["disks"] = disks
|
|
await save_node_ops(request, node, ops)
|
|
return await _node_task(request, node=node, task_type="disk-initgpt", worker="diskinit")
|
|
|
|
async def disks_wipedisk(request: Request, inputs: dict[str, Any]) -> str:
|
|
node = str(values(inputs)["node"])
|
|
disk = str(values(inputs).get("disk") or values(inputs).get("device") or "")
|
|
if not disk:
|
|
raise ApiError(400, "parameter verification failed - 'disk' missing")
|
|
ops = await load_node_ops(request, node)
|
|
disks = ops.get("disks")
|
|
if not isinstance(disks, dict):
|
|
raise ApiError(404, "disk does not exist")
|
|
items = list(disks.get("list") or [])
|
|
for item in items:
|
|
if item.get("devpath") == disk:
|
|
item["wiped"] = 1
|
|
item["gpt"] = 0
|
|
break
|
|
else:
|
|
raise ApiError(404, "disk does not exist")
|
|
disks["list"] = items
|
|
smart = disks.get("smart")
|
|
if isinstance(smart, dict):
|
|
smart.pop(disk, None)
|
|
ops["disks"] = disks
|
|
await save_node_ops(request, node, ops)
|
|
return await _node_task(request, node=node, task_type="disk-wipe", worker="diskwipe")
|
|
|
|
async def services_index(request: Request, inputs: dict[str, Any]) -> list[dict[str, Any]]:
|
|
node = str(values(inputs)["node"])
|
|
ops = await load_node_ops(request, node)
|
|
services = ops.get("services") or {}
|
|
result: list[dict[str, Any]] = []
|
|
for name in sorted(services):
|
|
payload = dict(services[name]) if isinstance(services[name], dict) else {}
|
|
state_name = str(payload.get("state", "stopped"))
|
|
enabled = bool(int(payload.get("enabled", 0) or 0))
|
|
result.append(
|
|
{
|
|
"service": name,
|
|
"name": f"{name}.service",
|
|
"desc": str(payload.get("desc") or name),
|
|
"state": state_name,
|
|
"active-state": "active" if state_name == "running" else "inactive",
|
|
"unit-state": "enabled" if enabled else "disabled",
|
|
}
|
|
)
|
|
return result
|
|
|
|
async def service_get(request: Request, inputs: dict[str, Any]) -> list[dict[str, str]]:
|
|
node = str(values(inputs)["node"])
|
|
service = str(values(inputs)["service"])
|
|
ops = await load_node_ops(request, node)
|
|
services = ops.setdefault("services", {})
|
|
if service not in services:
|
|
services[service] = {"state": "stopped", "enabled": 0}
|
|
await save_node_ops(request, node, ops)
|
|
return subdirs("state", "start", "stop", "restart", "reload")
|
|
|
|
async def service_state(request: Request, inputs: dict[str, Any]) -> dict[str, Any]:
|
|
node = str(values(inputs)["node"])
|
|
service = str(values(inputs)["service"])
|
|
ops = await load_node_ops(request, node)
|
|
services = ops.setdefault("services", {})
|
|
if service not in services:
|
|
services[service] = {"state": "stopped", "enabled": 0}
|
|
await save_node_ops(request, node, ops)
|
|
payload = dict(services[service]) if isinstance(services[service], dict) else {}
|
|
state_name = str(payload.get("state", "stopped"))
|
|
enabled = bool(int(payload.get("enabled", 0) or 0))
|
|
return {
|
|
"service": service,
|
|
"state": state_name,
|
|
"active-state": "active" if state_name == "running" else "inactive",
|
|
"unit-state": "enabled" if enabled else "disabled",
|
|
}
|
|
|
|
async def service_action(request: Request, inputs: dict[str, Any]) -> str:
|
|
node = str(values(inputs)["node"])
|
|
service = str(values(inputs)["service"])
|
|
path = request.url.path.rstrip("/")
|
|
action = path.rsplit("/", 1)[-1]
|
|
ops = await load_node_ops(request, node)
|
|
services = ops.setdefault("services", {})
|
|
current = dict(services.get(service) or {"state": "stopped", "enabled": 0})
|
|
if action == "start":
|
|
current["state"] = "running"
|
|
current["enabled"] = 1
|
|
elif action == "stop":
|
|
current["state"] = "stopped"
|
|
elif action in {"restart", "reload"}:
|
|
current["state"] = "running"
|
|
current["enabled"] = 1
|
|
else:
|
|
raise ApiError(400, f"unknown service action: {action}")
|
|
services[service] = current
|
|
ops["services"] = services
|
|
await save_node_ops(request, node, ops)
|
|
return await _node_task(
|
|
request,
|
|
node=node,
|
|
task_type=f"service-{action}",
|
|
worker=f"srv{action}",
|
|
)
|
|
|
|
registry.register("/nodes/{node}/apt", "GET", apt_index)
|
|
registry.register("/nodes/{node}/apt/versions", "GET", apt_versions)
|
|
registry.register("/nodes/{node}/apt/repositories", "GET", apt_repositories)
|
|
registry.register("/nodes/{node}/apt/changelog", "GET", apt_changelog)
|
|
registry.register("/nodes/{node}/apt/update", "GET", apt_update_status)
|
|
registry.register("/nodes/{node}/apt/update", "POST", apt_update_start)
|
|
registry.register("/nodes/{node}/network", "GET", network_list)
|
|
registry.register("/nodes/{node}/network", "POST", network_mutate)
|
|
registry.register("/nodes/{node}/network", "PUT", network_mutate)
|
|
registry.register("/nodes/{node}/network/{iface}", "GET", network_get)
|
|
registry.register("/nodes/{node}/network/{iface}", "PUT", network_mutate)
|
|
registry.register("/nodes/{node}/network/{iface}", "DELETE", network_mutate)
|
|
registry.register("/nodes/{node}/disks", "GET", disks_index)
|
|
registry.register("/nodes/{node}/disks/list", "GET", disks_list)
|
|
registry.register("/nodes/{node}/disks/smart", "GET", disks_smart)
|
|
registry.register("/nodes/{node}/disks/directory", "GET", disks_directory)
|
|
registry.register("/nodes/{node}/disks/lvm", "GET", disks_lvm)
|
|
registry.register("/nodes/{node}/disks/lvmthin", "GET", disks_lvmthin)
|
|
registry.register("/nodes/{node}/disks/zfs", "GET", disks_zfs)
|
|
registry.register("/nodes/{node}/disks/initgpt", "POST", disks_initgpt)
|
|
registry.register("/nodes/{node}/disks/wipedisk", "PUT", disks_wipedisk)
|
|
registry.register("/nodes/{node}/services", "GET", services_index)
|
|
registry.register("/nodes/{node}/services/{service}", "GET", service_get)
|
|
registry.register("/nodes/{node}/services/{service}/state", "GET", service_state)
|
|
registry.register("/nodes/{node}/services/{service}/start", "POST", service_action)
|
|
registry.register("/nodes/{node}/services/{service}/stop", "POST", service_action)
|
|
registry.register("/nodes/{node}/services/{service}/restart", "POST", service_action)
|
|
registry.register("/nodes/{node}/services/{service}/reload", "POST", service_action)
|
|
|
|
|
|
async def _node_task(request: Request, *, node: str, task_type: str, worker: str) -> str:
|
|
import secrets
|
|
|
|
from app.api.errors import ApiError
|
|
from app.db.primitives import ConflictError
|
|
|
|
pool = database(request).pool
|
|
upid = str(Upid.allocate(node, worker, "0", str(request.state.principal)))
|
|
try:
|
|
task = await TaskRepository(pool).create(
|
|
upid=upid,
|
|
task_type=task_type,
|
|
payload={"node": node},
|
|
resource_key=f"node:{node}:{task_type}:{secrets.token_hex(4)}",
|
|
)
|
|
except ConflictError as error:
|
|
raise ApiError(409, str(error)) from error
|
|
return task.upid
|