PR fixes

lib/run.js

@@ -1,9 +1,10 @@
 "use strict";
 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
@@ -13,7 +14,7 @@ const core = require("@actions/core");
 const io = require("@actions/io");
 const path = require("path");
 const utility_1 = require("./utilities/utility");
-const kubectl_util_1 = require("./kubectl-util");
+const kubectl_util_1 = require("./utilities/kubectl-util");
 const deployment_helper_1 = require("./utilities/strategy-helpers/deployment-helper");
 const promote_1 = require("./actions/promote");
 const reject_1 = require("./actions/reject");

lib/utilities/kubectl-util.js

@@ -0,0 +1,81 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os = require("os");
+const path = require("path");
+const util = require("util");
+const fs = require("fs");
+const toolCache = require("@actions/tool-cache");
+const core = require("@actions/core");
+const kubectlToolName = 'kubectl';
+const stableKubectlVersion = 'v1.15.0';
+const stableVersionUrl = 'https://storage.googleapis.com/kubernetes-release/release/stable.txt';
+function getExecutableExtension() {
+    if (os.type().match(/^Win/)) {
+        return '.exe';
+    }
+    return '';
+}
+function getkubectlDownloadURL(version) {
+    switch (os.type()) {
+        case 'Linux':
+            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/linux/amd64/kubectl', version);
+        case 'Darwin':
+            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/darwin/amd64/kubectl', version);
+        case 'Windows_NT':
+        default:
+            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/windows/amd64/kubectl.exe', version);
+    }
+}
+function getStableKubectlVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return toolCache.downloadTool(stableVersionUrl).then((downloadPath) => {
+            let version = fs.readFileSync(downloadPath, 'utf8').toString().trim();
+            if (!version) {
+                version = stableKubectlVersion;
+            }
+            return version;
+        }, (error) => {
+            core.debug(error);
+            core.warning('GetStableVersionFailed');
+            return stableKubectlVersion;
+        });
+    });
+}
+exports.getStableKubectlVersion = getStableKubectlVersion;
+function downloadKubectl(version) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let cachedToolpath = toolCache.find(kubectlToolName, version);
+        let kubectlDownloadPath = '';
+        if (!cachedToolpath) {
+            try {
+                kubectlDownloadPath = yield toolCache.downloadTool(getkubectlDownloadURL(version));
+            }
+            catch (exception) {
+                throw new Error('DownloadKubectlFailed');
+            }
+            cachedToolpath = yield toolCache.cacheFile(kubectlDownloadPath, kubectlToolName + getExecutableExtension(), kubectlToolName, version);
+        }
+        const kubectlPath = path.join(cachedToolpath, kubectlToolName + getExecutableExtension());
+        fs.chmodSync(kubectlPath, '777');
+        return kubectlPath;
+    });
+}
+exports.downloadKubectl = downloadKubectl;
+function getTrafficSplitAPIVersion(kubectl) {
+    const result = kubectl.executeCommand('api-versions');
+    const trafficSplitAPIVersion = result.stdout.split('\n').find(version => version.startsWith('split.smi-spec.io'));
+    if (trafficSplitAPIVersion == null || typeof trafficSplitAPIVersion == 'undefined') {
+        throw new Error('UnableToCreateTrafficSplitManifestFile');
+    }
+    return trafficSplitAPIVersion;
+}
+exports.getTrafficSplitAPIVersion = getTrafficSplitAPIVersion;

lib/utilities/manifest-utilities.js

@@ -1,15 +1,16 @@
 'use strict';
 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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core = require("@actions/core");
