kubeview-mcp 1.0.0

package/src/kubernetes/resources/PersistentVolumeOperations.ts

@@ -0,0 +1,438 @@
+import * as k8s from '@kubernetes/client-node';
+import { V1PersistentVolume } from '@kubernetes/client-node';
+import {
+  BaseResourceOperations,
+  ResourceOperationOptions,
+  WatchCallback,
+  WatchEventType,
+} from '../BaseResourceOperations.js';
+import { KubernetesClient } from '../KubernetesClient.js';
+
+/**
+ * PersistentVolume-specific operation options
+ */
+export interface PersistentVolumeOperationOptions extends ResourceOperationOptions {
+  /**
+   * Filter by storage class
+   */
+  storageClass?: string;
+
+  /**
+   * Filter by reclaim policy
+   */
+  reclaimPolicy?: string;
+
+  /**
+   * Filter by access mode
+   */
+  accessMode?: string;
+}
+
+/**
+ * Represents a PV with usage information
+ */
+export interface PVWithUsage extends V1PersistentVolume {
+  usage?: {
+    capacity?: string;
+    used?: string;
+    available?: string;
+    percentUsed?: number;
+  };
+}
+
+/**
+ * PV analysis result
+ */
+export interface PVAnalysisResult {
+  total: number;
+  byStatus: Record<string, number>;
+  byStorageClass: Record<string, number>;
+  byReclaimPolicy: Record<string, number>;
+  unbound: V1PersistentVolume[];
+  issues: Array<{
+    pv: V1PersistentVolume;
+    issue: string;
+    severity: 'info' | 'warning' | 'error';
+    recommendation?: string;
+  }>;
+}
+
+/**
+ * Operations for Kubernetes Persistent Volumes
+ */
+export class PersistentVolumeOperations extends BaseResourceOperations<V1PersistentVolume> {
+  constructor(client: KubernetesClient) {
+    super(client, 'PersistentVolume');
+  }
+
+  protected getResourceNamespaced(): boolean {
+    return false; // PVs are cluster-scoped
+  }
+
+  /**
+   * Create operation is not supported for this read-only tool
+   */
+  async create(
+    _resource: V1PersistentVolume,
+    _options?: ResourceOperationOptions,
+  ): Promise<V1PersistentVolume> {
+    throw new Error('Create operation is not supported for this read-only tool');
+  }
+
+  /**
+   * Update operation is not supported for this read-only tool
+   */
+  async update(
+    _resource: V1PersistentVolume,
+    _options?: ResourceOperationOptions,
+  ): Promise<V1PersistentVolume> {
+    throw new Error('Update operation is not supported for this read-only tool');
+  }
+
+  /**
+   * Patch operation is not supported for this read-only tool
+   */
+  async patch(
+    _name: string,
+    _patch: any,
+    _options?: ResourceOperationOptions,
+  ): Promise<V1PersistentVolume> {
+    throw new Error('Patch operation is not supported for this read-only 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 tool');
+  }
+
+  /**
+   * List all Persistent Volumes
+   */
+  async list(options?: PersistentVolumeOperationOptions): Promise<k8s.V1PersistentVolumeList> {
+    try {
+      const response = await this.client.core.listPersistentVolume(this.buildListOptions(options));
+
+      // Apply additional filtering if needed
+      if (options?.storageClass || options?.reclaimPolicy || options?.accessMode) {
+        response.items = response.items.filter((pv) => {
+          if (options.storageClass && pv.spec?.storageClassName !== options.storageClass) {
+            return false;
+          }
+          if (
+            options.reclaimPolicy &&
+            pv.spec?.persistentVolumeReclaimPolicy !== options.reclaimPolicy
+          ) {
+            return false;
+          }
+          if (options.accessMode && !pv.spec?.accessModes?.includes(options.accessMode)) {
+            return false;
+          }
+          return true;
+        });
+      }
+
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'List', 'all PVs');
+    }
+  }
+
+  /**
+   * Get a specific Persistent Volume by name
+   */
+  async get(name: string, _options?: ResourceOperationOptions): Promise<V1PersistentVolume> {
+    try {
+      const response = await this.client.core.readPersistentVolume({ name });
+      return response;
+    } catch (error) {
+      this.handleApiError(error, 'Get', name);
+    }
+  }
+
+  /**
+   * Watch Persistent Volumes for changes
+   */
+  watch(
+    callback: WatchCallback<V1PersistentVolume>,
+    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/persistentvolumes',
+          this.buildListOptions(options),
+          (type: string, obj: V1PersistentVolume) => {
+            if (!aborted) {
+              callback({
+                type: type as WatchEventType,
+                object: obj,
+              });
+            }
+          },
+          (err: any) => {
+            if (!aborted) {
+              this.logger?.error(`Watch error for PVs: ${err}`);
+              callback({
+                type: WatchEventType.ERROR,
+                object: err,
+              });
+            }
+          },
+        );
+        return req;
+      } catch (error) {
+        this.logger?.error(`Failed to start watch for PVs: ${error}`);
+        throw error;
+      }
+    };
+
+    let request: any;
+    startWatch().then((req) => {
+      request = req;
+    });
+
+    return () => {
+      aborted = true;
+      if (request) {
+        request.abort();
+      }
+    };
+  }
+
+  /**
+   * Analyze PV status and issues
+   */
+  async analyzePVs(options?: PersistentVolumeOperationOptions): Promise<PVAnalysisResult> {
+    const pvList = await this.list(options);
+    const analysis: PVAnalysisResult = {
+      total: pvList.items.length,
+      byStatus: {},
+      byStorageClass: {},
+      byReclaimPolicy: {},
+      unbound: [],
+      issues: [],
+    };
+
+    // Get all PVCs to cross-reference
+    const pvcList = await this.client.core.listPersistentVolumeClaimForAllNamespaces();
+
+    for (const pv of pvList.items) {
+      const status = pv.status?.phase || 'Unknown';
+      const storageClass = pv.spec?.storageClassName || 'default';
+      const reclaimPolicy = pv.spec?.persistentVolumeReclaimPolicy || 'Unknown';
+
+      // Count by status
+      analysis.byStatus[status] = (analysis.byStatus[status] || 0) + 1;
+
+      // Count by storage class
+      analysis.byStorageClass[storageClass] = (analysis.byStorageClass[storageClass] || 0) + 1;
+
+      // Count by reclaim policy
+      analysis.byReclaimPolicy[reclaimPolicy] = (analysis.byReclaimPolicy[reclaimPolicy] || 0) + 1;
+
+      // Track unbound PVs
+      if (status === 'Available') {
+        analysis.unbound.push(pv);
+      }
+
+      // Check for issues
+      // Failed PVs
+      if (status === 'Failed') {
+        analysis.issues.push({
+          pv,
+          issue: 'PersistentVolume is in Failed state',
+          severity: 'error',
+          recommendation:
+            'Check storage backend health and PV configuration. Consider recreating the PV if storage is accessible.',
+        });
+      }
+
+      // Released PVs that should be reclaimed
+      if (status === 'Released') {
+        if (reclaimPolicy === 'Delete') {
+          analysis.issues.push({
+            pv,
+            issue:
+              'PersistentVolume is Released but has Delete reclaim policy - should have been automatically deleted',
+            severity: 'warning',
+            recommendation:
+              'Check storage controller logs for deletion issues or manually delete the PV if safe',
+          });
+        } else if (reclaimPolicy === 'Recycle') {
+          analysis.issues.push({
+            pv,
+            issue: 'PersistentVolume is Released and waiting for recycling (deprecated feature)',
+            severity: 'warning',
+            recommendation:
+              'Recycle policy is deprecated. Consider changing to Retain or Delete policy and handle cleanup manually',
+          });
+        } else {
+          // Retain policy - this might be expected but worth noting
+          analysis.issues.push({
+            pv,
+            issue: 'PersistentVolume is Released with Retain policy and needs manual cleanup',
+            severity: 'info',
+            recommendation:
+              'Remove claimRef from the PV spec to make it Available again, or delete if no longer needed',
+          });
+        }
+      }
+
+      // Zero capacity PVs
+      if (pv.spec?.capacity?.storage) {
+        const capacityBytes = this.parseStorageSize(pv.spec.capacity.storage);
+        if (capacityBytes === 0) {
+          analysis.issues.push({
+            pv,
+            issue: 'PersistentVolume has zero storage capacity',
+            severity: 'error',
+            recommendation: 'Set a valid storage capacity in the PV spec',
+          });
+        }
+      } else {
+        analysis.issues.push({
+          pv,
+          issue: 'PersistentVolume is missing storage capacity specification',
+          severity: 'error',
+          recommendation: 'Add storage capacity to the PV spec',
+        });
+      }
+
+      // Bound PVs without corresponding PVCs
+      if (status === 'Bound' && pv.spec?.claimRef) {
+        const claimRef = pv.spec.claimRef;
+        const boundPVC = pvcList.items.find(
+          (pvc) =>
+            pvc.metadata?.name === claimRef.name && pvc.metadata?.namespace === claimRef.namespace,
+        );
+
+        if (!boundPVC) {
+          analysis.issues.push({
+            pv,
+            issue: `PersistentVolume is bound to PVC '${claimRef.namespace}/${claimRef.name}' which does not exist`,
+            severity: 'warning',
+            recommendation:
+              'Clear the claimRef to make the PV available or investigate why the PVC is missing',
+          });
+        } else if (boundPVC.status?.phase !== 'Bound') {
+          analysis.issues.push({
+            pv,
+            issue: `PV is bound but the referenced PVC is in '${boundPVC.status?.phase}' state`,
+            severity: 'warning',
+            recommendation: 'Check the PVC status and binding process',
+          });
+        }
+      }
+
+      // Available PVs with no storage class but default exists
+      if (status === 'Available' && !pv.spec?.storageClassName) {
+        analysis.issues.push({
+          pv,
+          issue: 'PersistentVolume is Available but has no storage class',
+          severity: 'info',
+          recommendation:
+            'Consider setting a storage class for better organization and matching with PVCs',
+        });
+      }
+
+      // Check for PVs with deprecated volume types or configurations
+      if (pv.spec?.hostPath) {
+        analysis.issues.push({
+          pv,
+          issue: 'PersistentVolume uses hostPath which is not recommended for production',
+          severity: 'warning',
+          recommendation: 'Consider using a more robust storage solution for production workloads',
+        });
+      }
+
+      // Check for missing access modes
+      if (!pv.spec?.accessModes || pv.spec.accessModes.length === 0) {
+        analysis.issues.push({
+          pv,
+          issue: 'PersistentVolume has no access modes defined',
+          severity: 'error',
+          recommendation:
+            'Define appropriate access modes (ReadWriteOnce, ReadOnlyMany, or ReadWriteMany)',
+        });
+      }
+
+      // Check for node affinity issues (if nodeAffinity is set)
+      if (pv.spec?.nodeAffinity?.required?.nodeSelectorTerms) {
+        // This is a simplified check - we'd need to verify against actual nodes
+        const terms = pv.spec.nodeAffinity.required.nodeSelectorTerms;
+        if (
+          terms.length === 0 ||
+          terms.some((term) => !term.matchExpressions || term.matchExpressions.length === 0)
+        ) {
+          analysis.issues.push({
+            pv,
+            issue: 'PersistentVolume has nodeAffinity set but no valid selector terms',
+            severity: 'warning',
+            recommendation: 'Review nodeAffinity configuration to ensure proper node selection',
+          });
+        }
+      }
+    }
+
+    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 PV usage information (requires metrics or node stats)
+   */
+  async getPVUsage(pvName: string): Promise<PVWithUsage | null> {
+    try {
+      const pv = await this.get(pvName);
+      const pvWithUsage: PVWithUsage = { ...pv };
+
+      // Try to get usage information from node stats
+      // This would typically require access to kubelet stats API
+      // For now, we'll return the PV without usage info
+      pvWithUsage.usage = {
+        capacity: pv.spec?.capacity?.storage || 'Unknown',
+        used: 'Unknown',
+        available: 'Unknown',
+        percentUsed: 0,
+      };
+
+      return pvWithUsage;
+    } catch (error) {
+      this.logger?.error(`Failed to get PV usage for ${pvName}: ${error}`);
+      return null;
+    }
+  }
+}