teraslice 2.10.0 → 2.12.0

package/dist/src/lib/cluster/services/cluster/backends/kubernetesV2/k8sJobResource.js

@@ -0,0 +1,55 @@
+import { V1Job } from '@kubernetes/client-node';
+import { convertToTSResource, makeTemplate } from './utils.js';
+import { K8sResource } from './k8sResource.js';
+export class K8sJobResource extends K8sResource {
+    nodeType = 'execution_controller';
+    nameInfix = 'exc';
+    templateGenerator;
+    templateConfig;
+    resource;
+    /**
+     * K8sJobResource allows the generation of a k8s job based on a template.
+     * After creating the object, the k8s job is accessible on the objects
+     * .resource property.
+     *
+     * @param {Object} terasliceConfig - teraslice cluster config from context
+     * @param {Object} execution - teraslice execution
+     * @param {Logger} logger - teraslice logger
+     */
+    constructor(terasliceConfig, execution, logger) {
+        super(terasliceConfig, execution, logger);
+        this.templateGenerator = makeTemplate('jobs', this.nodeType);
+        this.templateConfig = this._makeConfig(this.nameInfix);
+        const k8sJob = new V1Job();
+        Object.assign(k8sJob, this.templateGenerator(this.templateConfig));
+        this.resource = convertToTSResource(k8sJob);
+        this._setJobLabels(this.resource);
+        // Apply job `targets` setting as k8s nodeAffinity
+        // We assume that multiple targets require both to match ...
+        // NOTE: If you specify multiple `matchExpressions` associated with
+        // `nodeSelectorTerms`, then the pod can be scheduled onto a node
+        // only if *all* `matchExpressions` can be satisfied.
+        this._setTargets(this.resource);
+        this._setResources(this.resource);
+        this._setVolumes(this.resource);
+        if (process.env.MOUNT_LOCAL_TERASLICE !== undefined) {
+            this._mountLocalTeraslice(this.resource);
+        }
+        this._setEnvVariables();
+        this._setAssetsVolume(this.resource);
+        this._setImagePullSecret(this.resource);
+        this._setEphemeralStorage(this.resource);
+        this._setExternalPorts(this.resource);
+        this._setPriorityClassName(this.resource);
+        // Execution controller targets are required nodeAffinities, if
+        // required job targets are also supplied, then *all* of the matches
+        // will have to be satisfied for the job to be scheduled.  This also
+        // adds tolerations for any specified targets
+        this._setExecutionControllerTargets(this.resource);
+        // override must happen last
+        if (this.terasliceConfig.kubernetes_overrides_enabled) {
+            this._mergePodSpecOverlay(this.resource);
+        }
+    }
+}
+//# sourceMappingURL=k8sJobResource.js.map

package/dist/src/lib/cluster/services/cluster/backends/kubernetesV2/k8sResource.js

