@mittwald/kubernetes/client.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.KubernetesRESTClient = exports.patchKindJSONPatch = exports.patchKindMergePatch = exports.patchKindStrategicMergePatch = void 0;
const label_1 = require("./label");
const meta_1 = require("./types/meta");
const security_1 = require("./security");
const axios_1 = __importDefault(require("axios"));
const http2 = __importStar(require("http2"));
const qs_1 = __importDefault(require("qs"));
const debug = require("debug")("kubernetes:client");
exports.patchKindStrategicMergePatch = "application/stategic-merge-patch+json";
exports.patchKindMergePatch = "application/merge-patch+json";
exports.patchKindJSONPatch = "application/json-patch+json";
const joinURL = (left, right) => (left + "/" + right).replace(/([^:])(\/\/)/g, "$1/");
class KubernetesRESTClient {
    constructor(config) {
        this.config = config;
    }
    request(url, body, method = "POST", additionalOptions = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            const absoluteURL = joinURL(this.config.apiServerURL, url);
            let opts = {
                method,
                url: absoluteURL,
                responseType: "json",
                validateStatus: () => true,
            };
            if (body) {
                opts.data = body;
            }
            opts = this.config.mapAxiosOptions(opts);
            if (additionalOptions.headers) {
                additionalOptions.headers = Object.assign(Object.assign({}, (opts.headers || {})), additionalOptions.headers);
            }
            opts = Object.assign(Object.assign({}, opts), additionalOptions);
            debug(`executing ${method} request on ${opts.url}`);
            const response = yield (0, axios_1.default)(opts);
            const responseBody = response.data;
            if (typeof responseBody === "object" && (0, meta_1.isStatus)(responseBody) && responseBody.status === "Failure") {
                throw new Error(responseBody.message);
            }
            debug(`${method} request on ${opts.url} succeeded with status ${response.status}: ${(0, security_1.redactResponseBodyForLogging)(responseBody)}`);
            return responseBody;
        });
    }
    post(url, body) {
        return this.request(url, body, "POST");
    }
    put(url, body) {
        return this.request(url, body, "PUT");
    }
    patch(url, body, patchKind) {
        return this.request(url, body, "PATCH", {
            headers: {
                "Content-Type": patchKind,
            }
        });
    }
    delete(url, deleteOptions, queryParams = {}, body) {
        const opts = {};
        opts.params = queryParams;
        if (deleteOptions && deleteOptions.labelSelector) {
            opts.params.labelSelector = (0, label_1.selectorToQueryString)(deleteOptions.labelSelector);
        }
        if (deleteOptions && deleteOptions.fieldSelector) {
            opts.params.fieldSelector = (0, label_1.selectorToQueryString)(deleteOptions.fieldSelector);
        }
        return this.request(url, body, "DELETE", opts);
    }
    watch(url, onUpdate, onError, watchOpts = {}) {
        const absoluteURL = joinURL(this.config.apiServerURL, url);
        const params = { watch: "true" };
        const { pingIntervalSeconds = 15 } = watchOpts;
        if (watchOpts.labelSelector) {
            params.labelSelector = (0, label_1.selectorToQueryString)(watchOpts.labelSelector);
        }
        if (watchOpts.fieldSelector) {
            params.fieldSelector = (0, label_1.selectorToQueryString)(watchOpts.fieldSelector);
        }
        if (watchOpts.resourceVersion) {
            params.resourceVersion = `${watchOpts.resourceVersion}`;
        }
        let clientPingInterval;
        const clientOpts = this.config.mapNativeOptions({});
        const client = http2.connect(this.config.apiServerURL, clientOpts, (session, socket) => {
            clientPingInterval = setInterval(() => {
                session.ping((err, duration) => {
                    if (err) {
                        debug("error on HTTP/2 client ping: %O", err);
                        session.destroy(err);
                    }
                });
            }, pingIntervalSeconds * 1000);
        });
        let lastVersion = watchOpts.resourceVersion || 0;
        debug(`executing WATCH request on ${absoluteURL} (starting revision ${lastVersion})`);
        return new Promise((res, rej) => {
            const requestHeaders = Object.assign({ [http2.constants.HTTP2_HEADER_METHOD]: "GET", [http2.constants.HTTP2_HEADER_PATH]: url + "?" + qs_1.default.stringify(params), [http2.constants.HTTP2_HEADER_ACCEPT]: "application/json" }, this.config.mapHeaders({}));
            const request = client.request(requestHeaders);
            let body = "";
            let buffer = "";
            request.on("error", (err) => {
                debug(`watch: error: %O`, err);
                rej(err);
            });
            request.on("response", (headers, flags) => {
                const status = headers[":status"];
                debug(`%o request on %o completed with status %o`, "WATCH", absoluteURL, status);
                if (status && status >= 400) {
                    if (status === 410) {
                        debug(`last known resource has expired -- resync required`);
                        res({ resourceVersion: lastVersion, resyncRequired: true });
                        return;
                    }
                    rej(new Error("Unexpected status code: " + status));
                    return;
                }
            });
            request.on("end", () => {
                if (clientPingInterval) {
                    clearInterval(clientPingInterval);
                }
                try {
                    const parsedBody = JSON.parse(body);
                    if ((0, meta_1.isStatus)(parsedBody) && parsedBody.status === "Failure") {
                        debug(`watch: failed with status %O`, parsedBody);
                        rej(parsedBody.message);
                        return;
                    }
                }
                catch (_) {
                    // this is fine; the request body is not guaranteed to be a single JSON document.
                }
                res({ resourceVersion: lastVersion });
            });
            request.on("data", (chunk) => __awaiter(this, void 0, void 0, function* () {
                if (chunk instanceof Buffer) {
                    chunk = chunk.toString("utf-8");
                }
                debug("WATCH request on %o received %d bytes of data", absoluteURL, chunk.length);
                buffer += chunk;
                body += chunk;
                // Line is not yet complete; wait for next chunk.
                if (!buffer.endsWith("\n")) {
                    return;
                }
                try {
                    const obj = JSON.parse(buffer);
                    buffer = "";
                    const resourceVersion = obj.object.metadata.resourceVersion ? parseInt(obj.object.metadata.resourceVersion, 10) : -1;
                    if (resourceVersion > lastVersion) {
                        debug(`watch: emitting ${obj.type} event for ${obj.object.metadata.name}`);
                        lastVersion = resourceVersion;
                        yield onUpdate(obj);
                    }
                }
                catch (err) {
                    onError(err);
                }
            }));
        });
    }
    get(url, listOptions = {}) {
        return __awaiter(this, void 0, void 0, function* () {
            const absoluteURL = joinURL(this.config.apiServerURL, url);
            const { labelSelector, fieldSelector } = listOptions;
            let opts = {
                url: absoluteURL,
                params: {},
                validateStatus: () => true,
            };
            if (labelSelector) {
                opts.params.labelSelector = (0, label_1.selectorToQueryString)(labelSelector);
            }
            if (fieldSelector) {
                opts.params.fieldSelector = (0, label_1.selectorToQueryString)(fieldSelector);
            }
            opts = this.config.mapAxiosOptions(opts);
            debug(`executing GET request on ${opts.url}`);
            const response = yield (0, axios_1.default)(opts);
            if (response.status === 404) {
                debug(`GET request on %o failed with status %o`, opts.url, response.status);
                return undefined;
            }
            if ((0, meta_1.isStatus)(response.data) && response.data.status === "Failure") {
                if (response.data.code === 404) {
                    return undefined;
                }
                debug(`executing GET request on %o failed. response body: %O`, response.status, response.data);
                throw (new Error(response.data.message));
            }
            debug(`GET request on %o succeeded with status %o: %O`, opts.url, response.status, response.data);
            return response.data;
        });
    }
}
exports.KubernetesRESTClient = KubernetesRESTClient;
//# sourceMappingURL=client.js.map