teraslice 2.14.2 → 2.14.4

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

@@ -78,7 +78,7 @@ export class K8sResource {
         }
     }
     _mountLocalTeraslice() {
-        const devMounts = JSON.parse(process.env.MOUNT_LOCAL_TERASLICE);
+        const devMounts = JSON.parse(Buffer.from(process.env.MOUNT_LOCAL_TERASLICE, 'base64').toString('utf-8'));
         this.resource.spec.template.spec.containers[0].volumeMounts.push(...devMounts.volumeMounts);
         this.resource.spec.template.spec.volumes.push(...devMounts.volumes);
         this.resource.spec.template.spec.containers[0].args = [

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

@@ -44,7 +44,7 @@ export class K8s {
             });
             throw error;
         }
-        return namespaces.body;
+        return namespaces;
     }
     /**
      * Returns the first pod matching the provided selector after it has
@@ -67,10 +67,10 @@ export class K8s {
         let now = Date.now();
         const end = now + timeout;
         while (true) {
-            const result = await pRetry(() => this.k8sCoreV1Api
-                .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, selector), getRetryConfig());
+            const podListObj = await pRetry(() => this.k8sCoreV1Api
+                .listNamespacedPod({ namespace, labelSelector: selector }), getRetryConfig());
             // NOTE: This assumes the first pod returned.
-            const pod = get(result, 'body.items[0]');
+            const pod = get(podListObj, 'items[0]');
             if (pod && isTSPod(pod)) {
                 if (statusType === 'readiness-probe') {
                     if (pod.status.conditions) {
@@ -110,9 +110,9 @@ export class K8s {
         let now = Date.now();
         const end = now + timeout;
         while (true) {
-            const result = await pRetry(() => this.k8sCoreV1Api
-                .listNamespacedPod(namespace, undefined, undefined, undefined, undefined, selector), getRetryConfig());
-            const podList = get(result, 'body.items');
+            const podListObj = await pRetry(() => this.k8sCoreV1Api
+                .listNamespacedPod({ namespace, labelSelector: selector }), getRetryConfig());
+            const podList = get(podListObj, 'items');
             if (podList.length === number)
                 return podList;
             const msg = `Waiting: pods matching ${selector} is ${podList.length}/${number}`;
@@ -125,37 +125,33 @@ export class K8s {
     }
     async list(selector, objType, ns) {
         const namespace = ns || this.defaultNamespace;
-        let responseObj;
-        const params = [
+        let resourceListObj;
+        const params = {
             namespace,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            selector
-        ];
+            labelSelector: selector
+        };
         try {
             if (objType === 'deployments') {
-                responseObj = await pRetry(() => this.k8sAppsV1Api.listNamespacedDeployment(...params), getRetryConfig());
+                resourceListObj = await pRetry(() => this.k8sAppsV1Api.listNamespacedDeployment(params), getRetryConfig());
             }
             else if (objType === 'jobs') {
-                responseObj = await pRetry(() => this.k8sBatchV1Api.listNamespacedJob(...params), getRetryConfig());
+                resourceListObj = await pRetry(() => this.k8sBatchV1Api.listNamespacedJob(params), getRetryConfig());
             }
             else if (objType === 'pods') {
-                responseObj = await pRetry(() => this.k8sCoreV1Api.listNamespacedPod(...params), getRetryConfig());
+                resourceListObj = await pRetry(() => this.k8sCoreV1Api.listNamespacedPod(params), getRetryConfig());
             }
             else if (objType === 'replicasets') {
-                responseObj = await pRetry(() => this.k8sAppsV1Api.listNamespacedReplicaSet(...params), getRetryConfig());
+                resourceListObj = await pRetry(() => this.k8sAppsV1Api.listNamespacedReplicaSet(params), getRetryConfig());
             }
             else if (objType === 'services') {
-                responseObj = await pRetry(() => this.k8sCoreV1Api.listNamespacedService(...params), getRetryConfig());
+                resourceListObj = await pRetry(() => this.k8sCoreV1Api.listNamespacedService(params), getRetryConfig());
             }
             else {
                 const error = new Error(`Invalid objType provided to get: ${objType}`);
                 this.logger.error(error);
                 return Promise.reject(error);
             }
-            return convertToTSResourceList(responseObj.body);
+            return convertToTSResourceList(resourceListObj);
         }
         catch (e) {
             const err = new Error(`Request k8s.list of ${objType} with selector ${selector} failed: ${e}`);
@@ -180,33 +176,34 @@ export class K8s {
         }
     }
     async post(manifest) {
-        let responseObj;
+        let resourceObj;
+        const namespace = this.defaultNamespace;
         try {
             if (isDeployment(manifest)) {
-                responseObj = await this.k8sAppsV1Api
-                    .createNamespacedDeployment(this.defaultNamespace, manifest);
+                resourceObj = await this.k8sAppsV1Api
+                    .createNamespacedDeployment({ namespace, body: manifest });
             }
             else if (isJob(manifest)) {
-                responseObj = await this.k8sBatchV1Api
-                    .createNamespacedJob(this.defaultNamespace, manifest);
+                resourceObj = await this.k8sBatchV1Api
+                    .createNamespacedJob({ namespace, body: manifest });
             }
             else if (isPod(manifest)) {
-                responseObj = await this.k8sCoreV1Api
-                    .createNamespacedPod(this.defaultNamespace, manifest);
+                resourceObj = await this.k8sCoreV1Api
+                    .createNamespacedPod({ namespace, body: manifest });
             }
             else if (isReplicaSet(manifest)) {
-                responseObj = await this.k8sAppsV1Api
-                    .createNamespacedReplicaSet(this.defaultNamespace, manifest);
+                resourceObj = await this.k8sAppsV1Api
+                    .createNamespacedReplicaSet({ namespace, body: manifest });
             }
             else if (isService(manifest)) {
-                responseObj = await this.k8sCoreV1Api
-                    .createNamespacedService(this.defaultNamespace, manifest);
+                resourceObj = await this.k8sCoreV1Api
+                    .createNamespacedService({ namespace, body: manifest });
             }
             else {
                 const error = new Error('Invalid manifest type');
                 return Promise.reject(error);
             }
-            return convertToTSResource(responseObj.body);
+            return convertToTSResource(resourceObj);
         }
         catch (e) {
             const err = new Error(`Request k8s.post of ${manifest.kind} with body ${JSON.stringify(manifest)} failed: ${e}`);
@@ -217,7 +214,7 @@ export class K8s {
      * Patches specified k8s deployment with the provided record
      * @param  {String} record record, like 'app=teraslice'
      * @param  {String} name   Name of the deployment to patch
-     * @return {Object}        body of k8s patch response.
+     * @return {Object}        k8s V1Deployment object.
      */
     // TODO: I renamed this from patchDeployment to just patch because this is
     // the low level k8s api method, I expect to eventually change the interface