@@ -0,0 +1,359 @@
+import { isNumber, get, set, has, isEmpty, merge } from '@terascope/utils';
+import { safeEncode } from '../../../../../utils/encoding_utils.js';
+import { setMaxOldSpaceViaEnv } from './utils.js';
+export class K8sResource {
+    execution;
+    jobLabelPrefix;
+    jobPropertyLabelPrefix;
+    logger;
+    terasliceConfig;
+    /**
+     * K8sResource allows the generation of k8s resources based on templates.
+     * After creating the object, the k8s resource is accessible on the objects
+     * .resource property.
+     *
+     * @param {Object} terasliceConfig - teraslice cluster config from context
+     * @param {Object} execution - teraslice execution
+     * @param {Logger} logger - teraslice logger
+     */
+    constructor(terasliceConfig, execution, logger) {
+        this.execution = execution;
+        this.jobLabelPrefix = 'job.teraslice.terascope.io';
+        this.jobPropertyLabelPrefix = 'job-property.teraslice.terascope.io';
+        this.logger = logger;
+        this.terasliceConfig = terasliceConfig;
+    }
+    _setEnvVariables() {
+    }
+    _mountLocalTeraslice(resource) {
+        const devMounts = JSON.parse(process.env.MOUNT_LOCAL_TERASLICE);
+        resource.spec.template.spec.containers[0].volumeMounts.push(...devMounts.volumeMounts);
+        resource.spec.template.spec.volumes.push(...devMounts.volumes);
+        if (resource.spec.template.spec.containers[0]) {
+            resource.spec.template.spec.containers[0].args = [
+                'node',
+                'service.js'
+            ];
+        }
+    }
+    _makeConfig(nameInfix, exName, exUid) {
+        const clusterName = get(this.terasliceConfig, 'name');
+        const clusterNameLabel = clusterName.replace(/[^a-zA-Z0-9_\-.]/g, '_').substring(0, 63);
+        const configMapName = get(this.terasliceConfig, 'kubernetes_config_map_name', `${this.terasliceConfig.name}-worker`);
+        const dockerImage = this.execution.kubernetes_image
+            || this.terasliceConfig.kubernetes_image;
+        // name needs to be a valid DNS name since it is used in the svc name,
+        // so we can only permit alphanumeric and - characters.  _ is forbidden.
+        // -> regex used for validation is '[a-z]([-a-z0-9]*[a-z0-9])?'
+        const jobNameLabel = this.execution.name
+            .toLowerCase()
+            .replace(/[^a-zA-Z0-9\-.]/g, '-')
+            .replace(/^[^a-z]/, 'a')
+            .replace(/[^a-z0-9]$/, '0')
+            .substring(0, 63);
+        const name = `ts-${nameInfix}-${jobNameLabel.substring(0, 35)}-${this.execution.job_id.substring(0, 13)}`;
+        const shutdownTimeoutMs = get(this.terasliceConfig, 'shutdown_timeout', 60000);
+        const shutdownTimeoutSeconds = Math.round(shutdownTimeoutMs / 1000);
+        const config = {
+            // assetsDirectory: get(this.terasliceConfig, 'assets_directory', ''),
+            // assetsVolume: get(this.terasliceConfig, 'assets_volume', ''),
+            clusterName,
+            clusterNameLabel,
+            configMapName,
+            dockerImage,
+            execution: safeEncode(this.execution),
+            exId: this.execution.ex_id,
+            exName: exName,
+            exUid: exUid,
+            jobId: this.execution.job_id,
+            jobNameLabel,
+            name,
+            namespace: get(this.terasliceConfig, 'kubernetes_namespace', 'default'),
+            nodeType: this.nodeType,
+            replicas: this.execution.workers,
+            shutdownTimeout: shutdownTimeoutSeconds
+        };
+        return config;
+    }
+    _setWorkerAntiAffinity(resource) {
+        if (this.terasliceConfig.kubernetes_worker_antiaffinity) {
+            const targetKey = 'spec.template.spec.affinity.podAntiAffinity.preferredDuringSchedulingIgnoredDuringExecution';
+            if (!has(this.resource, targetKey)) {
+                set(this.resource, targetKey, []);
+            }
+            resource.spec.template.spec.affinity?.podAntiAffinity
+                ?.preferredDuringSchedulingIgnoredDuringExecution?.push({
+                weight: 1,
+                podAffinityTerm: {
+                    labelSelector: {
+                        matchExpressions: [
+                            {
+                                key: 'app.kubernetes.io/name',
+                                operator: 'In',
+                                values: [
+                                    'teraslice'
+                                ]
+                            },
+                            {
+                                key: 'app.kubernetes.io/instance',
+                                operator: 'In',
+                                values: [
+                                    this.templateConfig.clusterNameLabel
+                                ]
+                            }
+                        ]
+                    },
+                    topologyKey: 'kubernetes.io/hostname'
+                }
+            });
+        }
+    }
+    /**
+     * Execution Controllers get tolerations and required affinities
+     *
+     * NOTE: We considered changing `execution_controller_targets` to be an
+     * object but the inconsistency with `targets` made this awkward.  See the
+     * `teraslice config with execution_controller_targets and job targets set`
+     * test for an example.  If the syntax for this were to change, we should
+     * also consider changing `execution.targets`, which is a change on the job.
+     */
+    _setExecutionControllerTargets(resource) {
+        if (this.terasliceConfig.execution_controller_targets) {
+            this.terasliceConfig.execution_controller_targets.forEach((target) => {
+                this._setTargetRequired(target, resource);
+                this._setTargetAccepted(target, resource);
+            });
+        }
+    }
+    _setEphemeralStorage(resource) {
+        if (this.execution.ephemeral_storage) {
+            resource.spec.template.spec.containers[0].volumeMounts.push({
+                name: 'ephemeral-volume',
+                mountPath: '/ephemeral0'
+            });
+            resource.spec.template.spec.volumes.push({
+                name: 'ephemeral-volume',
+                emptyDir: {}
+            });
+        }
+    }
+    _setExternalPorts(resource) {
+        if (this.execution.external_ports) {
+            this.execution.external_ports.forEach((portValue) => {
+                if (isNumber(portValue)) {
+                    resource.spec.template.spec.containers[0].ports
+                        .push({ containerPort: portValue });
+                }
+                else {
+                    resource.spec.template.spec.containers[0].ports
+                        .push({
+                        name: portValue.name,
+                        containerPort: portValue.port
+                    });
+                }
+            });
+        }
+    }
+    _setImagePullSecret(resource) {
+        if (this.terasliceConfig.kubernetes_image_pull_secret) {
+            if (resource.spec.template.spec.imagePullSecrets) {
+                resource.spec.template.spec.imagePullSecrets.push({ name: this.terasliceConfig.kubernetes_image_pull_secret });
+            }
+            else {
+                resource.spec.template.spec.imagePullSecrets = [
+                    { name: this.terasliceConfig.kubernetes_image_pull_secret }
+                ];
+            }
+        }
+    }
+    _setPriorityClassName(resource) {
+        if (this.terasliceConfig.kubernetes_priority_class_name) {
+            const className = this.terasliceConfig.kubernetes_priority_class_name;
+            if (this.nodeType === 'execution_controller') {
+                resource.spec.template.spec.priorityClassName = className;
+                if (this.execution.stateful) {
+                    resource.spec.template.metadata.labels[`${this.jobPropertyLabelPrefix}/stateful`] = 'true';
+                }
+            }
+            if (this.nodeType === 'worker' && this.execution.stateful) {
+                resource.spec.template.spec.priorityClassName = className;
+                resource.spec.template.metadata.labels[`${this.jobPropertyLabelPrefix}/stateful`] = 'true';
+            }
+        }
+    }
+    _setAssetsVolume(resource) {
+        if (this.terasliceConfig.assets_volume
+            && this.terasliceConfig.assets_directory
+            && typeof this.terasliceConfig.assets_directory === 'string') {
+            resource.spec.template.spec.volumes.push({
+                name: this.terasliceConfig.assets_volume,
+                persistentVolumeClaim: { claimName: this.terasliceConfig.assets_volume }
+            });
+            resource.spec.template.spec.containers[0].volumeMounts.push({
+                name: this.terasliceConfig.assets_volume,
+                mountPath: this.terasliceConfig.assets_directory
+            });
+        }
+    }
+    _setJobLabels(resource) {
+        if (this.execution.labels != null) {
+            Object.entries(this.execution.labels).forEach(([k, v]) => {
+                const key = `${this.jobLabelPrefix}/${k.replace(/[^a-zA-Z0-9\-._]/g, '-').substring(0, 63)}`;
+                const value = v.replace(/[^a-zA-Z0-9\-._]/g, '-').substring(0, 63);
+                resource.metadata.labels[key] = value;
+                resource.spec.template.metadata.labels[key] = value;
+            });
+        }
+    }
+    _setVolumes(resource) {
+        if (this.execution.volumes != null) {
+            this.execution.volumes.forEach((volume) => {
+                resource.spec.template.spec.volumes.push({
+                    name: volume.name,
+                    persistentVolumeClaim: { claimName: volume.name }
+                });
+                resource.spec.template.spec.containers[0].volumeMounts.push({
+                    name: volume.name,
+                    mountPath: volume.path
+                });
+            });
+        }
+    }
+    _setResources(resource) {
+        let cpu;
+        let memory;
+        let maxMemory;
+        const container = resource.spec.template.spec.containers[0];
+        // use teraslice config as defaults and execution config will override it
+        const envVars = Object.assign({}, this.terasliceConfig.env_vars, this.execution.env_vars);
+        if (this.nodeType === 'worker') {
+            if (this.execution.resources_requests_cpu
+                || this.execution.resources_limits_cpu) {
+                if (this.execution.resources_requests_cpu) {
+                    set(container, 'resources.requests.cpu', this.execution.resources_requests_cpu);
+                }
+                if (this.execution.resources_limits_cpu) {
+                    set(container, 'resources.limits.cpu', this.execution.resources_limits_cpu);
+                }
+            }
+            else if (this.execution.cpu || this.terasliceConfig.cpu) {
+                // The settings on the executions override the cluster configs
+                cpu = this.execution.cpu || this.terasliceConfig.cpu || -1;
+                set(container, 'resources.requests.cpu', cpu);
+                set(container, 'resources.limits.cpu', cpu);
+            }
+            if (this.execution.resources_requests_memory
+                || this.execution.resources_limits_memory) {
+                set(container, 'resources.requests.memory', this.execution.resources_requests_memory);
+                set(container, 'resources.limits.memory', this.execution.resources_limits_memory);
+                maxMemory = this.execution.resources_limits_memory;
+            }
+            else if (this.execution.memory || this.terasliceConfig.memory) {
+                // The settings on the executions override the cluster configs
+                memory = this.execution.memory || this.terasliceConfig.memory || -1;
+                set(container, 'resources.requests.memory', memory);
+                set(container, 'resources.limits.memory', memory);
+                maxMemory = memory;
+            }
+        }
+        if (this.nodeType === 'execution_controller') {
+            // The settings on the executions override the cluster configs
+            cpu = this.execution.cpu_execution_controller
+                || this.terasliceConfig.cpu_execution_controller || -1;
+            memory = this.execution.memory_execution_controller
+                || this.terasliceConfig.memory_execution_controller || -1;
+            set(container, 'resources.requests.cpu', cpu);
+            set(container, 'resources.limits.cpu', cpu);
+            set(container, 'resources.requests.memory', memory);
+            set(container, 'resources.limits.memory', memory);
+            maxMemory = memory;
+        }
+        // NOTE: This sucks, this manages the memory env var but it ALSO is
+        // responsible for doing the config and execution env var merge, which
+        // should NOT be in this function
+        if (container.env === undefined) {
+            throw new Error('Resource container V1EnvVar[] undefined while setting resources.');
+        }
+        setMaxOldSpaceViaEnv(container.env, envVars, maxMemory);
+    }
+    _setTargets(resource) {
+        if (this.execution.targets && !isEmpty(this.execution.targets)) {
+            this.execution.targets?.forEach((target) => {
+                // `required` is the default if no `constraint` is provided for
+                // backwards compatibility and as the most likely case
+                if (target.constraint === 'required' || !has(target, 'constraint')) {
+                    this._setTargetRequired(target, resource);
+                }
+                if (target.constraint === 'preferred') {
+                    this._setTargetPreferred(target, resource);
+                }
+                if (target.constraint === 'accepted') {
+                    this._setTargetAccepted(target, resource);
+                }
+            });
+        }
+    }
+    _setTargetRequired(target, resource) {
+        const targetKey = 'spec.template.spec.affinity.nodeAffinity.requiredDuringSchedulingIgnoredDuringExecution';
+        if (!has(this.resource, targetKey)) {
+            const nodeSelectorObj = {
+                nodeSelectorTerms: [{ matchExpressions: [] }]
+            };
+            set(this.resource, targetKey, nodeSelectorObj);
+        }
+        resource.spec.template.spec.affinity?.nodeAffinity
+            ?.requiredDuringSchedulingIgnoredDuringExecution
+            ?.nodeSelectorTerms[0].matchExpressions?.push({
+            key: target.key,
+            operator: 'In',
+            values: [target.value]
+        });
+    }
+    _setTargetPreferred(target, resource) {
+        const targetKey = 'spec.template.spec.affinity.nodeAffinity.preferredDuringSchedulingIgnoredDuringExecution';
+        if (!has(this.resource, targetKey)) {
+            set(this.resource, targetKey, []);
+        }
+        resource.spec.template.spec.affinity?.nodeAffinity
+            ?.preferredDuringSchedulingIgnoredDuringExecution?.push({
+            weight: 1,
+            preference: {
+                matchExpressions: [{
+                        key: target.key,
+                        operator: 'In',
+                        values: [target.value]
+                    }]
+            }
+        });
+    }
+    _setTargetAccepted(target, resource) {
+        const targetKey = 'spec.template.spec.tolerations';
+        if (!has(this.resource, targetKey)) {
+            set(this.resource, targetKey, []);
+        }
+        resource.spec.template.spec.tolerations?.push({
+            key: target.key,
+            operator: 'Equal',
+            value: target.value,
+            effect: 'NoSchedule'
+        });
+    }
+    /**
+     * _mergePodSpecOverlay - allows the author of the job to override anything
+     * in the pod .spec for both the execution controller and the worker pods
+     * created in Kubernetes.  This can be useful in many ways including these:
+     *
+     *   * add `initContainers` to the pods
+     *   * add `hostAliases` to the pods
+     *
+     * Note that this happens at the end of the process, so anything added by
+     * this overlay will overwrite any other setting set on the job or by the
+     * config.
+     *
+     * Job setting: `pod_spec_override`
+     */
+    _mergePodSpecOverlay(resource) {
+        resource.spec.template.spec = merge(resource.spec.template.spec, this.execution.pod_spec_override);
+    }
+}
+//# sourceMappingURL=k8sResource.js.map

