@mittwald/kubernetes/config.js

Kubernetes client library

"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;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.InClusterConfig = exports.FileBasedConfig = exports.GenericClientConfig = void 0;
const fs = __importStar(require("fs"));
const yaml = __importStar(require("yamljs"));
const https = __importStar(require("https"));
const http2 = __importStar(require("http2"));
class GenericClientConfig {
    constructor(kubeconfig) {
        this.kubeconfig = kubeconfig;
        const context = this.kubeconfig.contexts.find((c) => c.name === this.kubeconfig["current-context"]);
        const cluster = this.kubeconfig.clusters.find((c) => c.name === context.context.cluster);
        this.apiServerURL = cluster.cluster.server.replace(/\/$/, "");
        this.namespace = context.context.namespace || "default";
    }
    getHTTPSAgentOptions() {
        const context = this.kubeconfig.contexts.find((c) => c.name === this.kubeconfig["current-context"]);
        const cluster = this.kubeconfig.clusters.find((c) => c.name === context.context.cluster);
        const user = this.kubeconfig.users.find((c) => c.name === context.context.user);
        const httpsOpts = {};
        const ca = cluster.cluster["certificate-authority-data"];
        if (ca) {
            httpsOpts.ca = Buffer.from(ca, "base64");
        }
        const caFile = cluster.cluster["certificate-authority"];
        if (caFile) {
            httpsOpts.ca = fs.readFileSync(caFile);
        }
        const clientCert = user.user["client-certificate-data"];
        if (clientCert) {
            httpsOpts.cert = Buffer.from(clientCert, "base64");
        }
        const clientCertFile = user.user["client-certificate"];
        if (clientCertFile) {
            httpsOpts.cert = fs.readFileSync(clientCertFile);
        }
        const clientKey = user.user["client-key-data"];
        if (clientKey) {
            httpsOpts.key = Buffer.from(clientKey, "base64");
        }
        const clientKeyFile = user.user["client-key"];
        if (clientKeyFile) {
            httpsOpts.key = fs.readFileSync(clientKeyFile);
        }
        return httpsOpts;
    }
    mapNativeOptions(opts) {
        const agentOpts = this.getHTTPSAgentOptions();
        return Object.assign(Object.assign({}, structuredClone(opts)), { ca: agentOpts.ca, cert: agentOpts.cert, key: agentOpts.key });
    }
    mapHeaders(headers) {
        const context = this.kubeconfig.contexts.find((c) => c.name === this.kubeconfig["current-context"]);
        const user = this.kubeconfig.users.find((c) => c.name === context.context.user);
        const out = Object.assign({}, headers);
        if (user.user.token) {
            out[http2.constants.HTTP2_HEADER_AUTHORIZATION] = "Bearer " + user.user.token;
        }
        if (user.user.username && user.user.password) {
            out[http2.constants.HTTP2_HEADER_AUTHORIZATION] =
                "Basic " + Buffer.from(user.user.username + ":" + user.user.password).toString("base64");
        }
        return out;
    }
    mapAxiosOptions(opts) {
        const context = this.kubeconfig.contexts.find((c) => c.name === this.kubeconfig["current-context"]);
        const user = this.kubeconfig.users.find((c) => c.name === context.context.user);
        if (!opts.headers) {
            opts.headers = {};
        }
        if (user.user.token) {
            opts.headers.Authorization = "Bearer " + user.user.token;
        }
        if (user.user.username && user.user.password) {
            opts.auth = { username: user.user.username, password: user.user.password };
        }
        const headers = this.mapHeaders({});
        for (const key of Object.keys(headers)) {
            opts.headers[key] = headers[key];
        }
        opts.httpsAgent = new https.Agent(this.getHTTPSAgentOptions());
        return opts;
    }
}
exports.GenericClientConfig = GenericClientConfig;
class FileBasedConfig extends GenericClientConfig {
    constructor(kubeconfigFile) {
        // const contents = fs.readFileSync(kubeconfigFile, "utf-8");
        const kubeconfig = yaml.load(kubeconfigFile);
        super(kubeconfig);
    }
}
exports.FileBasedConfig = FileBasedConfig;
class InClusterConfig extends GenericClientConfig {
    constructor(namespace) {
        const kubeconfig = {
            apiVersion: "v1",
            clusters: [
                {
                    name: "local",
                    cluster: {
                        "certificate-authority": "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt",
                        server: "https://kubernetes.default",
                    },
                },
            ],
            users: [
                {
                    name: "serviceaccount",
                    user: {
                        token: fs.readFileSync("/var/run/secrets/kubernetes.io/serviceaccount/token", "utf-8"),
                    },
                },
            ],
            contexts: [
                {
                    name: "local",
                    context: { cluster: "local", user: "serviceaccount", namespace: namespace || "default" },
                },
            ],
            "current-context": "local",
        };
        super(kubeconfig);
    }
}
exports.InClusterConfig = InClusterConfig;
//# sourceMappingURL=config.js.map