getPodsMetrics method

Author: mclarke47

src/index.ts

@@ -13,4 +13,5 @@ export * from './top';
 export * from './object';
 export * from './cp';
 export * from './patch';
+export * from './metrics';
 export { ConfigOptions, User, Cluster, Context } from './config_types';

src/metrics.ts

@@ -0,0 +1,83 @@
+import * as request from 'request';
+import { KubeConfig } from './config';
+import { HttpError, ObjectSerializer, Authentication } from './gen/api';
+
+export interface ContainerMetric {
+    name: string,
+    usage:{
+        cpu: string,
+        memory: string
+    }
+}
+
+export interface PodMetric {
+    metadata: {
+        name: string;
+        namespace: string;
+        selfLink: string;
+        creationTimestamp: string;
+    }
+    timestamp: string,
+    window: string,
+    containers: Array<ContainerMetric>
+}
+
+export interface PodMetricsList {
+    kind: 'PodMetricsList';
+    apiVersion: 'metrics.k8s.io/v1beta1';
+    metadata: {
+        selfLink: string
+    };
+    items: Array<PodMetric>
+}
+
+export class Metrics {
+    private config: KubeConfig;
+
+    public constructor(config: KubeConfig) {
+        this.config = config;
+    }
+
+    // TODO getNodeMetrics
+    
+    public async getPodMetrics(namespace?: string): Promise<PodMetricsList> {
+
+        let path:string;
+
+        if (namespace !== undefined && namespace.length > 0){
+            path = `/apis/metrics.k8s.io/v1beta1/${namespace}/default/pods`;   
+        } else {
+            path = "/apis/metrics.k8s.io/v1beta1/pods";
+        }
+
+        const cluster = this.config.getCurrentCluster();
+        if (!cluster) {
+            throw new Error('No currently active cluster');
+        }
+
+        const requestOptions: request.Options = {
+            method: 'GET',
+            uri: cluster.server + path,
+        };
+        await this.config.applyToRequest(requestOptions);
+        
+        return new Promise((resolve, reject) => {
+            const req = request(requestOptions, (error, response, body) => {
+                if (error) {
+                    reject(error);
+                } else if (response.statusCode !== 200) {
+                    try {
+                        const deserializedBody = ObjectSerializer.deserialize(JSON.parse(body), 'V1Status');
+                        reject(new HttpError(response, deserializedBody, response.statusCode));
+                    } catch (e) {
+                        reject(new HttpError(response, body, response.statusCode));
+                    }
+                } else {
+                    const result: PodMetricsList = JSON.parse(body)
+                    resolve(result);
+                }
+            });
+        });
+
+    }
+}

src/metrics_test.ts

