feat: add firewall, pools, access, disks, node admin and VM hardware management
All checks were successful
Backend Tests / pytest (Python 3.12) (push) Successful in 1m0s
Deploy to Production / Trigger production update (push) Successful in 7s

Backend: new proxmox mixins and API routes for firewall, pools, access
control, node admin and disks; extend storage and VM endpoints.

Frontend: node managers (firewall, pool, access, disk, node admin), VM
firewall and hardware tabs, PCI/USB device dialogs, related hooks and
locale strings.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
markmorado
2026-07-04 00:02:15 +05:00
parent c12fbf13e5
commit 5c8baefb3f
37 changed files with 6627 additions and 10 deletions

View File

@@ -0,0 +1,97 @@
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { apiClient } from '@/lib/api-client';
export interface Realm {
realm: string;
type: string; // pam | pve | ldap | ad | openid
comment?: string;
tfa?: string;
}
export interface AccessUser {
userid: string;
enable?: number;
comment?: string;
email?: string;
}
export interface ApiToken {
tokenid: string;
comment?: string;
expire?: number;
privsep?: number;
}
export const accessKeys = {
realms: (s: number) => ['access-realms', s] as const,
users: (s: number) => ['access-users', s] as const,
tokens: (s: number, u: string) => ['access-tokens', s, u] as const,
};
const base = (s: number) => `/proxmox/api/servers/${s}/access`;
// ---------- Realms ----------
export function useRealms(serverId: number, enabled = true) {
return useQuery({
queryKey: accessKeys.realms(serverId),
queryFn: () => apiClient.get<{ realms: Realm[] }>(`${base(serverId)}/realms`),
enabled: serverId > 0 && enabled,
});
}
export function useCreateRealm(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.post(`${base(serverId)}/realms`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: accessKeys.realms(serverId) }),
});
}
export function useDeleteRealm(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (realm: string) => apiClient.delete(`${base(serverId)}/realms/${realm}`),
onSuccess: () => qc.invalidateQueries({ queryKey: accessKeys.realms(serverId) }),
});
}
// ---------- Users & tokens ----------
export function useAccessUsers(serverId: number, enabled = true) {
return useQuery({
queryKey: accessKeys.users(serverId),
queryFn: () => apiClient.get<{ users: AccessUser[] }>(`${base(serverId)}/users`),
enabled: serverId > 0 && enabled,
});
}
export function useUserTokens(serverId: number, userid: string, enabled = true) {
return useQuery({
queryKey: accessKeys.tokens(serverId, userid),
queryFn: () => apiClient.get<{ tokens: ApiToken[] }>(`${base(serverId)}/users/${encodeURIComponent(userid)}/tokens`),
enabled: serverId > 0 && !!userid && enabled,
});
}
export interface CreatedToken {
success: boolean;
value?: string;
full_tokenid?: string;
}
export function useCreateToken(serverId: number) {
const qc = useQueryClient();
return useMutation<CreatedToken, Error, { userid: string; tokenid: string; comment?: string; privsep: boolean }>({
mutationFn: ({ userid, tokenid, ...data }) =>
apiClient.post(`${base(serverId)}/users/${encodeURIComponent(userid)}/tokens/${encodeURIComponent(tokenid)}`, data),
onSuccess: (_r, v) => qc.invalidateQueries({ queryKey: accessKeys.tokens(serverId, v.userid) }),
});
}
export function useDeleteToken(serverId: number, userid: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (tokenid: string) =>
apiClient.delete(`${base(serverId)}/users/${encodeURIComponent(userid)}/tokens/${encodeURIComponent(tokenid)}`),
onSuccess: () => qc.invalidateQueries({ queryKey: accessKeys.tokens(serverId, userid) }),
});
}

View File