-const kubectlutility = require("../kubectl-util");
+const kubectlutility = require("./kubectl-util");
 const io = require("@actions/io");
 const utility_1 = require("./utility");
 function getManifestFiles(manifestFilePaths) {

lib/utilities/strategy-helpers/smi-canary-deployment-helper.js

@@ -8,12 +8,12 @@ const TaskInputParameters = require("../../input-parameters");
 const fileHelper = require("../files-helper");
 const helper = require("../resource-object-utility");
 const utils = require("../manifest-utilities");
-const kubectlUtils = require("../../kubectl-util");
+const kubectlUtils = require("../kubectl-util");
 const canaryDeploymentHelper = require("./canary-deployment-helper");
 const utility_1 = require("../utility");
 const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-workflow-rollout';
 const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit';
-var trafficSplitAPIVersion = null;
+let trafficSplitAPIVersion = "";
 function deploySMICanary(kubectl, filePaths) {
     const newObjectsList = [];
     const canaryReplicaCount = parseInt(TaskInputParameters.baselineAndCanaryReplicas);

src/run.ts

@@ -4,7 +4,7 @@ import * as io from '@actions/io';
 import * as path from 'path';
 
 import { getExecutableExtension, isEqual } from "./utilities/utility";
-import { downloadKubectl, getStableKubectlVersion } from "./kubectl-util";
+import { downloadKubectl, getStableKubectlVersion } from "./utilities/kubectl-util";
 import { deploy } from './utilities/strategy-helpers/deployment-helper';
 import { promote } from './actions/promote';
 import { reject } from './actions/reject';

src/utilities/kubectl-util.ts

@@ -1,76 +1,76 @@
-import * as os from 'os';
-import * as path from 'path';
-import * as util from 'util';
-import * as fs from 'fs';
-
-import * as toolCache from '@actions/tool-cache';
-import * as core from '@actions/core';
-import { Kubectl } from './kubectl-object-model';
-
-const kubectlToolName = 'kubectl';
-const stableKubectlVersion = 'v1.15.0';
-const stableVersionUrl = 'https://storage.googleapis.com/kubernetes-release/release/stable.txt';
-
-function getExecutableExtension(): string {
-    if (os.type().match(/^Win/)) {
-        return '.exe';
-    }
-    return '';
-}
-
-function getkubectlDownloadURL(version: string): string {
-    switch (os.type()) {
-        case 'Linux':
-            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/linux/amd64/kubectl', version);
-
-        case 'Darwin':
-            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/darwin/amd64/kubectl', version);
-
-        case 'Windows_NT':
-        default:
-            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/windows/amd64/kubectl.exe', version);
-
-    }
-}
-
-export async function getStableKubectlVersion(): Promise<string> {
-    return toolCache.downloadTool(stableVersionUrl).then((downloadPath) => {
-        let version = fs.readFileSync(downloadPath, 'utf8').toString().trim();
-        if (!version) {
-            version = stableKubectlVersion;
-        }
-        return version;
-    }, (error) => {
-        core.debug(error);
-        core.warning('GetStableVersionFailed');
-        return stableKubectlVersion;
-    });
-}
-
-export async function downloadKubectl(version: string): Promise<string> {
-    let cachedToolpath = toolCache.find(kubectlToolName, version);
-    let kubectlDownloadPath = '';
-    if (!cachedToolpath) {
-        try {
-            kubectlDownloadPath = await toolCache.downloadTool(getkubectlDownloadURL(version));
-        } catch (exception) {
-            throw new Error('DownloadKubectlFailed');
-        }
-
-        cachedToolpath = await toolCache.cacheFile(kubectlDownloadPath, kubectlToolName + getExecutableExtension(), kubectlToolName, version);
-    }
-
-    const kubectlPath = path.join(cachedToolpath, kubectlToolName + getExecutableExtension());
-    fs.chmodSync(kubectlPath, '777');
-    return kubectlPath;
-}
-
-export function getTrafficSplitAPIVersion(kubectl: Kubectl): string {
-    const result = kubectl.executeCommand('api-versions');
-    const trafficSplitAPIVersion = result.stdout.split('\n').find(version => version.startsWith('split.smi-spec.io'));
-    if (trafficSplitAPIVersion == null || typeof trafficSplitAPIVersion == 'undefined') {
-        throw new Error('UnableToCreateTrafficSplitManifestFile');
-    }
-
-    return trafficSplitAPIVersion;
+import * as os from 'os';
+import * as path from 'path';
+import * as util from 'util';
+import * as fs from 'fs';
+
+import * as toolCache from '@actions/tool-cache';
+import * as core from '@actions/core';
+import { Kubectl } from '../kubectl-object-model';
+
+const kubectlToolName = 'kubectl';
+const stableKubectlVersion = 'v1.15.0';
+const stableVersionUrl = 'https://storage.googleapis.com/kubernetes-release/release/stable.txt';
+
+function getExecutableExtension(): string {
+    if (os.type().match(/^Win/)) {
+        return '.exe';
+    }
+    return '';
+}
+
+function getkubectlDownloadURL(version: string): string {
+    switch (os.type()) {
+        case 'Linux':
+            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/linux/amd64/kubectl', version);
+
+        case 'Darwin':
+            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/darwin/amd64/kubectl', version);
+
+        case 'Windows_NT':
+        default:
+            return util.format('https://storage.googleapis.com/kubernetes-release/release/%s/bin/windows/amd64/kubectl.exe', version);
+
+    }
+}
+
+export async function getStableKubectlVersion(): Promise<string> {
+    return toolCache.downloadTool(stableVersionUrl).then((downloadPath) => {
+        let version = fs.readFileSync(downloadPath, 'utf8').toString().trim();
+        if (!version) {
+            version = stableKubectlVersion;
+        }
+        return version;
+    }, (error) => {
+        core.debug(error);
+        core.warning('GetStableVersionFailed');
+        return stableKubectlVersion;
+    });
+}
+
+export async function downloadKubectl(version: string): Promise<string> {
+    let cachedToolpath = toolCache.find(kubectlToolName, version);
+    let kubectlDownloadPath = '';
+    if (!cachedToolpath) {
+        try {
+            kubectlDownloadPath = await toolCache.downloadTool(getkubectlDownloadURL(version));
+        } catch (exception) {
+            throw new Error('DownloadKubectlFailed');
+        }
+
+        cachedToolpath = await toolCache.cacheFile(kubectlDownloadPath, kubectlToolName + getExecutableExtension(), kubectlToolName, version);
+    }
+
+    const kubectlPath = path.join(cachedToolpath, kubectlToolName + getExecutableExtension());
+    fs.chmodSync(kubectlPath, '777');
+    return kubectlPath;
+}
+
+export function getTrafficSplitAPIVersion(kubectl: Kubectl): string {
+    const result = kubectl.executeCommand('api-versions');
+    const trafficSplitAPIVersion = result.stdout.split('\n').find(version => version.startsWith('split.smi-spec.io'));
+    if (trafficSplitAPIVersion == null || typeof trafficSplitAPIVersion == 'undefined') {
+        throw new Error('UnableToCreateTrafficSplitManifestFile');
+    }
+
+    return trafficSplitAPIVersion;
 }

src/utilities/manifest-utilities.ts

@@ -1,7 +1,7 @@
 'use strict';
 
 import * as core from '@actions/core';
-import * as kubectlutility from '../kubectl-util';
+import * as kubectlutility from './kubectl-util';
 import * as io from '@actions/io';
 import { isEqual } from "./utility";
 

src/utilities/strategy-helpers/smi-canary-deployment-helper.ts

@@ -10,13 +10,13 @@ import * as TaskInputParameters from '../../input-parameters';
 import * as fileHelper from '../files-helper';
 import * as helper from '../resource-object-utility';
 import * as utils from '../manifest-utilities';
-import * as kubectlUtils from '../../kubectl-util';
+import * as kubectlUtils from '../kubectl-util';
 import * as canaryDeploymentHelper from './canary-deployment-helper';
 import { checkForErrors } from "../utility";
 
 const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-workflow-rollout';
 const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit';
-var trafficSplitAPIVersion = null;
+let trafficSplitAPIVersion = "";
 
 export function deploySMICanary(kubectl: Kubectl, filePaths: string[]) {
     const newObjectsList = [];