Add backend support for pod and queue creation

Signed-off-by: Shrutim1505 <[email protected]>

Author: Shrutim1505

backend/src/server.js

@@ -8,6 +8,8 @@ import {
 import yaml from "js-yaml";
 
 export const app = express();
+app.use(express.json());
+
 app.use(cors({ origin: "*" }));
 
 const kc = new KubeConfig();
@@ -479,6 +481,192 @@ app.get("/api/all-pods", async (req, res) => {
     }
 });
 
+// POST /api/pods - Create a pod
+app.post("/api/pods", async (req, res) => {
+    let podManifest = req.body;
+    console.log("Received pod manifest:", JSON.stringify(podManifest, null, 2));
+
+    try {
+        // Defensive: check manifest shape
+        if (
+            !podManifest ||
+            !podManifest.metadata ||
+            !podManifest.metadata.name ||
+            !podManifest.spec
+        ) {
+            return res.status(400).json({ error: "Invalid pod manifest" });
+        }
+
+        // Fix the apiVersion for regular Pods
+        if (podManifest.apiVersion === "scheduling.volcano.sh/v1beta1") {
+            podManifest.apiVersion = "v1";
+        }
+
+        // Fix the kind
+        if (podManifest.kind !== "Pod") {
+            podManifest.kind = "Pod";
+        }
+
+        // Validate that this is a proper Pod spec (not Queue spec)
+        if (podManifest.spec.weight || podManifest.spec.reclaimable) {
+            return res.status(400).json({
+                error: "Invalid Pod spec. Use proper Pod specification with containers, not Queue fields.",
+            });
+        }
+
+        // Ensure Pod spec has required containers field
+        if (
+            !podManifest.spec.containers ||
+            !Array.isArray(podManifest.spec.containers)
+        ) {
+            return res.status(400).json({
+                error: "Pod spec must include 'containers' array",
+            });
+        }
+
+        // Defensive: never allow "All", fallback to "default" if missing
+        let namespace = podManifest.metadata.namespace;
+        if (
+            !namespace ||
+            namespace === "All" ||
+            typeof namespace !== "string" ||
+            !namespace.trim()
+        ) {
+            namespace = "default";
+            podManifest.metadata.namespace = namespace;
+        }
+
+        console.log("Creating pod in namespace:", namespace);
+        console.log(
+            "Final pod manifest:",
+            JSON.stringify(podManifest, null, 2),
+        );
+
+        // Use object-based syntax for consistency
+        const response = await k8sCoreApi.createNamespacedPod({
+            namespace: namespace,
+            body: podManifest,
+        });
+
+        res.status(201).json({
+            message: "Pod created successfully",
+            data: response.body,
+        });
+    } catch (error) {
+        console.error("Error creating pod:", error?.body || error);
+        let msg = "Failed to create pod";
+        if (error?.body?.message) {
+            msg = error.body.message;
+        } else if (error?.message) {
+            msg = error.message;
+        }
+        res.status(500).json({ error: msg });
+    }
+});
+// POST /api/jobs - Create a job (Volcano custom job)
+app.post("/api/jobs", async (req, res) => {
+    const jobManifest = req.body;
+    try {
+        if (
+            !jobManifest ||
+            !jobManifest.metadata ||
+            !jobManifest.metadata.name ||
+            !jobManifest.spec
+        ) {
+            return res.status(400).json({ error: "Invalid job manifest" });
+        }
+
+        const namespace = jobManifest.metadata.namespace || "default";
+        const response = await k8sApi.createNamespacedCustomObject(
+            "batch.volcano.sh",
+            "v1alpha1",
+            namespace,
+            "jobs",
+            jobManifest,
+        );
+
+        res.status(201).json({
+            message: "Job created successfully",
+            data: response.body,
+        });
+    } catch (error) {
+        console.error("Error creating job:", error?.body || error);
+        let msg = "Failed to create job";
+        if (error?.body?.message) msg = error.body.message;
+        res.status(500).json({ error: msg });
+    }
+});
+
+//create a queue
+app.post("/api/queues", async (req, res) => {
+    const queueManifest = req.body;
+
+    try {
+        if (
+            !queueManifest ||
+            !queueManifest.metadata ||
+            !queueManifest.metadata.name ||
+            !queueManifest.spec
+        ) {
+            return res.status(400).json({ error: "Invalid queue manifest" });
+        }
+
+        // Debug the API client
+        console.log("API client type:", typeof k8sApi);
+        console.log(
+            "createClusterCustomObject method exists:",
+            typeof k8sApi.createClusterCustomObject,
+        );
+
+        // Test if we can list queues first (simpler operation)
+        console.log("Testing list operation first...");
+        try {
+            const listResponse = await k8sApi.listClusterCustomObject({
+                group: "scheduling.volcano.sh",
+                version: "v1beta1",
+                plural: "queues",
+            });
+            console.log(
+                "List operation successful, found",
+                listResponse.items?.length || 0,
+                "queues",
+            );
+        } catch (listError) {
+            console.error("List operation failed:", listError.message);
+        }
+
+        // Add timeout and more detailed logging
+        console.log("About to call k8sApi.createClusterCustomObject...");
+
+        const response = await Promise.race([
+            k8sApi.createClusterCustomObject({
+                group: "scheduling.volcano.sh",
+                version: "v1beta1",
+                plural: "queues",
+                body: queueManifest,
+            }),
+            new Promise((_, reject) =>
+                setTimeout(
+                    () => reject(new Error("API call timeout after 30s")),
+                    30000,
+                ),
+            ),
+        ]);
+
+        console.log("API call successful, response:", response);
+
+        res.status(201).json({
+            message: "Queue created successfully",
+            data: response.body,
+        });
+    } catch (error) {
+        console.error("Error creating queue:", error?.body || error);
+        let msg = "Failed to create queue";
+        if (error?.body?.message) msg = error.body.message;
+        res.status(500).json({ error: msg });
+    }
+});
+
 app.delete("/api/queues/:name", async (req, res) => {
     const { name } = req.params;
     const queueName = name.toLowerCase();