@@ -0,0 +1,109 @@
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { apiClient } from '@/lib/api-client';
export interface NodeDisk {
devpath: string;
size?: number;
model?: string;
serial?: string;
type?: string; // 'ssd' | 'hdd' | 'nvme' | ...
vendor?: string;
used?: string; // 'LVM' | 'ZFS' | 'partitions' | ... | undefined
health?: string; // 'PASSED' | 'OK' | 'FAILED' | ...
wearout?: number | string;
rpm?: number;
gpt?: number;
}
export interface ZfsPool {
name: string;
size?: number;
alloc?: number;
free?: number;
frag?: number;
dedup?: number;
health?: string;
}
export interface SmartAttribute {
id?: number;
name?: string;
value?: number | string;
worst?: number | string;
threshold?: number | string;
raw?: string;
flags?: string;
}
export interface SmartData {
health?: string;
type?: string;
text?: string;
attributes?: SmartAttribute[];
error?: string;
}
export const diskKeys = {
disks: (s: number, n: string) => ['node-disks', s, n] as const,
smart: (s: number, n: string, d: string) => ['disk-smart', s, n, d] as const,
zfs: (s: number, n: string) => ['zfs-pools', s, n] as const,
};
const base = (s: number, n: string) => `/proxmox/api/servers/${s}/nodes/${n}/disks`;
export function useNodeDisks(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: diskKeys.disks(serverId, node),
queryFn: () => apiClient.get<{ disks: NodeDisk[] }>(base(serverId, node)),
enabled: serverId > 0 && !!node && enabled,
});
}
export function useDiskSmart(serverId: number, node: string, disk: string, enabled = true) {
return useQuery({
queryKey: diskKeys.smart(serverId, node, disk),
queryFn: () => apiClient.get<{ smart: SmartData }>(`${base(serverId, node)}/smart?disk=${encodeURIComponent(disk)}`),
enabled: serverId > 0 && !!node && !!disk && enabled,
});
}
export function useZfsPools(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: diskKeys.zfs(serverId, node),
queryFn: () => apiClient.get<{ pools: ZfsPool[] }>(`${base(serverId, node)}/zfs`),
enabled: serverId > 0 && !!node && enabled,
});
}
function useInvalidate(serverId: number, node: string) {
const qc = useQueryClient();
return () => {
qc.invalidateQueries({ queryKey: diskKeys.zfs(serverId, node) });
qc.invalidateQueries({ queryKey: diskKeys.disks(serverId, node) });
};
}
export function useCreateZfsPool(serverId: number, node: string) {
const invalidate = useInvalidate(serverId, node);
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.post(`${base(serverId, node)}/zfs`, data),
onSuccess: () => invalidate(),
});
}
export function useDestroyZfsPool(serverId: number, node: string) {
const invalidate = useInvalidate(serverId, node);
return useMutation({
mutationFn: ({ name, cleanupDisks }: { name: string; cleanupDisks?: boolean }) =>
apiClient.delete(`${base(serverId, node)}/zfs/${name}?cleanup_disks=${cleanupDisks ? 'true' : 'false'}`),
onSuccess: () => invalidate(),
});
}
export function useWipeDisk(serverId: number, node: string) {
const invalidate = useInvalidate(serverId, node);
return useMutation({
mutationFn: (disk: string) => apiClient.put(`${base(serverId, node)}/wipe?disk=${encodeURIComponent(disk)}`, {}),
onSuccess: () => invalidate(),
});
}

View File

