Files
Homelab-manager/server/src/routes/ipam.ts
T
bobbanandClaude Sonnet 5.5 5e26e77340 UniFi: servers plugged into switches; server page in sections; My work; settings search and undo
UniFi: the controller's client list is matched to servers by IP address, so a
server is connected through a switch or access point (and port). That is a
dependency made by itself, shown on the server page, the Network devices page
and the Connections map. IP Addresses can sync the devices' addresses.

A server's page is split into Overview, Health, Network, History, Tasks and
Settings, by ?view=; alerts link to the section they are about.

My work lists what has your name on it: alerts you have, maintenance you
started (extend, end with undo) and update runs you started, with a badge.

Settings has a search box (and the command palette lists every setting).
Removing a dependency, admin link, runbook, hand-made IP address, port opening
or restore test is undone from the message instead of asked about first.

Two backup tests used a fixed date and failed as days passed; they follow the
real clock now.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 19:35:45 +02:00

371 lines
13 KiB
TypeScript

import { Router } from "express";
import { isIP } from "node:net";
import { and, eq, inArray } from "drizzle-orm";
import { z } from "zod";
import { db } from "../db/client.js";
import { ipamEntries, integrations, dnsRecordsCache, networkDevices } from "../db/schema.js";
import { requireAuth, requireRole } from "../auth/middleware.js";
import { recordAudit } from "../services/audit.js";
import { asyncHandler } from "../utils/asyncHandler.js";
import { loadIntegrationConfig } from "../integrations/loadIntegration.js";
import { createTailscaleAdapter } from "../integrations/tailscale/adapter.js";
import { createProxmoxAdapter } from "../integrations/proxmox/adapter.js";
import { createPhpIpamAdapter } from "../integrations/phpipam/adapter.js";
import { makeExclusion } from "../services/consistency.js";
import { getSettings } from "../services/settingsStore.js";
export const ipamRouter = Router();
ipamRouter.use(requireAuth);
async function matchingDnsRecordsByIp(ips: string[]): Promise<Map<string, string[]>> {
const byIp = new Map<string, string[]>();
if (ips.length === 0) return byIp;
const rows = await db
.select({ ip: dnsRecordsCache.content, name: dnsRecordsCache.name })
.from(dnsRecordsCache)
.where(inArray(dnsRecordsCache.content, ips));
for (const row of rows) {
const list = byIp.get(row.ip) ?? [];
list.push(row.name);
byIp.set(row.ip, list);
}
return byIp;
}
ipamRouter.get("/", asyncHandler(async (_req, res) => {
const rows = await db.select().from(ipamEntries).orderBy(ipamEntries.ipAddress);
const byIp = await matchingDnsRecordsByIp(rows.map((r) => r.ipAddress));
// Same excluded-ranges setting the Consistency page manages — "not interesting" addresses (Docker's bridge
// network repeating on every host, say) can be hidden here too, without duplicating that configuration.
const { consistency } = await getSettings();
const excluded = makeExclusion(consistency.excludedRanges);
res.json({
entries: rows.map((r) => ({ ...r, matchingDnsRecords: byIp.get(r.ipAddress) ?? [], excluded: excluded(r.ipAddress) })),
excludedRanges: consistency.excludedRanges,
});
}));
const createInput = z.object({
ipAddress: z.string().refine((v) => isIP(v) !== 0, "Must be a valid IPv4 or IPv6 address"),
label: z.string().max(200).optional(),
vendor: z.string().max(200).optional(),
location: z.string().max(200).optional(),
notes: z.string().max(4000).optional(),
});
const updateInput = createInput.omit({ ipAddress: true }).partial();
ipamRouter.post("/", requireRole("operator"), asyncHandler(async (req, res) => {
const parsed = createInput.safeParse(req.body);
if (!parsed.success) {
return res.status(400).json({ error: "invalid_body", details: parsed.error.flatten() });
}
const [existing] = await db
.select({ id: ipamEntries.id })
.from(ipamEntries)
.where(eq(ipamEntries.ipAddress, parsed.data.ipAddress))
.limit(1);
if (existing) {
return res.status(409).json({ error: "duplicate_ip" });
}
const [created] = await db.insert(ipamEntries).values(parsed.data).returning();
await recordAudit({
actor: req.currentUser!,
category: "ipam",
action: "create",
targetType: "ipam_entry",
targetId: created.id,
detail: { ipAddress: created.ipAddress },
});
const byIp = await matchingDnsRecordsByIp([created.ipAddress]);
res.status(201).json({ entry: { ...created, matchingDnsRecords: byIp.get(created.ipAddress) ?? [] } });
}));
ipamRouter.patch("/:id", requireRole("operator"), asyncHandler(async (req, res) => {
const id = Number(req.params.id);
const parsed = updateInput.safeParse(req.body);
if (!parsed.success) {
return res.status(400).json({ error: "invalid_body", details: parsed.error.flatten() });
}
const [existing] = await db.select().from(ipamEntries).where(eq(ipamEntries.id, id)).limit(1);
if (!existing) {
return res.status(404).json({ error: "not_found" });
}
const [updated] = await db
.update(ipamEntries)
.set({ ...parsed.data, updatedAt: new Date().toISOString() })
.where(eq(ipamEntries.id, id))
.returning();
await recordAudit({
actor: req.currentUser!,
category: "ipam",
action: "update",
targetType: "ipam_entry",
targetId: id,
detail: { ipAddress: updated.ipAddress },
});
const byIp = await matchingDnsRecordsByIp([updated.ipAddress]);
res.json({ entry: { ...updated, matchingDnsRecords: byIp.get(updated.ipAddress) ?? [] } });
}));
ipamRouter.delete("/:id", requireRole("operator"), asyncHandler(async (req, res) => {
const id = Number(req.params.id);
const [existing] = await db.select().from(ipamEntries).where(eq(ipamEntries.id, id)).limit(1);
if (!existing) {
return res.status(404).json({ error: "not_found" });
}
await db.delete(ipamEntries).where(eq(ipamEntries.id, id));
await recordAudit({
actor: req.currentUser!,
category: "ipam",
action: "delete",
targetType: "ipam_entry",
targetId: id,
detail: { ipAddress: existing.ipAddress },
});
res.status(204).end();
}));
/**
* Inserts a new IPAM entry for `ip`, or updates one this same sync source
* previously created — but never touches an entry that already exists from
* a manual entry or a different sync source, so two syncs (or a sync and a
* human) can never clobber each other.
*/
async function upsertSyncedEntry(
ip: string,
label: string,
vendor: string,
notes: string | null,
location: string | null,
source: string,
): Promise<"added" | "updated" | "skipped"> {
const [existing] = await db.select().from(ipamEntries).where(eq(ipamEntries.ipAddress, ip)).limit(1);
if (!existing) {
await db.insert(ipamEntries).values({ ipAddress: ip, label, vendor, notes, location, source });
return "added";
}
if (existing.source === source) {
await db
.update(ipamEntries)
.set({ label, notes, location, updatedAt: new Date().toISOString() })
.where(eq(ipamEntries.id, existing.id));
return "updated";
}
return "skipped";
}
ipamRouter.post("/sync-tailscale", requireRole("operator"), asyncHandler(async (req, res) => {
const tailscaleIntegrations = await db
.select()
.from(integrations)
.where(and(eq(integrations.type, "tailscale"), eq(integrations.enabled, true)));
if (tailscaleIntegrations.length === 0) {
return res.status(400).json({ error: "no_tailscale_integration" });
}
let added = 0;
let updated = 0;
let skipped = 0;
const skippedIps: string[] = [];
const errors: string[] = [];
for (const integration of tailscaleIntegrations) {
const loaded = await loadIntegrationConfig(integration.id);
if (!loaded || loaded.integration.type !== "tailscale") continue;
let devices;
try {
const adapter = createTailscaleAdapter(loaded.config as { tailnet: string; apiKey: string });
devices = await adapter.listDevices();
} catch (err) {
errors.push(`${integration.name}: ${err instanceof Error ? err.message : String(err)}`);
continue;
}
for (const device of devices) {
const ip = device.primaryAddress;
if (!ip) continue;
const label = device.label || device.hostname || ip;
const notes = device.os ? `OS: ${device.os}` : null;
const result = await upsertSyncedEntry(ip, label, "Tailscale", notes, null, "tailscale");
if (result === "added") added++;
else if (result === "updated") updated++;
else {
skipped++;
skippedIps.push(ip);
}
}
}
await recordAudit({
actor: req.currentUser!,
category: "ipam",
action: "sync_tailscale",
detail: { added, updated, skipped },
});
res.json({ added, updated, skipped, skippedIps, errors });
}));
ipamRouter.post("/sync-proxmox", requireRole("operator"), asyncHandler(async (req, res) => {
const proxmoxIntegrations = await db
.select()
.from(integrations)
.where(and(eq(integrations.type, "proxmox"), eq(integrations.enabled, true)));
if (proxmoxIntegrations.length === 0) {
return res.status(400).json({ error: "no_proxmox_integration" });
}
let added = 0;
let updated = 0;
let skipped = 0;
const skippedIps: string[] = [];
const errors: string[] = [];
for (const integration of proxmoxIntegrations) {
const loaded = await loadIntegrationConfig(integration.id);
if (!loaded || loaded.integration.type !== "proxmox") continue;
const adapter = createProxmoxAdapter(
loaded.config as { url: string; tokenId: string; tokenSecret: string; insecure?: boolean },
);
let guests;
try {
guests = await adapter.listGuests();
} catch (err) {
errors.push(`${integration.name}: ${err instanceof Error ? err.message : String(err)}`);
continue;
}
for (const guest of guests) {
let detail;
try {
detail = await adapter.getGuestDetail(guest.node, guest.type, guest.vmid);
} catch (err) {
errors.push(`${integration.name}/${guest.name}: ${err instanceof Error ? err.message : String(err)}`);
continue;
}
const label = guest.name || `${guest.type}/${guest.vmid}`;
const notes = `Proxmox ${guest.type === "qemu" ? "VM" : "LXC"} #${guest.vmid} on ${guest.node}`;
for (const ip of detail.ipAddresses) {
const result = await upsertSyncedEntry(ip, label, "Proxmox", notes, null, "proxmox");
if (result === "added") added++;
else if (result === "updated") updated++;
else {
skipped++;
skippedIps.push(ip);
}
}
}
}
await recordAudit({
actor: req.currentUser!,
category: "ipam",
action: "sync_proxmox",
detail: { added, updated, skipped },
});
res.json({ added, updated, skipped, skippedIps, errors });
}));
ipamRouter.post("/sync-unifi", requireRole("operator"), asyncHandler(async (req, res) => {
const controllers = await db.select({ id: integrations.id }).from(integrations).where(and(eq(integrations.type, "unifi"), eq(integrations.enabled, true)));
if (controllers.length === 0) {
return res.status(400).json({ error: "no_unifi_integration" });
}
let added = 0;
let updated = 0;
let skipped = 0;
const skippedIps: string[] = [];
// What was last read from the controllers (the page's own copy), not a new call: a device is as current as the Network devices page says.
for (const d of await db.select().from(networkDevices)) {
if (!d.ip) continue;
const kind = d.kind.replace("_", " ");
const notes = [`${kind}${d.model ? `, ${d.model}` : ""}`, d.mac ? `MAC ${d.mac}` : null].filter((v): v is string => !!v).join(" — ");
const result = await upsertSyncedEntry(d.ip, d.name, "UniFi", notes, d.siteName && d.siteName !== "Default" ? d.siteName : null, "unifi");
if (result === "added") added++;
else if (result === "updated") updated++;
else {
skipped++;
skippedIps.push(d.ip);
}
}
await recordAudit({ actor: req.currentUser!, category: "ipam", action: "sync_unifi", detail: { added, updated, skipped } });
res.json({ added, updated, skipped, skippedIps, errors: [] });
}));
ipamRouter.post("/sync-phpipam", requireRole("operator"), asyncHandler(async (req, res) => {
const phpIpamIntegrations = await db
.select()
.from(integrations)
.where(and(eq(integrations.type, "phpipam"), eq(integrations.enabled, true)));
if (phpIpamIntegrations.length === 0) {
return res.status(400).json({ error: "no_phpipam_integration" });
}
let added = 0;
let updated = 0;
let skipped = 0;
const skippedIps: string[] = [];
const errors: string[] = [];
for (const integration of phpIpamIntegrations) {
const loaded = await loadIntegrationConfig(integration.id);
if (!loaded || loaded.integration.type !== "phpipam") continue;
let addresses;
try {
const adapter = createPhpIpamAdapter(loaded.config as { url: string; appId: string; token: string; insecure?: boolean });
addresses = await adapter.listAddresses();
} catch (err) {
errors.push(`${integration.name}: ${err instanceof Error ? err.message : String(err)}`);
continue;
}
for (const addr of addresses) {
const label = addr.hostname || addr.description || addr.ip;
const notes = [addr.description, addr.note, addr.mac ? `MAC ${addr.mac}` : null].filter((v): v is string => !!v).join(" — ") || null;
const result = await upsertSyncedEntry(addr.ip, label, "phpIPAM", notes, addr.subnetLabel, "phpipam");
if (result === "added") added++;
else if (result === "updated") updated++;
else {
skipped++;
skippedIps.push(addr.ip);
}
}
}
await recordAudit({
actor: req.currentUser!,
category: "ipam",
action: "sync_phpipam",
detail: { added, updated, skipped },
});
res.json({ added, updated, skipped, skippedIps, errors });
}));