@@ -225,10 +222,13 @@ export class K8s {
     async patch(record, name) {
         let responseObj;
         try {
-            const options = { headers: { 'Content-type': k8s.PatchUtils.PATCH_FORMAT_JSON_PATCH } };
-            responseObj = await pRetry(() => this.k8sAppsV1Api
-                .patchNamespacedDeployment(name, this.defaultNamespace, record, undefined, undefined, undefined, undefined, undefined, options), getRetryConfig());
-            return responseObj.body;
+            const options = k8s.setHeaderOptions('Content-Type', k8s.PatchStrategy.JsonPatch);
+            responseObj = await pRetry(() => this.k8sAppsV1Api.patchNamespacedDeployment({
+                name,
+                namespace: this.defaultNamespace,
+                body: record
+            }, options), getRetryConfig());
+            return responseObj;
         }
         catch (e) {
             const err = new Error(`Request k8s.patch with name: ${name} failed with: ${e}`);
@@ -252,27 +252,23 @@ export class K8s {
         if (force) {
             deleteOptions.gracePeriodSeconds = 1;
         }
-        const params = [
+        const params = {
             name,
-            this.defaultNamespace,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            deleteOptions
-        ];
+            namespace: this.defaultNamespace,
+            body: deleteOptions
+        };
         const deleteWithErrorHandling = async (deleteFn) => {
             try {
                 const res = await deleteFn();
                 return res;
             }
             catch (e) {
-                if (e.statusCode) {
+                if (e.body) {
+                    const bodyObj = JSON.parse(e.body);
                     // 404 should be an acceptable response to a delete request, not an error
-                    if (e.statusCode === 404) {
+                    if (bodyObj.code === 404) {
                         this.logger.info(`No ${objType} with name ${name} found while attempting to delete.`);
-                        return e;
+                        return bodyObj;
                     }
                 }
                 throw e;
@@ -281,28 +277,28 @@ export class K8s {
         try {
             if (objType === 'services') {
                 responseObj = await pRetry(() => deleteWithErrorHandling(() => this.k8sCoreV1Api
-                    .deleteNamespacedService(...params)), getRetryConfig());
+                    .deleteNamespacedService(params)), getRetryConfig());
             }
             else if (objType === 'deployments') {
                 responseObj = await pRetry(() => deleteWithErrorHandling(() => this.k8sAppsV1Api
-                    .deleteNamespacedDeployment(...params)), getRetryConfig());
+                    .deleteNamespacedDeployment(params)), getRetryConfig());
             }
             else if (objType === 'jobs') {
                 responseObj = await pRetry(() => deleteWithErrorHandling(() => this.k8sBatchV1Api
-                    .deleteNamespacedJob(...params)), getRetryConfig());
+                    .deleteNamespacedJob(params)), getRetryConfig());
             }
             else if (objType === 'pods') {
                 responseObj = await pRetry(() => deleteWithErrorHandling(() => this.k8sCoreV1Api
-                    .deleteNamespacedPod(...params)), getRetryConfig());
+                    .deleteNamespacedPod(params)), getRetryConfig());
             }
             else if (objType === 'replicasets') {
                 responseObj = await pRetry(() => deleteWithErrorHandling(() => this.k8sAppsV1Api
-                    .deleteNamespacedReplicaSet(...params)), getRetryConfig());
+                    .deleteNamespacedReplicaSet(params)), getRetryConfig());
             }
             else {
                 throw new Error(`Invalid objType: ${objType}`);
             }