@@ -0,0 +1,391 @@
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { apiClient } from '@/lib/api-client';
// ==================== Types ====================
export interface FirewallRule {
pos?: number;
type: string; // 'in' | 'out' | 'group'
action: string; // ACCEPT | DROP | REJECT | <security group name>
enable?: number;
source?: string;
dest?: string;
proto?: string;
dport?: string;
sport?: string;
macro?: string;
iface?: string;
log?: string;
comment?: string;
}
export interface FirewallGroup {
group: string;
comment?: string;
digest?: string;
}
export interface FirewallIpset {
name: string;
comment?: string;
digest?: string;
}
export interface IpsetEntry {
cidr: string;
comment?: string;
nomatch?: number;
}
export interface FirewallAlias {
name: string;
cidr: string;
comment?: string;
ipversion?: number;
}
export interface FirewallOptions {
enable?: number;
policy_in?: string;
policy_out?: string;
log_ratelimit?: string;
[key: string]: unknown;
}
export interface FirewallMacro {
macro: string;
descr?: string;
}
export interface FirewallLogLine {
n?: number;
t?: string;
}
// ==================== Query keys ====================
export const fwKeys = {
options: (s: number) => ['fw-options', s] as const,
rules: (s: number) => ['fw-rules', s] as const,
groups: (s: number) => ['fw-groups', s] as const,
groupRules: (s: number, g: string) => ['fw-group-rules', s, g] as const,
ipsets: (s: number) => ['fw-ipsets', s] as const,
ipsetEntries: (s: number, n: string) => ['fw-ipset-entries', s, n] as const,
aliases: (s: number) => ['fw-aliases', s] as const,
macros: (s: number) => ['fw-macros', s] as const,
nodeOptions: (s: number, n: string) => ['fw-node-options', s, n] as const,
nodeRules: (s: number, n: string) => ['fw-node-rules', s, n] as const,
nodeLog: (s: number, n: string) => ['fw-node-log', s, n] as const,
guestOptions: (s: number, t: string, v: number) => ['fw-guest-options', s, t, v] as const,
guestRules: (s: number, t: string, v: number) => ['fw-guest-rules', s, t, v] as const,
guestLog: (s: number, t: string, v: number) => ['fw-guest-log', s, t, v] as const,
};
const base = (s: number) => `/proxmox/api/servers/${s}/firewall`;
// ==================== Options ====================
export function useFirewallOptions(serverId: number, enabled = true) {
return useQuery({
queryKey: fwKeys.options(serverId),
queryFn: () => apiClient.get<{ options: FirewallOptions }>(`${base(serverId)}/options`),
enabled: serverId > 0 && enabled,
});
}
export function useUpdateFirewallOptions(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.put(`${base(serverId)}/options`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.options(serverId) }),
});
}
// ==================== Datacenter rules ====================
export function useFirewallRules(serverId: number, enabled = true) {
return useQuery({
queryKey: fwKeys.rules(serverId),
queryFn: () => apiClient.get<{ rules: FirewallRule[] }>(`${base(serverId)}/rules`),
enabled: serverId > 0 && enabled,
});
}
export function useCreateFirewallRule(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.post(`${base(serverId)}/rules`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.rules(serverId) }),
});
}
export function useUpdateFirewallRule(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: ({ pos, data }: { pos: number; data: Record<string, unknown> }) =>
apiClient.put(`${base(serverId)}/rules/${pos}`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.rules(serverId) }),
});
}
export function useDeleteFirewallRule(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (pos: number) => apiClient.delete(`${base(serverId)}/rules/${pos}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.rules(serverId) }),
});
}
// ==================== Security groups ====================
export function useFirewallGroups(serverId: number, enabled = true) {
return useQuery({
queryKey: fwKeys.groups(serverId),
queryFn: () => apiClient.get<{ groups: FirewallGroup[] }>(`${base(serverId)}/groups`),
enabled: serverId > 0 && enabled,
});
}
export function useCreateFirewallGroup(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: { group: string; comment?: string }) => apiClient.post(`${base(serverId)}/groups`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.groups(serverId) }),
});
}
export function useDeleteFirewallGroup(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (group: string) => apiClient.delete(`${base(serverId)}/groups/${group}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.groups(serverId) }),
});
}
export function useFirewallGroupRules(serverId: number, group: string, enabled = true) {
return useQuery({
queryKey: fwKeys.groupRules(serverId, group),
queryFn: () => apiClient.get<{ rules: FirewallRule[] }>(`${base(serverId)}/groups/${group}/rules`),
enabled: serverId > 0 && !!group && enabled,
});
}
export function useCreateFirewallGroupRule(serverId: number, group: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.post(`${base(serverId)}/groups/${group}/rules`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.groupRules(serverId, group) }),
});
}
export function useDeleteFirewallGroupRule(serverId: number, group: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (pos: number) => apiClient.delete(`${base(serverId)}/groups/${group}/rules/${pos}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.groupRules(serverId, group) }),
});
}
// ==================== IP sets ====================
export function useFirewallIpsets(serverId: number, enabled = true) {
return useQuery({
queryKey: fwKeys.ipsets(serverId),
queryFn: () => apiClient.get<{ ipsets: FirewallIpset[] }>(`${base(serverId)}/ipsets`),
enabled: serverId > 0 && enabled,
});
}
export function useCreateFirewallIpset(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: { name: string; comment?: string }) => apiClient.post(`${base(serverId)}/ipsets`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.ipsets(serverId) }),
});
}
export function useDeleteFirewallIpset(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (name: string) => apiClient.delete(`${base(serverId)}/ipsets/${name}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.ipsets(serverId) }),
});
}
export function useFirewallIpsetEntries(serverId: number, name: string, enabled = true) {
return useQuery({
queryKey: fwKeys.ipsetEntries(serverId, name),
queryFn: () => apiClient.get<{ entries: IpsetEntry[] }>(`${base(serverId)}/ipsets/${name}/entries`),
enabled: serverId > 0 && !!name && enabled,
});
}
export function useAddIpsetEntry(serverId: number, name: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: { cidr: string; comment?: string; nomatch?: boolean }) =>
apiClient.post(`${base(serverId)}/ipsets/${name}/entries`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.ipsetEntries(serverId, name) }),
});
}
export function useDeleteIpsetEntry(serverId: number, name: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (cidr: string) =>
apiClient.delete(`${base(serverId)}/ipsets/${name}/entries?cidr=${encodeURIComponent(cidr)}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.ipsetEntries(serverId, name) }),
});
}
// ==================== Aliases ====================
export function useFirewallAliases(serverId: number, enabled = true) {
return useQuery({
queryKey: fwKeys.aliases(serverId),
queryFn: () => apiClient.get<{ aliases: FirewallAlias[] }>(`${base(serverId)}/aliases`),
enabled: serverId > 0 && enabled,
});
}
export function useCreateFirewallAlias(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: { name: string; cidr: string; comment?: string }) =>
apiClient.post(`${base(serverId)}/aliases`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.aliases(serverId) }),
});
}
export function useUpdateFirewallAlias(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: ({ name, data }: { name: string; data: Record<string, unknown> }) =>
apiClient.put(`${base(serverId)}/aliases/${name}`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.aliases(serverId) }),
});
}
export function useDeleteFirewallAlias(serverId: number) {
const qc = useQueryClient();
return useMutation({
mutationFn: (name: string) => apiClient.delete(`${base(serverId)}/aliases/${name}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.aliases(serverId) }),
});
}
// ==================== Node-level ====================
const nodeBase = (s: number, n: string) => `/proxmox/api/servers/${s}/nodes/${n}/firewall`;
export function useNodeFirewallOptions(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: fwKeys.nodeOptions(serverId, node),
queryFn: () => apiClient.get<{ options: FirewallOptions }>(`${nodeBase(serverId, node)}/options`),
enabled: serverId > 0 && !!node && enabled,
});
}
export function useUpdateNodeFirewallOptions(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.put(`${nodeBase(serverId, node)}/options`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.nodeOptions(serverId, node) }),
});
}
export function useNodeFirewallRules(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: fwKeys.nodeRules(serverId, node),
queryFn: () => apiClient.get<{ rules: FirewallRule[] }>(`${nodeBase(serverId, node)}/rules`),
enabled: serverId > 0 && !!node && enabled,
});
}
export function useCreateNodeFirewallRule(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) => apiClient.post(`${nodeBase(serverId, node)}/rules`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.nodeRules(serverId, node) }),
});
}
export function useUpdateNodeFirewallRule(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: ({ pos, data }: { pos: number; data: Record<string, unknown> }) =>
apiClient.put(`${nodeBase(serverId, node)}/rules/${pos}`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.nodeRules(serverId, node) }),
});
}
export function useDeleteNodeFirewallRule(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (pos: number) => apiClient.delete(`${nodeBase(serverId, node)}/rules/${pos}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.nodeRules(serverId, node) }),
});
}
export function useNodeFirewallLog(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: fwKeys.nodeLog(serverId, node),
queryFn: () => apiClient.get<{ log: FirewallLogLine[] }>(`${nodeBase(serverId, node)}/log?limit=200`),
enabled: serverId > 0 && !!node && enabled,
});
}
// ==================== Guest-level (VM/LXC) ====================
const guestBase = (s: number, t: string, v: number) => `/proxmox/api/servers/${s}/guests/${t}/${v}/firewall`;
export function useGuestFirewallOptions(serverId: number, vmType: string, vmid: number, node: string, enabled = true) {
return useQuery({
queryKey: fwKeys.guestOptions(serverId, vmType, vmid),
queryFn: () => apiClient.get<{ options: FirewallOptions }>(`${guestBase(serverId, vmType, vmid)}/options?node=${node}`),
enabled: serverId > 0 && !!node && vmid > 0 && enabled,
});
}
export function useUpdateGuestFirewallOptions(serverId: number, vmType: string, vmid: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) =>
apiClient.put(`${guestBase(serverId, vmType, vmid)}/options?node=${node}`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.guestOptions(serverId, vmType, vmid) }),
});
}
export function useGuestFirewallRules(serverId: number, vmType: string, vmid: number, node: string, enabled = true) {
return useQuery({
queryKey: fwKeys.guestRules(serverId, vmType, vmid),
queryFn: () => apiClient.get<{ rules: FirewallRule[] }>(`${guestBase(serverId, vmType, vmid)}/rules?node=${node}`),
enabled: serverId > 0 && !!node && vmid > 0 && enabled,
});
}
export function useCreateGuestFirewallRule(serverId: number, vmType: string, vmid: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: Record<string, unknown>) =>
apiClient.post(`${guestBase(serverId, vmType, vmid)}/rules?node=${node}`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.guestRules(serverId, vmType, vmid) }),
});
}
export function useUpdateGuestFirewallRule(serverId: number, vmType: string, vmid: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: ({ pos, data }: { pos: number; data: Record<string, unknown> }) =>
apiClient.put(`${guestBase(serverId, vmType, vmid)}/rules/${pos}?node=${node}`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.guestRules(serverId, vmType, vmid) }),
});
}
export function useDeleteGuestFirewallRule(serverId: number, vmType: string, vmid: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (pos: number) =>
apiClient.delete(`${guestBase(serverId, vmType, vmid)}/rules/${pos}?node=${node}`),
onSuccess: () => qc.invalidateQueries({ queryKey: fwKeys.guestRules(serverId, vmType, vmid) }),
});
}
export function useGuestFirewallLog(serverId: number, vmType: string, vmid: number, node: string, enabled = true) {
return useQuery({
queryKey: fwKeys.guestLog(serverId, vmType, vmid),
queryFn: () => apiClient.get<{ log: FirewallLogLine[] }>(`${guestBase(serverId, vmType, vmid)}/log?node=${node}&limit=200`),
enabled: serverId > 0 && !!node && vmid > 0 && enabled,
});
}

View File

@@ -682,6 +682,44 @@ export function useNodeNetworks(serverId: number, node: string, enabled = true)
});
}
// ==================== Node hardware (PCI/USB passthrough) ====================
export interface NodePciDevice {
id: string; // 0000:01:00.0
vendor_name?: string;
device_name?: string;
subsystem_device_name?: string;
iommugroup?: number;
mdev?: number | boolean;
}
export interface NodeUsbDevice {
busnum?: number | string;
devnum?: number | string;
vendid?: string;
prodid?: string;
port?: number | string;
usbpath?: string;
speed?: string;
manufacturer?: string;
prodname?: string;
}
export function useNodePciDevices(serverId: number, node: string, enabled = true) {
return useQuery<NodePciDevice[]>({
queryKey: ['node-pci', serverId, node],
queryFn: () => apiClient.get(`/proxmox/api/${serverId}/nodes/${node}/hardware/pci`),
enabled: enabled && !!node,
});
}
export function useNodeUsbDevices(serverId: number, node: string, enabled = true) {
return useQuery<NodeUsbDevice[]>({
queryKey: ['node-usb', serverId, node],
queryFn: () => apiClient.get(`/proxmox/api/${serverId}/nodes/${node}/hardware/usb`),
enabled: enabled && !!node,
});
}
// ==================== ISO mount/unmount (KVM only) ====================
export interface IsoItem {
volid: string;

View File

@@ -0,0 +1,101 @@
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { apiClient } from '@/lib/api-client';
export interface NodeService {
service: string;
name?: string;
desc?: string;
state?: string; // running | stopped | dead | ...
'active-state'?: string;
'unit-state'?: string;
}
export interface AptUpdate {
Package: string;
Version?: string;
OldVersion?: string;
Title?: string;
Description?: string;
Priority?: string;
}
export interface AptRepo {
Enabled?: number | boolean;
Types?: string[];
URIs?: string[];
Suites?: string[];
Components?: string[];
Comment?: string;
}
export interface AptRepoFile {
path: string;
'file-type'?: string;
repositories?: AptRepo[];
}
export interface AptRepositories {
files?: AptRepoFile[];
'standard-repos'?: Array<{ handle: string; name: string; status?: number }>;
errors?: unknown[];
}
export const nodeAdminKeys = {
services: (s: number, n: string) => ['node-services', s, n] as const,
updates: (s: number, n: string) => ['apt-updates', s, n] as const,
repos: (s: number, n: string) => ['apt-repos', s, n] as const,
};
const base = (s: number, n: string) => `/proxmox/api/servers/${s}/nodes/${n}`;
// ---------- Services ----------
export function useNodeServices(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: nodeAdminKeys.services(serverId, node),
queryFn: () => apiClient.get<{ services: NodeService[] }>(`${base(serverId, node)}/services`),
enabled: serverId > 0 && !!node && enabled,
});
}
export function useServiceAction(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: ({ service, action }: { service: string; action: string }) =>
apiClient.post(`${base(serverId, node)}/services/${service}/${action}`, {}),
onSuccess: () => qc.invalidateQueries({ queryKey: nodeAdminKeys.services(serverId, node) }),
});
}
// ---------- APT ----------
export function useAptUpdates(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: nodeAdminKeys.updates(serverId, node),
queryFn: () => apiClient.get<{ updates: AptUpdate[] }>(`${base(serverId, node)}/apt/updates`),
enabled: serverId > 0 && !!node && enabled,
});
}
export function useAptRefresh(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: () => apiClient.post(`${base(serverId, node)}/apt/refresh`, {}),
onSuccess: () => qc.invalidateQueries({ queryKey: nodeAdminKeys.updates(serverId, node) }),
});
}
export function useAptRepositories(serverId: number, node: string, enabled = true) {
return useQuery({
queryKey: nodeAdminKeys.repos(serverId, node),
queryFn: () => apiClient.get<{ repositories: AptRepositories }>(`${base(serverId, node)}/apt/repositories`),
enabled: serverId > 0 && !!node && enabled,
});
}
export function useSetAptRepository(serverId: number, node: string) {
const qc = useQueryClient();
return useMutation({
mutationFn: (data: { path: string; index: number; enabled: boolean }) =>
apiClient.post(`${base(serverId, node)}/apt/repositories`, data),
onSuccess: () => qc.invalidateQueries({ queryKey: nodeAdminKeys.repos(serverId, node) }),
});
}

View File

@@ -0,0 +1,78 @@
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
import { apiClient } from '@/lib/api-client';
export interface Pool {
poolid: string;
comment?: string;
}
export interface PoolMember {
id: string;
type: string; // 'qemu' | 'lxc' | 'storage'
vmid?: number;
name?: string;
node?: string;
storage?: string;
status?: string;
}
export interface PoolDetail {
comment?: string;
members?: PoolMember[];
}
export const poolKeys = {
list: (s: number) => ['pools', s] as const,
detail: (s: number, p: string) => ['pool', s, p] as const,
};
const base = (s: number) => `/proxmox/api/servers/${s}/pools`;
export function usePools(serverId: number, enabled = true) {
return useQuery({
queryKey: poolKeys.list(serverId),
queryFn: () => apiClient.get<{ pools: Pool[] }>(base(serverId)),
enabled: serverId > 0 && enabled,
});
}
export function usePool(serverId: number, poolid: string, enabled = true) {
return useQuery({
queryKey: poolKeys.detail(serverId, poolid),
queryFn: () => apiClient.get<{ pool: PoolDetail }>(`${base(serverId)}/${poolid}`),
enabled: serverId > 0 && !!poolid && enabled,
});
}
function useInvalidatePools(serverId: number) {
const qc = useQueryClient();
return (poolid?: string) => {
qc.invalidateQueries({ queryKey: poolKeys.list(serverId) });
if (poolid) qc.invalidateQueries({ queryKey: poolKeys.detail(serverId, poolid) });
};
}
export function useCreatePool(serverId: number) {
const invalidate = useInvalidatePools(serverId);
return useMutation({
mutationFn: (data: { poolid: string; comment?: string }) => apiClient.post(base(serverId), data),
onSuccess: () => invalidate(),
});
}
export function useUpdatePool(serverId: number) {
const invalidate = useInvalidatePools(serverId);
return useMutation({
mutationFn: ({ poolid, data }: { poolid: string; data: Record<string, unknown> }) =>
apiClient.put(`${base(serverId)}/${poolid}`, data),
onSuccess: (_r, v) => invalidate(v.poolid),
});
}
export function useDeletePool(serverId: number) {
const invalidate = useInvalidatePools(serverId);
return useMutation({
mutationFn: (poolid: string) => apiClient.delete(`${base(serverId)}/${poolid}`),
onSuccess: () => invalidate(),
});
}