hammerkit 1.5.0 → 1.6.0-alpha.1

package/dist/kubernetes/ensure-http-route.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureHttpRoute = exports.HTTP_ROUTE_KIND = exports.HTTP_ROUTE_API_VERSION = void 0;
+const apply_1 = require("./apply");
+const resources_1 = require("./resources");
+exports.HTTP_ROUTE_API_VERSION = 'gateway.networking.k8s.io/v1';
+exports.HTTP_ROUTE_KIND = 'HTTPRoute';
+async function ensureHttpRoute(instance, env, ingress, service) {
+    if (!ingress.gateway) {
+        throw new Error(`httproute for ${ingress.host} requires a "gateway" (the parent Gateway name)`);
+    }
+    const resource = {
+        apiVersion: exports.HTTP_ROUTE_API_VERSION,
+        kind: exports.HTTP_ROUTE_KIND,
+        metadata: {
+            name: ingress.host,
+            namespace: env.namespace,
+            labels: {
+                'hammerkit.dev/id': service.id(),
+            },
+        },
+        spec: {
+            parentRefs: [
+                {
+                    name: ingress.gateway,
+                    ...(ingress.gatewayNamespace ? { namespace: ingress.gatewayNamespace } : {}),
+                },
+            ],
+            hostnames: [ingress.host],
+            rules: [
+                {
+                    matches: [
+                        {
+                            path: {
+                                type: 'PathPrefix',
+                                value: ingress.path ?? '/',
+                            },
+                        },
+                    ],
+                    backendRefs: [
+                        {
+                            name: (0, resources_1.getResourceName)(service),
+                            port: ingress.servicePort ?? service.data.ports[0].containerPort,
+                        },
+                    ],
+                },
+            ],
+        },
+    };
+    return await (0, apply_1.apply)(instance, resource);
+}
+exports.ensureHttpRoute = ensureHttpRoute;
+//# sourceMappingURL=ensure-http-route.js.map