package/dist/src/lib/cluster/services/cluster/backends/kubernetesV2/k8sServiceResource.js

@@ -0,0 +1,37 @@
+import { V1Service } from '@kubernetes/client-node';
+import { convertToTSResource, makeTemplate } from './utils.js';
+import { K8sResource } from './k8sResource.js';
+export class K8sServiceResource extends K8sResource {
+    nodeType = 'execution_controller';
+    nameInfix = 'exc';
+    templateGenerator;
+    templateConfig;
+    resource;
+    exName;
+    exUid;
+    /**
+     * K8sServiceResource allows the generation of a k8s service based on a template.
+     * After creating the object, the k8s service is accessible on the objects
+     * .resource property.
+     *
+     * @param {Object} terasliceConfig - teraslice cluster config from context
+     * @param {Object} execution - teraslice execution
+     * @param {Logger} logger - teraslice logger
+     * @param {String} exName - name from execution resource
+     * @param {String} exUid - uid from execution resource
+     */
+    constructor(terasliceConfig, execution, logger, exName, exUid) {
+        super(terasliceConfig, execution, logger);
+        this.execution = execution;
+        this.logger = logger;
+        this.terasliceConfig = terasliceConfig;
+        this.exName = exName;
+        this.exUid = exUid;
+        this.templateGenerator = makeTemplate('services', this.nodeType);
+        this.templateConfig = this._makeConfig(this.nameInfix, exName, exUid);
+        const k8sService = new V1Service();
+        Object.assign(k8sService, this.templateGenerator(this.templateConfig));
+        this.resource = convertToTSResource(k8sService);
+    }
+}
+//# sourceMappingURL=k8sServiceResource.js.map

