mirror of
https://github.com/hansjone/netx.git
synced 2026-10-09 05:30:46 +08:00
oliver
617d4245b0
Persist Fabric edge deletes, stop LLDP jobs from the canvas, surface truncation/placeholders/stale edges, and fix LLDP job deep-links. Co-authored-by: Cursor <cursoragent@cursor.com>
1540 lines
51 KiB
TypeScript
1540 lines
51 KiB
TypeScript
import type {
|
|
CollectionJobDetail,
|
|
CollectionJobItem,
|
|
CollectionDashboard,
|
|
CollectionRunList,
|
|
EligibleNeItem,
|
|
IntegrationStatus,
|
|
ManagedNeImportResult,
|
|
ManagedNeItem,
|
|
ManagedNeListResponse,
|
|
ManagedNeMeta,
|
|
UmeAlarmItem,
|
|
UmeAlarmSubscriptionStatus,
|
|
UmeKeyAlertMonitorResponse,
|
|
UmeNeItem,
|
|
UmeSyncStatusResponse,
|
|
UmeTokenStatus,
|
|
CliConnectProfileItem,
|
|
CliMeta,
|
|
CliTargetListResponse,
|
|
UmeCliOverrideItem,
|
|
FabricEdge,
|
|
FabricSummary,
|
|
TopologyDiscoverJob,
|
|
TopologyOutsidePeer,
|
|
TopologyTree,
|
|
TopologyViewGraph,
|
|
TopologyViewItem,
|
|
LldpCollectDashboard,
|
|
LldpCollectJobSummary,
|
|
LldpCollectPolicy,
|
|
ConfigSyncCycle,
|
|
ConfigSyncDashboard,
|
|
ConfigSyncPolicy,
|
|
ConfigSyncTask,
|
|
NeConfigSnapshotDetail,
|
|
NeConfigSnapshotMeta,
|
|
PortTrafficCompare,
|
|
PortTrafficDashboard,
|
|
PortTrafficDevice,
|
|
PortTrafficDiscoverResponse,
|
|
PortTrafficEvent,
|
|
PortTrafficBoard,
|
|
PortTrafficBoardPanelIn,
|
|
PortTrafficBoardSummary,
|
|
PortTrafficIfaceIn,
|
|
PortTrafficSamples,
|
|
PortTrafficTarget,
|
|
} from "../types";
|
|
|
|
|
|
export const AUTH_TOKEN_KEY = "netx_access_token";
|
|
|
|
export const getAuthToken = (): string | null => {
|
|
try {
|
|
return localStorage.getItem(AUTH_TOKEN_KEY);
|
|
} catch {
|
|
return null;
|
|
}
|
|
};
|
|
|
|
export const setAuthToken = (token: string): void => {
|
|
localStorage.setItem(AUTH_TOKEN_KEY, String(token || ""));
|
|
};
|
|
|
|
export const clearAuthToken = (): void => {
|
|
try {
|
|
localStorage.removeItem(AUTH_TOKEN_KEY);
|
|
} catch {
|
|
// ignore
|
|
}
|
|
};
|
|
|
|
const authHeaders = (extra?: Record<string, string>): Record<string, string> => {
|
|
const h: Record<string, string> = { accept: "application/json", ...(extra || {}) };
|
|
const tok = getAuthToken();
|
|
if (tok) h.authorization = `Bearer ${tok}`;
|
|
return h;
|
|
};
|
|
|
|
const handleUnauthorized = (path: string): void => {
|
|
if (path.startsWith("/v1/auth/login")) return;
|
|
clearAuthToken();
|
|
if (typeof window !== "undefined" && !window.location.pathname.startsWith("/login")) {
|
|
const next = `${window.location.pathname}${window.location.search || ""}`;
|
|
window.location.assign(`/login?next=${encodeURIComponent(next)}`);
|
|
}
|
|
};
|
|
|
|
const parseApiResponse = async (res: Response): Promise<Record<string, unknown>> => {
|
|
const text = await res.text();
|
|
if (!text) return {};
|
|
try {
|
|
return JSON.parse(text) as Record<string, unknown>;
|
|
} catch {
|
|
const snippet = text.replace(/\s+/g, " ").trim().slice(0, 160);
|
|
throw new Error(res.ok ? "invalid_json_response" : `${res.status} ${snippet || res.statusText}`);
|
|
}
|
|
};
|
|
|
|
/** Preserve FastAPI structured ``detail`` objects (e.g. connect_failed + ne). */
|
|
export class ApiRequestError extends Error {
|
|
status: number;
|
|
detail: unknown;
|
|
|
|
constructor(status: number, detail: unknown) {
|
|
super(formatApiDetail(detail) || `${status}`);
|
|
this.name = "ApiRequestError";
|
|
this.status = status;
|
|
this.detail = detail;
|
|
}
|
|
}
|
|
|
|
export function formatApiDetail(detail: unknown): string {
|
|
if (typeof detail === "string") return detail;
|
|
if (Array.isArray(detail)) {
|
|
return detail
|
|
.map((item) => {
|
|
if (typeof item === "string") return item;
|
|
if (item && typeof item === "object" && "msg" in item) {
|
|
return String((item as { msg?: unknown }).msg || "");
|
|
}
|
|
return "";
|
|
})
|
|
.filter(Boolean)
|
|
.join("; ");
|
|
}
|
|
if (detail && typeof detail === "object") {
|
|
const obj = detail as Record<string, unknown>;
|
|
if (typeof obj.message === "string" && obj.message.trim()) return obj.message;
|
|
if (typeof obj.error === "string" && obj.error.trim()) return obj.error;
|
|
try {
|
|
return JSON.stringify(detail);
|
|
} catch {
|
|
/* fall through */
|
|
}
|
|
}
|
|
return detail == null ? "" : String(detail);
|
|
}
|
|
|
|
export const apiGet = async <T,>(path: string): Promise<T> => {
|
|
const res = await fetch(path, { headers: authHeaders() });
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new Error("401 unauthorized");
|
|
}
|
|
if (!res.ok) throw new Error(`${res.status} ${path}`);
|
|
return (await res.json()) as T;
|
|
};
|
|
|
|
export const apiPost = async <T,>(path: string, body: unknown): Promise<T> => {
|
|
const res = await fetch(path, {
|
|
method: "POST",
|
|
headers: authHeaders({ "content-type": "application/json" }),
|
|
body: JSON.stringify(body),
|
|
});
|
|
const data = await parseApiResponse(res);
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new ApiRequestError(401, data.detail || "unauthorized");
|
|
}
|
|
if (!res.ok) throw new ApiRequestError(res.status, data.detail || `${res.status} ${path}`);
|
|
return data as T;
|
|
};
|
|
|
|
export const apiPatch = async <T,>(path: string, body: unknown): Promise<T> => {
|
|
const res = await fetch(path, {
|
|
method: "PATCH",
|
|
headers: authHeaders({ "content-type": "application/json" }),
|
|
body: JSON.stringify(body),
|
|
});
|
|
const data = await parseApiResponse(res);
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new ApiRequestError(401, data.detail || "unauthorized");
|
|
}
|
|
if (!res.ok) throw new ApiRequestError(res.status, data.detail || `${res.status} ${path}`);
|
|
return data as T;
|
|
};
|
|
|
|
export const apiDelete = async <T,>(path: string): Promise<T> => {
|
|
const res = await fetch(path, { method: "DELETE", headers: authHeaders() });
|
|
const data = await parseApiResponse(res);
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new ApiRequestError(401, data.detail || "unauthorized");
|
|
}
|
|
if (!res.ok) throw new ApiRequestError(res.status, data.detail || `${res.status} ${path}`);
|
|
return data as T;
|
|
};
|
|
|
|
export const apiPut = async <T,>(path: string, body: unknown): Promise<T> => {
|
|
const res = await fetch(path, {
|
|
method: "PUT",
|
|
headers: authHeaders({ "content-type": "application/json" }),
|
|
body: JSON.stringify(body),
|
|
});
|
|
const data = await parseApiResponse(res);
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new ApiRequestError(401, data.detail || "unauthorized");
|
|
}
|
|
if (!res.ok) throw new ApiRequestError(res.status, data.detail || `${res.status} ${path}`);
|
|
return data as T;
|
|
};
|
|
|
|
export const fetchIntegrationStatus = () => apiGet<IntegrationStatus>("/v1/integrations/status");
|
|
|
|
export type OpsTaskItem = {
|
|
kind: string;
|
|
id: string;
|
|
title: string;
|
|
status: string;
|
|
trigger: string;
|
|
actor: string;
|
|
started_at: string | null;
|
|
updated_at: string | null;
|
|
progress: string;
|
|
inflight?: number;
|
|
detail: string;
|
|
href: string;
|
|
};
|
|
|
|
export type OpsTasksResponse = {
|
|
generated_at: string;
|
|
total: number;
|
|
active: number;
|
|
by_kind: Record<string, number>;
|
|
by_status: Record<string, number>;
|
|
items: OpsTaskItem[];
|
|
};
|
|
|
|
export const fetchOpsTasks = () => apiGet<OpsTasksResponse>("/v1/ops/tasks");
|
|
|
|
export type RuntimeMetrics = {
|
|
uptime_sec?: number;
|
|
pid?: number;
|
|
thread_count?: number;
|
|
host?: {
|
|
source?: string;
|
|
platform?: string;
|
|
cpu_percent?: number;
|
|
mem_percent?: number;
|
|
mem_used_bytes?: number;
|
|
mem_total_bytes?: number;
|
|
mem_available_bytes?: number;
|
|
error?: string;
|
|
};
|
|
db_pool?: {
|
|
checked_out?: number;
|
|
checked_in?: number;
|
|
overflow?: number;
|
|
size?: number;
|
|
};
|
|
cli_budget?: {
|
|
limit?: number;
|
|
in_use?: number;
|
|
available?: number;
|
|
};
|
|
webcrt?: {
|
|
active_sessions?: number;
|
|
max_sessions?: number;
|
|
};
|
|
config_sync?: { running?: boolean };
|
|
lldp_collect?: { running?: boolean };
|
|
port_traffic?: { running?: boolean };
|
|
device_schedulers?: {
|
|
stale?: boolean;
|
|
config_sync?: { running?: boolean };
|
|
lldp_collect?: { running?: boolean };
|
|
port_traffic?: { running?: boolean };
|
|
};
|
|
[key: string]: unknown;
|
|
};
|
|
|
|
export const fetchRuntimeMetrics = () => apiGet<RuntimeMetrics>("/v1/metrics/json");
|
|
|
|
export type AuditLogItem = {
|
|
id: string;
|
|
ts: string | null;
|
|
actor_username: string;
|
|
action: string;
|
|
method: string;
|
|
path: string;
|
|
status_code: number;
|
|
client_ip: string;
|
|
detail: Record<string, unknown>;
|
|
};
|
|
|
|
export const fetchAuditLogs = (params?: {
|
|
page?: number;
|
|
pageSize?: number;
|
|
username?: string;
|
|
action?: string;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params?.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, Number(params?.pageSize || 20)))));
|
|
if (params?.username?.trim()) p.set("username", params.username.trim());
|
|
if (params?.action?.trim()) p.set("action", params.action.trim());
|
|
return apiGet<{ total: number; page: number; page_size: number; items: AuditLogItem[] }>(
|
|
`/v1/audit-logs?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchUmeAlarmSubscriptionStatus = () =>
|
|
apiGet<UmeAlarmSubscriptionStatus>("/v1/ume/alarm-subscription/status");
|
|
|
|
export const establishUmeAlarmSubscription = (opts?: { forceReestablish?: boolean }) =>
|
|
apiPost<UmeAlarmSubscriptionStatus>("/v1/ume/alarm-subscription/establish", {
|
|
force_reestablish: Boolean(opts?.forceReestablish),
|
|
});
|
|
|
|
export const cancelUmeAlarmSubscription = (opts?: { forceClearLocal?: boolean }) =>
|
|
apiPost<UmeAlarmSubscriptionStatus>("/v1/ume/alarm-subscription/cancel", {
|
|
force_clear_local: Boolean(opts?.forceClearLocal),
|
|
});
|
|
|
|
export const clearLocalUmeAlarmSubscription = () =>
|
|
apiPost<UmeAlarmSubscriptionStatus>("/v1/ume/alarm-subscription/clear-local", {});
|
|
|
|
export const fetchUmeKeyAlertMonitor = (params?: {
|
|
page?: number;
|
|
pageSize?: number;
|
|
keyword?: string;
|
|
enabled?: "" | "true" | "false";
|
|
matchType?: "" | "notification_id" | "keyword";
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params?.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(200, Number(params?.pageSize || 50)))));
|
|
const kw = String(params?.keyword || "").trim();
|
|
if (kw) p.set("keyword", kw);
|
|
const en = String(params?.enabled || "").trim();
|
|
if (en) p.set("enabled", en);
|
|
const mt = String(params?.matchType || "").trim();
|
|
if (mt) p.set("match_type", mt);
|
|
return apiGet<UmeKeyAlertMonitorResponse>(`/v1/ume/key-alert-monitor?${p.toString()}`);
|
|
};
|
|
|
|
export const upsertUmeKeyAlertRule = (payload: {
|
|
match_type: "notification_id" | "keyword";
|
|
match_value: string;
|
|
label: string;
|
|
enabled?: boolean;
|
|
ne_types?: string[];
|
|
}) => apiPost<{ ok: boolean; item?: unknown }>("/v1/ume/key-alert-rules", payload);
|
|
|
|
export const updateUmeKeyAlertMonitorConfig = (payload: { forward_on_clear: boolean }) =>
|
|
apiPatch<{ ok: boolean; config: { forward_on_clear: boolean } }>("/v1/ume/key-alert-monitor/config", payload);
|
|
|
|
export const deleteUmeKeyAlertRule = (ruleKey: string) =>
|
|
apiDelete<{ ok: boolean }>(`/v1/ume/key-alert-rules/${encodeURIComponent(ruleKey)}`);
|
|
|
|
export const patchUmeKeyAlertRule = (
|
|
ruleKey: string,
|
|
payload: { enabled?: boolean; ne_types?: string[] },
|
|
) =>
|
|
apiPatch<{ ok: boolean; item?: unknown }>(
|
|
`/v1/ume/key-alert-rules/${encodeURIComponent(ruleKey)}`,
|
|
payload,
|
|
);
|
|
|
|
export const fetchUmeNotificationIds = (limit = 200) =>
|
|
apiGet<{ items: Array<{ notification_id: string; native_probable_cause_sample: string }> }>(
|
|
`/v1/ume/notification-ids?limit=${encodeURIComponent(String(limit))}`,
|
|
);
|
|
|
|
export const fetchUmeAlarmKeywords = (limit = 200) =>
|
|
apiGet<{ items: Array<{ keyword: string; alarm_count: number }> }>(
|
|
`/v1/ume/alarm-keywords?limit=${encodeURIComponent(String(limit))}`,
|
|
);
|
|
|
|
export const fetchUmeInventoryNeTypes = (limit = 500) =>
|
|
apiGet<{ items: Array<{ ne_type: string; ne_count: number }>; total: number }>(
|
|
`/v1/ume/inventory/ne-types?limit=${encodeURIComponent(String(limit))}`,
|
|
);
|
|
|
|
export const fetchUmeSyncStatus = (params: { page: number; pageSize: number }) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(200, Number(params.pageSize || 20)))));
|
|
return apiGet<UmeSyncStatusResponse>(`/v1/ume/sync/status?${p.toString()}`);
|
|
};
|
|
|
|
export const fetchUmeTokenStatus = () => apiGet<UmeTokenStatus>("/v1/ume/token/status");
|
|
export const refreshUmeToken = () => apiPost<UmeTokenStatus>("/v1/ume/token/refresh", {});
|
|
export const disconnectUmeToken = () => apiPost<UmeTokenStatus>("/v1/ume/token/disconnect", {});
|
|
|
|
export const fetchUmeNe = (params: { keyword: string; page: number; pageSize: number }) => {
|
|
const p = new URLSearchParams();
|
|
if (params.keyword) p.set("keyword", params.keyword);
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(500, Number(params.pageSize || 50)))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: UmeNeItem[] }>(
|
|
`/v1/ume/inventory/ne?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchManagedNeMeta = () =>
|
|
Promise.all([
|
|
apiGet<ManagedNeMeta>("/v1/managed-ne/meta/device-types"),
|
|
apiGet<{ configured: boolean }>("/v1/managed-ne/meta/credentials-configured"),
|
|
]).then(([types, creds]) => ({
|
|
device_types: types.device_types,
|
|
vendors: types.vendors,
|
|
credentials_configured: creds.configured,
|
|
}));
|
|
|
|
export type ManagedNeStats = {
|
|
total: number;
|
|
by_status: Record<string, number>;
|
|
tags: string[];
|
|
no_tag_count: number;
|
|
tag_counts: Record<string, number>;
|
|
per_tag: Record<
|
|
string,
|
|
{
|
|
total: number;
|
|
by_status: Record<string, number>;
|
|
}
|
|
>;
|
|
};
|
|
|
|
export const fetchManagedNeStats = () => apiGet<ManagedNeStats>("/v1/managed-ne/meta/stats");
|
|
|
|
export const fetchIdsByTag = (tag: string | null) => {
|
|
const url = tag ? `/v1/managed-ne/meta/ids-by-tag?tag=${encodeURIComponent(tag)}` : "/v1/managed-ne/meta/ids-by-tag";
|
|
return apiGet<{ ids: string[] }>(url);
|
|
};
|
|
|
|
export const fetchManagedNe = (params: {
|
|
keyword: string;
|
|
vendor: string;
|
|
connectStatus: string;
|
|
page: number;
|
|
pageSize: number;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
if (params.keyword) p.set("keyword", params.keyword);
|
|
if (params.vendor) p.set("vendor", params.vendor);
|
|
if (params.connectStatus) p.set("connect_status", params.connectStatus);
|
|
p.set("page", String(Math.max(1, params.page)));
|
|
p.set("page_size", String(Math.max(1, Math.min(500, params.pageSize))));
|
|
return apiGet<ManagedNeListResponse>(`/v1/managed-ne?${p.toString()}`);
|
|
};
|
|
|
|
export const createManagedNe = (body: Record<string, unknown>) =>
|
|
apiPost<ManagedNeItem>("/v1/managed-ne", body);
|
|
|
|
export const updateManagedNe = (id: string, body: Record<string, unknown>) =>
|
|
apiPatch<ManagedNeItem>(`/v1/managed-ne/${id}`, body);
|
|
|
|
export const deleteManagedNe = (id: string) => apiDelete<{ ok: boolean }>(`/v1/managed-ne/${id}`);
|
|
|
|
export const batchDeleteManagedNe = (ids: string[]) =>
|
|
apiPost<{ ok: boolean; deleted: number }>("/v1/managed-ne/batch-delete", { ids });
|
|
|
|
export const connectTestManagedNe = (ids: string[]) =>
|
|
apiPost<{ ok: boolean; submitted: number }>("/v1/managed-ne/connect-test", { ids });
|
|
|
|
export const batchApplyHopManagedNe = (
|
|
ids: string[],
|
|
hop: {
|
|
hop_host: string;
|
|
hop_port: number;
|
|
hop_protocol: string;
|
|
hop_username: string;
|
|
hop_password: string;
|
|
hop_command_template: string;
|
|
hop_vrf: string;
|
|
hop_vendor?: string;
|
|
hop_target_auth_mode?: string;
|
|
},
|
|
) => apiPost<{ ok: boolean; updated: number }>("/v1/managed-ne/batch-hop", { ids, hop });
|
|
|
|
export const batchApplyAccountManagedNe = (
|
|
ids: string[],
|
|
account: {
|
|
username?: string;
|
|
password?: string;
|
|
},
|
|
) => apiPost<{ ok: boolean; updated: number }>("/v1/managed-ne/batch-account", { ids, account });
|
|
|
|
export const syncUmeManagedNe = () =>
|
|
apiPost<{ inserted: number; updated: number; deleted: number; total_inventory: number }>("/v1/managed-ne/ume-sync", {});
|
|
|
|
export const deleteUmeManagedNe = () =>
|
|
apiDelete<{ deleted: number }>("/v1/managed-ne/ume-sync");
|
|
|
|
export const managedNeImportTemplateUrl = (format: "xlsx" | "csv" = "xlsx") =>
|
|
`/v1/managed-ne/import/template?format=${format}`;
|
|
|
|
export const downloadManagedNeImportTemplate = async (format: "xlsx" | "csv" = "xlsx"): Promise<void> => {
|
|
const path = managedNeImportTemplateUrl(format);
|
|
const res = await fetch(path, { headers: authHeaders() });
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new Error("unauthorized");
|
|
}
|
|
if (!res.ok) throw new Error(`${res.status} template`);
|
|
const blob = await res.blob();
|
|
const cd = res.headers.get("content-disposition") || "";
|
|
const matched = /filename\*?=(?:UTF-8''|")?([^\";]+)/i.exec(cd);
|
|
const filename = matched
|
|
? decodeURIComponent(matched[1].replace(/"/g, ""))
|
|
: `managed_ne_import_template.${format}`;
|
|
const url = URL.createObjectURL(blob);
|
|
try {
|
|
const a = document.createElement("a");
|
|
a.href = url;
|
|
a.download = filename;
|
|
a.click();
|
|
} finally {
|
|
URL.revokeObjectURL(url);
|
|
}
|
|
};
|
|
|
|
export const importManagedNe = async (file: File): Promise<ManagedNeImportResult> => {
|
|
const form = new FormData();
|
|
form.append("file", file);
|
|
const path = "/v1/managed-ne/import";
|
|
// Do not set content-type — browser must add multipart boundary.
|
|
const res = await fetch(path, { method: "POST", headers: authHeaders(), body: form });
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new Error("unauthorized");
|
|
}
|
|
const text = await res.text();
|
|
const data = text ? JSON.parse(text) : {};
|
|
if (!res.ok) throw new Error(String((data as { detail?: string }).detail || `${res.status} import`));
|
|
return data as ManagedNeImportResult;
|
|
};
|
|
|
|
export const fetchEligibleNe = (params: { page: number; pageSize: number; keyword?: string }) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, params.page)));
|
|
p.set("page_size", String(Math.max(1, Math.min(500, params.pageSize))));
|
|
if (params.keyword?.trim()) p.set("keyword", params.keyword.trim());
|
|
return apiGet<{ total: number; page: number; page_size: number; items: EligibleNeItem[] }>(
|
|
`/v1/ne-collections/eligible-ne?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const createNeCollection = (body: {
|
|
title?: string;
|
|
commands: string;
|
|
ne_ids?: string[];
|
|
ume_ne_ids?: string[];
|
|
}) =>
|
|
apiPost<CollectionJobItem>("/v1/ne-collections", body);
|
|
|
|
export const fetchNeCollections = (params: { page: number; pageSize: number }) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, params.page)));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, params.pageSize))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: CollectionJobItem[] }>(
|
|
`/v1/ne-collections?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchCollectionDashboard = () =>
|
|
apiGet<CollectionDashboard>("/v1/ne-collections/dashboard");
|
|
|
|
export const fetchCollectionJob = (jobId: string) => apiGet<CollectionJobDetail>(`/v1/ne-collections/${jobId}`);
|
|
|
|
export const fetchCollectionRuns = (params: {
|
|
jobId: string;
|
|
page: number;
|
|
pageSize: number;
|
|
status?: string;
|
|
keyword?: string;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, params.page)));
|
|
p.set("page_size", String(Math.max(1, Math.min(200, params.pageSize))));
|
|
if (params.status) p.set("status", params.status);
|
|
if (params.keyword?.trim()) p.set("keyword", params.keyword.trim());
|
|
return apiGet<CollectionRunList>(`/v1/ne-collections/${params.jobId}/runs?${p.toString()}`);
|
|
};
|
|
|
|
export const pauseCollectionJob = (jobId: string) =>
|
|
apiPost<CollectionJobItem>(`/v1/ne-collections/${jobId}/pause`, {});
|
|
|
|
export const startCollectionJob = (jobId: string) =>
|
|
apiPost<CollectionJobItem>(`/v1/ne-collections/${jobId}/start`, {});
|
|
|
|
export const restartCollectionJob = (jobId: string) =>
|
|
apiPost<CollectionJobItem>(`/v1/ne-collections/${jobId}/restart`, {});
|
|
|
|
export const retryFailedCollectionJob = (jobId: string) =>
|
|
apiPost<CollectionJobItem>(`/v1/ne-collections/${jobId}/retry-failed`, {});
|
|
|
|
export const deleteCollectionJob = (jobId: string) =>
|
|
apiDelete<{ ok: boolean }>(`/v1/ne-collections/${jobId}`);
|
|
|
|
export const collectionRunDownloadUrl = (runId: string) => `/v1/ne-collections/runs/${runId}/download`;
|
|
|
|
export const collectionJobDownloadUrl = (jobId: string) => `/v1/ne-collections/${jobId}/download`;
|
|
|
|
export const fetchManagedNeById = (neId: string) =>
|
|
apiGet<ManagedNeItem>(`/v1/managed-ne/${encodeURIComponent(neId)}`);
|
|
|
|
export type WebcrtSessionCreateResult = {
|
|
session_id: string;
|
|
ne_id: string;
|
|
ne_name: string;
|
|
ne_ip: string;
|
|
protocol: string;
|
|
cols: number;
|
|
rows: number;
|
|
ws_path: string;
|
|
encoding?: string;
|
|
state?: string;
|
|
/** True when session used a vendor CLI hop (nested stelnet/telnet). */
|
|
cli_hop?: boolean;
|
|
/** True when SFTP channel opened on the same SSH transport. */
|
|
sftp_ready?: boolean;
|
|
};
|
|
|
|
export const createWebcrtSession = (body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
cols?: number;
|
|
rows?: number;
|
|
encoding?: string;
|
|
keepalive_sec?: number;
|
|
post_login_commands?: string[];
|
|
async_connect?: boolean;
|
|
username?: string;
|
|
password?: string;
|
|
}) => apiPost<WebcrtSessionCreateResult>("/v1/webcrt/sessions", body);
|
|
|
|
export type WebcrtQuickConnectResult = WebcrtSessionCreateResult & {
|
|
ne: ManagedNeItem;
|
|
ne_action: "created" | "updated" | "reused" | string;
|
|
list_source: "webcrt" | "managed" | string;
|
|
};
|
|
|
|
export const quickConnectWebcrtSession = (body: {
|
|
name?: string;
|
|
ip_address: string;
|
|
port?: number;
|
|
protocol?: string;
|
|
username?: string;
|
|
password?: string;
|
|
save_password?: boolean;
|
|
/** Claim existing LLDP / incomplete ManagedNE → promote to webcrt. */
|
|
ne_id?: string;
|
|
cols?: number;
|
|
rows?: number;
|
|
encoding?: string;
|
|
keepalive_sec?: number;
|
|
async_connect?: boolean;
|
|
}) => apiPost<WebcrtQuickConnectResult>("/v1/webcrt/sessions/quick-connect", body);
|
|
|
|
export const closeWebcrtSession = (sessionId: string) =>
|
|
apiDelete<{ ok: boolean; session_id: string; closed: boolean }>(
|
|
`/v1/webcrt/sessions/${encodeURIComponent(sessionId)}`,
|
|
);
|
|
|
|
export type WebcrtSftpItem = {
|
|
name: string;
|
|
size: number;
|
|
mtime: number;
|
|
is_dir: boolean;
|
|
mode?: string;
|
|
owner?: string;
|
|
group?: string;
|
|
uid?: number;
|
|
gid?: number;
|
|
};
|
|
|
|
export type WebcrtSftpListResult = {
|
|
ne_id: string;
|
|
ne_name: string;
|
|
path: string;
|
|
items: WebcrtSftpItem[];
|
|
truncated?: boolean;
|
|
max_entries?: number;
|
|
};
|
|
|
|
export const webcrtSftpList = (body: { ne_id?: string; ume_ne_id?: string; path?: string }) =>
|
|
apiPost<WebcrtSftpListResult>("/v1/webcrt/sftp/list", body);
|
|
|
|
export const webcrtSftpMkdir = (body: { ne_id?: string; ume_ne_id?: string; path: string }) =>
|
|
apiPost<{ ok: boolean; path: string; ne_id: string }>("/v1/webcrt/sftp/mkdir", body);
|
|
|
|
export const webcrtSftpRemove = (body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
path: string;
|
|
recursive?: boolean;
|
|
}) => apiPost<{ ok: boolean; path: string; ne_id: string }>("/v1/webcrt/sftp/remove", body);
|
|
|
|
export const webcrtSftpRename = (body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
old_path: string;
|
|
new_path: string;
|
|
}) => apiPost<{ ok: boolean; old_path: string; new_path: string; ne_id: string }>("/v1/webcrt/sftp/rename", body);
|
|
|
|
export const webcrtSftpChmod = (body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
path: string;
|
|
mode: string;
|
|
}) => apiPost<{ ok: boolean; path: string; mode: string; ne_id: string }>("/v1/webcrt/sftp/chmod", body);
|
|
|
|
export type WebcrtSftpTransferProgress = {
|
|
loaded: number;
|
|
total: number;
|
|
};
|
|
|
|
export type WebcrtSftpTransferOpts = {
|
|
signal?: AbortSignal;
|
|
onProgress?: (p: WebcrtSftpTransferProgress) => void;
|
|
/** Extra attempts after the first failure. Default 2 (3 tries total). */
|
|
retries?: number;
|
|
onRetry?: (attempt: number, err: unknown) => void;
|
|
};
|
|
|
|
const isAbortError = (err: unknown): boolean => {
|
|
const raw = String(err || "").toLowerCase();
|
|
return raw.includes("aborted") || raw.includes("abort");
|
|
};
|
|
|
|
async function withSftpRetries<T>(
|
|
run: () => Promise<T>,
|
|
opts?: Pick<WebcrtSftpTransferOpts, "retries" | "signal" | "onRetry">,
|
|
): Promise<T> {
|
|
const retries = Math.max(0, Number(opts?.retries ?? 2));
|
|
let lastErr: unknown;
|
|
for (let attempt = 0; attempt <= retries; attempt += 1) {
|
|
if (opts?.signal?.aborted) throw new Error("aborted");
|
|
try {
|
|
return await run();
|
|
} catch (err) {
|
|
lastErr = err;
|
|
if (isAbortError(err) || attempt >= retries) break;
|
|
opts?.onRetry?.(attempt + 1, err);
|
|
}
|
|
}
|
|
throw lastErr instanceof Error ? lastErr : new Error(String(lastErr || "transfer_failed"));
|
|
}
|
|
|
|
async function webcrtSftpDownloadOnce(
|
|
body: { ne_id?: string; ume_ne_id?: string; path: string },
|
|
opts?: Pick<WebcrtSftpTransferOpts, "signal" | "onProgress">,
|
|
): Promise<Blob> {
|
|
const path = "/v1/webcrt/sftp/download";
|
|
const res = await fetch(path, {
|
|
method: "POST",
|
|
headers: authHeaders({ "Content-Type": "application/json" }),
|
|
body: JSON.stringify(body),
|
|
signal: opts?.signal,
|
|
});
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new Error("401 unauthorized");
|
|
}
|
|
if (!res.ok) {
|
|
const text = await res.text();
|
|
throw new Error(text || `HTTP ${res.status}`);
|
|
}
|
|
const total = Number(res.headers.get("content-length") || 0);
|
|
if (!res.body) {
|
|
const blob = await res.blob();
|
|
opts?.onProgress?.({ loaded: blob.size, total: total || blob.size });
|
|
return blob;
|
|
}
|
|
const reader = res.body.getReader();
|
|
const chunks: Uint8Array[] = [];
|
|
let loaded = 0;
|
|
try {
|
|
for (;;) {
|
|
if (opts?.signal?.aborted) {
|
|
await reader.cancel().catch(() => undefined);
|
|
throw new Error("aborted");
|
|
}
|
|
const { done, value } = await reader.read();
|
|
if (done) break;
|
|
if (value) {
|
|
chunks.push(value);
|
|
loaded += value.byteLength;
|
|
opts?.onProgress?.({ loaded, total });
|
|
}
|
|
}
|
|
} catch (err) {
|
|
if (opts?.signal?.aborted || isAbortError(err)) throw new Error("aborted");
|
|
throw err;
|
|
}
|
|
return new Blob(chunks as BlobPart[], { type: "application/octet-stream" });
|
|
}
|
|
|
|
export async function webcrtSftpDownload(
|
|
body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
path: string;
|
|
},
|
|
optsOrProgress?: WebcrtSftpTransferOpts | ((p: WebcrtSftpTransferProgress) => void),
|
|
): Promise<Blob> {
|
|
const opts: WebcrtSftpTransferOpts =
|
|
typeof optsOrProgress === "function" ? { onProgress: optsOrProgress } : optsOrProgress || {};
|
|
return withSftpRetries(
|
|
() => webcrtSftpDownloadOnce(body, opts),
|
|
opts,
|
|
);
|
|
}
|
|
|
|
function webcrtSftpUploadOnce(
|
|
body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
remote_path: string;
|
|
file: File;
|
|
},
|
|
opts?: Pick<WebcrtSftpTransferOpts, "signal" | "onProgress">,
|
|
): Promise<{ ok: boolean; path: string; size: number }> {
|
|
const path = "/v1/webcrt/sftp/upload";
|
|
const fd = new FormData();
|
|
if (body.ne_id) fd.append("ne_id", body.ne_id);
|
|
if (body.ume_ne_id) fd.append("ume_ne_id", body.ume_ne_id);
|
|
fd.append("remote_path", body.remote_path);
|
|
fd.append("file", body.file);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
const xhr = new XMLHttpRequest();
|
|
const onAbort = () => {
|
|
try {
|
|
xhr.abort();
|
|
} catch {
|
|
/* ignore */
|
|
}
|
|
};
|
|
if (opts?.signal) {
|
|
if (opts.signal.aborted) {
|
|
reject(new Error("aborted"));
|
|
return;
|
|
}
|
|
opts.signal.addEventListener("abort", onAbort, { once: true });
|
|
}
|
|
xhr.open("POST", path);
|
|
const tok = getAuthToken();
|
|
if (tok) xhr.setRequestHeader("Authorization", `Bearer ${tok}`);
|
|
xhr.responseType = "text";
|
|
xhr.upload.onprogress = (ev) => {
|
|
if (!opts?.onProgress) return;
|
|
opts.onProgress({
|
|
loaded: Number(ev.loaded || 0),
|
|
total: ev.lengthComputable ? Number(ev.total || 0) : body.file.size || 0,
|
|
});
|
|
};
|
|
xhr.onload = () => {
|
|
opts?.signal?.removeEventListener("abort", onAbort);
|
|
if (xhr.status === 401) {
|
|
handleUnauthorized(path);
|
|
reject(new Error("401 unauthorized"));
|
|
return;
|
|
}
|
|
if (xhr.status < 200 || xhr.status >= 300) {
|
|
reject(new Error(xhr.responseText || `HTTP ${xhr.status}`));
|
|
return;
|
|
}
|
|
try {
|
|
resolve(JSON.parse(xhr.responseText || "{}") as { ok: boolean; path: string; size: number });
|
|
} catch {
|
|
reject(new Error("invalid_upload_response"));
|
|
}
|
|
};
|
|
xhr.onerror = () => {
|
|
opts?.signal?.removeEventListener("abort", onAbort);
|
|
reject(new Error("network_error"));
|
|
};
|
|
xhr.onabort = () => {
|
|
opts?.signal?.removeEventListener("abort", onAbort);
|
|
reject(new Error("aborted"));
|
|
};
|
|
xhr.send(fd);
|
|
});
|
|
}
|
|
|
|
export function webcrtSftpUpload(
|
|
body: {
|
|
ne_id?: string;
|
|
ume_ne_id?: string;
|
|
remote_path: string;
|
|
file: File;
|
|
},
|
|
optsOrProgress?: WebcrtSftpTransferOpts | ((p: WebcrtSftpTransferProgress) => void),
|
|
): Promise<{ ok: boolean; path: string; size: number }> {
|
|
const opts: WebcrtSftpTransferOpts =
|
|
typeof optsOrProgress === "function" ? { onProgress: optsOrProgress } : optsOrProgress || {};
|
|
return withSftpRetries(() => webcrtSftpUploadOnce(body, opts), opts);
|
|
}
|
|
|
|
export async function webcrtWsUrl(sessionId: string): Promise<string> {
|
|
const proto = window.location.protocol === "https:" ? "wss:" : "ws:";
|
|
const path = `/v1/webcrt/sessions/${encodeURIComponent(sessionId)}/ws`;
|
|
let qs = "";
|
|
try {
|
|
const ticketResp = await apiPost<{ ticket: string; expires_in: number }>("/v1/webcrt/ws-ticket", {});
|
|
if (ticketResp?.ticket) {
|
|
qs = `?ws_ticket=${encodeURIComponent(ticketResp.ticket)}`;
|
|
}
|
|
} catch {
|
|
qs = "";
|
|
}
|
|
// Optional override, e.g. ws://127.0.0.1:8890
|
|
const override = String((import.meta as ImportMeta & { env?: Record<string, string> }).env?.VITE_NETX_WS_BASE || "").trim();
|
|
if (override) {
|
|
return `${override.replace(/\/$/, "")}${path}${qs}`;
|
|
}
|
|
// Vite/preview: HTTP is proxied, but WS proxy is often flaky — hit API directly.
|
|
const port = window.location.port;
|
|
if (port === "5173" || port === "4173") {
|
|
const apiHost = window.location.hostname === "localhost" ? "127.0.0.1" : window.location.hostname;
|
|
return `${proto}//${apiHost}:8890${path}${qs}`;
|
|
}
|
|
return `${proto}//${window.location.host}${path}${qs}`;
|
|
}
|
|
|
|
export const fetchCliMeta = () => apiGet<CliMeta>("/v1/cli/meta");
|
|
|
|
export const fetchCliProfiles = () =>
|
|
apiGet<{ items: CliConnectProfileItem[] }>("/v1/cli/profiles");
|
|
|
|
export const fetchCliTargets = (params: {
|
|
source?: "managed" | "ume" | "webcrt" | "all";
|
|
keyword?: string;
|
|
page?: number;
|
|
pageSize?: number;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("source", params.source || "all");
|
|
if (params.keyword?.trim()) p.set("keyword", params.keyword.trim());
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(500, Number(params.pageSize || 50)))));
|
|
return apiGet<CliTargetListResponse>(`/v1/cli/targets?${p.toString()}`);
|
|
};
|
|
|
|
export const postUmeConnectTest = (umeNeIds: string[]) =>
|
|
apiPost<{ ok: boolean; submitted: number }>("/v1/cli/ume-connect-test", { ume_ne_ids: umeNeIds });
|
|
|
|
export const fetchUmeCliOverride = (umeNeId: string) =>
|
|
apiGet<UmeCliOverrideItem | null>(`/v1/cli/ume-overrides/${encodeURIComponent(umeNeId)}`);
|
|
|
|
export const fetchUmeCurrentAlarms = (params: {
|
|
severity: string;
|
|
isCleared: string;
|
|
hostName: string;
|
|
keyword: string;
|
|
page: number;
|
|
pageSize: number;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
if (params.severity) p.set("severity", params.severity);
|
|
if (params.isCleared) p.set("is_cleared", params.isCleared);
|
|
if (params.hostName) p.set("host_name", params.hostName);
|
|
if (params.keyword) p.set("keyword", params.keyword);
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(500, Number(params.pageSize || 50)))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: UmeAlarmItem[] }>(
|
|
`/v1/ume/alarms?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchTopologyViews = () =>
|
|
apiGet<{ total: number; items: TopologyViewItem[] }>("/v1/topology/views");
|
|
|
|
export const fetchTopologyTree = () => apiGet<TopologyTree>("/v1/topology/tree");
|
|
|
|
export const createTopologyFolder = (body: { name: string; kind?: string; parent_id?: string; sort_order?: number }) =>
|
|
apiPost<{
|
|
id: string;
|
|
parent_id: string;
|
|
kind: string;
|
|
name: string;
|
|
sort_order: number;
|
|
is_system: boolean;
|
|
}>("/v1/topology/folders", body);
|
|
|
|
export const updateTopologyFolder = (
|
|
folderId: string,
|
|
body: { name?: string; parent_id?: string; sort_order?: number },
|
|
) =>
|
|
apiPatch<{
|
|
id: string;
|
|
parent_id: string;
|
|
kind: string;
|
|
name: string;
|
|
sort_order: number;
|
|
is_system: boolean;
|
|
}>(`/v1/topology/folders/${encodeURIComponent(folderId)}`, body);
|
|
|
|
export const deleteTopologyFolder = (folderId: string, force = false) =>
|
|
apiDelete<{ ok: boolean; folder_id: string; deleted: boolean }>(
|
|
`/v1/topology/folders/${encodeURIComponent(folderId)}?force=${force ? "true" : "false"}`,
|
|
);
|
|
|
|
export const createTopologyView = (body: {
|
|
name: string;
|
|
remark?: string;
|
|
filter?: Record<string, unknown>;
|
|
folder_id?: string;
|
|
kind?: string;
|
|
role?: string;
|
|
sort_order?: number;
|
|
}) => apiPost<TopologyViewItem>("/v1/topology/views", body);
|
|
|
|
export const populateTopologyView = (
|
|
viewId: string,
|
|
body?: { dry_run?: boolean; membership?: Record<string, unknown>; freeze_after?: boolean },
|
|
) =>
|
|
apiPost<{
|
|
view_id: string;
|
|
dry_run: boolean;
|
|
candidate_count: number;
|
|
would_add: number;
|
|
added: number;
|
|
max_nodes: number;
|
|
truncated: boolean;
|
|
outside_peers: TopologyOutsidePeer[];
|
|
graph: TopologyViewGraph | null;
|
|
}>(`/v1/topology/views/${encodeURIComponent(viewId)}/populate`, body || {});
|
|
|
|
export const fetchTopologyViewGraph = (viewId: string) =>
|
|
apiGet<TopologyViewGraph>(`/v1/topology/views/${encodeURIComponent(viewId)}`);
|
|
|
|
export const updateTopologyView = (
|
|
viewId: string,
|
|
body: {
|
|
name?: string;
|
|
remark?: string;
|
|
filter?: Record<string, unknown>;
|
|
viewport?: Record<string, unknown>;
|
|
folder_id?: string;
|
|
role?: string;
|
|
sort_order?: number;
|
|
},
|
|
) => apiPatch<TopologyViewItem>(`/v1/topology/views/${encodeURIComponent(viewId)}`, body);
|
|
|
|
export const deleteTopologyView = (viewId: string, force = false) =>
|
|
apiDelete<{ ok: boolean; view_id: string; deleted: boolean }>(
|
|
`/v1/topology/views/${encodeURIComponent(viewId)}?force=${force ? "true" : "false"}`,
|
|
);
|
|
|
|
export const patchTopologyPositions = (
|
|
viewId: string,
|
|
positions: Array<{
|
|
fabric_node_id: string;
|
|
x?: number;
|
|
y?: number;
|
|
label?: string;
|
|
locked?: boolean;
|
|
}>,
|
|
) =>
|
|
apiPatch<TopologyViewGraph>(`/v1/topology/views/${encodeURIComponent(viewId)}/positions`, {
|
|
positions,
|
|
});
|
|
|
|
export const addTopologyViewNodes = (
|
|
viewId: string,
|
|
body: {
|
|
managed_ne_ids?: string[];
|
|
ume_ne_ids?: string[];
|
|
fabric_node_ids?: string[];
|
|
layout?: string;
|
|
},
|
|
) => apiPost<TopologyViewGraph>(`/v1/topology/views/${encodeURIComponent(viewId)}/nodes`, body);
|
|
|
|
export const createTopologyPlaceholder = (
|
|
viewId: string,
|
|
body: { name: string; ip_address?: string; x?: number; y?: number },
|
|
) =>
|
|
apiPost<TopologyViewGraph>(
|
|
`/v1/topology/views/${encodeURIComponent(viewId)}/nodes/create-placeholder`,
|
|
body,
|
|
);
|
|
|
|
export const removeTopologyViewNodes = (viewId: string, fabricNodeIds: string[]) =>
|
|
apiPost<TopologyViewGraph>(`/v1/topology/views/${encodeURIComponent(viewId)}/nodes/remove`, {
|
|
fabric_node_ids: fabricNodeIds,
|
|
});
|
|
|
|
export const projectTopologyNeighbors = (viewId: string) =>
|
|
apiPost<TopologyViewGraph>(`/v1/topology/views/${encodeURIComponent(viewId)}/project-neighbors`, {});
|
|
|
|
export const patchTopologyEdgeStyle = (
|
|
viewId: string,
|
|
body: { fabric_edge_id: string; stroke_color?: string; stroke_width?: number; line_style?: string },
|
|
) =>
|
|
apiPatch<TopologyViewGraph>(`/v1/topology/views/${encodeURIComponent(viewId)}/edge-style`, body);
|
|
|
|
export const fetchFabricSummary = () => apiGet<FabricSummary>("/v1/topology/fabric/summary");
|
|
|
|
export const fetchFabricNodes = (params?: {
|
|
keyword?: string;
|
|
role?: string;
|
|
regionFolderId?: string;
|
|
unmatched?: string;
|
|
linkStatus?: string;
|
|
page?: number;
|
|
pageSize?: number;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
if (params?.keyword) p.set("keyword", params.keyword);
|
|
if (params?.role) p.set("role", params.role);
|
|
if (params?.regionFolderId) p.set("region_folder_id", params.regionFolderId);
|
|
if (params?.unmatched) p.set("unmatched", params.unmatched);
|
|
if (params?.linkStatus) p.set("link_status", params.linkStatus);
|
|
p.set("page", String(Math.max(1, Number(params?.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(500, Number(params?.pageSize || 50)))));
|
|
return apiGet<{
|
|
total: number;
|
|
page: number;
|
|
page_size: number;
|
|
items: import("../types").FabricNodeSearchHit[];
|
|
}>(`/v1/topology/fabric/nodes?${p.toString()}`);
|
|
};
|
|
|
|
export const matchFabricNodes = (body: {
|
|
pattern: string;
|
|
match_field?: string;
|
|
sample_limit?: number;
|
|
}) =>
|
|
apiPost<{
|
|
pattern: string;
|
|
match_field: string;
|
|
total_matched: number;
|
|
samples: Array<Record<string, string>>;
|
|
fabric_node_ids: string[];
|
|
}>("/v1/topology/fabric/nodes/match", body);
|
|
|
|
export const bulkTagFabricNodes = (body: {
|
|
fabric_node_ids?: string[];
|
|
pattern?: string;
|
|
match_field?: string;
|
|
role?: string | null;
|
|
region_folder_id?: string | null;
|
|
dry_run?: boolean;
|
|
}) =>
|
|
apiPost<{
|
|
dry_run: boolean;
|
|
matched: number;
|
|
updated: number;
|
|
role?: string | null;
|
|
region_folder_id?: string | null;
|
|
samples: Array<Record<string, string>>;
|
|
}>("/v1/topology/fabric/nodes/tags/bulk", body);
|
|
|
|
export const patchFabricNodeTags = (
|
|
fabricNodeId: string,
|
|
body: { role?: string | null; region_folder_id?: string | null },
|
|
) =>
|
|
apiPatch<import("../types").FabricNodeSearchHit>(
|
|
`/v1/topology/fabric/nodes/${encodeURIComponent(fabricNodeId)}/tags`,
|
|
body,
|
|
);
|
|
|
|
export const deleteFabricNode = (fabricNodeId: string) =>
|
|
apiDelete<{ deleted: number; edges_deleted: number; placements_deleted: number }>(
|
|
`/v1/topology/fabric/nodes/${encodeURIComponent(fabricNodeId)}`,
|
|
);
|
|
|
|
export const deleteFabricNodes = (fabricNodeIds: string[]) =>
|
|
apiPost<{ deleted: number; edges_deleted: number; placements_deleted: number }>(
|
|
"/v1/topology/fabric/nodes/delete",
|
|
{ fabric_node_ids: fabricNodeIds },
|
|
);
|
|
|
|
export const generateTopologySlices = (body: {
|
|
folder_id: string;
|
|
template: "core_only" | "core_agg" | "agg_access";
|
|
dry_run?: boolean;
|
|
max_nodes?: number;
|
|
seed_physical_cores?: boolean;
|
|
}) => apiPost<import("../types").SliceGenerateResult>("/v1/topology/slices/generate", body);
|
|
|
|
export const searchFabricNodes = (params?: { q?: string; page?: number; pageSize?: number }) => {
|
|
const p = new URLSearchParams();
|
|
if (params?.q) p.set("q", params.q);
|
|
p.set("page", String(Math.max(1, Number(params?.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(200, Number(params?.pageSize || 50)))));
|
|
return apiGet<{
|
|
total: number;
|
|
page: number;
|
|
page_size: number;
|
|
items: import("../types").FabricNodeSearchHit[];
|
|
}>(`/v1/topology/fabric/nodes/search?${p.toString()}`);
|
|
};
|
|
|
|
export const fetchFabricEdges = (params?: {
|
|
keyword?: string;
|
|
status?: string;
|
|
source?: string;
|
|
nodeId?: string;
|
|
page?: number;
|
|
pageSize?: number;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
if (params?.keyword) p.set("keyword", params.keyword);
|
|
if (params?.status) p.set("status", params.status);
|
|
if (params?.source) p.set("source", params.source);
|
|
if (params?.nodeId) p.set("node_id", params.nodeId);
|
|
p.set("page", String(Math.max(1, Number(params?.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(200, Number(params?.pageSize || 20)))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: FabricEdge[] }>(
|
|
`/v1/topology/fabric/edges?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const startLldpDiscover = (body?: {
|
|
scope?: "all_inventory" | "ne_ids";
|
|
ne_ids?: string[];
|
|
auto_add_unmatched?: boolean;
|
|
concurrency?: number;
|
|
trigger_mode?: "manual" | "schedule" | "topology";
|
|
}) => apiPost<TopologyDiscoverJob>("/v1/topology/fabric/discover", body || {});
|
|
|
|
export const fetchLldpDiscoverJob = (jobId: string) =>
|
|
apiGet<TopologyDiscoverJob>(`/v1/topology/fabric/discover/${encodeURIComponent(jobId)}`);
|
|
|
|
export const fetchLldpCollectDashboard = () =>
|
|
apiGet<LldpCollectDashboard>("/v1/topology/lldp-collect/dashboard");
|
|
|
|
export const updateLldpCollectPolicy = (body: Partial<LldpCollectPolicy>) =>
|
|
apiPut<LldpCollectPolicy>("/v1/topology/lldp-collect/policy", body);
|
|
|
|
export const startLldpCollect = () =>
|
|
apiPost<{ ok: boolean; job: TopologyDiscoverJob }>("/v1/topology/lldp-collect/start", {});
|
|
|
|
export const pauseLldpCollectJob = (jobId: string) =>
|
|
apiPost<TopologyDiscoverJob>(`/v1/topology/lldp-collect/jobs/${encodeURIComponent(jobId)}/pause`, {});
|
|
|
|
export const resumeLldpCollectJob = (jobId: string) =>
|
|
apiPost<TopologyDiscoverJob>(`/v1/topology/lldp-collect/jobs/${encodeURIComponent(jobId)}/resume`, {});
|
|
|
|
export const stopLldpCollectJob = (jobId: string) =>
|
|
apiPost<TopologyDiscoverJob>(`/v1/topology/lldp-collect/jobs/${encodeURIComponent(jobId)}/stop`, {});
|
|
|
|
export const fetchLldpCollectJobs = (params: { page?: number; pageSize?: number }) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, Number(params.pageSize || 20)))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: LldpCollectJobSummary[] }>(
|
|
`/v1/topology/lldp-collect/jobs?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchLldpCollectJob = (
|
|
jobId: string,
|
|
params?: { page?: number; pageSize?: number },
|
|
) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params?.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, Number(params?.pageSize || 20)))));
|
|
return apiGet<TopologyDiscoverJob>(
|
|
`/v1/topology/lldp-collect/jobs/${encodeURIComponent(jobId)}?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const createFabricManualEdge = (body: {
|
|
a_node_id: string;
|
|
b_node_id: string;
|
|
a_port?: string;
|
|
b_port?: string;
|
|
}) => apiPost<{ ok: boolean; action: string; edge: Record<string, unknown> }>("/v1/topology/fabric/edges", body);
|
|
|
|
export const deleteFabricEdges = (edgeIds: string[]) =>
|
|
apiPost<{ ok: boolean; deleted: number }>("/v1/topology/fabric/edges/delete", {
|
|
edge_ids: edgeIds,
|
|
});
|
|
|
|
export const deleteFabricEdge = (edgeId: string) =>
|
|
apiDelete<{ ok: boolean; deleted: number }>(
|
|
`/v1/topology/fabric/edges/${encodeURIComponent(edgeId)}`,
|
|
);
|
|
|
|
/** Back-compat aliases used by older call sites during cutover. */
|
|
export const fetchTopologyMaps = fetchTopologyViews;
|
|
export const createTopologyMap = createTopologyView;
|
|
export const fetchTopologyGraph = fetchTopologyViewGraph;
|
|
export const updateTopologyMap = updateTopologyView;
|
|
export const deleteTopologyMap = deleteTopologyView;
|
|
|
|
export const fetchConfigSyncDashboard = () =>
|
|
apiGet<ConfigSyncDashboard>("/v1/config-sync/dashboard");
|
|
|
|
export const fetchConfigSyncPolicy = () => apiGet<ConfigSyncPolicy>("/v1/config-sync/policy");
|
|
|
|
export const updateConfigSyncPolicy = (body: Partial<ConfigSyncPolicy>) =>
|
|
apiPut<ConfigSyncPolicy>("/v1/config-sync/policy", body);
|
|
|
|
export const fetchConfigSyncCycles = (params: { page?: number; pageSize?: number }) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, Number(params.pageSize || 20)))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: ConfigSyncCycle[] }>(
|
|
`/v1/config-sync/cycles?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const createConfigSyncCycle = (body: { mode: "full" | "retry_failed"; cycle_id?: string }) =>
|
|
apiPost<ConfigSyncCycle>("/v1/config-sync/cycles", body);
|
|
|
|
export const pauseConfigSyncCycle = (cycleId: string) =>
|
|
apiPost<ConfigSyncCycle>(`/v1/config-sync/cycles/${encodeURIComponent(cycleId)}/pause`, {});
|
|
|
|
export const resumeConfigSyncCycle = (cycleId: string) =>
|
|
apiPost<ConfigSyncCycle>(`/v1/config-sync/cycles/${encodeURIComponent(cycleId)}/resume`, {});
|
|
|
|
export const stopConfigSyncCycle = (cycleId: string) =>
|
|
apiPost<ConfigSyncCycle>(`/v1/config-sync/cycles/${encodeURIComponent(cycleId)}/stop`, {});
|
|
|
|
export const fetchConfigSyncCycleTasks = (params: {
|
|
cycleId: string;
|
|
page?: number;
|
|
pageSize?: number;
|
|
status?: string;
|
|
keyword?: string;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(200, Number(params.pageSize || 20)))));
|
|
if (params.status) p.set("status", params.status);
|
|
if (params.keyword?.trim()) p.set("keyword", params.keyword.trim());
|
|
return apiGet<{ total: number; page: number; page_size: number; items: ConfigSyncTask[] }>(
|
|
`/v1/config-sync/cycles/${encodeURIComponent(params.cycleId)}/tasks?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchNeConfigSnapshots = (params: {
|
|
page?: number;
|
|
pageSize?: number;
|
|
keyword?: string;
|
|
source?: string;
|
|
vendor?: string;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, Number(params.pageSize || 20)))));
|
|
if (params.keyword?.trim()) p.set("keyword", params.keyword.trim());
|
|
if (params.source) p.set("source", params.source);
|
|
if (params.vendor?.trim()) p.set("vendor", params.vendor.trim());
|
|
return apiGet<{ total: number; page: number; page_size: number; items: NeConfigSnapshotMeta[] }>(
|
|
`/v1/config-sync/snapshots?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
export const fetchNeConfigSnapshotDetail = (
|
|
source: string,
|
|
targetId: string,
|
|
field: "primary" | "alt" | "both" = "both",
|
|
) =>
|
|
apiGet<NeConfigSnapshotDetail>(
|
|
`/v1/config-sync/snapshots/${encodeURIComponent(source)}/${encodeURIComponent(targetId)}?field=${field}`,
|
|
);
|
|
|
|
export const downloadNeConfigSnapshot = async (
|
|
source: string,
|
|
targetId: string,
|
|
field: "primary" | "alt" | "both" = "primary",
|
|
): Promise<void> => {
|
|
const path =
|
|
`/v1/config-sync/snapshots/${encodeURIComponent(source)}/${encodeURIComponent(targetId)}` +
|
|
`/download?field=${encodeURIComponent(field)}`;
|
|
const res = await fetch(path, { headers: authHeaders() });
|
|
if (res.status === 401) {
|
|
handleUnauthorized(path);
|
|
throw new Error("unauthorized");
|
|
}
|
|
if (!res.ok) throw new Error(`${res.status} download`);
|
|
const blob = await res.blob();
|
|
const cd = res.headers.get("content-disposition") || "";
|
|
const star = /filename\*=UTF-8''([^;]+)/i.exec(cd);
|
|
const plain = /filename="?([^";]+)"?/i.exec(cd);
|
|
const filename = star
|
|
? decodeURIComponent(star[1])
|
|
: plain
|
|
? plain[1]
|
|
: `ne-config-${source}-${targetId}.txt`;
|
|
const url = URL.createObjectURL(blob);
|
|
try {
|
|
const a = document.createElement("a");
|
|
a.href = url;
|
|
a.download = filename;
|
|
a.click();
|
|
} finally {
|
|
URL.revokeObjectURL(url);
|
|
}
|
|
};
|
|
|
|
export const fetchPortTrafficDashboard = () =>
|
|
apiGet<PortTrafficDashboard>("/v1/port-traffic/dashboard");
|
|
|
|
export const fetchPortTrafficDevices = (params: { page?: number; pageSize?: number }) => {
|
|
const p = new URLSearchParams();
|
|
p.set("page", String(Math.max(1, Number(params.page || 1))));
|
|
p.set("page_size", String(Math.max(1, Math.min(100, Number(params.pageSize || 20)))));
|
|
return apiGet<{ total: number; page: number; page_size: number; items: PortTrafficDevice[] }>(
|
|
`/v1/port-traffic/devices?${p.toString()}`,
|
|
);
|
|
};
|
|
|
|
/** @deprecated */
|
|
export const fetchPortTrafficTasks = fetchPortTrafficDevices;
|
|
|
|
export const createPortTrafficDevice = (body: {
|
|
source: "managed" | "ume";
|
|
ne_id: string;
|
|
ne_name?: string;
|
|
ne_ip?: string;
|
|
vendor?: string;
|
|
note?: string;
|
|
interval_sec?: number;
|
|
retention_days?: number;
|
|
concurrency?: number;
|
|
interfaces?: PortTrafficIfaceIn[];
|
|
start_now?: boolean;
|
|
}) => apiPost<PortTrafficDevice>("/v1/port-traffic/devices", body);
|
|
|
|
export const updatePortTrafficDevice = (
|
|
deviceId: string,
|
|
body: {
|
|
note?: string;
|
|
interval_sec?: number;
|
|
retention_days?: number;
|
|
concurrency?: number;
|
|
ne_name?: string;
|
|
ne_ip?: string;
|
|
vendor?: string;
|
|
},
|
|
) => apiPatch<PortTrafficDevice>(`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}`, body);
|
|
|
|
export const startPortTrafficDevice = (deviceId: string) =>
|
|
apiPost<PortTrafficDevice>(`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/start`, {});
|
|
|
|
export const pausePortTrafficDevice = (deviceId: string) =>
|
|
apiPost<PortTrafficDevice>(`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/pause`, {});
|
|
|
|
export const stopPortTrafficDevice = (deviceId: string) =>
|
|
apiPost<PortTrafficDevice>(`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/stop`, {});
|
|
|
|
export const collectPortTrafficNow = (deviceId: string) =>
|
|
apiPost<PortTrafficDevice & { ok: boolean; started: boolean; reason?: string }>(
|
|
`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/collect-now`,
|
|
{},
|
|
);
|
|
|
|
export const deletePortTrafficDevice = (deviceId: string) =>
|
|
apiDelete<{ ok: boolean; id: string }>(`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}`);
|
|
|
|
export const rebindPortTrafficDevice = (deviceId: string, body: { ne_id: string }) =>
|
|
apiPost<PortTrafficDevice>(
|
|
`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/rebind`,
|
|
body,
|
|
);
|
|
|
|
export const fetchPortTrafficTargets = (deviceId: string) =>
|
|
apiGet<{ items: PortTrafficTarget[] }>(
|
|
`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/targets`,
|
|
);
|
|
|
|
export const fetchPortTrafficEvents = (deviceId: string, limit = 100) =>
|
|
apiGet<{ items: PortTrafficEvent[]; total: number }>(
|
|
`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/events?limit=${limit}`,
|
|
);
|
|
|
|
export const putPortTrafficInterfaces = (deviceId: string, interfaces: PortTrafficIfaceIn[]) =>
|
|
apiPut<{ items: PortTrafficTarget[] }>(
|
|
`/v1/port-traffic/devices/${encodeURIComponent(deviceId)}/interfaces`,
|
|
{ interfaces },
|
|
);
|
|
|
|
export const discoverPortTrafficPorts = (body: { source: "managed" | "ume"; id: string }) =>
|
|
apiPost<PortTrafficDiscoverResponse>("/v1/port-traffic/discover/ports", body);
|
|
|
|
export const fetchPortTrafficSamples = (params: {
|
|
targetId: string;
|
|
from?: string;
|
|
to?: string;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("target_id", params.targetId);
|
|
if (params.from) p.set("from", params.from);
|
|
if (params.to) p.set("to", params.to);
|
|
return apiGet<PortTrafficSamples>(`/v1/port-traffic/samples?${p.toString()}`);
|
|
};
|
|
|
|
export const fetchPortTrafficCompare = (params: {
|
|
targetId: string;
|
|
rangeHours: number;
|
|
baseline: string;
|
|
offsetHours?: number;
|
|
aheadHours?: number;
|
|
baselineTargetId?: string;
|
|
to?: string;
|
|
}) => {
|
|
const p = new URLSearchParams();
|
|
p.set("target_id", params.targetId);
|
|
p.set("range_hours", String(params.rangeHours));
|
|
p.set("baseline", params.baseline);
|
|
if (params.offsetHours != null) p.set("offset_hours", String(params.offsetHours));
|
|
if (params.aheadHours != null && params.aheadHours > 0) {
|
|
p.set("ahead_hours", String(params.aheadHours));
|
|
}
|
|
if (params.baselineTargetId) p.set("baseline_target_id", params.baselineTargetId);
|
|
if (params.to) p.set("to", params.to);
|
|
return apiGet<PortTrafficCompare>(`/v1/port-traffic/compare?${p.toString()}`);
|
|
};
|
|
|
|
export const fetchPortTrafficBoards = () =>
|
|
apiGet<{ items: PortTrafficBoardSummary[] }>("/v1/port-traffic/boards");
|
|
|
|
export const fetchPortTrafficBoard = (boardId: string) =>
|
|
apiGet<PortTrafficBoard>(`/v1/port-traffic/boards/${encodeURIComponent(boardId)}`);
|
|
|
|
export const createPortTrafficBoard = (body: {
|
|
name: string;
|
|
remark?: string;
|
|
cols?: number;
|
|
panels?: PortTrafficBoardPanelIn[];
|
|
}) => apiPost<PortTrafficBoard>("/v1/port-traffic/boards", body);
|
|
|
|
export const updatePortTrafficBoard = (
|
|
boardId: string,
|
|
body: { name?: string; remark?: string; cols?: number },
|
|
) => apiPatch<PortTrafficBoard>(`/v1/port-traffic/boards/${encodeURIComponent(boardId)}`, body);
|
|
|
|
export const putPortTrafficBoardPanels = (boardId: string, panels: PortTrafficBoardPanelIn[]) =>
|
|
apiPut<PortTrafficBoard>(`/v1/port-traffic/boards/${encodeURIComponent(boardId)}/panels`, {
|
|
panels,
|
|
});
|
|
|
|
export const deletePortTrafficBoard = (boardId: string) =>
|
|
apiDelete<{ ok: boolean; id: string }>(
|
|
`/v1/port-traffic/boards/${encodeURIComponent(boardId)}`,
|
|
);
|