@skyhook-io/k8s-ui 1.13.0 → 1.13.4

package/src/components/resources/resource-utils-nim.ts

@@ -0,0 +1,109 @@
+// NVIDIA NIM Operator CRD utility functions
+
+import type { StatusBadge } from './resource-utils'
+import { healthColors } from './resource-utils'
+
+// ============================================================================
+// SHARED HELPERS
+// ============================================================================
+
+function stateToBadge(state: string | undefined): StatusBadge {
+  switch (state) {
+    case 'Ready':
+      return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
+    case 'Failed':
+      return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+    case 'NotReady':
+    case 'Pending':
+    case 'InProgress':
+    case 'Started':
+    case 'PVC-Created':
+      return { text: state, color: healthColors.degraded, level: 'degraded' }
+    default:
+      return { text: state || 'Unknown', color: healthColors.unknown, level: 'unknown' }
+  }
+}
+
+// ============================================================================
+// NIMSERVICE UTILITIES
+// ============================================================================
+
+export function getNIMServiceStatus(resource: any): StatusBadge {
+  return stateToBadge(resource.status?.state)
+}
+
+export function getNIMServiceImage(resource: any): string {
+  const image = resource.spec?.image
+  if (!image?.repository) return '-'
+  return image.tag ? `${image.repository}:${image.tag}` : image.repository
+}
+
+export function getNIMServiceModel(resource: any): string {
+  const modelName = resource.status?.model?.name
+  if (modelName) return modelName
+  return getNIMServiceImage(resource)
+}
+
+export function getNIMServiceReplicas(resource: any): string {
+  const available = resource.status?.availableReplicas ?? 0
+  const scale = resource.spec?.scale
+  if (scale?.enabled) {
+    const min = scale.hpa?.minReplicas
+    const max = scale.hpa?.maxReplicas
+    if (min !== undefined && max !== undefined) return `${available} (${min}-${max})`
+    return `${available} (hpa)`
+  }
+  const desired = resource.spec?.replicas
+  if (desired !== undefined && desired !== null) return `${available}/${desired}`
+  return `${available}`
+}
+
+// ============================================================================
+// NIMCACHE UTILITIES
+// ============================================================================
+
+export function getNIMCacheStatus(resource: any): StatusBadge {
+  return stateToBadge(resource.status?.state)
+}
+
+export function getNIMCacheSourceType(resource: any): string {
+  const source = resource.spec?.source
+  if (!source) return '-'
+  if (source.ngc) return 'NGC'
+  if (source.dataStore) return 'DataStore'
+  if (source.hf) return 'HF'
+  return '-'
+}
+
+export function getNIMCacheModelSource(resource: any): string {
+  const source = resource.spec?.source
+  if (!source) return '-'
+  if (source.ngc) return source.ngc.modelPuller || source.ngc.modelEndpoint || '-'
+  const dshf = source.dataStore || source.hf
+  if (dshf) return dshf.modelName || dshf.datasetName || '-'
+  return '-'
+}
+
+export function getNIMCacheStorageSize(resource: any): string {
+  return resource.spec?.storage?.pvc?.size || '-'
+}
+
+export function getNIMCachePVCName(resource: any): string {
+  return resource.status?.pvc || resource.spec?.storage?.pvc?.name || '-'
+}
+
+// ============================================================================
+// NIMPIPELINE UTILITIES
+// ============================================================================
+
+export function getNIMPipelineStatus(resource: any): StatusBadge {
+  return stateToBadge(resource.status?.state)
+}
+
+export function getNIMPipelineServiceCount(resource: any): string {
+  const services = resource.spec?.services || []
+  if (services.length === 0) return '0'
+  const enabled = services.filter((s: any) => s?.enabled !== false).length
+  if (enabled < services.length) return `${enabled}/${services.length} enabled`
+  return `${services.length}`
+}

package/src/components/resources/resource-utils-ray.ts