@@ -0,0 +1,145 @@
+import { fail } from 'assert';
+import { expect } from 'chai';
+import * as nock from 'nock';
+import { KubeConfig } from './config';
+import { V1Status, HttpError } from './gen/api';
+import { Metrics, PodMetricsList } from './metrics';
+
+const emptyPodMetrics: PodMetricsList = {
+    kind: 'PodMetricsList',
+    apiVersion: 'metrics.k8s.io/v1beta1',
+    metadata: {
+        selfLink: '/apis/metrics.k8s.io/v1beta1/pods',
+    },
+    items: [],
+};
+
+const mockedPodMetrics: PodMetricsList = {
+    kind: 'PodMetricsList',
+    apiVersion: 'metrics.k8s.io/v1beta1',
+    metadata: { selfLink: '/apis/metrics.k8s.io/v1beta1/pods/' },
+    items: [
+        {
+            metadata: {
+                name: 'dice-roller-7c76898b4d-shm9p',
+                namespace: 'default',
+                selfLink: '/apis/metrics.k8s.io/v1beta1/namespaces/default/pods/dice-roller-7c76898b4d-shm9p',
+                creationTimestamp: '2021-09-26T11:57:27Z',
+            },
+            timestamp: '2021-09-26T11:57:21Z',
+            window: '30s',
+            containers: [{ name: 'nginx', usage: { cpu: '10', memory: '3912Ki' } }],
+        },
+        {
+            metadata: {
+                name: 'other-pod-7c76898b4e-12kj',
+                namespace: 'default',
+                selfLink: '/apis/metrics.k8s.io/v1beta1/namespaces/default/pods/other-pod-7c76898b4e-12kj',
+                creationTimestamp: '2021-09-26T11:57:27Z',
+            },
+            timestamp: '2021-09-26T11:57:21Z',
+            window: '30s',
+            containers: [{ name: 'nginx', usage: { cpu: '15', memory: '4012Ki' } },{ name: 'sidecar', usage: { cpu: '16', memory: '3012Ki' } }],
+        },
+    ],
+};
+
+const TEST_NAMESPACE = 'test-namespace';
+
+const testConfigOptions: any = {
+    clusters: [{ name: 'cluster', server: 'https://127.0.0.1:51010' }],
+    users: [{ name: 'user', password: 'password' }],
+    contexts: [{ name: 'currentContext', cluster: 'cluster', user: 'user' }],
+    currentContext: 'currentContext',
+};
+
+
+const systemUnderTest = ():[Metrics, nock.Scope] => {
+    const kc = new KubeConfig();
+    kc.loadFromOptions(testConfigOptions);
+    const metricsClient = new Metrics(kc);
+
+    const scope = nock(testConfigOptions.clusters[0].server)
+
+    return [metricsClient, scope]
+}
+
+describe('Metrics', () => {
+
+    describe('getPodMetrics', () => {
+        it('should return cluster scope empty pods list', async () => {
+            const [metricsClient, scope] = systemUnderTest()
+            const s = scope
+                .get('/apis/metrics.k8s.io/v1beta1/pods')
+                .reply(200, emptyPodMetrics);
+
+            const response = await metricsClient.getPodMetrics();
+            expect(response.items.length).to.equal(0);
+            s.done();
+        });
+        it('should return cluster scope empty pods list when namespace is empty string', async () => {            
+            const [metricsClient, scope] = systemUnderTest()
+            const s = scope
+                .get('/apis/metrics.k8s.io/v1beta1/pods')
+                .reply(200, emptyPodMetrics);
+
+            const response = await metricsClient.getPodMetrics("");
+            expect(response.items.length).to.equal(0);
+            s.done();
+        });
+        it('should return namespace scope empty pods list', async () => {
+            const [metricsClient, scope] = systemUnderTest()
+            const s = scope
+                .get(`/apis/metrics.k8s.io/v1beta1/${TEST_NAMESPACE}/default/pods`)
+                .reply(200, emptyPodMetrics);
+
+            const response = await metricsClient.getPodMetrics(TEST_NAMESPACE);
+            expect(response.items.length).to.equal(0);
+            s.done();
+        });
+        it('should return cluster scope pods metrics list', async () => {
+            const [metricsClient, scope] = systemUnderTest()
+            const s = scope
+                .get('/apis/metrics.k8s.io/v1beta1/pods')
+                .reply(200, mockedPodMetrics);
+
+            const response = await metricsClient.getPodMetrics();
+            expect(response).to.deep.equal(mockedPodMetrics);
+
+            s.done();
+        });
+        it('should return namespace scope pods metric list', async () => {
+            const [metricsClient, scope] = systemUnderTest()
+            const s = scope
+                .get(`/apis/metrics.k8s.io/v1beta1/${TEST_NAMESPACE}/default/pods`)
+                .reply(200, mockedPodMetrics);
+
+            const response = await metricsClient.getPodMetrics(TEST_NAMESPACE);
+            expect(response).to.deep.equal(mockedPodMetrics);
+            s.done();
+        });
+        it('should resolve to error when 500', async () => {
+
+            const response: V1Status = {
+                code: 12345,
+                message: 'some message',
+            };
+            const [metricsClient, scope] = systemUnderTest()
+            const s = scope
+                .get('/apis/metrics.k8s.io/v1beta1/pods')
+                .reply(500, response);
+
+            try {
+                await metricsClient.getPodMetrics();
+                fail("expected thrown error");
+            } catch (e) {
+                if (!(e instanceof HttpError)){
+                    fail("expected HttpError error");
+                } 
+                expect(e.body.code).to.equal(response.code);             
+                expect(e.body.message).to.equal(response.message); 
+            }
+            s.done();
+        });
+    });
+});