feat: consolidate k8s service fetching

Author: CasLubbers

src/api-v2.authz.test.ts

@@ -27,7 +27,7 @@ function createTeamResource(kind: AplKind, spec: Record<string, any>) {
   }
 }
 
-jest.mock('./k8s_operations')
+jest.mock('./k8s-operations')
 jest.mock('./utils/sealedSecretUtils')
 beforeAll(async () => {
   jest.spyOn(console, 'log').mockImplementation(() => {})

src/api.authz.test.ts

@@ -20,7 +20,7 @@ const userToken = getToken([])
 const teamId = 'team1'
 const otherTeamId = 'team2'
 
-jest.mock('./k8s_operations')
+jest.mock('./k8s-operations')
 jest.mock('./utils/sealedSecretUtils')
 beforeAll(async () => {
   jest.spyOn(console, 'log').mockImplementation(() => {})

src/api/v1/sealedsecretskeys.ts

@@ -1,6 +1,6 @@
 import Debug from 'debug'
 import { Request, Response } from 'express'
-import { getSealedSecretsKeys } from 'src/k8s_operations'
+import { getSealedSecretsKeys } from 'src/k8s-operations'
 import YAML from 'yaml'
 
 const debug = Debug('otomi:api:v1:sealedsecrets')

src/app.ts

@@ -33,7 +33,7 @@ import {
 } from 'src/validators'
 import swaggerUi from 'swagger-ui-express'
 import getLatestRemoteCommitSha from './git/connect'
-import { getBuildStatus, getSealedSecretStatus, getServiceStatus, getWorkloadStatus } from './k8s_operations'
+import { getBuildStatus, getSealedSecretStatus, getServiceStatus, getWorkloadStatus } from './k8s-operations'
 
 const env = cleanEnv({
   CATALOG_CACHE_REFRESH_INTERVAL_MS,

src/k8s-operations.test.ts

@@ -0,0 +1,168 @@
+import { CoreV1Api, V1Service } from '@kubernetes/client-node'
+import { getCloudttyActiveTime, getLogTime, groupK8sServices, toK8sService } from './k8s-operations'
+
+// Mock the KubeConfig
+jest.mock('@kubernetes/client-node', () => {
+  const actual = jest.requireActual('@kubernetes/client-node')
+  return {
+    ...actual,
+    KubeConfig: jest.fn().mockImplementation(() => ({
+      loadFromDefault: jest.fn(),
+      makeApiClient: jest.fn((apiClientType) => {
+        if (apiClientType === actual.CoreV1Api) {
+          return new actual.CoreV1Api()
+        }
+        return {}
+      }),
+    })),
+  }
+})
+
+const makeService = (overrides: Partial<V1Service> = {}): V1Service => ({
+  metadata: { name: 'my-svc', labels: {} },
+  spec: { type: 'ClusterIP', ports: [{ port: 8080 }] },
+  ...overrides,
+})
+
+describe('toK8sService', () => {
+  test('maps a regular service', () => {
+    const result = toK8sService(makeService())
+    expect(result).toEqual({ name: 'my-svc', ports: [8080], managedByKnative: false })
+  })
+
+  test('uses app.kubernetes.io/name label as canonical name', () => {
+    const svc = makeService({ metadata: { name: 'my-svc-v1', labels: { 'app.kubernetes.io/name': 'my-svc' } } })
+    expect(toK8sService(svc)?.name).toBe('my-svc')
+  })
+
+  test('filters out knative private services', () => {
+    const svc = makeService({
+      metadata: { name: 'private-svc', labels: { 'networking.internal.knative.dev/serviceType': 'Private' } },
+    })
+    expect(toK8sService(svc)).toBeNull()
+  })
+
+  test('filters out ClusterIP knative revision services', () => {
+    const svc = makeService({
+      metadata: { name: 'revision-svc', labels: { 'serving.knative.dev/service': 'my-ksvc' } },
+      spec: { type: 'ClusterIP', ports: [{ port: 80 }] },
+    })
+    expect(toK8sService(svc)).toBeNull()
+  })
+
+  test('maps ExternalName knative service and sets managedByKnative', () => {
+    const svc = makeService({
+      metadata: { name: 'external-svc', labels: { 'serving.knative.dev/service': 'my-ksvc' } },
+      spec: { type: 'ExternalName', ports: [{ port: 80 }] },
+    })
+    const result = toK8sService(svc)
+    expect(result).toEqual({ name: 'my-ksvc', ports: [80], managedByKnative: true })
+  })
+})
+
+describe('groupK8sServices', () => {
+  test('returns services unchanged when no duplicates', () => {
+    const services = [
+      { name: 'svc-a', ports: [80], managedByKnative: false },
+      { name: 'svc-b', ports: [8080], managedByKnative: false },
+    ]
+    expect(groupK8sServices(services)).toEqual(services)
+  })
+
+  test('merges canary variants with the same canonical name', () => {
+    const services = [
+      { name: 'my-svc', ports: [80], managedByKnative: false },
+      { name: 'my-svc', ports: [80], managedByKnative: false },
+    ]
+    expect(groupK8sServices(services)).toEqual([{ name: 'my-svc', ports: [80], managedByKnative: false }])
+  })
+
+  test('deduplicates ports across merged services', () => {
+    const services = [
+      { name: 'my-svc', ports: [80, 443], managedByKnative: false },
+      { name: 'my-svc', ports: [443, 8080], managedByKnative: false },
+    ]
+    const result = groupK8sServices(services)
+    expect(result).toHaveLength(1)
+    expect(result[0].ports).toEqual(expect.arrayContaining([80, 443, 8080]))
+    expect(result[0].ports).toHaveLength(3)
+  })
+
+  test('propagates managedByKnative if any service in the group has it set', () => {
+    const services = [
+      { name: 'my-svc', ports: [80], managedByKnative: false },
+      { name: 'my-svc', ports: [80], managedByKnative: true },
+    ]
+    expect(groupK8sServices(services)[0].managedByKnative).toBe(true)
+  })
+})
+
+describe('getCloudttyLogTime', () => {
+  test('should return the timestamp for a valid log timestamp', () => {
+    const timestampMatch = ['[2023/10/10 00:00:00:0000]', '2023/10/10 00:00:00:0000']
+    const result = getLogTime(timestampMatch)
+    const timestamp = new Date('2023-10-10T00:00:00.000').getTime()
+    expect(result).toBe(timestamp)
+  })
+
+  test('should return NaN for an invalid log timestamp', () => {
+    const timestampMatch = ['[invalid-timestamp]', 'invalid-date invalid-time']
+    const result = getLogTime(timestampMatch)
+    expect(result).toBeNaN()
+  })
+})
+
+describe('getCloudttyActiveTime', () => {
+  afterEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('should return the time difference if no clients', async () => {
+    const namespace = 'test-namespace'
+    const podName = 'test-pod'
+    const log = '[2023/10/10 00:00:00:0000] [INFO] clients: 0'
+    jest.spyOn(CoreV1Api.prototype, 'readNamespacedPodLog').mockResolvedValue(log)
+
+    const result = await getCloudttyActiveTime(namespace, podName)
+    expect(result).toBeGreaterThan(0)
+  })
+
+  test('should return 0 if clients are connected', async () => {
+    const namespace = 'test-namespace'
+    const podName = 'test-pod'
+    const log = '[2023/10/10 00:00:00:0000] [INFO] clients: 1'
+    jest.spyOn(CoreV1Api.prototype, 'readNamespacedPodLog').mockResolvedValue(log)
+
+    const result = await getCloudttyActiveTime(namespace, podName)
+    expect(result).toBe(0)
+  })
+
+  test('should return undefined if log does not contain client count', async () => {
+    const namespace = 'test-namespace'
+    const podName = 'test-pod'
+    const log = '[2023/10/10 00:00:00:0000] [INFO] some other log message'
+    jest.spyOn(CoreV1Api.prototype, 'readNamespacedPodLog').mockResolvedValue(log)
+
+    const result = await getCloudttyActiveTime(namespace, podName)
+    expect(result).toBeUndefined()
+  })
+
+  test('should return undefined if log is empty', async () => {
+    const namespace = 'test-namespace'
+    const podName = 'test-pod'
+    const log = ''
+    jest.spyOn(CoreV1Api.prototype, 'readNamespacedPodLog').mockResolvedValue(log)
+
+    const result = await getCloudttyActiveTime(namespace, podName)
+    expect(result).toBeUndefined()
+  })
+
+  test('should return undefined if an error occurs', async () => {
+    const namespace = 'test-namespace'
+    const podName = 'test-pod'
+    jest.spyOn(CoreV1Api.prototype, 'readNamespacedPodLog').mockRejectedValue(new Error('test error'))
+
+    const result = await getCloudttyActiveTime(namespace, podName)
+    expect(result).toBeUndefined()
+  })
+})

src/k8s_operations.ts src/k8s-operations.tssrc/k8s_operations.ts renamed to src/k8s-operations.ts

@@ -1,6 +1,12 @@
-import { CoreV1Api, CustomObjectsApi, KubeConfig, VersionApi } from '@kubernetes/client-node'
+import { CoreV1Api, CustomObjectsApi, KubeConfig, V1Service, VersionApi } from '@kubernetes/client-node'
 import Debug from 'debug'
-import { AplBuildResponse, AplServiceResponse, AplWorkloadResponse, SealedSecretManifestResponse } from './otomi-models'
+import {
+  AplBuildResponse,
+  AplServiceResponse,
+  AplWorkloadResponse,
+  K8sService,
+  SealedSecretManifestResponse,
+} from './otomi-models'
 
 const debug = Debug('otomi:api:k8sOperations')
 
@@ -414,3 +420,49 @@ export async function getTeamSecretsFromK8s(namespace: string) {
     debug(`Failed to get team secrets from k8s for ${namespace}.`)
   }
 }
+
+export function toK8sService(item: V1Service): K8sService | null {
+  const knativeServiceTypeLabel = 'networking.internal.knative.dev/serviceType'
+  const knativeServiceLabel = 'serving.knative.dev/service'
+  const appNameLabel = 'app.kubernetes.io/name'
+
+  const labels = item.metadata?.labels ?? {}
+
+  // Filter out knative private services
+  if (labels[knativeServiceTypeLabel] === 'Private') return null
+  // Filter out services that are knative service revision
+  if (item.spec?.type === 'ClusterIP' && labels[knativeServiceLabel]) return null
+
+  let name = item.metadata?.name ?? 'unknown'
+  let managedByKnative = false
+
+  if (item.spec?.type === 'ExternalName' && labels[knativeServiceLabel]) {
+    name = labels[knativeServiceLabel]
+    managedByKnative = true
+  }
+
+  // Group canary services (e.g. foo-v1 and foo-v2) by their common app.kubernetes.io/name label
+  const canonicalName = labels[appNameLabel] ?? name
+  const ports = item.spec?.ports?.map((p) => p.port) ?? []
+
+  return { name: canonicalName, ports, managedByKnative }
+}
+
+export function groupK8sServices(services: K8sService[]): K8sService[] {
+  const grouped = new Map<string, K8sService>()
+
+  for (const svc of services) {
+    const existing = grouped.get(svc.name)
+    if (existing) {
+      grouped.set(svc.name, {
+        ...existing,
+        ports: Array.from(new Set([...(existing.ports ?? []), ...(svc.ports ?? [])])),
+        managedByKnative: existing.managedByKnative || svc.managedByKnative,
+      })
+    } else {
+      grouped.set(svc.name, svc)
+    }
+  }
+
+  return Array.from(grouped.values())
+}