Merge pull request #92 from dhruvthak3r/feat/add_configmap

Feat/add configmap

Author: Flux159

src/index.ts

@@ -67,6 +67,7 @@ import {
   describeDeployment,
   describeDeploymentSchema,
 } from "./tools/describe_deployment.js";
+import {createConfigMap, CreateConfigMapSchema } from "./tools/create_configmap.js";
 
 const k8sManager = new KubernetesManager();
 
@@ -112,6 +113,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       StopPortForwardSchema,
       scaleDeploymentSchema,
       DeleteCronJobSchema,
+      CreateConfigMapSchema,
     ],
   };
 });
@@ -449,6 +451,17 @@ server.setRequestHandler(
           );
         }
 
+        case "create_configmap" : {
+          return await createConfigMap(
+            k8sManager,
+            input as {
+              name : string,
+              namespace : string,
+              data : Record<string, string>
+            }
+          );
+        }
+
         default:
           throw new McpError(ErrorCode.InvalidRequest, `Unknown tool: ${name}`);
       }

src/models/response-schemas.ts

@@ -108,3 +108,12 @@ export const DeleteCronJobResponseSchema = z.object({
     })
   ),
 });
+
+export const CreateConfigMapResponseSchema = z.object({
+  content: z.array(
+    z.object({
+      success: z.boolean(),
+      message: z.string(),
+    })
+  ),
+});

src/tools/create_configmap.ts

@@ -0,0 +1,75 @@
+import { KubernetesManager } from "../types.js";
+import * as k8s from "@kubernetes/client-node";
+export const CreateConfigMapSchema = {
+    name : "create_configmap",
+    description :  "Create a new Kubernetes ConfigMap",
+    inputSchema : {
+        type : "object",
+        properties : {
+            name : { type : "string" },
+            namespace : { type : "string" },
+            data : {
+                type : "object",
+                ConfigData : { type : "string" },
+            },
+        },
+        required : ["name", "namespace", "data"],
+    },
+};
+
+export async function createConfigMap(
+    k8sManager : KubernetesManager,
+    input : {
+        name : string;
+        namespace : string;
+        data : Record<string, string>;
+    }
+): Promise<{ content: { success: boolean; message: string}[] }> {
+    try {
+        const configmap : k8s.V1ConfigMap = {
+            apiVersion : "v1",
+            kind : "ConfigMap",
+            binaryData : undefined,
+            data : input.data,
+            immutable : false,
+            metadata : {
+                name : input.name,
+                namespace : input.namespace,
+                labels : {
+                    "mcp-managed" : "true",
+                    app : input.name,
+                },
+            },
+        }
+        const response = await k8sManager.getCoreApi().createNamespacedConfigMap(input.namespace, configmap);
+        if(response.response?.statusCode !== undefined && (response.response.statusCode == 200 || response.response.statusCode == 201 || response.response.statusCode == 202)) {
+            return {
+                content : [
+                    {
+                        success : true,
+                        message : `Created ConfigMap ${response.body.metadata?.name} in namespace ${response.body.metadata?.namespace}`,
+                    }
+                ]
+            }
+        }
+        else {
+            return {
+                content : [
+                    {
+                        success : false,
+                        message : `Failed to create ConfigMap ${response.body.metadata?.name} in namespace ${response.body.metadata?.namespace}`,
+                    }
+                ]
+        }
+    }
+    } catch (error : any) {
+        return {
+            content : [
+                {
+                    success : false,
+                    message : `Failed to create ConfigMap ${input.name} in namespace ${input.namespace}. Error: ${error.message}`,
+                }
+            ]
+        };
+    }
+}

tests/configmap.test.ts

@@ -0,0 +1,118 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { CreateNamespaceResponseSchema } from "../src/types";
+import {CreateConfigMapResponseSchema} from "../src/models/response-schemas.js";
+import { KubernetesManager } from "../src/types";
+async function sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  function generateRandomId(): string {
+    return Math.random().toString(36).substring(2, 10);
+  }
+
+  function generateRandomSHA(): string {
+    return Math.random().toString(36).substring(2, 15);
+  }
+
+
+  describe("test kubernetes configmap",()=> {
+    let transport: StdioClientTransport;
+    let client: Client;
+    const NAMESPACE_PREFIX = "test-configmap";
+    let testNamespace : string;
+
+    const testName = `test-configmap-${generateRandomSHA()}`
+
+    beforeEach(async () =>{
+        try {
+            transport = new StdioClientTransport({
+                    command: "bun",
+                    args: ["src/index.ts"],
+                    stderr: "pipe",
+                  });
+            
+                  client = new Client(
+                    {
+                      name: "test-client",
+                      version: "1.0.0",
+                    },
+                    {
+                      capabilities: {},
+                    }
+                  );
+            
+                  await client.connect(transport);
+                  // Wait for connection to be established
+                  await sleep(1000);
+            
+                  // Create a unique test namespace for test isolation
+                 testNamespace = `${NAMESPACE_PREFIX}-${generateRandomId()}`;
+                  console.log(`Creating test namespace: ${testNamespace}`);
+            
+                  await client.request(
+                    {
+                      method: "tools/call",
+                      params: {
+                        name: "create_namespace",
+                        arguments: {
+                          name: testNamespace,
+                        },
+                      },
+                    },
+                    CreateNamespaceResponseSchema
+                  );
+            
+                  // Wait for namespace to be fully created
+                  await sleep(2000);
+        } catch (error : any) {
+            console.error("Error in beforeEach:", error);
+            throw error;
+        }
+    });
+
+    afterEach(async () => {
+        try {
+          // Clean up namespace using direct API call
+          console.log(`Cleaning up test namespace: ${testNamespace}`);
+          const k8sManager = new KubernetesManager();
+          await k8sManager.getCoreApi().deleteNamespace(testNamespace);
+    
+          // Close client connection
+          await transport.close();
+          await sleep(1000);
+        } catch (e) {
+          console.error("Error during cleanup:", e);
+        }
+      });
+
+      test("verify creation of configmap",async () =>{
+        const testdata = {
+            key1: "hello",
+            key2: "world",
+          };
+        const configmap_response = client.request(
+          {
+            method : "tools/call",
+            params : {
+              name : "create_configmap",
+              arguments : {
+                name : testName,
+                namespace : testNamespace,
+                data : testdata,
+              },
+            },
+          },
+          CreateConfigMapResponseSchema,
+        );
+
+        await sleep(2000); 
+        console.log((await configmap_response).content[0]);
+        expect((await configmap_response).content[0].success).toBe(true);
+        expect((await configmap_response).content[0].message).toContain(`Created ConfigMap ${testName} in namespace ${testNamespace}`);
+
+
+      }
+    );
+  });