Merge pull request kubernetes-client#415 from brendandburns/top

Initial implementation of "top" command for nodes

Author: k8s-ci-robot

examples/top.js

@@ -0,0 +1,8 @@
+const k8s = require('../dist/index');
+
+const kc = new k8s.KubeConfig();
+kc.loadFromDefault();
+
+const k8sApi = kc.makeApiClient(k8s.CoreV1Api);
+
+k8s.topNodes(k8sApi).then((obj) => console.log(obj));

src/index.ts

@@ -9,3 +9,4 @@ export * from './types';
 export * from './yaml';
 export * from './log';
 export * from './informer';
+export * from './top';

src/top.ts

@@ -0,0 +1,48 @@
+import { CoreV1Api, V1Node, V1Pod } from './gen/api';
+import { podsForNode, quantityToScalar, totalCPU, totalMemory } from './util';
+
+export class ResourceUsage {
+    constructor(
+        public readonly Capacity: number,
+        public readonly RequestTotal: number,
+        public readonly LimitTotal: number,
+    ) {}
+}
+
+export class NodeStatus {
+    constructor(
+        public readonly Node: V1Node,
+        public readonly CPU: ResourceUsage,
+        public readonly Memory: ResourceUsage,
+    ) {}
+}
+
+export async function topNodes(api: CoreV1Api): Promise<NodeStatus[]> {
+    // TODO: Support metrics APIs in the client and this library
+    const nodes = await api.listNode();
+    const result: NodeStatus[] = [];
+    for (const node of nodes.body!.items) {
+        const availableCPU = quantityToScalar(node.status!.allocatable!.cpu);
+        const availableMem = quantityToScalar(node.status!.allocatable!.memory);
+        let totalPodCPU = 0;
+        let totalPodCPULimit = 0;
+        let totalPodMem = 0;
+        let totalPodMemLimit = 0;
+        let pods = await podsForNode(api, node.metadata!.name!);
+        pods = pods.filter((pod: V1Pod) => pod.status!.phase === 'Running');
+        pods.forEach((pod: V1Pod) => {
+            const cpuTotal = totalCPU(pod);
+            totalPodCPU += cpuTotal.request;
+            totalPodCPULimit += cpuTotal.limit;
+
+            const memTotal = totalMemory(pod);
+            totalPodMem += memTotal.request;
+            totalPodMemLimit += memTotal.limit;
+        });
+
+        const cpuUsage = new ResourceUsage(availableCPU, totalPodCPU, totalPodCPULimit);
+        const memUsage = new ResourceUsage(availableMem, totalPodMem, totalPodMemLimit);
+        result.push(new NodeStatus(node, cpuUsage, memUsage));
+    }
+    return result;
+}

src/util.ts

@@ -0,0 +1,55 @@
+import { CoreV1Api, V1Container, V1Pod } from './gen/api';
+
+export async function podsForNode(api: CoreV1Api, nodeName: string): Promise<V1Pod[]> {
+    const allPods = await api.listPodForAllNamespaces();
+    return allPods.body.items.filter((pod: V1Pod) => pod.spec!.nodeName === nodeName);
+}
+
+export function quantityToScalar(quantity: string): number {
+    if (!quantity) {
+        return 0;
+    }
+    if (quantity.endsWith('m')) {
+        return parseInt(quantity.substr(0, quantity.length - 1), 10) / 1000.0;
+    }
+    if (quantity.endsWith('Ki')) {
+        return parseInt(quantity.substr(0, quantity.length - 2), 10) * 1024;
+    }
+    const num = parseInt(quantity, 10);
+    if (isNaN(num)) {
+        throw new Error('Unknown quantity ' + quantity);
+    }
+    return num;
+}
+
+export class ResourceStatus {
+    constructor(
+        public readonly request: number,
+        public readonly limit: number,
+        public readonly resourceType: string,
+    ) {}
+}
+
+export function totalCPU(pod: V1Pod): ResourceStatus {
+    return totalForResource(pod, 'cpu');
+}
+
+export function totalMemory(pod: V1Pod): ResourceStatus {
+    return totalForResource(pod, 'memory');
+}
+
+export function totalForResource(pod: V1Pod, resource: string): ResourceStatus {
+    let reqTotal = 0;
+    let limitTotal = 0;
+    pod.spec!.containers.forEach((container: V1Container) => {
+        if (container.resources) {
+            if (container.resources.requests) {
+                reqTotal += quantityToScalar(container.resources.requests[resource]);
+            }
+            if (container.resources.limits) {
+                limitTotal += quantityToScalar(container.resources.limits[resource]);
+            }
+        }
+    });
+    return new ResourceStatus(reqTotal, limitTotal, resource);
+}

src/util_test.ts

@@ -0,0 +1,106 @@
+import { expect } from 'chai';
+import { CoreV1Api, V1Container, V1Pod } from './api';
+import { podsForNode, quantityToScalar, totalCPU, totalMemory } from './util';
+
+describe('Utils', () => {
+    it('should get zero pods for a node', async () => {
+        const podList = {
+            body: {
+                items: [],
+            },
+        };
+        const mockApi = {
+            listPodForAllNamespaces: (): Promise<any> => {
+                return new Promise<any>((resolve) => {
+                    resolve(podList);
+                });
+            },
+        };
+
+        const pods = await podsForNode(mockApi as CoreV1Api, 'foo');
+        expect(pods.length).to.equal(0);
+    });
+
+    it('should only gets for pods named node', async () => {
+        const podList = {
+            body: {
+                items: [
+                    {
+                        spec: {
+                            nodeName: 'foo',
+                        },
+                    },
+                    {
+                        spec: {
+                            nodeName: 'bar',
+                        },
+                    },
+                ],
+            },
+        };
+        const mockApi = {
+            listPodForAllNamespaces: (): Promise<any> => {
+                return new Promise<any>((resolve) => {
+                    resolve(podList);
+                });
+            },
+        };
+
+        const pods = await podsForNode(mockApi as CoreV1Api, 'foo');
+        expect(pods.length).to.equal(1);
+        expect(pods[0].spec!.nodeName).to.equal('foo');
+    });
+
+    it('should parse quantities', () => {
+        expect(quantityToScalar('')).to.equal(0);
+
+        expect(quantityToScalar('100m')).to.equal(0.1);
+        expect(quantityToScalar('1976m')).to.equal(1.976);
+
+        expect(quantityToScalar('10Ki')).to.equal(10240);
+
+        expect(quantityToScalar('1024')).to.equal(1024);
+
+        expect(() => quantityToScalar('foobar')).to.throw('Unknown quantity foobar');
+    });
+
+    it('should get resources for pod', () => {
+        const pod = {
+            spec: {
+                containers: [
+                    {
+                        name: 'foo',
+                        resources: {
+                            requests: {
+                                cpu: '100m',
+                                memory: '10Ki',
+                            },
+                            limits: {
+                                cpu: '200m',
+                            },
+                        },
+                    } as V1Container,
+                    {
+                        name: 'bar',
+                        resources: {
+                            requests: {
+                                cpu: '1.0',
+                            },
+                            limits: {
+                                memory: '20Ki',
+                            },
+                        },
+                    } as V1Container,
+                ] as V1Container[],
+            },
+        } as V1Pod;
+
+        const cpuResult = totalCPU(pod);
+        expect(cpuResult.request).to.equal(1.1);
+        expect(cpuResult.limit).to.equal(0.2);
+
+        const memResult = totalMemory(pod);
+        expect(memResult.request).to.equal(10240);
+        expect(memResult.limit).to.equal(20480);
+    });
+});