package/dist/src/lib/cluster/services/cluster/backends/kubernetesV2/k8sState.js

@@ -0,0 +1,60 @@
+import { get, has, uniq, difference } from '@terascope/utils';
+/**
+ * Given the k8s Pods API output generates the appropriate Teraslice cluster
+ * state.  NOTE: This assumes the pods have already been filtered to ensure they
+ * are teraslice pods and match the cluster in question.
+ * @param  {TSPodList} k8sPods          k8s pods API object (k8s v1.10+)
+ * @param  {Object} clusterState     Teraslice Cluster State
+ * @param  {String} clusterNameLabel k8s label containing clusterName
+ * @param  {Logger} logger           Teraslice logger
+ */
+export function gen(k8sPods, clusterState) {
+    // Make sure we clean up the old
+    const hostIPs = uniq(k8sPods.items.map((item) => get(item, 'status.hostIP')));
+    const oldHostIps = difference(Object.keys(clusterState), hostIPs);
+    oldHostIps.forEach((ip) => {
+        delete clusterState[ip];
+    });
+    // Loop over the nodes in clusterState and set active = [] so we can append
+    // later
+    Object.keys(clusterState).forEach((nodeId) => {
+        clusterState[nodeId].active = [];
+    });
+    // add a worker for each pod
+    k8sPods.items.forEach((pod) => {
+        if (!has(clusterState, pod.status.hostIP)) {
+            // If the node isn't in clusterState, add it
+            clusterState[pod.status.hostIP] = {
+                node_id: pod.status.hostIP,
+                hostname: pod.status.hostIP,
+                pid: 'N/A',
+                node_version: 'N/A',
+                teraslice_version: 'N/A',
+                total: 'N/A',
+                state: 'connected',
+                available: 'N/A',
+                active: []
+            };
+        }
+        const worker = {
+            assets: [],
+            assignment: pod.metadata.labels['app.kubernetes.io/component'],
+            ex_id: pod.metadata.labels['teraslice.terascope.io/exId'],
+            // WARNING: This makes the assumption that the first container
+            // in the pod is the teraslice container.  Currently it is the
+            // only container, so this assumption is safe for now.
+            image: pod.spec.containers[0].image,
+            job_id: pod.metadata.labels['teraslice.terascope.io/jobId'],
+            pod_name: pod.metadata.name,
+            pod_ip: pod.status.podIP,
+            worker_id: pod.metadata.name,
+        };
+        // k8s pods can have status.phase = `Pending`, `Running`, `Succeeded`,
+        // `Failed`, `Unknown`.  We will only add `Running` pods to the
+        // Teraslice cluster state.
+        if (pod.status.phase === 'Running') {
+            clusterState[pod.status.hostIP].active.push(worker);
+        }
+    });
+}
+//# sourceMappingURL=k8sState.js.map