package/dist/kubernetes/ensure-http-route.spec.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ensure_http_route_1 = require("./ensure-http-route");
+function httpError(statusCode) {
+    return Object.assign(new Error(`http ${statusCode}`), { statusCode });
+}
+function makeInstance(objectApi) {
+    return { objectApi };
+}
+const env = { type: 'kubernetes', namespace: 'demo', context: 'ctx', ingresses: [] };
+const service = {
+    name: 'api',
+    id: () => 'abc123',
+    data: { ports: [{ containerPort: 3000, hostPort: null }] },
+};
+function ingress(overrides = {}) {
+    return {
+        kind: 'httproute',
+        host: 'api.example.com',
+        service: 'api',
+        gateway: 'web',
+        ...overrides,
+    };
+}
+describe('ensureHttpRoute', () => {
+    it('creates an HTTPRoute with the expected shape', async () => {
+        const read = vi.fn().mockRejectedValue(httpError(404));
+        const create = vi.fn().mockResolvedValue({ body: {} });
+        await (0, ensure_http_route_1.ensureHttpRoute)(makeInstance({ read, create }), env, ingress(), service);
+        expect(create).toHaveBeenCalledTimes(1);
+        expect(create.mock.calls[0][0]).toMatchObject({
+            apiVersion: 'gateway.networking.k8s.io/v1',
+            kind: 'HTTPRoute',
+            metadata: { name: 'api.example.com', namespace: 'demo', labels: { 'hammerkit.dev/id': 'abc123' } },
+            spec: {
+                parentRefs: [{ name: 'web' }],
+                hostnames: ['api.example.com'],
+                rules: [
+                    {
+                        matches: [{ path: { type: 'PathPrefix', value: '/' } }],
+                        backendRefs: [{ name: 'api-abc123', port: 3000 }],
+                    },
+                ],
+            },
+        });
+    });
+    it('uses servicePort, path and gatewayNamespace when provided', async () => {
+        const read = vi.fn().mockRejectedValue(httpError(404));
+        const create = vi.fn().mockResolvedValue({ body: {} });
+        await (0, ensure_http_route_1.ensureHttpRoute)(makeInstance({ read, create }), env, ingress({ servicePort: 8080, path: '/api', gatewayNamespace: 'gateways' }), service);
+        expect(create.mock.calls[0][0]).toMatchObject({
+            spec: {
+                parentRefs: [{ name: 'web', namespace: 'gateways' }],
+                rules: [
+                    {
+                        matches: [{ path: { type: 'PathPrefix', value: '/api' } }],
+                        backendRefs: [{ name: 'api-abc123', port: 8080 }],
+                    },
+                ],
+            },
+        });
+    });
+    it('throws when no gateway is set', async () => {
+        const read = vi.fn();
+        const create = vi.fn();
+        await expect((0, ensure_http_route_1.ensureHttpRoute)(makeInstance({ read, create }), env, ingress({ gateway: undefined }), service)).rejects.toThrow(/requires a "gateway"/);
+        expect(create).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=ensure-http-route.spec.js.map

package/dist/kubernetes/ensure-ingress.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureIngress = void 0;
+const apply_1 = require("./apply");
+const resources_1 = require("./resources");
+async function ensureIngress(instance, env, ingress, service) {
+    const resource = {
+        kind: 'Ingress',
+        apiVersion: 'networking.k8s.io/v1',
+        metadata: {
+            name: ingress.host,
+            namespace: env.namespace,
+            annotations: {
+                'cert-manager.io/cluster-issuer': 'hammerkit-issuer',
+            },
+            labels: {
+                'hammerkit.dev/id': service.id(),
+            },
+        },
+        spec: {
+            ingressClassName: 'nginx',
+            rules: [
+                {
+                    host: ingress.host,
+                    http: {
+                        paths: [
+                            {
+                                path: ingress.path ?? '/',
+                                pathType: 'Prefix',
+                                backend: {
+                                    service: {
+                                        name: (0, resources_1.getResourceName)(service),
+                                        port: {
+                                            number: ingress.servicePort ?? service.data.ports[0].containerPort,
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                },
+            ],
+            tls: [
+                {
+                    secretName: `${ingress.host}-tls`,
+                    hosts: [ingress.host],
+                },
+            ],
+        },
+    };
+    return await (0, apply_1.apply)(instance, resource);
+}
+exports.ensureIngress = ensureIngress;
+//# sourceMappingURL=ensure-ingress.js.map

package/dist/kubernetes/ensure-kubernetes-deployment-exists.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureKubernetesDeploymentExists = void 0;
+const work_item_1 = require("../planner/work-item");
+const apply_1 = require("./apply");
+const get_service_ip_1 = require("./get-service-ip");
+const version_1 = require("../version");
+const replace_env_variables_1 = require("../environment/replace-env-variables");
+const await_running_state_1 = require("./await-running-state");
+const resources_1 = require("./resources");
+async function ensureKubernetesDeploymentExists(instance, env, service, persistence, stateKey) {
+    const hostAliases = [];
+    for (const need of service.needs) {
+        if (!(0, work_item_1.isContainerWorkServiceItem)(need.service)) {
+            continue;
+        }
+        const ip = await (0, get_service_ip_1.getServiceIp)(instance, env, need.service);
+        if (!ip) {
+            throw new Error(`unable to get service ip for ${need.name}`);
+        }
+        hostAliases.push({
+            ip,
+            hostnames: [need.name],
+        });
+    }
+    const envs = (0, replace_env_variables_1.getEnvironmentVariables)(service.data.envs);
+    const name = (0, resources_1.getResourceName)(service);
+    const probe = service.data.healthcheck
+        ? {
+            exec: {
+                command: [service.data.healthcheck.cmd.parsed.command, ...service.data.healthcheck.cmd.parsed.args],
+            },
+            periodSeconds: 5,
+            failureThreshold: 3,
+        }
+        : undefined;
+    const deployment = {
+        kind: 'Deployment',
+        apiVersion: 'apps/v1',
+        metadata: {
+            namespace: env.namespace,
+            name: name,
+            annotations: {
+                'hammerkit.dev/version': (0, version_1.getVersion)(),
+            },
+            labels: {
+                'hammerkit.dev/id': service.id(),
+                'hammerkit.dev/state': stateKey,
+            },
+        },
+        spec: {
+            selector: {
+                matchLabels: {
+                    'hammerkit.dev/id': service.id(),
+                },
+            },
+            replicas: 1,
+            template: {
+                metadata: {
+                    labels: {
+                        'hammerkit.dev/id': service.id(),
+                        'hammerkit.dev/state': stateKey,
+                    },
+                },
+                spec: {
+                    hostAliases: hostAliases,
+                    containers: [
+                        {
+                            name: service.name.replace(/:/, '-'),
+                            image: service.data.image,
+                            workingDir: service.data.cwd ?? undefined,
+                            env: Object.entries(envs).map(([key, value]) => ({
+                                name: key,
+                                value: value,
+                            })),
+                            command: service.data.cmd ? [service.data.cmd.parsed.command] : undefined,
+                            args: service.data.cmd ? service.data.cmd.parsed.args : undefined,
+                            ports: service.data.ports.map((p) => ({
+                                containerPort: p.containerPort,
+                            })),
+                            readinessProbe: probe,
+                            livenessProbe: probe,
+                            volumeMounts: persistence.mounts.map((m) => m.mount),
+                        },
+                        {
+                            name: 'debug',
+                            image: service.data.image,
+                            command: ['sleep'],
+                            args: ['3600'],
+                            volumeMounts: persistence.mounts.map((m) => m.mount),
+                        },
+                    ],
+                    volumes: persistence.volumes,
+                },
+            },
+        },
+    };
+    const deploy = await (0, apply_1.apply)(instance, deployment);
+    if (deploy.status?.readyReplicas ?? 0 > 0) {
+        return;
+    }
+    await (0, await_running_state_1.awaitDeployRunningState)(instance, env, name);
+}
+exports.ensureKubernetesDeploymentExists = ensureKubernetesDeploymentExists;
+//# sourceMappingURL=ensure-kubernetes-deployment-exists.js.map

package/dist/kubernetes/ensure-kubernetes-persistent-volume-claim-exists.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureKubernetesPersistentVolumeClaimExists = void 0;
+const apply_1 = require("./apply");
+const version_1 = require("../version");
+async function ensureKubernetesPersistentVolumeClaimExists(instance, env, volume, service) {
+    const pvc = {
+        kind: 'PersistentVolumeClaim',
+        apiVersion: 'v1',
+        metadata: {
+            namespace: env.namespace,
+            name: volume.name,
+            annotations: {
+                'hammerkit.dev/version': (0, version_1.getVersion)(),
+            },
+            labels: {
+                'hammerkit.dev/id': service.id(),
+            },
+        },
+        spec: {
+            accessModes: ['ReadWriteOnce'],
+            storageClassName: env.storageClass,
+            resources: {
+                requests: {
+                    storage: '1Gi',
+                },
+            },
+        },
+    };
+    service.status.console('stdout', `ensure volume ${volume.name}`);
+    // Don't block on the PVC reaching "Bound". Storage classes with
+    // volumeBindingMode WaitForFirstConsumer (docker-desktop's "standard",
+    // k3d/k3s local-path, most cloud defaults) keep the claim Pending until a pod
+    // mounts it — and hammerkit creates that pod (upload pod / deployment) only
+    // after this call. Waiting here deadlocks until the test times out. k8s binds
+    // the claim when the consuming pod is scheduled, so applying it is enough.
+    return await (0, apply_1.apply)(instance, pvc);
+}
+exports.ensureKubernetesPersistentVolumeClaimExists = ensureKubernetesPersistentVolumeClaimExists;
+//# sourceMappingURL=ensure-kubernetes-persistent-volume-claim-exists.js.map

package/dist/kubernetes/ensure-kubernetes-service-exists.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureKubernetesServiceExists = void 0;
+const apply_1 = require("./apply");
+const resources_1 = require("./resources");
+const version_1 = require("../version");
+async function ensureKubernetesServiceExists(instance, env, service) {
+    const name = (0, resources_1.getResourceName)(service);
+    const svc = {
+        kind: 'Service',
+        apiVersion: 'v1',
+        metadata: {
+            namespace: env.namespace,
+            name,
+            annotations: {
+                'hammerkit.dev/version': (0, version_1.getVersion)(),
+            },
+            labels: {
+                'hammerkit.dev/id': service.id(),
+            },
+        },
+        spec: {
+            type: 'ClusterIP',
+            selector: {
+                'hammerkit.dev/id': service.id(),
+            },
+            ports: service.data.ports.map((port) => ({
+                port: port.hostPort ?? port.containerPort,
+                targetPort: port.containerPort,
+            })),
+        },
+    };
+    return await (0, apply_1.apply)(instance, svc);
+}
+exports.ensureKubernetesServiceExists = ensureKubernetesServiceExists;
+//# sourceMappingURL=ensure-kubernetes-service-exists.js.map

package/dist/kubernetes/ensure-namespace.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNamespace = void 0;
+function statusCodeOf(e) {
+    const err = e;
+    return err?.statusCode ?? err?.response?.statusCode ?? err?.body?.code;
+}
+/**
+ * Idempotently make sure `namespace` exists. hammerkit does not otherwise
+ * create namespaces — deployments/services/jobs are applied straight into
+ * `env.namespace` and silently fail to schedule if it is missing. Creating it
+ * up front lets build files (and the integration suite) use per-job /
+ * per-suite namespaces for isolation without a separate `kubectl create ns`.
+ *
+ * Safe to call concurrently: a 409 from a racing create is treated as success.
+ */
+async function ensureNamespace(instance, namespace) {
+    try {
+        await instance.coreApi.readNamespace(namespace);
+        return;
+    }
+    catch (e) {
+        if (statusCodeOf(e) !== 404) {
+            throw e;
+        }
+    }
+    try {
+        await instance.coreApi.createNamespace({
+            metadata: {
+                name: namespace,
+                labels: { 'hammerkit.dev/managed': 'true' },
+            },
+        });
+    }
+    catch (e) {
+        // another worker created it between our read and create
+        if (statusCodeOf(e) !== 409) {
+            throw e;
+        }
+    }
+}
+exports.ensureNamespace = ensureNamespace;
+//# sourceMappingURL=ensure-namespace.js.map

package/dist/kubernetes/ensure-namespace.spec.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ensure_namespace_1 = require("./ensure-namespace");
+function httpError(statusCode) {
+    return Object.assign(new Error(`http ${statusCode}`), { statusCode });
+}
+function makeInstance(coreApi) {
+    return { coreApi };
+}
+describe('ensureNamespace', () => {
+    it('does nothing when the namespace already exists', async () => {
+        const readNamespace = vi.fn().mockResolvedValue({ body: {} });
+        const createNamespace = vi.fn();
+        await (0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo');
+        expect(readNamespace).toHaveBeenCalledWith('demo');
+        expect(createNamespace).not.toHaveBeenCalled();
+    });
+    it('creates the namespace (labeled managed) when missing', async () => {
+        const readNamespace = vi.fn().mockRejectedValue(httpError(404));
+        const createNamespace = vi.fn().mockResolvedValue({ body: {} });
+        await (0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo');
+        expect(createNamespace).toHaveBeenCalledTimes(1);
+        expect(createNamespace.mock.calls[0][0]).toMatchObject({
+            metadata: { name: 'demo', labels: { 'hammerkit.dev/managed': 'true' } },
+        });
+    });
+    it('swallows a 409 from a racing create', async () => {
+        const readNamespace = vi.fn().mockRejectedValue(httpError(404));
+        const createNamespace = vi.fn().mockRejectedValue(httpError(409));
+        await expect((0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo')).resolves.toBeUndefined();
+    });
+    it('rethrows unexpected read errors', async () => {
+        const readNamespace = vi.fn().mockRejectedValue(httpError(500));
+        const createNamespace = vi.fn();
+        await expect((0, ensure_namespace_1.ensureNamespace)(makeInstance({ readNamespace, createNamespace }), 'demo')).rejects.toThrow();
+        expect(createNamespace).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=ensure-namespace.spec.js.map

package/dist/kubernetes/ensure-persistent-data.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePersistentData = exports.getPodForPersistence = void 0;
+const apply_1 = require("./apply");
+const path_1 = require("path");
+const tar_1 = require("tar");
+const resources_1 = require("./resources");
+const await_running_state_1 = require("./await-running-state");
+const sleep_1 = require("../utils/sleep");
+const version_1 = require("../version");
+const log_1 = require("../log");
+const ensure_kubernetes_persistent_volume_claim_exists_1 = require("./ensure-kubernetes-persistent-volume-claim-exists");
+// A previous run that crashed between creating an upload/download pod and its
+// `finally` cleanup leaves a pod behind under the same deterministic name. apply()
+// would then patch that stale pod in place — and if it is stuck in a terminal
+// phase the subsequent awaitRunningState never resolves. Force-delete any leftover
+// and wait for it to disappear before scheduling a fresh one.
+async function removeStalePod(instance, namespace, name) {
+    try {
+        await instance.coreApi.deleteNamespacedPod(name, namespace, undefined, undefined, 0);
+    }
+    catch (e) {
+        if ((0, apply_1.statusCodeOf)(e) === 404) {
+            return;
+        }
+        throw e;
+    }
+    for (let attempt = 0; attempt < 30; attempt++) {
+        try {
+            await instance.coreApi.readNamespacedPod(name, namespace);
+        }
+        catch (e) {
+            if ((0, apply_1.statusCodeOf)(e) === 404) {
+                return;
+            }
+            throw e;
+        }
+        await (0, sleep_1.sleep)(500);
+    }
+}
+async function getPodForPersistence(instance, env, service, persistence, type, fn) {
+    if (persistence.volumes.length === 0) {
+        return;
+    }
+    const mounts = type === 'read'
+        ? persistence.mounts.map((m) => m.mount)
+        : persistence.mounts.reduce((array, v) => {
+            if (!array.some((i) => i.name === v.mount.name)) {
+                array.push({
+                    mountPath: v.uploadPath,
+                    name: v.mount.name,
+                    readOnly: false,
+                });
+            }
+            return array;
+        }, []);
+    // Guarantee the claims exist right before scheduling the pod that mounts
+    // them. ensurePersistentData also creates them, but store/restore reach this
+    // function directly, and a claim shared with another work item can be removed
+    // concurrently — without this the pod would hang Pending on "pvc not found".
+    for (const volume of persistence.volumes) {
+        await (0, ensure_kubernetes_persistent_volume_claim_exists_1.ensureKubernetesPersistentVolumeClaimExists)(instance, env, volume, service);
+    }
+    const name = (0, resources_1.getResourceName)(service, type === 'write' ? '-upload' : '-download');
+    const podSpec = {
+        kind: 'Pod',
+        apiVersion: 'v1',
+        metadata: {
+            namespace: env.namespace,
+            name,
+            labels: {
+                'hammerkit.dev/id': service.id(),
+            },
+            annotations: {
+                'hammerkit.dev/version': (0, version_1.getVersion)(),
+            },
+        },
+        spec: {
+            containers: [
+                {
+                    name: 'volume',
+                    image: 'alpine',
+                    command: ['sh'],
+                    tty: true,
+                    volumeMounts: mounts,
+                },
+            ],
+            volumes: persistence.volumes,
+        },
+    };
+    service.status.console('stdout', `create pod ${name}`);
+    await removeStalePod(instance, env.namespace, name);
+    const pod = await (0, apply_1.apply)(instance, podSpec);
+    if (pod.status?.phase !== 'Running') {
+        service.status.console('stdout', `await running state ${name}`);
+        await (0, await_running_state_1.awaitRunningState)(instance, env, name, 'Running');
+    }
+    try {
+        await fn(name);
+    }
+    finally {
+        service.status.console('stdout', `delete pod ${name}`);
+        await instance.coreApi.deleteNamespacedPod(name, env.namespace);
+    }
+}
+exports.getPodForPersistence = getPodForPersistence;
+async function ensurePersistentData(instance, env, environment, service, persistence) {
+    // Dedupe of already-uploaded state (skip the upload when the persisted state
+    // key still matches) needs an in-cluster state marker per volume — deferred
+    // post-1.6.0, tracked in FOLLOWUPS.md alongside the volumes.ts stateKey/matcher.
+    for (const volume of persistence.volumes) {
+        await (0, ensure_kubernetes_persistent_volume_claim_exists_1.ensureKubernetesPersistentVolumeClaimExists)(instance, env, volume, service);
+    }
+    if (persistence.sources.length === 0) {
+        return;
+    }
+    service.status.console('stdout', 'start upload container');
+    await getPodForPersistence(instance, env, service, persistence, 'write', async (name) => {
+        for (const source of persistence.sources) {
+            // skip sources that don't exist on disk — nothing to upload
+            if (!(await environment.file.exists(source.localPath))) {
+                continue;
+            }
+            const fileItem = (0, path_1.basename)(source.localPath);
+            const data = (0, tar_1.create)({
+                cwd: (0, path_1.dirname)(source.localPath),
+                filter(path) {
+                    return source.matcher(path, source.localPath);
+                },
+            }, [fileItem]);
+            service.status.console('stdout', `upload ${source.localPath}`);
+            const targetPath = `/dev/hammerkit/${service.id()}`;
+            const res = await instance.exec.exec(env.namespace, name, 'volume', ['tar', 'xf', '-', '-C', targetPath], process.stdout, process.stderr, data, false, (status) => {
+                service.status.write('debug', `upload ${source.localPath} to ${name}: ${status}`);
+            });
+            await new Promise((resolve, reject) => {
+                try {
+                    res.on('open', () => {
+                        service.status.write('debug', `start upload of ${source} to ${name}:${targetPath}`);
+                    });
+                    res.on('error', (err) => {
+                        service.status.write('error', `error during upload of ${source.localPath} to ${name}: ${(0, log_1.getErrorMessage)(err)}`);
+                        reject(err);
+                    });
+                    res.on('close', () => {
+                        service.status.write('debug', `uploaded ${source.localPath} to ${name}:${targetPath}`);
+                        resolve();
+                    });
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        }
+    });
+}
+exports.ensurePersistentData = ensurePersistentData;
+//# sourceMappingURL=ensure-persistent-data.js.map

package/dist/kubernetes/get-service-ip.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServiceIp = void 0;
+const resources_1 = require("./resources");
+async function getServiceIp(instance, env, workService) {
+    const name = (0, resources_1.getResourceName)(workService);
+    const svc = await instance.coreApi.readNamespacedService(name, env.namespace);
+    return svc.body.spec?.clusterIP ?? null;
+}
+exports.getServiceIp = getServiceIp;
+//# sourceMappingURL=get-service-ip.js.map

package/dist/kubernetes/kubernetes-instance.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKubernetesInstances = void 0;
+const client_node_1 = require("@kubernetes/client-node");
+const log_1 = require("../log");
+function createKubernetesInstances(kubernetes) {
+    const kc = new client_node_1.KubeConfig();
+    try {
+        if (kubernetes.kubeConfig) {
+            kc.loadFromFile(kubernetes.kubeConfig);
+        }
+        else {
+            kc.loadFromDefault();
+        }
+        kc.setCurrentContext(kubernetes.context);
+        const coreApi = kc.makeApiClient(client_node_1.CoreV1Api);
+        const batchApi = kc.makeApiClient(client_node_1.BatchV1Api);
+        const appsApi = kc.makeApiClient(client_node_1.AppsV1Api);
+        const networkingApi = kc.makeApiClient(client_node_1.NetworkingV1Api);
+        const objectApi = kc.makeApiClient(client_node_1.KubernetesObjectApi);
+        const exec = new client_node_1.Exec(kc);
+        const watch = new client_node_1.Watch(kc);
+        return {
+            objectApi,
+            networkingApi,
+            watch,
+            exec,
+            appsApi,
+            coreApi,
+            batchApi,
+        };
+    }
+    catch (e) {
+        if ((0, log_1.getErrorMessage)(e) === 'No active cluster!') {
+            if (kubernetes.kubeConfig) {
+                throw new Error(`No cluster found for context ${kubernetes.context} in ${kubernetes.kubeConfig}`);
+            }
+            else {
+                throw new Error(`No cluster found for context ${kubernetes.context}`);
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+}
+exports.createKubernetesInstances = createKubernetesInstances;
+//# sourceMappingURL=kubernetes-instance.js.map