tronnet/ProxmoxAAS-API
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

major rework of backend loading and usage:

Browse Source 
- split config from user data to config.json, add config.hson.template
- moved default user data localdb to root folder
- moved pve, localdb, ldap backend handlers to backends sub folder
- add dynamic loading of all backends
- add dynamic mapping for auth backends to support multiple auth sources
- update affected endpoints
This commit is contained in:
Arthur Lu
2024-01-06 22:36:18 +00:00
parent c801ca99df
commit 18590011cc
21 changed files with 629 additions and 674 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/routes/auth.js
View File

@@ -1,11 +1,7 @@
import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const db = global.db;
const domain = global.db.domain;
const checkAuth = global.utils.checkAuth;
const requestPVE = global.pve.requestPVE;
const pveAPIToken = global.db.pveAPIToken;
/**
* GET - check authentication
@@ -31,12 +27,13 @@ router.get("/", async (req, res) => {
* - 401: {auth: false}
*/
router.post("/ticket", async (req, res) => {
const response = await requestPVE("/access/ticket", "POST", null, JSON.stringify(req.body));
const response = await global.pve.requestPVE("/access/ticket", "POST", null, JSON.stringify(req.body));
if (!(response.status === 200)) {
res.status(response.status).send({ auth: false });
res.end();
return;
}
const domain = global.config.application.domain;
const ticket = response.data.data.ticket;
const csrftoken = response.data.data.CSRFPreventionToken;
const username = response.data.data.username;
@@ -55,6 +52,7 @@ router.post("/ticket", async (req, res) => {
*/
router.delete("/ticket", async (req, res) => {
const expire = new Date(0);
const domain = global.config.application.domain;
res.cookie("PVEAuthCookie", "", { domain, path: "/", httpOnly: true, secure: true, expires: expire });
res.cookie("CSRFPreventionToken", "", { domain, path: "/", httpOnly: true, secure: true, expires: expire });
res.cookie("username", "", { domain, path: "/", httpOnly: true, secure: true, expires: expire });
@@ -69,16 +67,19 @@ router.post("/password", async (req, res) => {
};
const userRealm = params.userid.split("@").at(-1);
const domains = (await requestPVE("/access/domains", "GET", pveAPIToken)).data.data;
const domains = (await global.pve.requestPVE("/access/domains", "GET", { token: true })).data.data;
const realm = domains.find((e) => e.realm === userRealm);
const authTypes = db.getStatic().types.auth;
const realmType = authTypes[realm.type];
const authHandlers = global.config.handlers.auth;
const handlerType = authHandlers[realm.type];
if (realmType === "pve") {
const response = await requestPVE("/access/password", "PUT", { cookies: req.cookies }, JSON.stringify(params));
if (handlerType === "pve") {
const response = await global.pve.requestPVE("/access/password", "PUT", { cookies: req.cookies }, JSON.stringify(params));
res.status(response.status).send(response.data);
}
else if (handlerType === "paasldap") {
res.status(501).send({ error: `Auth type ${handlerType} not implemented yet.` });
}
else {
res.status(501).send({ error: `Auth type ${realmType} not implemented yet.` });
res.status(501).send({ error: `Auth type ${handlerType} not implemented yet.` });
}
});

22
src/routes/cluster.js
View File

@@ -2,12 +2,8 @@ import { Router } from "express";
export const router = Router({ mergeParams: true });
const db = global.db;
const requestPVE = global.pve.requestPVE;
const handleResponse = global.pve.handleResponse;
const checkAuth = global.utils.checkAuth;
const approveResources = global.utils.approveResources;
const pveAPIToken = global.db.pveAPIToken;
const getNodeAvailDevices = global.pve.getNodeAvailDevices;
const getUserResources = global.utils.getUserResources;
const nodeRegexP = "[\\w-]+";
@@ -16,7 +12,7 @@ const vmidRegexP = "\\d+";
const basePath = `/:node(${nodeRegexP})/:type(${typeRegexP})/:vmid(${vmidRegexP})`;
global.utils.recursiveImport(router, basePath, "cluster", import.meta.url);
global.utils.recursiveImportRoutes(router, basePath, "cluster", import.meta.url);
/**
* GET - get available pcie devices given node and user
@@ -46,7 +42,7 @@ router.get(`/:node(${nodeRegexP})/pci`, async (req, res) => {
// get remaining user resources
const userAvailPci = (await getUserResources(req, req.cookies.username)).pci.nodes[params.node];
// get node avail devices
let nodeAvailPci = await getNodeAvailDevices(params.node, req.cookies);
let nodeAvailPci = await global.pve.getNodeAvailDevices(params.node, req.cookies);
nodeAvailPci = nodeAvailPci.filter(nodeAvail => userAvailPci.some((userAvail) => {
return nodeAvail.device_name && nodeAvail.device_name.includes(userAvail.match) && userAvail.avail > 0;
}));
@@ -88,7 +84,7 @@ router.post(`${basePath}/resources`, async (req, res) => {
return;
}
// get current config
const currentConfig = await requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: pveAPIToken });
const currentConfig = await global.pve.requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: true });
const request = {
cores: Number(params.cores) - Number(currentConfig.data.data.cores),
memory: Number(params.memory) - Number(currentConfig.data.data.memory)
@@ -117,8 +113,8 @@ router.post(`${basePath}/resources`, async (req, res) => {
action = JSON.stringify(action);
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -229,8 +225,8 @@ router.post(`${basePath}/create`, async (req, res) => {
}
action = JSON.stringify(action);
// commit action
const result = await requestPVE(`/nodes/${params.node}/${params.type}`, "POST", { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`/nodes/${params.node}/${params.type}`, "POST", { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -257,6 +253,6 @@ router.delete(`${basePath}/delete`, async (req, res) => {
return;
}
// commit action
const result = await requestPVE(vmpath, "DELETE", { token: pveAPIToken });
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(vmpath, "DELETE", { token: true });
await global.pve.handleResponse(params.node, result, res);
});

51
src/routes/cluster/disk.js
View File

@@ -1,13 +1,8 @@
import { Router } from "express";
export const router = Router({ mergeParams: true });
const db = global.db;
const requestPVE = global.pve.requestPVE;
const handleResponse = global.pve.handleResponse;
const getDiskInfo = global.pve.getDiskInfo;
const checkAuth = global.utils.checkAuth;
const approveResources = global.utils.approveResources;
const pveAPIToken = global.db.pveAPIToken;
/**
* POST - detach mounted disk from instance
@@ -37,7 +32,7 @@ router.post("/:disk/detach", async (req, res) => {
return;
}
// get current config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
// disk must exist
if (!config[params.disk]) {
res.status(500).send({ error: `Disk ${params.disk} does not exist.` });
@@ -52,8 +47,8 @@ router.post("/:disk/detach", async (req, res) => {
}
const action = JSON.stringify({ delete: params.disk });
const method = params.type === "qemu" ? "POST" : "PUT";
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -86,7 +81,7 @@ router.post("/:disk/attach", async (req, res) => {
return;
}
// get current config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
// disk must exist
if (!config[`unused${params.source}`]) {
res.status(403).send({ error: `Requested disk unused${params.source} does not exist.` });
@@ -94,8 +89,8 @@ router.post("/:disk/attach", async (req, res) => {
return;
}
// target disk must be allowed according to source disk's storage options
const diskConfig = await getDiskInfo(params.node, config, `unused${params.source}`); // get target disk
const resourceConfig = db.getGlobal().resources;
const diskConfig = await global.pve.getDiskInfo(params.node, config, `unused${params.source}`); // get target disk
const resourceConfig = global.config.resources;
if (!resourceConfig[diskConfig.storage].disks.some(diskPrefix => params.disk.startsWith(diskPrefix))) {
res.status(500).send({ error: `Requested target ${params.disk} is not in allowed list [${resourceConfig[diskConfig.storage].disks}].` });
res.end();
@@ -107,8 +102,8 @@ router.post("/:disk/attach", async (req, res) => {
action = JSON.stringify(action);
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -142,9 +137,9 @@ router.post("/:disk/resize", async (req, res) => {
return;
}
// get current config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
// check disk existence
const diskConfig = await getDiskInfo(params.node, config, params.disk); // get target disk
const diskConfig = await global.pve.getDiskInfo(params.node, config, params.disk); // get target disk
if (!diskConfig) { // exit if disk does not exist
res.status(500).send({ error: `requested disk ${params.disk} does not exist.` });
res.end();
@@ -162,8 +157,8 @@ router.post("/:disk/resize", async (req, res) => {
}
// action approved, commit to action
const action = JSON.stringify({ disk: params.disk, size: `+${params.size}G` });
const result = await requestPVE(`${vmpath}/resize`, "PUT", { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/resize`, "PUT", { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -199,9 +194,9 @@ router.post("/:disk/move", async (req, res) => {
return;
}
// get current config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
// check disk existence
const diskConfig = await getDiskInfo(params.node, config, params.disk); // get target disk
const diskConfig = await global.pve.getDiskInfo(params.node, config, params.disk); // get target disk
if (!diskConfig) { // exit if disk does not exist
res.status(500).send({ error: `requested disk ${params.disk} does not exist.` });
res.end();
@@ -231,8 +226,8 @@ router.post("/:disk/move", async (req, res) => {
action = JSON.stringify(action);
const route = params.type === "qemu" ? "move_disk" : "move_volume";
// commit action
const result = await requestPVE(`${vmpath}/${route}`, "POST", { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/${route}`, "POST", { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -263,7 +258,7 @@ router.delete("/:disk/delete", async (req, res) => {
return;
}
// get current config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
// disk must exist
if (!config[params.disk]) {
res.status(403).send({ error: `Requested disk unused${params.source} does not exist.` });
@@ -280,8 +275,8 @@ router.delete("/:disk/delete", async (req, res) => {
const action = JSON.stringify({ delete: params.disk });
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -318,7 +313,7 @@ router.post("/:disk/create", async (req, res) => {
return;
}
// get current config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
// disk must not exist
if (config[params.disk]) {
res.status(403).send({ error: `Requested disk ${params.disk} already exists.` });
@@ -337,7 +332,7 @@ router.post("/:disk/create", async (req, res) => {
return;
}
// target disk must be allowed according to storage options
const resourceConfig = db.getGlobal().resources;
const resourceConfig = global.config.resources;
if (!resourceConfig[params.storage].disks.some(diskPrefix => params.disk.startsWith(diskPrefix))) {
res.status(500).send({ error: `Requested target ${params.disk} is not in allowed list [${resourceConfig[params.storage].disks}].` });
res.end();
@@ -358,6 +353,6 @@ router.post("/:disk/create", async (req, res) => {
action = JSON.stringify(action);
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});

21
src/routes/cluster/net.js
View File

@@ -2,11 +2,8 @@ import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const db = global.db;
const requestPVE = global.pve.requestPVE;
const handleResponse = global.pve.handleResponse;
const checkAuth = global.utils.checkAuth;
const approveResources = global.utils.approveResources;
const pveAPIToken = global.db.pveAPIToken;
/**
* POST - create new virtual network interface
@@ -41,7 +38,7 @@ router.post("/:netid/create", async (req, res) => {
return;
}
// get current config
const currentConfig = await requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: pveAPIToken });
const currentConfig = await global.pve.requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: true });
// net interface must not exist
if (currentConfig.data.data[`net${params.netid}`]) {
res.status(500).send({ error: `Network interface net${params.netid} already exists.` });
@@ -74,8 +71,8 @@ router.post("/:netid/create", async (req, res) => {
action = JSON.stringify(action);
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -109,7 +106,7 @@ router.post("/:netid/modify", async (req, res) => {
return;
}
// get current config
const currentConfig = await requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: pveAPIToken });
const currentConfig = await global.pve.requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: true });
// net interface must already exist
if (!currentConfig.data.data[`net${params.netid}`]) {
res.status(500).send({ error: `Network interface net${params.netid} does not exist.` });
@@ -133,8 +130,8 @@ router.post("/:netid/modify", async (req, res) => {
action = JSON.stringify(action);
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -165,7 +162,7 @@ router.delete("/:netid/delete", async (req, res) => {
return;
}
// get current config
const currentConfig = await requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: pveAPIToken });
const currentConfig = await global.pve.requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: true });
// net interface must already exist
if (!currentConfig.data.data[`net${params.netid}`]) {
res.status(500).send({ error: `Network interface net${params.netid} does not exist.` });
@@ -176,6 +173,6 @@ router.delete("/:netid/delete", async (req, res) => {
const action = JSON.stringify({ delete: `net${params.netid}` });
const method = params.type === "qemu" ? "POST" : "PUT";
// commit action
const result = await requestPVE(`${vmpath}/config`, method, { token: pveAPIToken }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, method, { token: true }, action);
await global.pve.handleResponse(params.node, result, res);
});

44
src/routes/cluster/pci.js
View File

@@ -1,14 +1,8 @@
import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const db = global.db;
const requestPVE = global.pve.requestPVE;
const handleResponse = global.pve.handleResponse;
const getDeviceInfo = global.pve.getDeviceInfo;
const getNodeAvailDevices = global.pve.getNodeAvailDevices;
const checkAuth = global.utils.checkAuth;
const approveResources = global.utils.approveResources;
const pveAPIToken = global.db.pveAPIToken;
/**
* GET - get instance pcie device data
@@ -37,7 +31,7 @@ router.get("/:hostpci", async (req, res) => {
return;
}
// check device is in instance config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
if (!config[`hostpci${params.hostpci}`]) {
res.status(500).send({ error: `Could not find hostpci${params.hostpci} in ${params.vmid}.` });
res.end();
@@ -45,7 +39,7 @@ router.get("/:hostpci", async (req, res) => {
}
const device = config[`hostpci${params.hostpci}`].split(",")[0];
// get node's pci devices
const deviceData = await getDeviceInfo(params.node, device);
const deviceData = await global.pve.getDeviceInfo(params.node, device);
if (!deviceData) {
res.status(500).send({ error: `Could not find hostpci${params.hostpci}=${device} in ${params.node}.` });
res.end();
@@ -95,8 +89,8 @@ router.post("/:hostpci/modify", async (req, res) => {
// force all functions
params.device = params.device.split(".")[0];
// get instance config to check if device has not changed
const config = (await requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: pveAPIToken })).data.data;
const currentDeviceData = await getDeviceInfo(params.node, config[`hostpci${params.hostpci}`].split(",")[0]);
const config = (await global.pve.requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { token: true })).data.data;
const currentDeviceData = await global.pve.getDeviceInfo(params.node, config[`hostpci${params.hostpci}`].split(",")[0]);
if (!currentDeviceData) {
res.status(500).send({ error: `No device in hostpci${params.hostpci}.` });
res.end();
@@ -105,7 +99,7 @@ router.post("/:hostpci/modify", async (req, res) => {
// only check user and node availability if base id is different
if (currentDeviceData.id.split(".")[0] !== params.device) {
// setup request
const deviceData = await getDeviceInfo(params.node, params.device);
const deviceData = await global.pve.getDeviceInfo(params.node, params.device);
const request = { pci: deviceData.device_name };
// check resource approval
if (!await approveResources(req, req.cookies.username, request, params.node)) {
@@ -114,7 +108,7 @@ router.post("/:hostpci/modify", async (req, res) => {
return;
}
// check node availability
const nodeAvailPci = await getNodeAvailDevices(params.node, req.cookies);
const nodeAvailPci = await global.pve.getNodeAvailDevices(params.node, req.cookies);
if (!nodeAvailPci.some(element => element.id.split(".")[0] === params.device)) {
res.status(500).send({ error: `Device ${params.device} is already in use on ${params.node}.` });
res.end();
@@ -126,7 +120,7 @@ router.post("/:hostpci/modify", async (req, res) => {
action[`hostpci${params.hostpci}`] = `${params.device},pcie=${params.pcie}`;
action = JSON.stringify(action);
// commit action
const rootauth = await requestPVE("/access/ticket", "POST", null, JSON.stringify(db.getGlobal().application.pveroot));
const rootauth = await global.pve.requestPVE("/access/ticket", "POST", null, JSON.stringify(global.config.backends.pve.config.root));
if (!(rootauth.status === 200)) {
res.status(rootauth.status).send({ auth: false, error: "API could not authenticate as root user." });
res.end();
@@ -136,8 +130,8 @@ router.post("/:hostpci/modify", async (req, res) => {
PVEAuthCookie: rootauth.data.data.ticket,
CSRFPreventionToken: rootauth.data.data.CSRFPreventionToken
};
const result = await requestPVE(`${vmpath}/config`, "POST", { cookies: rootcookies }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, "POST", { cookies: rootcookies }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -178,13 +172,13 @@ router.post("/create", async (req, res) => {
// force all functions
params.device = params.device.split(".")[0];
// get instance config to find next available hostpci slot
const config = requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { cookies: params.cookies });
const config = global.pve.requestPVE(`/nodes/${params.node}/${params.type}/${params.vmid}/config`, "GET", { cookies: params.cookies });
let hostpci = 0;
while (config[`hostpci${hostpci}`]) {
hostpci++;
}
// setup request
const deviceData = await getDeviceInfo(params.node, params.device);
const deviceData = await global.pve.getDeviceInfo(params.node, params.device);
const request = {
pci: deviceData.device_name
};
@@ -195,7 +189,7 @@ router.post("/create", async (req, res) => {
return;
}
// check node availability
const nodeAvailPci = await getNodeAvailDevices(params.node, req.cookies);
const nodeAvailPci = await global.pve.getNodeAvailDevices(params.node, req.cookies);
if (!nodeAvailPci.some(element => element.id.split(".")[0] === params.device)) {
res.status(500).send({ error: `Device ${params.device} is already in use on ${params.node}.` });
res.end();
@@ -206,7 +200,7 @@ router.post("/create", async (req, res) => {
action[`hostpci${hostpci}`] = `${params.device},pcie=${params.pcie}`;
action = JSON.stringify(action);
// commit action
const rootauth = await requestPVE("/access/ticket", "POST", null, JSON.stringify(db.getGlobal().application.pveroot));
const rootauth = await global.pve.requestPVE("/access/ticket", "POST", null, JSON.stringify(global.config.backends.pve.config.root));
if (!(rootauth.status === 200)) {
res.status(rootauth.status).send({ auth: false, error: "API could not authenticate as root user." });
res.end();
@@ -216,8 +210,8 @@ router.post("/create", async (req, res) => {
PVEAuthCookie: rootauth.data.data.ticket,
CSRFPreventionToken: rootauth.data.data.CSRFPreventionToken
};
const result = await requestPVE(`${vmpath}/config`, "POST", { cookies: rootcookies }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, "POST", { cookies: rootcookies }, action);
await global.pve.handleResponse(params.node, result, res);
});
/**
@@ -254,7 +248,7 @@ router.delete("/:hostpci/delete", async (req, res) => {
return;
}
// check device is in instance config
const config = (await requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
const config = (await global.pve.requestPVE(`${vmpath}/config`, "GET", { cookies: req.cookies })).data.data;
if (!config[`hostpci${params.hostpci}`]) {
res.status(500).send({ error: `Could not find hostpci${params.hostpci} in ${params.vmid}.` });
res.end();
@@ -263,7 +257,7 @@ router.delete("/:hostpci/delete", async (req, res) => {
// setup action
const action = JSON.stringify({ delete: `hostpci${params.hostpci}` });
// commit action, need to use root user here because proxmox api only allows root to modify hostpci for whatever reason
const rootauth = await requestPVE("/access/ticket", "POST", null, JSON.stringify(db.getGlobal().application.pveroot));
const rootauth = await global.pve.requestPVE("/access/ticket", "POST", null, JSON.stringify(global.config.backends.pve.config.root));
if (!(rootauth.status === 200)) {
res.status(rootauth.status).send({ auth: false, error: "API could not authenticate as root user." });
res.end();
@@ -273,6 +267,6 @@ router.delete("/:hostpci/delete", async (req, res) => {
PVEAuthCookie: rootauth.data.data.ticket,
CSRFPreventionToken: rootauth.data.data.CSRFPreventionToken
};
const result = await requestPVE(`${vmpath}/config`, "POST", { cookies: rootcookies }, action);
await handleResponse(params.node, result, res);
const result = await global.pve.requestPVE(`${vmpath}/config`, "POST", { cookies: rootcookies }, action);
await global.pve.handleResponse(params.node, result, res);
});

75
src/routes/cluster/user.js Normal file
View File

@@ -0,0 +1,75 @@
import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const config = global.config;
const checkAuth = global.utils.checkAuth;
const getUserResources = global.utils.getUserResources;
/**
* GET - get db user resource information including allocated, free, and maximum resource values along with resource metadata
* responses:
* - 200: {avail: Object, max: Object, used: Object, resources: Object}
* - 401: {auth: false}
*/
router.get("/dynamic/resources", async (req, res) => {
// check auth
const auth = await checkAuth(req.cookies, res);
if (!auth) {
return;
}
const resources = await getUserResources(req, req.cookies.username);
res.status(200).send(resources);
});
/**
* GET - get db user configuration by key
* request:
* - key: string - user config key
* responses:
* - 200: Object
* - 401: {auth: false}
* - 401: {auth: false, error: string}
*/
router.get("/config/:key", async (req, res) => {
const params = {
key: req.params.key
};
// check auth
const auth = await checkAuth(req.cookies, res);
if (!auth) {
return;
}
const allowKeys = ["resources", "cluster", "nodes"];
if (allowKeys.includes(params.key)) {
const config = global.db.getUser(req.cookies.username);
res.status(200).send(config[params.key]);
}
else {
res.status(401).send({ auth: false, error: `User is not authorized to access /user/config/${params.key}.` });
}
});
/**
* GET - get user accessible iso files
* response:
* - 200: Array.<Object>
* - 401: {auth: false}
*/
router.get("/iso", async (req, res) => {
// check auth
const auth = await checkAuth(req.cookies, res);
if (!auth) {
return;
}
// get user iso config
const userIsoConfig = config.useriso;
// get all isos
const isos = (await global.pve.requestPVE(`/nodes/${userIsoConfig.node}/storage/${userIsoConfig.storage}/content?content=iso`, "GET", { token: true })).data.data;
const userIsos = [];
isos.forEach((iso) => {
iso.name = iso.volid.replace(`${userIsoConfig.storage}:iso/`, "");
userIsos.push(iso);
});
userIsos.sort();
res.status(200).send(userIsos);
});

3
src/routes/global.js
View File

@@ -1,7 +1,6 @@
import { Router } from "express";
export const router = Router({ mergeParams: true });
const db = global.db;
const checkAuth = global.utils.checkAuth;
/**
@@ -20,7 +19,7 @@ router.get("/config/:key", async (req, res) => {
}
const allowKeys = ["resources"];
if (allowKeys.includes(params.key)) {
const config = db.getGlobal();
const config = global.config;
res.status(200).send(config[params.key]);
}
else {

6
src/routes/proxmox.js
View File

@@ -1,8 +1,6 @@
import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const requestPVE = global.pve.requestPVE;
/**
* GET - proxy proxmox api without privilege elevation
* request and responses passed through to/from proxmox
@@ -10,7 +8,7 @@ const requestPVE = global.pve.requestPVE;
router.get("/*", async (req, res) => { // proxy endpoint for GET proxmox api with no token
console.log(req.url);
const path = req.url.replace("/api/proxmox", "");
const result = await requestPVE(path, "GET", { cookies: req.cookies });
const result = await global.pve.requestPVE(path, "GET", { cookies: req.cookies });
res.status(result.status).send(result.data);
});
@@ -20,6 +18,6 @@ router.get("/*", async (req, res) => { // proxy endpoint for GET proxmox api wit
*/
router.post("/*", async (req, res) => { // proxy endpoint for POST proxmox api with no token
const path = req.url.replace("/api/proxmox", "");
const result = await requestPVE(path, "POST", { cookies: req.cookies }, JSON.stringify(req.body)); // need to stringify body because of other issues
const result = await global.pve.requestPVE(path, "POST", { cookies: req.cookies }, JSON.stringify(req.body)); // need to stringify body because of other issues
res.status(result.status).send(result.data);
});

15
src/routes/sync.js
View File

@@ -4,10 +4,7 @@ import * as cookie from "cookie";
import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const requestPVE = global.pve.requestPVE;
const checkAuth = global.utils.checkAuth;
const db = global.db;
const pveAPIToken = global.db.pveAPIToken;
const getObjectHash = global.utils.getObjectHash;
const getTimeLeft = global.utils.getTimeLeft;
@@ -24,8 +21,8 @@ let prevState = {};
// target ms value
let targetMSTime = null;
const schemes = db.getGlobal().clientsync.schemes;
const resourceTypes = db.getGlobal().clientsync.resourcetypes;
const schemes = global.config.clientsync.schemes;
const resourceTypes = global.config.clientsync.resourcetypes;
/**
* GET - get list of supported synchronization schemes
* responses:
@@ -55,7 +52,7 @@ if (schemes.hash.enabled) {
return;
}
// get current cluster resources
const status = (await requestPVE("/cluster/resources", "GET", { cookies: req.cookies })).data.data;
const status = (await global.pve.requestPVE("/cluster/resources", "GET", { cookies: req.cookies })).data.data;
// filter out just state information of resources that are needed
const state = extractClusterState(status, resourceTypes);
res.status(200).send(getObjectHash(state));
@@ -158,13 +155,13 @@ if (schemes.interrupt.enabled) {
// handle the wss upgrade request
global.server.on("upgrade", async (req, socket, head) => {
const cookies = cookie.parse(req.headers.cookie || "");
const auth = (await requestPVE("/version", "GET", { cookies })).status === 200;
const auth = (await global.pve.requestPVE("/version", "GET", { cookies })).status === 200;
if (!auth) {
socket.destroy();
}
else {
wsServer.handleUpgrade(req, socket, head, (socket) => {
const pool = db.getUser(cookies.username).cluster.pool;
const pool = global.db.getUser(cookies.username).cluster.pool;
wsServer.emit("connection", socket, cookies.username, pool);
});
}
@@ -185,7 +182,7 @@ if (schemes.interrupt.enabled) {
return;
}
// get current cluster resources
const status = (await requestPVE("/cluster/resources", "GET", { token: pveAPIToken })).data.data;
const status = (await global.pve.requestPVE("/cluster/resources", "GET", { token: true })).data.data;
// filter out just state information of resources that are needed, and hash each one
const currState = extractClusterState(status, resourceTypes, true);
// get a map of users to send sync notifications

9
src/routes/user.js
View File

@@ -1,11 +1,8 @@
import { Router } from "express";
export const router = Router({ mergeParams: true }); ;
const db = global.db;
const requestPVE = global.pve.requestPVE;
const checkAuth = global.utils.checkAuth;
const getUserResources = global.utils.getUserResources;
const pveAPIToken = global.db.pveAPIToken;
/**
* GET - get db user resource information including allocated, free, and maximum resource values along with resource metadata
@@ -43,7 +40,7 @@ router.get("/config/:key", async (req, res) => {
}
const allowKeys = ["resources", "cluster", "nodes"];
if (allowKeys.includes(params.key)) {
const config = db.getUser(req.cookies.username);
const config = global.db.getUser(req.cookies.username);
res.status(200).send(config[params.key]);
}
else {
@@ -64,9 +61,9 @@ router.get("/iso", async (req, res) => {
return;
}
// get user iso config
const userIsoConfig = db.getGlobal().useriso;
const userIsoConfig = global.config.useriso;
// get all isos
const isos = (await requestPVE(`/nodes/${userIsoConfig.node}/storage/${userIsoConfig.storage}/content?content=iso`, "GET", { token: pveAPIToken })).data.data;
const isos = (await global.pve.requestPVE(`/nodes/${userIsoConfig.node}/storage/${userIsoConfig.storage}/content?content=iso`, "GET", { token: true })).data.data;
const userIsos = [];
isos.forEach((iso) => {
iso.name = iso.volid.replace(`${userIsoConfig.storage}:iso/`, "");