package/dist/src/lib/cluster/services/cluster/backends/kubernetesV2/utils.js

@@ -0,0 +1,170 @@
+import fs from 'node:fs';
+import path from 'node:path';
+// @ts-expect-error
+import barbe from 'barbe';
+import * as k8s from '@kubernetes/client-node';
+import { isTest } from '@terascope/utils';
+const MAX_RETRIES = isTest ? 2 : 3;
+const RETRY_DELAY = isTest ? 50 : 1000; // time in ms
+const resourcePath = path.join(process.cwd(), './packages/teraslice/src/lib/cluster/services/cluster/backends/kubernetesV2/');
+export function makeTemplate(folder, fileName) {
+    const filePath = path.join(resourcePath, folder, `${fileName}.hbs`);
+    const templateData = fs.readFileSync(filePath, 'utf-8');
+    const templateKeys = ['{{', '}}'];
+    return (config) => {
+        if (folder !== 'jobs' && (config.exName === undefined || config.exUid === undefined)) {
+            throw new Error(`K8s config requires ${config.exName === undefined ? 'exName' : 'exUid'} to create a ${folder} template`);
+        }
+        if (folder !== 'services' && config.dockerImage === undefined) {
+            throw new Error(`K8s config requires a dockerImage to create a ${folder} template`);
+        }
+        const templated = barbe(templateData, templateKeys, config);
+        return JSON.parse(templated);
+    };
+}
+// Convert bytes to MB and reduce by 10%
+export function getMaxOldSpace(memory) {
+    return Math.round(0.9 * (memory / 1024 / 1024));
+}
+export function setMaxOldSpaceViaEnv(envArr, jobEnv, memory) {
+    const envObj = {};
+    if (memory && memory > -1) {
+        // Set NODE_OPTIONS to override max-old-space-size
+        const maxOldSpace = getMaxOldSpace(memory);
+        envObj.NODE_OPTIONS = `--max-old-space-size=${maxOldSpace}`;
+    }
+    Object.assign(envObj, jobEnv);
+    Object.entries(envObj).forEach(([name, value]) => {
+        envArr.push({
+            name,
+            value
+        });
+    });
+}
+export function getRetryConfig() {
+    return {
+        retries: MAX_RETRIES,
+        delay: RETRY_DELAY
+    };
+}
+export function isDeployment(resource) {
+    return resource instanceof k8s.V1Deployment;
+}
+export function isJob(resource) {
+    return resource instanceof k8s.V1Job;
+}
+export function isPod(resource) {
+    return resource instanceof k8s.V1Pod;
+}
+export function isReplicaSet(resource) {
+    return resource instanceof k8s.V1ReplicaSet;
+}
+export function isService(resource) {
+    return resource instanceof k8s.V1Service;
+}
+export function isTSDeployment(manifest) {
+    return manifest instanceof k8s.V1Deployment
+        && manifest.metadata?.labels !== undefined
+        && manifest.metadata.name !== undefined
+        && manifest.spec?.replicas !== undefined
+        && manifest.spec.template.metadata?.labels !== undefined
+        && manifest.spec.template.spec?.containers[0].volumeMounts !== undefined
+        && manifest.spec.template.spec.volumes !== undefined;
+}
+export function isTSJob(manifest) {
+    return manifest instanceof k8s.V1Job
+        && manifest.metadata?.labels !== undefined
+        && manifest.metadata.name !== undefined
+        && manifest.spec?.template.metadata?.labels !== undefined
+        && manifest.spec.template.spec?.containers[0].volumeMounts !== undefined
+        && manifest.spec.template.spec.volumes !== undefined;
+}
+export function isTSPod(manifest) {
+    return manifest instanceof k8s.V1Pod
+        && manifest.metadata?.name !== undefined
+        && manifest.status !== undefined;
+}
+export function isTSReplicaSet(manifest) {
+    return manifest instanceof k8s.V1ReplicaSet
+        && manifest.metadata?.name !== undefined
+        && manifest.status !== undefined;
+}
+export function isTSService(manifest) {
+    return manifest instanceof k8s.V1Service
+        && manifest.metadata?.name !== undefined
+        && manifest.spec?.selector !== undefined
+        && manifest.spec.ports !== undefined;
+}
+export function convertToTSResource(resource) {
+    if (isDeployment(resource) && isTSDeployment(resource)) {
+        return resource;
+    }
+    if (isJob(resource) && isTSJob(resource)) {
+        return resource;
+    }
+    if (isPod(resource) && isTSPod(resource)) {
+        return resource;
+    }
+    if (isReplicaSet(resource) && isTSReplicaSet(resource)) {
+        return resource;
+    }
+    if (isService(resource) && isTSService(resource)) {
+        return resource;
+    }
+    throw new Error('K8sResource missing required field(s) to be converted to TSResource.');
+}
+export function isDeploymentList(manifest) {
+    return manifest.kind === 'DeploymentList';
+}
+export function isJobList(manifest) {
+    return manifest.kind === 'JobList';
+}
+export function isPodList(manifest) {
+    return manifest.kind === 'PodList';
+}
+export function isReplicaSetList(manifest) {
+    return manifest.kind === 'ReplicaSetList';
+}
+export function isServiceList(manifest) {
+    return manifest.kind === 'ServiceList';
+}
+export function isTSDeploymentList(manifest) {
+    return manifest.kind === 'DeploymentList'
+        && (manifest.items[0] ? isTSDeployment(manifest.items[0]) : true);
+}
+export function isTSJobList(manifest) {
+    return manifest.kind === 'JobList'
+        && (manifest.items[0] ? isTSJob(manifest.items[0]) : true);
+}
+export function isTSPodList(manifest) {
+    return manifest.kind === 'PodList'
+        && (manifest.items[0] ? isTSPod(manifest.items[0]) : true);
+}
+export function isTSReplicaSetList(manifest) {
+    return manifest.kind === 'ReplicaSetList'
+        && (manifest.items[0] ? isTSReplicaSet(manifest.items[0]) : true);
+}
+export function isTSServiceList(manifest) {
+    return manifest.kind === 'ServiceList'
+        && (manifest.items[0] ? isTSService(manifest.items[0]) : true);
+}
+export function convertToTSResourceList(resourceList) {
+    resourceList.items.map((resource) => convertToTSResource(resource));
+    if (isDeploymentList(resourceList) && isTSDeploymentList(resourceList)) {
+        return resourceList;
+    }
+    if (isJobList(resourceList) && isTSJobList(resourceList)) {
+        return resourceList;
+    }
+    if (isPodList(resourceList) && isTSPodList(resourceList)) {
+        return resourceList;
+    }
+    if (isReplicaSetList(resourceList) && isTSReplicaSetList(resourceList)) {
+        return resourceList;
+    }
+    if (isServiceList(resourceList) && isTSServiceList(resourceList)) {
+        return resourceList;
+    }
+    throw new Error('K8sResource missing required field(s) to be converted to TSResourceList.');
+}
+//# sourceMappingURL=utils.js.map