kubernetes-fluent-client 3.1.0 → 3.1.2

package/dist/fluent/http2-watch.spec.js

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const globals_1 = require("@jest/globals");
+const http2_1 = __importDefault(require("http2"));
+const __1 = require("..");
+const types_1 = require("./types");
+const _1 = require(".");
+globals_1.jest.mock("http2");
+(0, globals_1.describe)("Watcher HTTP2", () => {
+    let watcher;
+    let mockClient;
+    let mockReq;
+    const evtMock = globals_1.jest.fn();
+    const errMock = globals_1.jest.fn();
+    const setupAndStartWatcher = (eventType, handler) => {
+        watcher.events.on(eventType, handler);
+        watcher.start().catch(errMock);
+    };
+    (0, globals_1.beforeEach)(() => {
+        globals_1.jest.clearAllMocks();
+        // http2.client
+        mockClient = {
+            request: globals_1.jest.fn(),
+            close: globals_1.jest.fn(),
+            on: globals_1.jest.fn(),
+            destroy: globals_1.jest.fn(),
+        };
+        // http2.request stream
+        mockReq = {
+            on: globals_1.jest.fn(),
+            end: globals_1.jest.fn(),
+            setEncoding: globals_1.jest.fn(),
+        };
+        // http2.connect function to return the mocked client session
+        http2_1.default.connect.mockReturnValue(mockClient);
+    });
+    (0, globals_1.afterEach)(() => {
+        watcher.close();
+    });
+    (0, globals_1.it)("should watch named resources", done => {
+        const pod = createMockPod("pod-1", "1");
+        const response = { type: "ADDED", object: pod };
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            useHTTP2: true,
+        });
+        mockReq.on.mockImplementation((event, callback) => {
+            switch (event) {
+                case "response":
+                    callback({ ":status": 200 }, 0);
+                    break;
+                case "data":
+                    setTimeout(() => {
+                        callback(Buffer.from(JSON.stringify(response)));
+                    }, 10);
+                    break;
+                case "end":
+                    setTimeout(() => {
+                        callback();
+                        done();
+                    }, 20);
+                    break;
+                case "error":
+                    errMock(new Error("HTTP2 connection error"));
+                    break;
+            }
+            return mockReq;
+        });
+        mockClient.request.mockReturnValue(mockReq);
+        setupAndStartWatcher(__1.WatchEvent.CONNECT, () => {
+            setupAndStartWatcher(__1.WatchEvent.DATA, (receivedPod, phase) => {
+                (0, globals_1.expect)(receivedPod.metadata?.name).toBe("pod-1");
+                (0, globals_1.expect)(receivedPod.metadata?.resourceVersion).toBe("1");
+                (0, globals_1.expect)(phase).toBe(types_1.WatchPhase.Added);
+                done();
+            });
+        });
+    });
+    (0, globals_1.it)("should handle resource version is too old", done => {
+        const errorResponse = {
+            type: "ERROR",
+            object: {
+                kind: "Status",
+                apiVersion: "v1",
+                metadata: {},
+                status: "Failure",
+                message: "too old resource version: 123 (391079)",
+                reason: "Gone",
+                code: 410,
+            },
+        };
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            useHTTP2: true,
+        });
+        mockReq.on.mockImplementation((event, callback) => {
+            switch (event) {
+                case "response":
+                    callback({ ":status": 200 }, 0);
+                    break;
+                case "data":
+                    setTimeout(() => {
+                        callback(Buffer.from(JSON.stringify(errorResponse)));
+                    }, 10);
+                    break;
+                case "end":
+                    setTimeout(() => {
+                        callback();
+                        done();
+                    }, 20);
+                    break;
+                case "error":
+                    errMock(new Error("HTTP2 connection error"));
+                    break;
+            }
+            return mockReq;
+        });
+        mockClient.request.mockReturnValue(mockReq);
+        setupAndStartWatcher(__1.WatchEvent.OLD_RESOURCE_VERSION, res => {
+            (0, globals_1.expect)(res).toEqual("123");
+            done();
+        });
+    });
+    (0, globals_1.it)("should call the event handler for each event", done => {
+        const pod = createMockPod("pod-0", "1");
+        const response = { type: "ADDED", object: pod };
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch((evt, phase) => {
+            (0, globals_1.expect)(evt.metadata?.name).toEqual("pod-0");
+            (0, globals_1.expect)(phase).toEqual(types_1.WatchPhase.Added);
+        }, { useHTTP2: true });
+        mockReq.on.mockImplementation((event, callback) => {
+            switch (event) {
+                case "response":
+                    callback({ ":status": 200 }, 0);
+                    break;
+                case "data":
+                    setTimeout(() => {
+                        callback(Buffer.from(JSON.stringify(response)));
+                    }, 10);
+                    break;
+                case "end":
+                    setTimeout(() => {
+                        callback();
+                    }, 20);
+                    break;
+                case "error":
+                    errMock(new Error("HTTP2 connection error"));
+                    break;
+            }
+            return mockReq;
+        });
+        mockClient.request.mockReturnValue(mockReq);
+        watcher.start().catch(errMock);
+        done();
+    });
+    (0, globals_1.it)("should return the cache id", () => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            resyncDelaySec: 1,
+            useHTTP2: true,
+        });
+        (0, globals_1.expect)(watcher.getCacheID()).toEqual("d69b75a611");
+    });
+    (0, globals_1.it)("should handle the CONNECT event", done => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            resyncDelaySec: 1,
+            useHTTP2: true,
+        });
+        setupAndStartWatcher(__1.WatchEvent.CONNECT, () => { });
+        done();
+    });
+    (0, globals_1.it)("should handle the DATA event", done => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            resyncDelaySec: 1,
+            useHTTP2: true,
+        });
+        setupAndStartWatcher(__1.WatchEvent.DATA, (pod, phase) => {
+            (0, globals_1.expect)(pod.metadata?.name).toEqual("pod-0");
+            (0, globals_1.expect)(phase).toEqual(types_1.WatchPhase.Added);
+        });
+        done();
+    });
+    (0, globals_1.it)("should handle the NETWORK_ERROR event", done => {
+        const errorMessage = "Something bad happened";
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            useHTTP2: true,
+            resyncDelaySec: 1,
+        });
+        mockReq.on.mockImplementation((event, callback) => {
+            if (event === "response") {
+                callback({ ":status": 200 }, 0);
+            }
+            else if (event === "error") {
+                callback(new Error(errorMessage));
+            }
+            return mockReq;
+        });
+        mockClient.request.mockReturnValue(mockReq);
+        setupAndStartWatcher(__1.WatchEvent.NETWORK_ERROR, error => {
+            (0, globals_1.expect)(error.message).toEqual(errorMessage);
+        });
+        watcher.start().catch(errMock);
+        done();
+    });
+    (0, globals_1.it)("should handle the RECONNECT event on an error", done => {
+        const errorMessage = "Something bad happened";
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            useHTTP2: true,
+            resyncDelaySec: 0.01,
+        });
+        let reconnectCount = 0;
+        mockReq.on.mockImplementation((event, callback) => {
+            if (event === "response") {
+                callback({ ":status": 200 }, 0);
+            }
+            else if (event === "error") {
+                reconnectCount += 1;
+                callback(new Error(errorMessage));
+            }
+            return mockReq;
+        });
+        mockClient.request.mockReturnValue(mockReq);
+        setupAndStartWatcher(__1.WatchEvent.RECONNECT, count => {
+            (0, globals_1.expect)(count).toEqual(reconnectCount);
+        });
+        watcher.start().catch(errMock);
+        done();
+    });
+    (0, globals_1.it)("should perform a resync after the resync interval", done => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            useHTTP2: true,
+            resyncDelaySec: 1,
+        });
+        watcher.start().catch(errMock);
+        done();
+    });
+    (0, globals_1.it)("should handle the GIVE_UP event", done => {
+        watcher = (0, _1.K8s)(__1.kind.Pod).Watch(evtMock, {
+            useHTTP2: true,
+            lastSeenLimitSeconds: 0.01,
+            resyncDelaySec: 0.01,
+            resyncFailureMax: 1,
+        });
+        setupAndStartWatcher(__1.WatchEvent.GIVE_UP, () => {
+            (0, globals_1.expect)(errMock).toBeCalled();
+        });
+        watcher.start().catch(errMock);
+        done();
+    });
+});
+/**
+ * Creates a mock pod object
+ *
+ * @param name The name of the pod
+ * @param resourceVersion The resource version of the pod
+ * @returns A mock pod object
+ */
+function createMockPod(name, resourceVersion) {
+    return {
+        kind: "Pod",
+        apiVersion: "v1",
+        metadata: {
+            name,
+            resourceVersion,
+            uid: "abc-123-xyz",
+        },
+        spec: {
+            containers: [
+                {
+                    name: "nginx",
+                    image: "nginx:1.14.2",
+                    ports: [
+                        {
+                            containerPort: 80,
+                            protocol: "TCP",
+                        },
+                    ],
+                },
+            ],
+        },
+        status: {},
+    };
+}