-            return responseObj.body;
+            return responseObj;
         }
         catch (e) {
             const err = new Error(`Request k8s.delete with name: ${name} failed with: ${e}`);

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

@@ -26,7 +26,7 @@ export class K8sResource {
     _setEnvVariables() {
     }
     _mountLocalTeraslice(resource) {
-        const devMounts = JSON.parse(process.env.MOUNT_LOCAL_TERASLICE);
+        const devMounts = JSON.parse(Buffer.from(process.env.MOUNT_LOCAL_TERASLICE, 'base64').toString('utf-8'));
         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]) {

package/dist/test/lib/cluster/services/cluster/backends/kubernetes/v2/k8s-v2-spec.js

@@ -110,6 +110,12 @@ describe('k8s', () => {
         kind: 'Status',
         status: 'Success'
     };
+    const apiException = {
+        'HTTP-Code': 400,
+        Message: 'Unknown API Status Code!',
+        Body: { statusCode: 400 },
+        Headers: { 'content-type': 'application/json' }
+    };
     beforeEach(async () => {
         nock(_url)
             .get('/api/v1/namespaces')
@@ -280,16 +286,16 @@ describe('k8s', () => {
             const response = await k8s.patch({ name: 'testName' }, 'test1');
             expect(response).toEqual({});
         });
-        it('will throw on a reponse code >= 400', async () => {
+        it('will throw on a response code >= 400', async () => {
             nock(_url)
                 .patch('/apis/apps/v1/namespaces/default/deployments/bad-response')
-                .replyWithError({ statusCode: 400 })
+                .reply(400, apiException)
                 .patch('/apis/apps/v1/namespaces/default/deployments/bad-response')
-                .replyWithError({ statusCode: 400 })
+                .reply(400, apiException)
                 .patch('/apis/apps/v1/namespaces/default/deployments/bad-response')
-                .replyWithError({ statusCode: 400 });
+                .reply(400, apiException);
             await expect(k8s.patch({ name: 'bad-response' }, 'bad-response'))
-                .rejects.toThrow('Request k8s.patch with name: bad-response failed with: TSError: {"statusCode":400}');
+                .rejects.toThrow('HTTP-Code: 400');
         });
     });
     describe('->delete', () => {
@@ -336,39 +342,36 @@ describe('k8s', () => {
             const response = await k8s.delete('test1', 'replicasets');
             expect(response).toEqual({});
         });
-        it('will throw on a reponse code >= 400, excluding 404', async () => {
+        it('will throw on a response code >= 400, excluding 404', async () => {
             nock(_url)
                 .delete('/api/v1/namespaces/default/pods/bad-response')
-                .replyWithError({ statusCode: 400 })
+                .reply(400, apiException)
                 .delete('/api/v1/namespaces/default/pods/bad-response')
-                .replyWithError({ statusCode: 400 })
+                .reply(400, apiException)
                 .delete('/api/v1/namespaces/default/pods/bad-response')
-                .replyWithError({ statusCode: 400 });
+                .reply(400, apiException);
             await expect(k8s.delete('bad-response', 'pods'))
-                .rejects.toThrow('Request k8s.delete with name: bad-response failed with: TSError: {"statusCode":400}');
+                .rejects.toThrow('HTTP-Code: 400');
         });
         it('will succeed on a 404 response code', async () => {
             const notFoundResponse = {
-                body: {
-                    kind: 'Status',
-                    apiVersion: 'v1',
-                    metadata: {},
-                    status: 'Failure',
-                    message: 'pods "non-existent" not found',
-                    reason: 'NotFound',
-                    details: { name: 'non-existent', kind: 'pods' },
-                    code: 404
-                },
-                statusCode: 404
+                kind: 'Status',
+                apiVersion: 'v1',
+                metadata: {},
+                status: 'Failure',
+                message: 'pods "non-existent" not found',
+                reason: 'NotFound',
+                details: { name: 'non-existent', kind: 'pods' },
+                code: 404
             };
             nock(_url)
                 .delete('/api/v1/namespaces/default/pods/non-existent')
-                .replyWithError(notFoundResponse);
+                .reply(404, notFoundResponse);
             const response = await k8s.delete('non-existent', 'pods');
-            expect(response).toEqual(notFoundResponse.body);
+            expect(response).toEqual(notFoundResponse);
         });
     });
-    describe('->_deletObjByExId', () => {
+    describe('->_deleteObjByExId', () => {
         it('can delete a single object', async () => {
             nock(_url)
                 .get('/apis/batch/v1/namespaces/default/jobs')

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "teraslice",
   "displayName": "Teraslice",
-  "version": "2.14.2",
+  "version": "2.14.4",
   "description": "Distributed computing platform for processing JSON data",
   "homepage": "https://github.com/terascope/teraslice#readme",
   "bugs": {
@@ -38,12 +38,12 @@
     "ms": "~2.1.3"
   },
   "dependencies": {
-    "@kubernetes/client-node": "~0.22.3",
-    "@terascope/elasticsearch-api": "~4.8.6",
-    "@terascope/job-components": "~1.9.9",
-    "@terascope/teraslice-messaging": "~1.10.9",
+    "@kubernetes/client-node": "~1.1.1",
+    "@terascope/elasticsearch-api": "~4.9.0",
+    "@terascope/job-components": "~1.10.0",
+    "@terascope/teraslice-messaging": "~1.11.0",
     "@terascope/types": "~1.4.1",
-    "@terascope/utils": "~1.7.8",
+    "@terascope/utils": "~1.8.0",
     "async-mutex": "~0.5.0",
     "barbe": "~3.0.17",
     "body-parser": "~2.2.0",
@@ -62,7 +62,7 @@
     "semver": "~7.7.1",
     "socket.io": "~1.7.4",
     "socket.io-client": "~1.7.4",
-    "terafoundation": "~1.11.2",
+    "terafoundation": "~1.12.1",
     "uuid": "~11.1.0"
   },
   "devDependencies": {