kubeview-mcp 1.0.0

package/src/kubernetes/resources/NamespaceOperations.ts

@@ -0,0 +1,129 @@
+import * as k8s from '@kubernetes/client-node';
+import {
+  BaseResourceOperations,
+  ResourceOperationOptions,
+  WatchCallback,
+  WatchEventType,
+} from '../BaseResourceOperations.js';
+import { KubernetesClient } from '../KubernetesClient.js';
+
+/**
+ * Namespace operations implementation - Read-only operations
+ */
+export class NamespaceOperations extends BaseResourceOperations<k8s.V1Namespace> {
+  constructor(client: KubernetesClient) {
+    super(client, 'Namespace');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async create(
+    _namespace: k8s.V1Namespace,
+    _options?: ResourceOperationOptions,
+  ): Promise<k8s.V1Namespace> {
+    throw new Error('Create operation is not supported in read-only mode');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async update(
+    _namespace: k8s.V1Namespace,
+    _options?: ResourceOperationOptions,
+  ): Promise<k8s.V1Namespace> {
+    throw new Error('Update operation is not supported in read-only mode');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async patch(
+    _name: string,
+    _patch: any,
+    _options?: ResourceOperationOptions,
+  ): Promise<k8s.V1Namespace> {
+    throw new Error('Patch operation is not supported in read-only mode');
+  }
+
+  /**
+   * @throws {Error} This operation is not supported in read-only mode
+   */
+  async delete(_name: string, _options?: ResourceOperationOptions): Promise<void> {
+    throw new Error('Delete operation is not supported in read-only mode');
+  }
+
+  /**
+   * Get a Namespace by name
+   */
+  async get(name: string, _options?: ResourceOperationOptions): Promise<k8s.V1Namespace> {
+    try {
+      const response = await this.client.core.readNamespace({ name });
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'Get', name);
+    }
+  }
+
+  /**
+   * List Namespaces
+   */
+  async list(_options?: ResourceOperationOptions): Promise<k8s.V1NamespaceList> {
+    try {
+      const response = await this.client.core.listNamespace();
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'List');
+    }
+  }
+
+  /**
+   * Watch Namespaces for changes
+   */
+  watch(callback: WatchCallback<k8s.V1Namespace>, options?: ResourceOperationOptions): () => void {
+    const watch = new k8s.Watch(this.client.kubeConfig);
+    let aborted = false;
+
+    const startWatch = async () => {
+      try {
+        const req = await watch.watch(
+          `/api/v1/namespaces`,
+          this.buildListOptions(options),
+          (type: string, obj: k8s.V1Namespace) => {
+            if (!aborted) {
+              callback({
+                type: type as WatchEventType,
+                object: obj,
+              });
+            }
+          },
+          (err: any) => {
+            if (!aborted) {
+              this.logger?.error(`Watch error for Namespaces: ${err}`);
+              callback({
+                type: WatchEventType.ERROR,
+                object: err,
+              });
+            }
+          },
+        );
+        return req;
+      } catch (error) {
+        this.logger?.error(`Failed to start watch for Namespaces: ${error}`);
+        throw error;
+      }
+    };
+
+    let request: any;
+    startWatch().then((req) => {
+      request = req;
+    });
+
+    return () => {
+      aborted = true;
+      if (request) {
+        request.abort();
+      }
+    };
+  }
+}

package/src/kubernetes/resources/PersistentVolumeClaimOperations.ts

@@ -0,0 +1,516 @@
+import * as k8s from '@kubernetes/client-node';
+import { V1PersistentVolumeClaim } from '@kubernetes/client-node';
+import {
+  BaseResourceOperations,
+  ResourceOperationOptions,
+  WatchCallback,
+  WatchEventType,
+} from '../BaseResourceOperations.js';
+import { KubernetesClient } from '../KubernetesClient.js';
+
+/**
+ * PersistentVolumeClaim-specific operation options
+ */
+export interface PersistentVolumeClaimOperationOptions extends ResourceOperationOptions {
+  /**
+   * Filter by storage class
+   */
+  storageClass?: string;
+
+  /**
+   * Filter by access mode
+   */
+  accessMode?: string;
+
+  /**
+   * Filter by volume mode
+   */
+  volumeMode?: string;
+}
+
+/**
+ * Represents a PVC with usage information
+ */
+export interface PVCWithUsage extends V1PersistentVolumeClaim {
+  usage?: {
+    capacity?: string;
+    used?: string;
+    available?: string;
+    percentUsed?: number;
+  };
+  boundPV?: string;
+}
+
+/**
+ * PVC analysis result
+ */
+export interface PVCAnalysisResult {
+  total: number;
+  byStatus: Record<string, number>;
+  byStorageClass: Record<string, number>;
+  pending: V1PersistentVolumeClaim[];
+  issues: Array<{
+    pvc: V1PersistentVolumeClaim;
+    issue: string;
+    severity: 'info' | 'warning' | 'error';
+    recommendation?: string;
+  }>;
+}
+
+/**
+ * Operations for Kubernetes Persistent Volume Claims
+ */
+export class PersistentVolumeClaimOperations extends BaseResourceOperations<V1PersistentVolumeClaim> {
+  constructor(client: KubernetesClient) {
+    super(client, 'PersistentVolumeClaim');
+  }
+
+  protected getResourceNamespaced(): boolean {
+    return true; // PVCs are namespaced
+  }
+
+  /**
+   * Create operation is not supported for this read-only tool
+   */
+  async create(
+    _resource: V1PersistentVolumeClaim,
+    _options?: ResourceOperationOptions,
+  ): Promise<V1PersistentVolumeClaim> {
+    throw new Error('Create operation is not supported for this read-only PVC analysis tool');
+  }
+
+  /**
+   * Update operation is not supported for this read-only tool
+   */
+  async update(
+    _resource: V1PersistentVolumeClaim,
+    _options?: ResourceOperationOptions,
+  ): Promise<V1PersistentVolumeClaim> {
+    throw new Error('Update operation is not supported for this read-only PVC analysis tool');
+  }
+
+  /**
+   * Patch operation is not supported for this read-only tool
+   */
+  async patch(
+    _name: string,
+    _patch: any,
+    _options?: ResourceOperationOptions,
+  ): Promise<V1PersistentVolumeClaim> {
+    throw new Error('Patch operation is not supported for this read-only PVC analysis tool');
+  }
+
+  /**
+   * Delete operation is not supported for this read-only tool
+   */
+  async delete(_name: string, _options?: ResourceOperationOptions): Promise<void> {
+    throw new Error('Delete operation is not supported for this read-only PVC analysis tool');
+  }
+
+  /**
+   * List Persistent Volume Claims
+   */
+  async list(
+    options?: PersistentVolumeClaimOperationOptions,
+  ): Promise<k8s.V1PersistentVolumeClaimList> {
+    try {
+      let response;
+      if (options?.namespace) {
+        response = await this.client.core.listNamespacedPersistentVolumeClaim({
+          namespace: options.namespace,
+          ...this.buildListOptions(options),
+        });
+      } else {
+        response = await this.client.core.listPersistentVolumeClaimForAllNamespaces(
+          this.buildListOptions(options),
+        );
+      }
+
+      // Apply additional filtering if needed
+      if (options?.storageClass || options?.accessMode || options?.volumeMode) {
+        response.items = response.items.filter((pvc) => {
+          if (options.storageClass && pvc.spec?.storageClassName !== options.storageClass) {
+            return false;
+          }
+          if (options.accessMode && !pvc.spec?.accessModes?.includes(options.accessMode)) {
+            return false;
+          }
+          if (options.volumeMode && pvc.spec?.volumeMode !== options.volumeMode) {
+            return false;
+          }
+          return true;
+        });
+      }
+
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'List', `PVCs in ${options?.namespace || 'all namespaces'}`);
+    }
+  }
+
+  /**
+   * Get a specific Persistent Volume Claim by name
+   */
+  async get(name: string, options?: ResourceOperationOptions): Promise<V1PersistentVolumeClaim> {
+    try {
+      const namespace = options?.namespace || 'default';
+      const response = await this.client.core.readNamespacedPersistentVolumeClaim({
+        name,
+        namespace,
+      });
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'Get', name);
+    }
+  }
+
+  /**
+   * Watch Persistent Volume Claims for changes
+   */
+  watch(
+    callback: WatchCallback<V1PersistentVolumeClaim>,
+    options?: ResourceOperationOptions,
+  ): () => void {
+    const namespace = options?.namespace;
+    const watch = new k8s.Watch(this.client.kubeConfig);
+    let aborted = false;
+
+    const startWatch = async () => {
+      try {
+        const path = namespace
+          ? `/api/v1/namespaces/${namespace}/persistentvolumeclaims`
+          : '/api/v1/persistentvolumeclaims';
+
+        const req = await watch.watch(
+          path,
+          this.buildListOptions(options),
+          (type: string, obj: V1PersistentVolumeClaim) => {
+            if (!aborted) {
+              callback({
+                type: type as WatchEventType,
+                object: obj,
+              });
+            }
+          },
+          (err: any) => {
+            if (!aborted) {
+              this.logger?.error(`Watch error for PVCs: ${err}`);
+              callback({
+                type: WatchEventType.ERROR,
+                object: err,
+              });
+            }
+          },
+        );
+        return req;
+      } catch (error) {
+        this.logger?.error(`Failed to start watch for PVCs: ${error}`);
+        throw error;
+      }
+    };
+
+    let request: any;
+    startWatch().then((req) => {
+      request = req;
+    });
+
+    return () => {
+      aborted = true;
+      if (request) {
+        request.abort();
+      }
+    };
+  }
+
+  /**
+   * Analyze PVC status and issues
+   */
+  async analyzePVCs(options?: PersistentVolumeClaimOperationOptions): Promise<PVCAnalysisResult> {
+    const pvcList = await this.list(options);
+    const analysis: PVCAnalysisResult = {
+      total: pvcList.items.length,
+      byStatus: {},
+      byStorageClass: {},
+      pending: [],
+      issues: [],
+    };
+
+    // Get all PVs to cross-reference
+    const pvList = await this.client.core.listPersistentVolume();
+
+    for (const pvc of pvcList.items) {
+      const status = pvc.status?.phase || 'Unknown';
+      const storageClass = pvc.spec?.storageClassName || 'default';
+
+      // Count by status
+      analysis.byStatus[status] = (analysis.byStatus[status] || 0) + 1;
+
+      // Count by storage class
+      analysis.byStorageClass[storageClass] = (analysis.byStorageClass[storageClass] || 0) + 1;
+
+      // Track pending PVCs
+      if (status === 'Pending') {
+        analysis.pending.push(pvc);
+
+        // Analyze why PVC is pending
+        const requestedSize = pvc.spec?.resources?.requests?.storage;
+        const requestedAccessModes = pvc.spec?.accessModes || [];
+        const requestedStorageClass = pvc.spec?.storageClassName;
+
+        // Check if there are available PVs that could satisfy this PVC
+        const availablePVs = pvList.items.filter((pv) => pv.status?.phase === 'Available');
+
+        if (availablePVs.length === 0) {
+          analysis.issues.push({
+            pvc,
+            issue: 'No available PersistentVolumes found in the cluster',
+            severity: 'error',
+            recommendation:
+              'Create a new PersistentVolume or enable dynamic provisioning for the storage class',
+          });
+          continue;
+        }
+
+        const matchingPVs = availablePVs.filter((pv) => {
+          // Check storage class
+          if (requestedStorageClass && pv.spec?.storageClassName !== requestedStorageClass) {
+            return false;
+          }
+
+          // Check access modes - PV must support at least one of the requested modes
+          const pvAccessModes = pv.spec?.accessModes || [];
+          const hasMatchingAccessMode = requestedAccessModes.some((mode) =>
+            pvAccessModes.includes(mode),
+          );
+          if (!hasMatchingAccessMode) {
+            return false;
+          }
+
+          // Enhanced capacity checking with proper size comparison
+          if (requestedSize && pv.spec?.capacity?.storage) {
+            const requestedBytes = this.parseStorageSize(requestedSize);
+            const pvCapacityBytes = this.parseStorageSize(pv.spec.capacity.storage);
+
+            if (requestedBytes > pvCapacityBytes) {
+              return false;
+            }
+          }
+
+          return true;
+        });
+
+        if (matchingPVs.length === 0) {
+          // Determine specific reasons for no matches
+          const storageClassMatches = availablePVs.filter(
+            (pv) => !requestedStorageClass || pv.spec?.storageClassName === requestedStorageClass,
+          );
+
+          const accessModeMatches = availablePVs.filter((pv) => {
+            const pvAccessModes = pv.spec?.accessModes || [];
+            return requestedAccessModes.some((mode) => pvAccessModes.includes(mode));
+          });
+
+          const sizeMatches = availablePVs.filter((pv) => {
+            if (!requestedSize || !pv.spec?.capacity?.storage) return true;
+            const requestedBytes = this.parseStorageSize(requestedSize);
+            const pvCapacityBytes = this.parseStorageSize(pv.spec.capacity.storage);
+            return requestedBytes <= pvCapacityBytes;
+          });
+
+          let issueDetail = 'No available PersistentVolumes match the PVC requirements';
+          let recommendation = 'Check PVC requirements and available PVs';
+
+          if (storageClassMatches.length === 0) {
+            issueDetail = `No PersistentVolumes with storage class '${requestedStorageClass}' are available`;
+            recommendation = `Create a PV with storage class '${requestedStorageClass}' or check if the storage class supports dynamic provisioning`;
+          } else if (accessModeMatches.length === 0) {
+            issueDetail = `No PersistentVolumes support the requested access modes: ${requestedAccessModes.join(', ')}`;
+            recommendation =
+              'Create a PV with compatible access modes or modify the PVC access mode requirements';
+          } else if (sizeMatches.length === 0) {
+            issueDetail = `No PersistentVolumes have sufficient capacity (requested: ${requestedSize})`;
+            recommendation = 'Create a larger PV or reduce the PVC storage request';
+          }
+
+          analysis.issues.push({
+            pvc,
+            issue: issueDetail,
+            severity: 'warning',
+            recommendation,
+          });
+        } else {
+          // PVC is pending but there are matching PVs - possible binding delay
+          analysis.issues.push({
+            pvc,
+            issue: `PVC is pending despite ${matchingPVs.length} matching PV(s) being available`,
+            severity: 'warning',
+            recommendation: 'Check PVC events and storage controller logs for binding delays',
+          });
+        }
+      }
+
+      // Check for lost claims
+      if (status === 'Lost') {
+        analysis.issues.push({
+          pvc,
+          issue: 'PersistentVolumeClaim has lost its bound volume',
+          severity: 'error',
+          recommendation: 'Investigate why the bound PV was lost and restore from backup if needed',
+        });
+      }
+
+      // Check for bound PVCs without a corresponding PV
+      if (status === 'Bound' && pvc.spec?.volumeName) {
+        const boundPV = pvList.items.find((pv) => pv.metadata?.name === pvc.spec?.volumeName);
+        if (!boundPV) {
+          analysis.issues.push({
+            pvc,
+            issue: `PersistentVolumeClaim is bound to PV '${pvc.spec.volumeName}' which does not exist`,
+            severity: 'error',
+            recommendation:
+              'Investigate why the bound PV is missing and consider recreating the PVC',
+          });
+        } else if (boundPV.status?.phase !== 'Bound') {
+          analysis.issues.push({
+            pvc,
+            issue: `PVC is bound but the referenced PV is in '${boundPV.status?.phase}' state`,
+            severity: 'warning',
+            recommendation: 'Check the PV status and storage backend health',
+          });
+        }
+      }
+
+      // Check for resource quota issues
+      if (status === 'Pending' && pvc.spec?.resources?.requests?.storage) {
+        // This is a simplified check - in reality, we'd need to query resource quotas
+        const requestedSize = pvc.spec.resources.requests.storage;
+        if (this.parseStorageSize(requestedSize) === 0) {
+          analysis.issues.push({
+            pvc,
+            issue: 'PVC has zero storage request',
+            severity: 'error',
+            recommendation: 'Set a valid storage request size in the PVC spec',
+          });
+        }
+      }
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Parse storage size string to bytes for comparison
+   * Supports common Kubernetes storage units (Ki, Mi, Gi, Ti, K, M, G, T)
+   */
+  private parseStorageSize(sizeStr: string): number {
+    if (!sizeStr) return 0;
+
+    const units: { [key: string]: number } = {
+      Ki: 1024,
+      Mi: 1024 * 1024,
+      Gi: 1024 * 1024 * 1024,
+      Ti: 1024 * 1024 * 1024 * 1024,
+      K: 1000,
+      M: 1000 * 1000,
+      G: 1000 * 1000 * 1000,
+      T: 1000 * 1000 * 1000 * 1000,
+      '': 1, // bytes
+    };
+
+    const match = sizeStr.match(/^(\d+(?:\.\d+)?)\s*([A-Za-z]*)$/);
+    if (!match) return 0;
+
+    const value = parseFloat(match[1]);
+    const unit = match[2] || '';
+    const multiplier = units[unit] || 1;
+
+    return Math.floor(value * multiplier);
+  }
+
+  /**
+   * Get PVC usage information with node stats integration
+   */
+  async getPVCUsage(name: string, namespace: string): Promise<PVCWithUsage | null> {
+    try {
+      const pvc = await this.get(name, { namespace });
+      const pvcWithUsage: PVCWithUsage = { ...pvc };
+
+      // Add bound PV information
+      if (pvc.spec?.volumeName) {
+        pvcWithUsage.boundPV = pvc.spec.volumeName;
+      }
+
+      // Try to get usage information from node stats
+      // This would typically require access to kubelet stats API
+      // For now, we'll return the PVC without usage info
+      pvcWithUsage.usage = {
+        capacity:
+          pvc.status?.capacity?.storage || pvc.spec?.resources?.requests?.storage || 'Unknown',
+        used: 'Unknown',
+        available: 'Unknown',
+        percentUsed: 0,
+      };
+
+      return pvcWithUsage;
+    } catch (error) {
+      this.logger?.error(`Failed to get PVC usage for ${name} in ${namespace}: ${error}`);
+      return null;
+    }
+  }
+
+  /**
+   * Check PVC to PV binding relationships
+   */
+  async checkBindingStatus(): Promise<{
+    bound: number;
+    pending: number;
+    available: number;
+    bindingIssues: Array<{
+      pvc: V1PersistentVolumeClaim;
+      issue: string;
+    }>;
+  }> {
+    const pvcList = await this.list();
+    const pvList = await this.client.core.listPersistentVolume();
+
+    const result = {
+      bound: 0,
+      pending: 0,
+      available: 0,
+      bindingIssues: [] as Array<{ pvc: V1PersistentVolumeClaim; issue: string }>,
+    };
+
+    for (const pvc of pvcList.items) {
+      const status = pvc.status?.phase || 'Unknown';
+
+      switch (status) {
+        case 'Bound':
+          result.bound++;
+          break;
+        case 'Pending':
+          result.pending++;
+          break;
+        default:
+          result.available++;
+      }
+
+      // Check for binding issues
+      if (status === 'Bound' && pvc.spec?.volumeName) {
+        const boundPV = pvList.items.find((pv) => pv.metadata?.name === pvc.spec?.volumeName);
+        if (!boundPV) {
+          result.bindingIssues.push({
+            pvc,
+            issue: `Bound to non-existent PV: ${pvc.spec.volumeName}`,
+          });
+        } else if (boundPV.status?.phase !== 'Bound') {
+          result.bindingIssues.push({
+            pvc,
+            issue: `Bound PV is not in Bound state: ${boundPV.status?.phase}`,
+          });
+        }
+      }
+    }
+
+    return result;
+  }
+}