package/dist/fluent/index.d.ts

@@ -0,0 +1,12 @@
+import { KubernetesObject } from "@kubernetes/client-node";
+import { GenericClass } from "../types";
+import { Filters, K8sInit } from "./types";
+/**
+ * Kubernetes fluent API inspired by Kubectl. Pass in a model, then call filters and actions on it.
+ *
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ * @returns a fluent API for the model
+ */
+export declare function K8s<T extends GenericClass, K extends KubernetesObject = InstanceType<T>>(model: T, filters?: Filters): K8sInit<T, K>;
+//# sourceMappingURL=index.d.ts.map

package/dist/fluent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fluent/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAwB,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAOjF,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAA0B,OAAO,EAAE,OAAO,EAAsB,MAAM,SAAS,CAAC;AAKvF;;;;;;GAMG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,gBAAgB,GAAG,YAAY,CAAC,CAAC,CAAC,EACtF,KAAK,EAAE,CAAC,EACR,OAAO,GAAE,OAAY,GACpB,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CA0Pf"}

package/dist/fluent/index.js

@@ -0,0 +1,228 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2023-Present The Kubernetes Fluent Client Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.K8s = K8s;
+const http_status_codes_1 = require("http-status-codes");
+const fetch_1 = require("../fetch");
+const kinds_1 = require("../kinds");
+const utils_1 = require("./utils");
+const watch_1 = require("./watch");
+const helpers_1 = require("../helpers");
+const upstream_1 = require("../upstream");
+/**
+ * Kubernetes fluent API inspired by Kubectl. Pass in a model, then call filters and actions on it.
+ *
+ * @param model - the model to use for the API
+ * @param filters - (optional) filter overrides, can also be chained
+ * @returns a fluent API for the model
+ */
+function K8s(model, filters = {}) {
+    const withFilters = { WithField, WithLabel, Get, Delete, Watch, Logs };
+    const matchedKind = filters.kindOverride || (0, kinds_1.modelToGroupVersionKind)(model.name);
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.InNamespace}
+     */
+    function InNamespace(namespace) {
+        if (filters.namespace) {
+            throw new Error(`Namespace already specified: ${filters.namespace}`);
+        }
+        filters.namespace = namespace;
+        return withFilters;
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.WithField}
+     */
+    function WithField(key, value) {
+        filters.fields = filters.fields || {};
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        filters.fields[key] = value;
+        return withFilters;
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.WithLabel}
+     */
+    function WithLabel(key, value = "") {
+        filters.labels = filters.labels || {};
+        filters.labels[key] = value;
+        return withFilters;
+    }
+    /**
+     * Sync the filters with the provided payload.
+     *
+     * @param payload - the payload to sync with
+     */
+    function syncFilters(payload) {
+        // Ensure the payload has metadata
+        payload.metadata = payload.metadata || {};
+        if (!filters.namespace) {
+            filters.namespace = payload.metadata.namespace;
+        }
+        if (!filters.name) {
+            filters.name = payload.metadata.name;
+        }
+        if (!payload.apiVersion) {
+            payload.apiVersion = [matchedKind.group, matchedKind.version].filter(Boolean).join("/");
+        }
+        if (!payload.kind) {
+            payload.kind = matchedKind.kind;
+        }
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Logs}
+     */
+    async function Logs(name) {
+        let labels = {};
+        const { kind } = matchedKind;
+        const { namespace } = filters;
+        const podList = [];
+        if (name) {
+            if (filters.name) {
+                throw new Error(`Name already specified: ${filters.name}`);
+            }
+            filters.name = name;
+        }
+        if (!namespace) {
+            throw new Error("Namespace must be defined");
+        }
+        if (!(0, helpers_1.hasLogs)(kind)) {
+            throw new Error("Kind must be Pod or have a selector");
+        }
+        try {
+            const object = await (0, utils_1.k8sExec)(model, filters, "GET");
+            if (kind !== "Pod") {
+                if (kind === "Service") {
+                    const svc = object;
+                    labels = svc.spec.selector ?? {};
+                }
+                else if (kind === "ReplicaSet" ||
+                    kind === "Deployment" ||
+                    kind === "StatefulSet" ||
+                    kind === "DaemonSet") {
+                    const rs = object;
+                    labels = rs.spec.selector.matchLabels ?? {};
+                }
+                const list = await K8s(upstream_1.Pod, { namespace: filters.namespace, labels }).Get();
+                list.items.forEach(item => {
+                    return podList.push(item);
+                });
+            }
+            else {
+                podList.push(object);
+            }
+        }
+        catch {
+            throw new Error(`Failed to get logs in KFC Logs function`);
+        }
+        const podModel = { ...model, name: "V1Pod" };
+        const logPromises = podList.map(po => (0, utils_1.k8sExec)(podModel, { ...filters, name: po.metadata.name }, "LOG"));
+        const responses = await Promise.all(logPromises);
+        const combinedString = responses.reduce((accumulator, currentString, i) => {
+            const prefixedLines = currentString
+                .split("\n")
+                .map(line => {
+                return line !== "" ? `[pod/${podList[i].metadata.name}] ${line}` : "";
+            })
+                .filter(str => str !== "");
+            return [...accumulator, ...prefixedLines];
+        }, []);
+        return combinedString;
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Get}
+     */
+    async function Get(name) {
+        if (name) {
+            if (filters.name) {
+                throw new Error(`Name already specified: ${filters.name}`);
+            }
+            filters.name = name;
+        }
+        return (0, utils_1.k8sExec)(model, filters, "GET");
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Delete}
+     */
+    async function Delete(filter) {
+        if (typeof filter === "string") {
+            filters.name = filter;
+        }
+        else if (filter) {
+            syncFilters(filter);
+        }
+        try {
+            // Try to delete the resource
+            await (0, utils_1.k8sExec)(model, filters, "DELETE");
+        }
+        catch (e) {
+            // If the resource doesn't exist, ignore the error
+            if (e.status === http_status_codes_1.StatusCodes.NOT_FOUND) {
+                return;
+            }
+            throw e;
+        }
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Apply}
+     */
+    async function Apply(resource, applyCfg = { force: false }) {
+        syncFilters(resource);
+        return (0, utils_1.k8sExec)(model, filters, "APPLY", resource, applyCfg);
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Create}
+     */
+    async function Create(resource) {
+        syncFilters(resource);
+        return (0, utils_1.k8sExec)(model, filters, "POST", resource);
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Patch}
+     */
+    async function Patch(payload) {
+        // If there are no operations, throw an error
+        if (payload.length < 1) {
+            throw new Error("No operations specified");
+        }
+        return (0, utils_1.k8sExec)(model, filters, "PATCH", payload);
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.PatchStatus}
+     */
+    async function PatchStatus(resource) {
+        syncFilters(resource);
+        return (0, utils_1.k8sExec)(model, filters, "PATCH_STATUS", resource);
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Watch}
+     */
+    function Watch(callback, watchCfg) {
+        return new watch_1.Watcher(model, filters, callback, watchCfg);
+    }
+    /**
+     * @inheritdoc
+     * @see {@link K8sInit.Raw}
+     */
+    async function Raw(url, method = "GET") {
+        const thing = await (0, utils_1.k8sCfg)(method);
+        const { opts, serverUrl } = thing;
+        const resp = await (0, fetch_1.fetch)(`${serverUrl}${url}`, opts);
+        if (resp.ok) {
+            return resp.data;
+        }
+        throw resp;
+    }
+    return { InNamespace, Apply, Create, Patch, PatchStatus, Raw, ...withFilters };
+}

package/dist/fluent/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/fluent/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../src/fluent/index.test.ts"],"names":[],"mappings":""}