@nexusgpu/repterm-plugin-kubectl 0.1.0

package/dist/plugin-kubectl/examples/06-advanced.js

@@ -0,0 +1,140 @@
+/**
+ * 示例 6: 进阶功能
+ *
+ * 演示 kubectl 插件的进阶 API：
+ * portForward, waitForService, getEvents, getNodes, cp
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/06-advanced.ts
+ *
+ * 前置条件:
+ *   - 已配置 kubectl 并连接到 Kubernetes 集群
+ */
+import { describe, defineConfig, createTestWithPlugins, } from '../../repterm/src/index.js';
+import { kubectlPlugin } from '../src/index.js';
+// 配置插件
+const config = defineConfig({
+    plugins: [kubectlPlugin({ namespace: 'default' })],
+});
+const test = createTestWithPlugins(config);
+// 测试用资源
+const webAppYaml = `
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: webapp
+spec:
+  replicas: 1
+  selector:
+    matchLabels:
+      app: webapp
+  template:
+    metadata:
+      labels:
+        app: webapp
+    spec:
+      containers:
+      - name: nginx
+        image: nginx:alpine
+        ports:
+        - containerPort: 80
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: webapp-svc
+spec:
+  selector:
+    app: webapp
+  ports:
+  - port: 80
+    targetPort: 80
+`;
+const filePodYaml = `
+apiVersion: v1
+kind: Pod
+metadata:
+  name: file-pod
+spec:
+  containers:
+  - name: main
+    image: busybox
+    command: ['sh', '-c', 'echo "test content" > /tmp/test.txt && sleep 3600']
+`;
+describe('进阶功能 API', () => {
+    // ===== getNodes - 获取节点信息 =====
+    test('getNodes - 获取集群节点', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        const nodes = await kubectl.getNodes();
+        for (const node of nodes) {
+        }
+    });
+    test('getNodes - 使用选择器过滤', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        // 尝试按标签过滤（可能返回空）
+        const controlPlaneNodes = await kubectl.getNodes({ selector: 'node-role.kubernetes.io/control-plane' });
+    });
+    // 准备测试资源
+    test('准备: 创建测试资源', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await kubectl.apply(webAppYaml);
+        await kubectl.apply(filePodYaml);
+        await kubectl.wait('deployment', 'webapp', 'Available', { timeout: 120000 });
+        await kubectl.waitForPod('file-pod', 'Running', 60000);
+    });
+    // ===== getEvents - 获取集群事件 =====
+    test('getEvents - 获取命名空间事件', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        const events = await kubectl.getEvents();
+        // 显示最近几个事件
+        const recentEvents = events.slice(0, 5);
+        for (const event of recentEvents) {
+        }
+    });
+    test('getEvents - 使用字段选择器过滤', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        // 过滤特定资源的事件
+        const webappEvents = await kubectl.getEvents({
+            fieldSelector: 'involvedObject.name=webapp',
+        });
+    });
+    // ===== waitForService - 等待 Service 就绪 =====
+    test('waitForService - 等待 Service 有 endpoints', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        const endpoint = await kubectl.waitForService('webapp-svc', 60000);
+    });
+    // ===== portForward - 端口转发 =====
+    test('portForward - 端口转发到 Service', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        // 启动端口转发
+        const handle = await kubectl.portForward('svc/webapp-svc', '18080:80', { delay: 2000 });
+        // 可以在这里测试连接
+        // const response = await fetch('http://localhost:18080');
+        // 停止端口转发
+        await handle.stop();
+    });
+    // ===== cp - 文件复制 =====
+    test('cp - 从 Pod 复制文件到本地', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        // 复制文件到本地
+        await kubectl.cp('file-pod:/tmp/test.txt', '/tmp/k8s-test.txt');
+    });
+    test('cp - 从本地复制文件到 Pod', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        // 创建本地文件
+        await ctx.terminal.run('echo "uploaded content" > /tmp/upload.txt');
+        // 复制到 Pod
+        await kubectl.cp('/tmp/upload.txt', 'file-pod:/tmp/uploaded.txt');
+        // 验证
+        await kubectl.exec('file-pod', 'cat /tmp/uploaded.txt');
+    });
+    // 清理
+    test('清理: 删除测试资源', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await kubectl.delete('deployment', 'webapp', { force: true });
+        await kubectl.delete('service', 'webapp-svc', { force: true });
+        await kubectl.delete('pod', 'file-pod', { force: true });
+        // 清理本地临时文件
+        await ctx.terminal.run('rm -f /tmp/k8s-test.txt /tmp/upload.txt');
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/00-prerequisites.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 测试场景 0: 前置条件检查
+ *
+ * 验证测试环境满足以下条件：
+ * - Kubernetes 集群连接正常
+ * - Tensor Fusion Controller 运行正常
+ * - GPUPool 存在且状态为 Ready
+ * - 至少有一个可用 GPU，资源充足
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/00-prerequisites.ts
+ */
+export {};
+//# sourceMappingURL=00-prerequisites.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/00-prerequisites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"00-prerequisites.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/00-prerequisites.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/plugin-kubectl/examples/tensor-fusion/00-prerequisites.js

@@ -0,0 +1,66 @@
+/**
+ * 测试场景 0: 前置条件检查
+ *
+ * 验证测试环境满足以下条件：
+ * - Kubernetes 集群连接正常
+ * - Tensor Fusion Controller 运行正常
+ * - GPUPool 存在且状态为 Ready
+ * - 至少有一个可用 GPU，资源充足
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/00-prerequisites.ts
+ */
+import { test, describe, expect, step, gpupool, resource, TEST_GPU_POOL, TF_SYSTEM_NAMESPACE, TF_CONTROLLER_DEPLOYMENT, getFirstGpuName, getGpuAvailable, parseTflops, } from './_config.js';
+describe('前置条件检查', { record: true }, () => {
+    // ===== 集群连接检查 =====
+    test('验证 Kubernetes 集群连接', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('检查集群连接状态', async () => {
+            const clusterInfo = await kubectl.clusterInfo();
+            expect(clusterInfo.reachable).toBe(true);
+        });
+    });
+    // ===== Tensor Fusion Controller 检查 =====
+    test('验证 Tensor Fusion Controller 运行状态', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('检查 Controller Deployment', async () => {
+            const originalNs = kubectl.getNamespace();
+            kubectl.setNamespace(TF_SYSTEM_NAMESPACE);
+            try {
+                const controllerDeployment = resource(kubectl, 'deployment', TF_CONTROLLER_DEPLOYMENT);
+                await expect(controllerDeployment).toExistInCluster();
+                await expect(controllerDeployment).toBeAvailable();
+            }
+            finally {
+                kubectl.setNamespace(originalNs);
+            }
+        });
+    });
+    // ===== GPUPool 检查 =====
+    test('验证 GPUPool 存在且就绪', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        await step('检查 GPUPool 存在', async () => {
+            const pool = gpupool(kubectl, TEST_GPU_POOL);
+            await expect(pool).toExistInCluster();
+        });
+        await step('检查 GPUPool 状态', async () => {
+            const pool = gpupool(kubectl, TEST_GPU_POOL);
+            await expect(pool).toHaveStatusField('phase', 'Running');
+        });
+    });
+    // ===== GPU 资源检查 =====
+    test('验证 GPU 资源充足', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        const gpuName = await getFirstGpuName(kubectl);
+        await step('检查 GPU 可用资源', async () => {
+            const available = await getGpuAvailable(kubectl, gpuName);
+            const tflopsValue = parseTflops(available.tflops);
+            // 验证资源满足测试要求 (至少 2000m TFlops)
+            expect(tflopsValue).toBeGreaterThanOrEqual(2000);
+        });
+        await step('检查 GPU 状态', async () => {
+            const exists = await kubectl.exists('gpu', gpuName);
+            expect(exists).toBe(true);
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/01-workload-allocation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 测试场景 1: 正常资源分配 - 使用 TensorFusionWorkload
+ *
+ * 验证通过创建 TensorFusionWorkload 可以：
+ * - 正确分配 GPU 资源
+ * - Workload 状态变为 Running
+ * - GPU 可用资源正确减少
+ * - Worker Pod 包含正确的 annotations
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/01-workload-allocation.ts
+ */
+export {};
+//# sourceMappingURL=01-workload-allocation.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/01-workload-allocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"01-workload-allocation.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/01-workload-allocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/plugin-kubectl/examples/tensor-fusion/01-workload-allocation.js

@@ -0,0 +1,145 @@
+/**
+ * 测试场景 1: 正常资源分配 - 使用 TensorFusionWorkload
+ *
+ * 验证通过创建 TensorFusionWorkload 可以：
+ * - 正确分配 GPU 资源
+ * - Workload 状态变为 Running
+ * - GPU 可用资源正确减少
+ * - Worker Pod 包含正确的 annotations
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/01-workload-allocation.ts
+ */
+import { sleep } from 'bun';
+import { test, describe, expect, step, tensorfusionworkload, workloadYaml, DEFAULT_TIMEOUT, getFirstGpuName, getGpuAvailable, parseTflops, } from './_config.js';
+const WORKLOAD_NAME = 'test-workload-alloc';
+describe('测试场景 1: 正常资源分配 - TensorFusionWorkload', { record: true }, () => {
+    test('TensorFusionWorkload 资源分配完整流程', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        let gpuName;
+        let initialTflops;
+        // ===== Step 1: 记录初始状态 =====
+        await step('获取测试 GPU', {
+            showStepTitle: false,
+            typingSpeed: 60, // 准备阶段快速执行
+            pauseAfter: 1000
+        }, async () => {
+            gpuName = await getFirstGpuName(kubectl);
+        });
+        await step('记录初始可用资源', {
+            typingSpeed: 60,
+            pauseAfter: 1500 // 让观众看清初始状态
+        }, async () => {
+            const available = await getGpuAvailable(kubectl, gpuName);
+            initialTflops = available.tflops;
+        });
+        // ===== Step 2: 创建资源（核心操作）=====
+        await step('创建 Workload', {
+            showStepTitle: false,
+            typingSpeed: 100, // 核心操作慢速打字
+            pauseAfter: 3000 // 重要输出，多停留
+        }, async () => {
+            const yaml = workloadYaml(WORKLOAD_NAME, {
+                tflopsRequest: '1000m',
+                tflopsLimit: '2000m',
+                vramRequest: '1Gi',
+                vramLimit: '2Gi',
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        // ===== Step 3: 等待 Workload 就绪 =====
+        await step('等待 Ready 条件', {
+            showStepTitle: false,
+            pauseAfter: 2000
+        }, async () => {
+            const result = await kubectl.wait('tensorfusionworkload', WORKLOAD_NAME, 'Ready', { timeout: DEFAULT_TIMEOUT });
+            await expect(result).toBeSuccessful();
+        });
+        await step('验证 Workload 状态为 Running', {
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const workload = tensorfusionworkload(kubectl, WORKLOAD_NAME);
+            await expect(workload).toHaveStatusField('phase', 'Running');
+        });
+        // ===== Step 4: 验证资源分配结果 =====
+        await step('检查 GPU 可用资源变化', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2500 // 验证结果需要阅读时间
+        }, async () => {
+            sleep(1000);
+            const afterAvailable = await getGpuAvailable(kubectl, gpuName);
+            const initialTflopsNum = parseTflops(initialTflops);
+            const afterTflopsNum = parseTflops(afterAvailable.tflops);
+            // TFlops 应该减少
+            expect(afterTflopsNum).toBeLessThan(initialTflopsNum);
+        });
+        await step('验证 Workload readyWorkers', {
+            pauseAfter: 1500
+        }, async () => {
+            const status = await kubectl.getJsonPath('tensorfusionworkload', WORKLOAD_NAME, '.status');
+            expect(status?.phase).toBe('Running');
+            expect(status?.readyWorkers).toBe(1);
+        });
+        // ===== Step 5: 验证 Worker Pod =====
+        await step('查找并验证 Worker Pod', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const pods = await kubectl.get('pod', undefined, {
+                selector: `tensor-fusion.ai/workload=${WORKLOAD_NAME}`,
+                jqFilter: '[.items[] | {name: .metadata.name, phase: .status.phase, annotations: .metadata.annotations}]'
+            });
+            expect(pods?.length).toBeGreaterThan(0);
+            const workerPod = pods[0];
+            expect(workerPod.phase).toBe('Running');
+            // 验证 annotations 存在
+            const annotations = workerPod.annotations ?? {};
+            expect(annotations['tensor-fusion.ai/tflops-request']).toBeDefined();
+            expect(annotations['tensor-fusion.ai/vram-request']).toBeDefined();
+        });
+        // ===== Step 6: 查看 TensorFusionConnection (如果使用 remote vGPU) =====
+        await step('查询关联的 Connection', {
+            pauseAfter: 1500
+        }, async () => {
+            try {
+                const connections = await kubectl.get('tensorfusionconnection', undefined, {
+                    selector: `tensor-fusion.ai/workload=${WORKLOAD_NAME}`,
+                    jqFilter: '[.items[] | {name: .metadata.name, phase: .status.phase}]'
+                });
+                // Connection 可能不存在（local GPU 模式），这不是错误
+                if (connections && connections.length > 0) {
+                    for (const conn of connections) {
+                        expect(conn.phase).toBeDefined();
+                    }
+                }
+            }
+            catch {
+                // TensorFusionConnection CRD 可能不存在
+            }
+        });
+        // ===== 清理 =====
+        await step('删除 TensorFusionWorkload', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const result = await kubectl.delete('tensorfusionworkload', WORKLOAD_NAME);
+            await expect(result).toBeSuccessful();
+        });
+        await step('等待资源释放并验证', {
+            pauseAfter: 2000
+        }, async () => {
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            // 验证资源已释放（TFlops 应该恢复）
+            const afterRelease = await getGpuAvailable(kubectl, gpuName);
+            const releasedTflops = parseTflops(afterRelease.tflops);
+            const initialTflopsNum = parseTflops(initialTflops);
+            // 允许小误差，但应该接近初始值
+            expect(releasedTflops).toBeGreaterThanOrEqual(initialTflopsNum - 100);
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/02-annotation-mode.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 测试场景 2: 正常资源分配 - 使用 Pod Annotation
+ *
+ * 验证通过在 Deployment Pod Template 中添加 Tensor Fusion annotation：
+ * - Webhook 自动创建 TensorFusionWorkload
+ * - GPU 资源正确分配
+ * - Pod 成功调度并运行
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/02-annotation-mode.ts
+ */
+export {};
+//# sourceMappingURL=02-annotation-mode.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/02-annotation-mode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"02-annotation-mode.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/02-annotation-mode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/plugin-kubectl/examples/tensor-fusion/02-annotation-mode.js

@@ -0,0 +1,123 @@
+/**
+ * 测试场景 2: 正常资源分配 - 使用 Pod Annotation
+ *
+ * 验证通过在 Deployment Pod Template 中添加 Tensor Fusion annotation：
+ * - Webhook 自动创建 TensorFusionWorkload
+ * - GPU 资源正确分配
+ * - Pod 成功调度并运行
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/02-annotation-mode.ts
+ */
+import { sleep } from 'bun';
+import { test, describe, expect, step, deployment, annotatedDeploymentYaml, DEFAULT_TIMEOUT, getFirstGpuName, getGpuAvailable, parseTflops, } from './_config.js';
+const DEPLOYMENT_NAME = 'test-workload-annotation';
+describe('测试场景 2: 正常资源分配 - Pod Annotation', { record: true }, () => {
+    test('Pod Annotation 模式资源分配完整流程', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        let gpuName;
+        let initialTflops;
+        // ===== Step 1: 准备环境 =====
+        await step('获取测试 GPU', {
+            showStepTitle: false,
+            typingSpeed: 60,
+            pauseAfter: 1000
+        }, async () => {
+            gpuName = await getFirstGpuName(kubectl);
+        });
+        await step('记录初始可用资源', {
+            typingSpeed: 60,
+            pauseAfter: 1500
+        }, async () => {
+            const available = await getGpuAvailable(kubectl, gpuName);
+            initialTflops = available.tflops;
+        });
+        // ===== Step 2: 创建带 Annotation 的 Deployment（核心操作）=====
+        await step('创建带 Annotation 的 Deployment', {
+            showStepTitle: false,
+            typingSpeed: 100,
+            pauseAfter: 3000
+        }, async () => {
+            const yaml = annotatedDeploymentYaml(DEPLOYMENT_NAME, {
+                tflopsRequest: '1000m',
+                tflopsLimit: '2000m',
+                vramRequest: '1Gi',
+                vramLimit: '2Gi',
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        await step('验证 Deployment 的 Tensor Fusion annotations', {
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            await sleep(2000);
+            const annotations = await kubectl.get('deployment', DEPLOYMENT_NAME, {
+                jqFilter: '.spec.template.metadata.annotations | with_entries(select(.key | startswith("tensor-fusion.ai")))'
+            });
+            expect(annotations['tensor-fusion.ai/gpu-pool']).toBeDefined();
+            expect(annotations['tensor-fusion.ai/tflops-request']).toBeDefined();
+        });
+        // ===== Step 3: 验证 Deployment 和 Pod 状态 =====
+        await step('检查 Deployment 可用状态', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const deploy = deployment(kubectl, DEPLOYMENT_NAME);
+            await expect(deploy).toExistInCluster();
+            await kubectl.wait('deployment', DEPLOYMENT_NAME, 'Available', {
+                timeout: DEFAULT_TIMEOUT,
+            });
+        });
+        await step('验证 Pod 运行状态', {
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const pods = await kubectl.get('pod', undefined, {
+                selector: `app=${DEPLOYMENT_NAME}`,
+                jqFilter: '[.items[] | {name: .metadata.name, phase: .status.phase}]'
+            });
+            expect(pods?.length).toBeGreaterThan(0);
+            expect(pods[0].phase).toBe('Running');
+        });
+        // ===== Step 4: 验证 GPU 资源分配结果 =====
+        await step('检查 GPU 可用资源变化', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2500
+        }, async () => {
+            await sleep(1000);
+            const available = await getGpuAvailable(kubectl, gpuName);
+            const currentTflops = parseTflops(available.tflops);
+            const initialTflopsNum = parseTflops(initialTflops);
+            // GPU 资源应该减少
+            expect(currentTflops).toBeLessThan(initialTflopsNum);
+        });
+        // ===== 清理 =====
+        await step('删除 Deployment', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const result = await kubectl.delete('deployment', DEPLOYMENT_NAME, { force: true });
+            await expect(result).toBeSuccessful();
+        });
+        await step('等待资源释放并验证', {
+            pauseAfter: 2000
+        }, async () => {
+            await sleep(5000);
+            // 验证 TensorFusionWorkload 自动清理
+            const workloadExists = await kubectl.exists('tensorfusionworkload', DEPLOYMENT_NAME);
+            if (workloadExists) {
+                await kubectl.delete('tensorfusionworkload', DEPLOYMENT_NAME, { force: true });
+            }
+            // 验证 GPU 资源已释放（TFlops 应该恢复）
+            const afterRelease = await getGpuAvailable(kubectl, gpuName);
+            const releasedTflops = parseTflops(afterRelease.tflops);
+            const initialTflopsNum = parseTflops(initialTflops);
+            // 允许小误差，但应该接近初始值
+            expect(releasedTflops).toBeGreaterThanOrEqual(initialTflopsNum - 100);
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/03-insufficient.d.ts

@@ -0,0 +1,17 @@
+/**
+ * 测试场景 3: 资源不足场景
+ *
+ * 验证当请求的 GPU 资源超过可用量时：
+ * - TensorFusionWorkload 状态应为 Pending
+ * - replicas 应为 0
+ * - GPU 可用资源不应减少
+ *
+ * 录制效果：
+ * - 主窗格：持续 watch workload 状态变化
+ * - 新窗格：执行查询和验证命令
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/03-insufficient.ts
+ */
+export {};
+//# sourceMappingURL=03-insufficient.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/03-insufficient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"03-insufficient.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/03-insufficient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}

package/dist/plugin-kubectl/examples/tensor-fusion/03-insufficient.js

@@ -0,0 +1,96 @@
+/**
+ * 测试场景 3: 资源不足场景
+ *
+ * 验证当请求的 GPU 资源超过可用量时：
+ * - TensorFusionWorkload 状态应为 Pending
+ * - replicas 应为 0
+ * - GPU 可用资源不应减少
+ *
+ * 录制效果：
+ * - 主窗格：持续 watch workload 状态变化
+ * - 新窗格：执行查询和验证命令
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/03-insufficient.ts
+ */
+import { sleep } from 'bun';
+import { test, describe, expect, step, workloadYaml, getFirstGpuName, getGpuAvailable, } from './_config.js';
+const WORKLOAD_NAME = 'test-workload-insufficient';
+describe('测试场景 3: 资源不足场景', { record: true }, () => {
+    test('GPU 资源不足时 Workload 行为验证', async (ctx) => {
+        const { kubectl } = ctx.plugins;
+        const { terminal } = ctx;
+        let gpuName;
+        let initialTflops;
+        let initialVram;
+        // ===== Step 1: 记录初始状态 =====
+        await step('获取测试 GPU', {
+            showStepTitle: false,
+            typingSpeed: 60,
+            pauseAfter: 1000
+        }, async () => {
+            gpuName = await getFirstGpuName(kubectl);
+        });
+        await step('记录初始可用资源', {
+            typingSpeed: 60,
+            pauseAfter: 1500
+        }, async () => {
+            const available = await getGpuAvailable(kubectl, gpuName);
+            initialTflops = available.tflops;
+            initialVram = available.vram;
+        });
+        // ===== Step 2: 创建超量资源请求的 Workload（核心操作）=====
+        await step('创建超量资源请求的 Workload', {
+            showStepTitle: false,
+            typingSpeed: 100,
+            pauseAfter: 2000
+        }, async () => {
+            // 请求 100 TFlops 和 100Gi VRAM - 远超任何单 GPU 的容量
+            const yaml = workloadYaml(WORKLOAD_NAME, {
+                tflopsRequest: '100000m', // 100 TFlops
+                tflopsLimit: '100000m',
+                vramRequest: '100Gi',
+                vramLimit: '100Gi',
+            });
+            const result = await kubectl.apply(yaml);
+            await expect(result).toBeSuccessful();
+        });
+        // ===== Step 3: 主窗格 watch，新窗格验证 =====
+        await step('观察 Workload 状态并验证', {
+            showStepTitle: false,
+            pauseAfter: 2000
+        }, async () => {
+            // 在主窗格启动 watch（等待命令输入完成后返回）
+            const watchProc = await kubectl.get('tensorfusionworkload', WORKLOAD_NAME, { watch: true });
+            // 创建新终端（自动携带 plugins）
+            const terminal2 = await terminal.create();
+            const kubectl2 = terminal2.plugins.kubectl;
+            // 在新窗格执行验证命令
+            // 检查状态不是 Running
+            const status = await kubectl2.getJsonPath('tensorfusionworkload', WORKLOAD_NAME, '.status');
+            expect(status?.phase).not.toBe('Running');
+            // 检查 GPU 资源未被分配
+            const currentAvailable = await getGpuAvailable(kubectl2, gpuName);
+            expect(currentAvailable.tflops).toBe(initialTflops);
+            expect(currentAvailable.vram).toBe(initialVram);
+            // 获取事件信息
+            await kubectl2.get('event', undefined, {
+                fieldSelector: `involvedObject.name=${WORKLOAD_NAME},involvedObject.kind=TensorFusionWorkload`,
+                jqFilter: '[.items[] | {reason: .reason, message: .message, type: .type}]'
+            });
+            // 观察一段时间后关闭
+            await sleep(3000);
+            // 中断 watch
+            await watchProc.interrupt();
+        });
+        // ===== Step 4: 清理 =====
+        await step('删除 TensorFusionWorkload', {
+            showStepTitle: false,
+            typingSpeed: 80,
+            pauseAfter: 2000
+        }, async () => {
+            const result = await kubectl.delete('tensorfusionworkload', WORKLOAD_NAME);
+            await expect(result).toBeSuccessful();
+        });
+    });
+});

package/dist/plugin-kubectl/examples/tensor-fusion/04-release.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 测试场景 4: 资源释放验证
+ *
+ * 验证删除 TensorFusionWorkload 后：
+ * - GPU 资源正确释放
+ * - 可用资源恢复到初始值
+ * - 关联的 Worker Pod 被清理
+ *
+ * 运行方式:
+ *   bun run repterm packages/plugin-kubectl/examples/tensor-fusion/04-release.ts
+ */
+export {};
+//# sourceMappingURL=04-release.d.ts.map

package/dist/plugin-kubectl/examples/tensor-fusion/04-release.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"04-release.d.ts","sourceRoot":"","sources":["../../../../examples/tensor-fusion/04-release.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}