@@ -0,0 +1,214 @@
+// KubeRay CRD utility functions (ray.io/v1)
+
+import type { StatusBadge } from './resource-utils'
+import { healthColors, formatAge } from './resource-utils'
+
+// ============================================================================
+// RAYCLUSTER UTILITIES
+// ============================================================================
+
+export function getRayClusterStatus(resource: any): StatusBadge {
+  const state = resource.status?.state
+  const conditions = resource.status?.conditions || []
+
+  const suspendingCond = conditions.find((c: any) => c.type === 'RayClusterSuspending')
+  if (suspendingCond?.status === 'True') {
+    return { text: 'Suspending', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  const suspendedCond = conditions.find((c: any) => c.type === 'RayClusterSuspended')
+  if (suspendedCond?.status === 'True') {
+    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  if (resource.spec?.suspend === true || state === 'suspended') {
+    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  const replicaFailureCond = conditions.find((c: any) => c.type === 'RayClusterReplicaFailure')
+  if (replicaFailureCond?.status === 'True') {
+    return { text: replicaFailureCond.reason || 'ReplicaFailure', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  if (state === 'failed') {
+    return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  const headReadyCond = conditions.find((c: any) => c.type === 'HeadPodReady')
+  if (headReadyCond?.status === 'False') {
+    return { text: headReadyCond.reason || 'HeadNotReady', color: healthColors.degraded, level: 'degraded' }
+  }
+  if (headReadyCond?.status === 'True') {
+    const availableWorkers = resource.status?.availableWorkerReplicas ?? 0
+    const desiredWorkers = resource.status?.desiredWorkerReplicas ?? 0
+    if (availableWorkers >= desiredWorkers) {
+      return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
+    }
+    return { text: `Workers ${availableWorkers}/${desiredWorkers}`, color: healthColors.degraded, level: 'degraded' }
+  }
+
+  if (conditions.length === 0 && state === 'ready') {
+    return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
+  }
+
+  const provisionedCond = conditions.find((c: any) => c.type === 'RayClusterProvisioned')
+  if (provisionedCond?.status === 'True') {
+    return { text: 'Provisioned', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  if (resource.status) {
+    return { text: 'Provisioning', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getRayClusterVersion(resource: any): string {
+  return resource.spec?.rayVersion || '-'
+}
+
+export function getRayClusterWorkers(resource: any): string {
+  const status = resource.status
+  if (!status) return '-'
+  const available = status.availableWorkerReplicas ?? 0
+  const desired = status.desiredWorkerReplicas ?? 0
+  return `${available}/${desired}`
+}
+
+export function getRayClusterHeadService(resource: any): string {
+  return resource.status?.head?.serviceName || '-'
+}
+
+// ============================================================================
+// RAYJOB UTILITIES
+// ============================================================================
+
+export function getRayJobStatus(resource: any): StatusBadge {
+  const jobStatus = resource.status?.jobStatus
+  const deploymentStatus = resource.status?.jobDeploymentStatus
+
+  if (deploymentStatus === 'Failed' || deploymentStatus === 'ValidationFailed') {
+    return { text: deploymentStatus, color: healthColors.unhealthy, level: 'unhealthy' }
+  }
+
+  switch (jobStatus) {
+    case 'SUCCEEDED':
+      return { text: 'Succeeded', color: healthColors.neutral, level: 'neutral' }
+    case 'RUNNING':
+      return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+    case 'FAILED':
+      return { text: 'Failed', color: healthColors.unhealthy, level: 'unhealthy' }
+    case 'STOPPED':
+      return { text: 'Stopped', color: healthColors.neutral, level: 'neutral' }
+    case 'PENDING':
+      return { text: 'Pending', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  switch (deploymentStatus) {
+    case 'Suspended':
+      return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
+    case 'Complete':
+      return { text: 'Complete', color: healthColors.neutral, level: 'neutral' }
+    case 'Running':
+      return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+    case 'Initializing':
+    case 'Suspending':
+    case 'Retrying':
+    case 'Waiting':
+      return { text: deploymentStatus, color: healthColors.degraded, level: 'degraded' }
+  }
+
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getRayJobJobStatus(resource: any): string {
+  return resource.status?.jobStatus || '-'
+}
+
+export function getRayJobDeploymentStatus(resource: any): string {
+  return resource.status?.jobDeploymentStatus || '-'
+}
+
+export function getRayJobClusterName(resource: any): string {
+  return resource.status?.rayClusterName || '-'
+}
+
+// ============================================================================
+// RAYSERVICE UTILITIES
+// ============================================================================
+
+export function getRayServiceStatus(resource: any): StatusBadge {
+  const conditions = resource.status?.conditions || []
+
+  const suspendingCond = conditions.find((c: any) => c.type === 'Suspending')
+  if (suspendingCond?.status === 'True') {
+    return { text: 'Suspending', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  const suspendedCond = conditions.find((c: any) => c.type === 'Suspended')
+  if (suspendedCond?.status === 'True' || resource.spec?.suspend === true) {
+    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
+  }
+
+  const upgradeCond = conditions.find((c: any) => c.type === 'UpgradeInProgress')
+  if (upgradeCond?.status === 'True') {
+    return { text: 'Upgrading', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  const rollbackCond = conditions.find((c: any) => c.type === 'RollbackInProgress')
+  if (rollbackCond?.status === 'True') {
+    return { text: 'RollingBack', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  const readyCond = conditions.find((c: any) => c.type === 'Ready')
+  if (readyCond?.status === 'True') {
+    return { text: 'Ready', color: healthColors.healthy, level: 'healthy' }
+  }
+  if (readyCond?.status === 'False') {
+    return { text: readyCond.reason || 'NotReady', color: healthColors.degraded, level: 'degraded' }
+  }
+
+  if (resource.status?.serviceStatus === 'Running') {
+    return { text: 'Running', color: healthColors.healthy, level: 'healthy' }
+  }
+
+  return { text: 'Unknown', color: healthColors.unknown, level: 'unknown' }
+}
+
+export function getRayServiceServiceStatus(resource: any): string {
+  return resource.status?.serviceStatus || '-'
+}
+
+export function getRayServiceClusters(resource: any): string {
+  const active = resource.status?.activeServiceStatus?.rayClusterName
+  const pending = resource.status?.pendingServiceStatus?.rayClusterName
+  const parts: string[] = []
+  if (active) parts.push(active)
+  if (pending) parts.push(`pending: ${pending}`)
+  return parts.join(' ') || '-'
+}
+
+// ============================================================================
+// RAYCRONJOB UTILITIES
+// ============================================================================
+
+export function getRayCronJobStatus(resource: any): StatusBadge {
+  if (resource.spec?.suspend === true) {
+    return { text: 'Suspended', color: healthColors.neutral, level: 'neutral' }
+  }
+  return { text: 'Active', color: healthColors.neutral, level: 'neutral' }
+}
+
+export function getRayCronJobSchedule(resource: any): string {
+  return resource.spec?.schedule || '-'
+}
+
+export function getRayCronJobSuspend(resource: any): boolean {
+  return resource.spec?.suspend === true
+}
+
+export function getRayCronJobLastSchedule(resource: any): string {
+  const lastSchedule = resource.status?.lastScheduleTime
+  if (!lastSchedule) return '-'
+  return formatAge(lastSchedule)
+}

package/src/components/resources/resource-utils-rollout.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from 'vitest'
+import { getCellFilterValue, getRolloutStep, getWorkloadDisplayStatus, getWorkloadStatus, workloadStatusLabel } from './resource-utils'
+
+describe('getRolloutStep', () => {
+  it('presents Argo currentStepIndex as a one-based step number', () => {
+    expect(getRolloutStep({
+      spec: { strategy: { canary: { steps: [{ setWeight: 25 }, { pause: {} }] } } },
+      status: { currentStepIndex: 0 },
+    })).toBe('1/2')
+  })
+
+  it('clamps Argo completed steps to the declared step count', () => {
+    expect(getRolloutStep({
+      spec: { strategy: { canary: { steps: [{ setWeight: 25 }, { pause: {} }] } } },
+      status: { currentStepIndex: 2 },
+    })).toBe('2/2')
+  })
+})
+
+describe('getWorkloadStatus', () => {
+  it('keeps a capacity-preserving surge healthy', () => {
+    expect(getWorkloadStatus({
+      spec: { replicas: 1 },
+      status: { readyReplicas: 2, availableReplicas: 1, updatedReplicas: 1 },
+    }, 'deployments')).toMatchObject({ text: '1/1', level: 'healthy' })
+  })
+
+  it('shows health instead of Stable for an idle under-replicated workload', () => {
+    expect(getWorkloadDisplayStatus({
+      metadata: { generation: 2 },
+      spec: { replicas: 3 },
+      status: {
+        observedGeneration: 2,
+        replicas: 2,
+        updatedReplicas: 3,
+        readyReplicas: 2,
+        availableReplicas: 2,
+      },
+    }, 'deployments').status).toMatchObject({ text: '2/3', level: 'degraded' })
+  })
+
+  it('shows rollout activity while a revision is progressing', () => {
+    expect(getWorkloadDisplayStatus({
+      metadata: { generation: 2 },
+      spec: { replicas: 3 },
+      status: {
+        observedGeneration: 2,
+        replicas: 4,
+        updatedReplicas: 2,
+        readyReplicas: 3,
+        availableReplicas: 3,
+      },
+    }, 'deployments').status).toMatchObject({ text: 'Rolling out', level: 'neutral' })
+  })
+
+  it('shows health instead of an inactive pause policy', () => {
+    expect(getWorkloadDisplayStatus({
+      metadata: { generation: 2 },
+      spec: { replicas: 3, paused: true },
+      status: {
+        observedGeneration: 2,
+        replicas: 3,
+        updatedReplicas: 3,
+        readyReplicas: 0,
+        availableReplicas: 0,
+      },
+    }, 'deployments').status).toMatchObject({ text: '0/3', level: 'unhealthy' })
+  })
+
+  it('keeps active rollout copy while preserving a worse health tone', () => {
+    expect(getWorkloadDisplayStatus({
+      metadata: { generation: 2 },
+      spec: { replicas: 3, paused: true },
+      status: {
+        observedGeneration: 2,
+        replicas: 3,
+        updatedReplicas: 0,
+        readyReplicas: 0,
+        availableReplicas: 0,
+      },
+    }, 'deployments').status).toMatchObject({ text: 'Unhealthy · Rollout paused', level: 'unhealthy' })
+  })
+
+  it('preserves unhealthy serving capacity while an Argo Rollout progresses', () => {
+    const resource = {
+      apiVersion: 'argoproj.io/v1alpha1',
+      metadata: { generation: 2 },
+      spec: { replicas: 3 },
+      status: {
+        observedGeneration: '2',
+        phase: 'Progressing',
+        updatedReplicas: 1,
+        readyReplicas: 0,
+        availableReplicas: 0,
+      },
+    }
+    const display = getWorkloadDisplayStatus(resource, 'rollouts')
+
+    expect(display.status).toMatchObject({ text: 'Degraded · Rolling out', level: 'degraded' })
+    expect(getCellFilterValue(resource, 'status', 'rollouts')).toBe('Degraded · Rolling out')
+  })
+
+  it('keeps Argo generation lag informational when observedGeneration is a string', () => {
+    const resource = {
+      apiVersion: 'argoproj.io/v1alpha1',
+      metadata: { generation: 3 },
+      spec: { replicas: 3 },
+      status: {
+        observedGeneration: '2',
+        phase: 'Healthy',
+        updatedReplicas: 0,
+        readyReplicas: 0,
+        availableReplicas: 0,
+      },
+    }
+
+    expect(getWorkloadDisplayStatus(resource, 'rollouts').status).toMatchObject({ text: 'Applying change', level: 'neutral' })
+    expect(getCellFilterValue(resource, 'status', 'rollouts')).toBe('Applying change')
+  })
+
+  it('uses semantic health for an idle Argo Rollout', () => {
+    const resource = {
+      apiVersion: 'argoproj.io/v1alpha1',
+      metadata: { generation: 2 },
+      spec: { replicas: 3 },
+      status: {
+        observedGeneration: '2',
+        phase: 'Healthy',
+        updatedReplicas: 3,
+        readyReplicas: 3,
+        availableReplicas: 3,
+      },
+    }
+
+    expect(getWorkloadDisplayStatus(resource, 'rollouts').status).toMatchObject({ text: '3/3', level: 'healthy' })
+    expect(getCellFilterValue(resource, 'status', 'rollouts')).toBe('Healthy')
+  })
+
+  it('does not fabricate Argo rollout state for a colliding CRD', () => {
+    const display = getWorkloadDisplayStatus({
+      apiVersion: 'rollouts.kruise.io/v1alpha1',
+      kind: 'Rollout',
+      metadata: { generation: 1 },
+      spec: { replicas: 3 },
+      status: { phase: 'Progressing', readyReplicas: 3, availableReplicas: 3, updatedReplicas: 3 },
+    }, 'rollouts')
+
+    expect(display.status).toMatchObject({ text: 'Progressing', level: 'unknown' })
+    expect(workloadStatusLabel(display.status)).toBe('Unknown')
+  })
+
+  it('shows health instead of a reached StatefulSet partition', () => {
+    const resource = {
+      metadata: { generation: 2 },
+      spec: { replicas: 5, updateStrategy: { rollingUpdate: { partition: 2 } } },
+      status: {
+        observedGeneration: 2,
+        updatedReplicas: 3,
+        readyReplicas: 4,
+        availableReplicas: 4,
+      },
+    }
+
+    expect(getWorkloadDisplayStatus(resource, 'statefulsets').status).toMatchObject({ text: '4/5', level: 'degraded' })
+    expect(getCellFilterValue(resource, 'status', 'statefulsets')).toBe('Degraded')
+  })
+
+  it('uses serving health as the filter value for an inactive pause policy', () => {
+    const resource = {
+      metadata: { generation: 2 },
+      spec: { replicas: 3, paused: true },
+      status: {
+        observedGeneration: 2,
+        replicas: 3,
+        updatedReplicas: 3,
+        readyReplicas: 0,
+        availableReplicas: 0,
+      },
+    }
+
+    expect(getCellFilterValue(resource, 'status', 'deployments')).toBe('Unhealthy')
+  })
+})

package/src/components/resources/resource-utils-velero.test.ts

@@ -94,6 +94,36 @@ describe('getCellFilterValue — Velero status column', () => {
     const bsl = { apiVersion: 'velero.io/v1', kind: 'BackupStorageLocation', status: { phase: 'Unavailable' } }
     expect(getCellFilterValue(bsl, 'status', 'backupstoragelocations')).toBe('Unavailable')
   })
+
+  // The cell dispatch sends a non-Velero BackupStorageLocation/BackupRepository
+  // to GenericCell. The filter dropdown and the sort key have to follow it
+  // there, or the column offers and orders values that appear on no row.
+  it('leaves a foreign BackupStorageLocation on the generic reader', () => {
+    // Conditions, not a phase: Velero's reader keys on phase and has nothing to
+    // say here, so this only passes if the generic derivation ran.
+    const foreign = {
+      apiVersion: 'other.io/v1',
+      kind: 'BackupStorageLocation',
+      status: { conditions: [{ type: 'Ready', status: 'True' }] },
+    }
+    expect(getCellFilterValue(foreign, 'status', 'backupstoragelocations')).toBe('Ready')
+  })
+
+  it('leaves a foreign BackupRepository on the generic reader', () => {
+    const foreign = {
+      apiVersion: 'other.io/v1',
+      kind: 'BackupRepository',
+      status: { conditions: [{ type: 'Ready', status: 'True' }] },
+    }
+    expect(getCellFilterValue(foreign, 'status', 'backuprepositories')).toBe('Ready')
+  })
+
+  // Velero's own readers speak a phase vocabulary a foreign CRD does not share,
+  // so the two must not produce the same string for the same object.
+  it('does not label a foreign resource with Velero vocabulary', () => {
+    const foreign = { apiVersion: 'other.io/v1', kind: 'BackupRepository', status: { phase: 'NotReady' } }
+    expect(getCellFilterValue(foreign, 'status', 'backuprepositories')).not.toBe('Not ready')
+  })
 })
 
 describe('Velero Backup phase vocabulary', () => {