revert the docker changes

README.md

@@ -96,10 +96,6 @@ Following are the key capabilities of this action:
     <td>version-switch-buffer </br></br>(Optional and relevant only if strategy is blue-green)</td>
     <td>Acceptable values: 1-300.</br>Default value: 0.</br>Waits for the given input in minutes before routing traffic to '-green' workloads.</td>
   </tr>
-  <tr>
-    <td>private-cluster </br></br>(Optional and relevant only using K8's deploy for a cluster with private cluster enabled)</td>
-    <td>Acceptable values: true, false</br>Default value: false.</td>
-  </tr>
   <tr>
     <td>force </br></br>(Optional)</td>
     <td>Deploy when a previous deployment already exists. If true then '--force' argument is added to the apply command. Using '--force' argument is not recommended in production.</td>
@@ -126,26 +122,6 @@ Following are the key capabilities of this action:
         image-pull-secret2
 ```
 
-### Private cluster deployment
-
-```yaml
-- uses: Azure/k8s-deploy@v4
-  with:
-     resource-group: yourResourceGroup
-     name: yourClusterName
-     action: deploy
-     strategy: basic
-
-     private-cluster: true
-     manifests: |
-        manifests/azure-vote-backend-deployment.yaml
-        manifests/azure-vote-backend-service.yaml
-        manifests/azure-vote-frontend-deployment.yaml
-        manifests/azure-vote-frontend-service.yaml
-     images: |
-        registry.azurecr.io/containername
-```
-
 ### Canary deployment without service mesh
 
 ```yaml

action.yml

@@ -62,16 +62,6 @@ inputs:
       description: 'Annotate the target namespace'
       required: false
       default: true
-   private-cluster:
-      description: 'True if cluster is AKS private cluster'
-      required: false
-      default: false
-   resource-group:
-      description: 'Name of resource group - Only required if using private cluster'
-      required: false
-   name:
-      description: 'Resource group name - Only required if using private cluster'
-      required: false
 
 branding:
    color: 'green'

package.json

@@ -23,8 +23,9 @@
       "@types/jest": "^26.0.0",
       "@types/js-yaml": "^3.12.7",
       "@types/node": "^12.20.41",
+      "@vercel/ncc": "^0.34.0",
       "jest": "^26.0.0",
-      "prettier": "^2.7.1",
+      "prettier": "2.7.1",
       "ts-jest": "^26.0.0",
       "typescript": "3.9.5"
    }

src/run.ts

@@ -6,7 +6,6 @@ import {reject} from './actions/reject'
 import {Action, parseAction} from './types/action'
 import {parseDeploymentStrategy} from './types/deploymentStrategy'
 import {getFilesFromDirectories} from './utilities/fileUtils'
-import {PrivateKubectl} from './types/privatekubectl'
 import {parseAnnotations} from './types/annotations'
 
 export async function run() {
@@ -31,22 +30,10 @@ export async function run() {
       .filter((manifest) => manifest.length > 0) // remove any blanks
 
    const fullManifestFilePaths = getFilesFromDirectories(manifestFilePaths)
+   // create kubectl
    const kubectlPath = await getKubectlPath()
    const namespace = core.getInput('namespace') || 'default'
-   const isPrivateCluster =
-      core.getInput('private-cluster').toLowerCase() === 'true'
-   const resourceGroup = core.getInput('resource-group') || ''
-   const resourceName = core.getInput('name') || ''
-
-   const kubectl = isPrivateCluster
-      ? new PrivateKubectl(
-           kubectlPath,
-           namespace,
-           true,
-           resourceGroup,
-           resourceName
-        )
-      : new Kubectl(kubectlPath, namespace, true)
+   const kubectl = new Kubectl(kubectlPath, namespace, true)
 
    // run action
    switch (action) {

src/strategyHelpers/blueGreen/blueGreenHelper.test.ts

@@ -1,128 +0,0 @@
-import {
-   createWorkloadsWithLabel,
-   deleteWorkloadsAndServicesWithLabel,
-   getManifestObjects,
-   getNewBlueGreenObject,
-   GREEN_LABEL_VALUE,
-   isServiceRouted,
-   NONE_LABEL_VALUE
-} from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-
-jest.mock('../../types/kubectl')
-
-describe('bluegreenhelper functions', () => {
-   let testObjects
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      testObjects = getManifestObjects(['test/unit/manifests/test-ingress.yml'])
-
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
-   })
-
-   test('it should parse objects correctly from one file', () => {
-      expect(testObjects.deploymentEntityList[0].kind).toBe('Deployment')
-      expect(testObjects.serviceEntityList[0].kind).toBe('Service')
-      expect(testObjects.ingressEntityList[0].kind).toBe('Ingress')
-
-      expect(
-         testObjects.deploymentEntityList[0].spec.selector.matchLabels.app
-      ).toBe('nginx')
-   })
-
-   test('correctly makes new blue green object', () => {
-      const modifiedDeployment = getNewBlueGreenObject(
-         testObjects.deploymentEntityList[0],
-         GREEN_LABEL_VALUE
-      )
-      //@ts-ignore
-      expect(modifiedDeployment.metadata.name).toBe('nginx-deployment-green')
-      //@ts-ignore
-      expect(modifiedDeployment.metadata.labels['k8s.deploy.color']).toBe(
-         'green'
-      )
-
-      const modifiedSvc = getNewBlueGreenObject(
-         testObjects.serviceEntityList[0],
-         GREEN_LABEL_VALUE
-      )
-      //@ts-ignore
-      expect(modifiedSvc.metadata.name).toBe('nginx-service-green')
-      //@ts-ignore
-      expect(modifiedSvc.metadata.labels['k8s.deploy.color']).toBe('green')
-   })
-
-   test('correctly makes labeled workloads', () => {
-      const kubectl = new Kubectl('')
-      expect(Kubectl).toBeCalledTimes(1)
-      const cwlResult = createWorkloadsWithLabel(
-         kubectl,
-         testObjects.deploymentEntityList,
-         GREEN_LABEL_VALUE
-      )
-      cwlResult.then((value) => {
-         //@ts-ignore
-         expect(value.newFilePaths[0]).toBe('')
-      })
-   })
-
-   test('correctly classifies routed services', () => {
-      expect(
-         isServiceRouted(
-            testObjects.serviceEntityList[0],
-            testObjects.deploymentEntityList
-         )
-      ).toBe(true)
-      testObjects.serviceEntityList[0].spec.selector.app = 'fakeapp'
-      expect(
-         isServiceRouted(
-            testObjects.serviceEntityList[0],
-            testObjects.deploymentEntityList
-         )
-      ).toBe(false)
-   })
-
-   test('correctly deletes services and workloads according to label', () => {
-      const kubectl = new Kubectl('')
-      jest.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
-
-      let objectsToDelete = deleteWorkloadsAndServicesWithLabel(
-         kubectl,
-         NONE_LABEL_VALUE,
-         testObjects.deploymentEntityList,
-         testObjects.serviceEntityList
-      )
-      objectsToDelete.then((value) => {
-         expect(value).toHaveLength(2)
-         expect(value).toContainEqual
-         ;({name: 'nginx-service', kind: 'Service'})
-         expect(value).toContainEqual({
-            name: 'nginx-deployment',
-            kind: 'Deployment'
-         })
-      })
-
-      objectsToDelete = deleteWorkloadsAndServicesWithLabel(
-         kubectl,
-         GREEN_LABEL_VALUE,
-         testObjects.deploymentEntityList,
-         testObjects.serviceEntityList
-      )
-      objectsToDelete.then((value) => {
-         expect(value).toHaveLength(2)
-         expect(value).toContainEqual({
-            name: 'nginx-service-green',
-            kind: 'Service'
-         })
-         expect(value).toContainEqual({
-            name: 'nginx-deployment-green',
-            kind: 'Deployment'
-         })
-      })
-   })
-})

src/strategyHelpers/blueGreen/blueGreenHelper.ts

@@ -112,7 +112,6 @@ export async function deleteWorkloadsWithLabel(
    })
 
    await deleteObjects(kubectl, resourcesToDelete)
-   return resourcesToDelete
 }
 
 export async function deleteWorkloadsAndServicesWithLabel(
@@ -144,7 +143,6 @@ export async function deleteWorkloadsAndServicesWithLabel(
    })
 
    await deleteObjects(kubectl, resourcesToDelete)
-   return resourcesToDelete
 }
 
 export async function deleteObjects(kubectl: Kubectl, deleteList: any[]) {
@@ -239,6 +237,9 @@ export async function createWorkloadsWithLabel(
    deploymentObjectList.forEach((inputObject) => {
       // creating deployment with label
       const newBlueGreenObject = getNewBlueGreenObject(inputObject, nextLabel)
+      core.debug(
+         'New blue-green object is: ' + JSON.stringify(newBlueGreenObject)
+      )
       newObjectsList.push(newBlueGreenObject)
    })
 
@@ -279,7 +280,7 @@ export function addBlueGreenLabelsAndAnnotations(
    updateObjectLabels(inputObject, newLabels, false)
    updateSelectorLabels(inputObject, newLabels, false)
 
-   // updating spec labels if it is not a service
+   // updating spec labels if it is a service
    if (!isServiceEntity(inputObject.kind)) {
       updateSpecLabels(inputObject, newLabels, false)
    }

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.test.ts

@@ -1,88 +0,0 @@
-import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper'
-import {
-   deployBlueGreenIngress,
-   getUpdatedBlueGreenIngress,
-   isIngressRouted,
-   routeBlueGreenIngress
-} from './ingressBlueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-
-jest.mock('../../types/kubectl')
-
-describe('ingress blue green helpers', () => {
-   let testObjects
-   const betaFilepath = ['test/unit/manifests/test-ingress.yml']
-   const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      testObjects = getManifestObjects(ingressFilepath)
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
-   })
-
-   test('it should correctly classify ingresses', () => {
-      expect(
-         isIngressRouted(
-            testObjects.ingressEntityList[0],
-            testObjects.serviceNameMap
-         )
-      ).toBe(true)
-      testObjects.ingressEntityList[0].spec.rules[0].http.paths = {}
-      expect(
-         isIngressRouted(
-            testObjects.ingressEntityList[0],
-            testObjects.serviceNameMap
-         )
-      ).toBe(false)
-
-      expect(
-         isIngressRouted(
-            getManifestObjects(betaFilepath).ingressEntityList[0],
-            testObjects.serviceNameMap
-         )
-      ).toBe(true)
-   })
-
-   test('it should correctly update ingresses', () => {
-      const updatedIng = getUpdatedBlueGreenIngress(
-         testObjects.ingressEntityList[0],
-         testObjects.serviceNameMap,
-         GREEN_LABEL_VALUE
-      )
-      //@ts-ignore
-      expect(updatedIng.metadata.labels['k8s.deploy.color']).toBe('green')
-      //@ts-ignore
-      expect(updatedIng.spec.rules[0].http.paths[0].backend.service.name).toBe(
-         'nginx-service-green'
-      )
-   })
-
-   test('correctly prepares blue/green ingresses for deployment', () => {
-      const kc = new Kubectl('')
-      const generatedObjects = routeBlueGreenIngress(
-         kc,
-         GREEN_LABEL_VALUE,
-         testObjects.serviceNameMap,
-         testObjects.ingressEntityList
-      )
-      generatedObjects.then((value) => {
-         expect(value).toHaveLength(1)
-         //@ts-ignore
-         expect(value[0].metadata.name).toBe('nginx-ingress')
-      })
-   })
-   test('correctly deploys services', () => {
-      const kc = new Kubectl('')
-      const result = deployBlueGreenIngress(kc, ingressFilepath)
-
-      result.then((value) => {
-         const nol = value.newObjectsList
-         //@ts-ignore
-         expect(nol[0].metadata.name).toBe('nginx-service-green')
-      })
-   })
-})

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.ts

@@ -14,7 +14,7 @@ import {
 } from './blueGreenHelper'
 import * as core from '@actions/core'
 
-const BACKEND = 'backend'
+const BACKEND = 'BACKEND'
 
 export async function deployBlueGreenIngress(
    kubectl: Kubectl,
@@ -24,12 +24,13 @@ export async function deployBlueGreenIngress(
    const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
 
    // create deployments with green label value
-   const workloadDeployment = await createWorkloadsWithLabel(
+   const result = createWorkloadsWithLabel(
       kubectl,
       manifestObjects.deploymentEntityList,
       GREEN_LABEL_VALUE
    )
 
+   // create new services and other objects
    let newObjectsList = []
    manifestObjects.serviceEntityList.forEach((inputObject) => {
       const newBlueGreenObject = getNewBlueGreenObject(
@@ -45,12 +46,7 @@ export async function deployBlueGreenIngress(
    const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
    await kubectl.apply(manifestFiles)
 
-   core.debug(
-      'new objects after processing services and other objects: \n' +
-         JSON.stringify(newObjectsList)
-   )
-
-   return {workloadDeployment, newObjectsList}
+   return result
 }
 
 export async function promoteBlueGreenIngress(
@@ -58,13 +54,14 @@ export async function promoteBlueGreenIngress(
    manifestObjects
 ) {
    //checking if anything to promote
-   const {areValid, invalidIngresses} = validateIngresses(
-      kubectl,
-      manifestObjects.ingressEntityList,
-      manifestObjects.serviceNameMap
-   )
-   if (!areValid) {
-      throw 'Ingresses are not in promote state' + invalidIngresses.toString()
+   if (
+      !validateIngressesState(
+         kubectl,
+         manifestObjects.ingressEntityList,
+         manifestObjects.serviceNameMap
+      )
+   ) {
+      throw 'Ingress not in promote state'
    }
 
    // create stable deployments with new configuration
@@ -141,18 +138,17 @@ export async function routeBlueGreenIngress(
       })
    }
 
+   core.debug('New objects: ' + JSON.stringify(newObjectsList))
    const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
    await kubectl.apply(manifestFiles)
-   return newObjectsList
 }
 
-export function validateIngresses(
+export function validateIngressesState(
    kubectl: Kubectl,
    ingressEntityList: any[],
    serviceNameMap: Map<string, string>
-): {areValid: boolean; invalidIngresses: string[]} {
-   let areValid: boolean = true
-   const invalidIngresses = []
+): boolean {
+   let areIngressesTargetingNewServices: boolean = true
    ingressEntityList.forEach(async (inputObject) => {
       if (isIngressRouted(inputObject, serviceNameMap)) {
          //querying existing ingress
@@ -162,32 +158,33 @@ export function validateIngresses(
             inputObject.metadata.name
          )
 
-         let isValid =
-            !!existingIngress &&
-            existingIngress?.metadata?.labels[BLUE_GREEN_VERSION_LABEL] ===
-               GREEN_LABEL_VALUE
-         if (!isValid) {
-            invalidIngresses.push(inputObject.metadata.name)
+         if (!!existingIngress) {
+            const currentLabel: string =
+               existingIngress?.metadata?.labels[BLUE_GREEN_VERSION_LABEL]
+
+            // if not green label, then wrong configuration
+            if (currentLabel != GREEN_LABEL_VALUE)
+               areIngressesTargetingNewServices = false
+         } else {
+            // no ingress at all, so nothing to promote
+            areIngressesTargetingNewServices = false
          }
-         // to be valid, ingress should exist and should be green
-         areValid = areValid && isValid
       }
    })
 
-   return {areValid, invalidIngresses}
+   return areIngressesTargetingNewServices
 }
 
-export function isIngressRouted(
+function isIngressRouted(
    ingressObject: any,
    serviceNameMap: Map<string, string>
 ): boolean {
    let isIngressRouted: boolean = false
    // check if ingress targets a service in the given manifests
    JSON.parse(JSON.stringify(ingressObject), (key, value) => {
-      isIngressRouted =
-         isIngressRouted || (key === 'service' && value.hasOwnProperty('name'))
-      isIngressRouted =
-         isIngressRouted || (key === 'serviceName' && serviceNameMap.has(value))
+      if (key === 'serviceName' && serviceNameMap.has(value)) {
+         isIngressRouted = true
+      }
 
       return value
    })
@@ -209,18 +206,15 @@ export function getUpdatedBlueGreenIngress(
    addBlueGreenLabelsAndAnnotations(newObject, type)
 
    // update ingress labels
-   if (inputObject.apiVersion === 'networking.k8s.io/v1beta1') {
-      return updateIngressBackendBetaV1(newObject, serviceNameMap)
-   }
    return updateIngressBackend(newObject, serviceNameMap)
 }
 
-export function updateIngressBackendBetaV1(
+export function updateIngressBackend(
    inputObject: any,
    serviceNameMap: Map<string, string>
 ): any {
    inputObject = JSON.parse(JSON.stringify(inputObject), (key, value) => {
-      if (key.toLowerCase() === BACKEND) {
+      if (key.toUpperCase() === BACKEND) {
          const {serviceName} = value
          if (serviceNameMap.has(serviceName)) {
             // update service name with corresponding bluegreen name only if service is provied in given manifests
@@ -233,20 +227,3 @@ export function updateIngressBackendBetaV1(
 
    return inputObject
 }
-
-export function updateIngressBackend(
-   inputObject: any,
-   serviceNameMap: Map<string, string>
-): any {
-   inputObject = JSON.parse(JSON.stringify(inputObject), (key, value) => {
-      if (
-         key.toLowerCase() === BACKEND &&
-         serviceNameMap.has(value?.service?.name)
-      ) {
-         value.service.name = serviceNameMap.get(value.service.name)
-      }
-      return value
-   })
-
-   return inputObject
-}

src/strategyHelpers/blueGreen/serviceBlueGreenHelper.ts

@@ -19,21 +19,21 @@ export async function deployBlueGreenService(
    const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
 
    // create deployments with green label value
-   const workloadDeployment = await createWorkloadsWithLabel(
+   const result = await createWorkloadsWithLabel(
       kubectl,
       manifestObjects.deploymentEntityList,
       GREEN_LABEL_VALUE
    )
 
+   // create other non deployment and non service entities
    const newObjectsList = manifestObjects.otherObjects
       .concat(manifestObjects.ingressEntityList)
       .concat(manifestObjects.unroutedServiceEntityList)
    const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
-
    if (manifestFiles.length > 0) await kubectl.apply(manifestFiles)
 
    // returning deployment details to check for rollout stability
-   return {workloadDeployment, newObjectsList}
+   return result
 }
 
 export async function promoteBlueGreenService(
@@ -76,6 +76,7 @@ export async function rejectBlueGreenService(
       manifestObjects.deploymentEntityList
    )
 }
+
 export async function routeBlueGreenService(
    kubectl: Kubectl,
    nextLabel: string,

src/strategyHelpers/blueGreen/smiBlueGreenHelper.ts

@@ -41,13 +41,11 @@ export async function deployBlueGreenSMI(
    await setupSMI(kubectl, manifestObjects.serviceEntityList, annotations)
 
    // create new deloyments
-   const workloadDeployment = await createWorkloadsWithLabel(
+   return await createWorkloadsWithLabel(
       kubectl,
       manifestObjects.deploymentEntityList,
       GREEN_LABEL_VALUE
    )
-
-   return {workloadDeployment, newObjectsList}
 }
 
 export async function promoteBlueGreenSMI(kubectl: Kubectl, manifestObjects) {

src/strategyHelpers/deploymentHelper.ts

@@ -60,7 +60,7 @@ export async function deployManifests(
             core.getInput('route-method', {required: true})
          )
 
-         const {workloadDeployment, newObjectsList} = await Promise.resolve(
+         const {result, newFilePaths} = await Promise.resolve(
             (routeStrategy == RouteStrategy.INGRESS &&
                deployBlueGreenIngress(kubectl, files)) ||
                (routeStrategy == RouteStrategy.SMI &&
@@ -68,8 +68,8 @@ export async function deployManifests(
                deployBlueGreenService(kubectl, files)
          )
 
-         checkForErrors([workloadDeployment.result])
-         return workloadDeployment.newFilePaths
+         checkForErrors([result])
+         return newFilePaths
       }
 
       case DeploymentStrategy.BASIC: {

src/types/kubectl.ts

@@ -10,25 +10,18 @@ export interface Resource {
 }
 
 export class Kubectl {
-   protected readonly kubectlPath: string
-   protected readonly namespace: string
-   protected readonly ignoreSSLErrors: boolean
-   protected readonly resourceGroup: string
-   protected readonly name: string
-   protected isPrivateCluster: boolean
+   private readonly kubectlPath: string
+   private readonly namespace: string
+   private readonly ignoreSSLErrors: boolean
 
    constructor(
       kubectlPath: string,
       namespace: string = 'default',
-      ignoreSSLErrors: boolean = false,
-      resourceGroup: string = '',
-      name: string = ''
+      ignoreSSLErrors: boolean = false
    ) {
       this.kubectlPath = kubectlPath
       this.ignoreSSLErrors = !!ignoreSSLErrors
       this.namespace = namespace
-      this.resourceGroup = resourceGroup
-      this.name = name
    }
 
    public async apply(
@@ -162,7 +155,7 @@ export class Kubectl {
       return this.execute(['delete', ...args])
    }
 
-   protected async execute(args: string[], silent: boolean = false) {
+   private async execute(args: string[], silent: boolean = false) {
       if (this.ignoreSSLErrors) {
          args.push('--insecure-skip-tls-verify')
       }

src/types/privatekubectl.ts

@@ -1,135 +0,0 @@
-import {Kubectl} from './kubectl'
-import {ExecOptions, ExecOutput, getExecOutput} from '@actions/exec'
-import * as core from '@actions/core'
-import * as os from 'os'
-import * as fs from 'fs'
-import * as path from 'path'
-
-export class PrivateKubectl extends Kubectl {
-   protected async execute(args: string[], silent: boolean = false) {
-      args.unshift('kubectl')
-      let kubectlCmd = args.join(' ')
-      let addFileFlag = false
-      let eo = <ExecOptions>{silent}
-
-      if (this.containsFilenames(kubectlCmd)) {
-         // For private clusters, files will referenced solely by their basename
-         kubectlCmd = this.replaceFilnamesWithBasenames(kubectlCmd)
-         addFileFlag = true
-      }
-
-      const privateClusterArgs = [
-         'aks',
-         'command',
-         'invoke',
-         '--resource-group',
-         this.resourceGroup,
-         '--name',
-         this.name,
-         '--command',
-         kubectlCmd
-      ]
-
-      if (addFileFlag) {
-         const filenames = this.extractFilesnames(kubectlCmd).split(' ')
-
-         const tempDirectory =
-            process.env['runner.tempDirectory'] || os.tmpdir() + '/manifests'
-         eo.cwd = tempDirectory
-         privateClusterArgs.push(...['--file', '.'])
-
-         let filenamesArr = filenames[0].split(',')
-         for (let index = 0; index < filenamesArr.length; index++) {
-            const file = filenamesArr[index]
-
-            if (!file) {
-               continue
-            }
-            this.moveFileToTempManifestDir(file)
-         }
-      }
-
-      core.debug(
-         `private cluster Kubectl run with invoke command: ${kubectlCmd}`
-      )
-      return await getExecOutput('az', privateClusterArgs, eo)
-   }
-
-   private replaceFilnamesWithBasenames(kubectlCmd: string) {
-      let exFilenames = this.extractFilesnames(kubectlCmd)
-      let filenames = exFilenames.split(' ')
-      let filenamesArr = filenames[0].split(',')
-
-      for (let index = 0; index < filenamesArr.length; index++) {
-         filenamesArr[index] = path.basename(filenamesArr[index])
-      }
-
-      let baseFilenames = filenamesArr.join()
-
-      let result = kubectlCmd.replace(exFilenames, baseFilenames)
-      return result
-   }
-
-   public extractFilesnames(strToParse: string) {
-      let start = strToParse.indexOf('-filename')
-      let offset = 7
-
-      if (start == -1) {
-         start = strToParse.indexOf('-f')
-
-         if (start == -1) {
-            return ''
-         }
-         offset = 0
-      }
-
-      let temp = strToParse.substring(start + offset)
-      let end = temp.indexOf(' -')
-
-      //End could be case where the -f flag was last, or -f is followed by some additonal flag and it's arguments
-      return temp.substring(3, end == -1 ? temp.length : end).trim()
-   }
-
-   private containsFilenames(str: string) {
-      return str.includes('-f ') || str.includes('filename ')
-   }
-
-   private createTempManifestsDirectory() {
-      const manifestsDir = '/tmp/manifests'
-      if (!fs.existsSync('/tmp/manifests')) {
-         fs.mkdirSync('/tmp/manifests', {recursive: true})
-      }
-   }
-
-   private moveFileToTempManifestDir(file: string) {
-      this.createTempManifestsDirectory()
-      if (!fs.existsSync('/tmp/' + file)) {
-         core.debug(
-            '/tmp/' +
-               file +
-               ' does not exist, and therefore cannot be moved to the manifest directory'
-         )
-      }
-
-      fs.copyFile('/tmp/' + file, '/tmp/manifests/' + file, function (err) {
-         if (err) {
-            core.debug(
-               'Could not rename ' +
-                  '/tmp/' +
-                  file +
-                  ' to  ' +
-                  '/tmp/manifests/' +
-                  file +
-                  ' ERROR: ' +
-                  err
-            )
-            return
-         }
-         core.debug(
-            "Successfully moved file '" +
-               file +
-               "' from /tmp to /tmp/manifest directory"
-         )
-      })
-   }
-}

src/utilities/fileUtils.test.ts

@@ -12,12 +12,11 @@ describe('File utils', () => {
          'test/unit/manifests/manifest_test_dir/another_layer/deep-service.yaml',
          'test/unit/manifests/manifest_test_dir/nested-test-service.yaml',
          'test/unit/manifests/test-ingress.yml',
-         'test/unit/manifests/test-ingress-new.yml',
          'test/unit/manifests/test-service.yml'
       ]
 
       // is there a more efficient way to test equality w random order?
-      expect(testSearch).toHaveLength(6)
+      expect(testSearch).toHaveLength(5)
       expectedManifests.forEach((fileName) => {
          expect(testSearch).toContain(fileName)
       })
@@ -54,7 +53,7 @@ describe('File utils', () => {
 
       expect(
          getFilesFromDirectories([outerPath, fileAtOuter, innerPath])
-      ).toHaveLength(6)
+      ).toHaveLength(5)
    })
 })
 

src/utilities/fileUtils.ts

@@ -57,7 +57,7 @@ export function writeManifestToFile(
 }
 
 function getManifestFileName(kind: string, name: string) {
-   const filePath = `${kind}_${name}_${getCurrentTime().toString()}`
+   const filePath = `${kind}_${name}_ ${getCurrentTime().toString()}`
    const tempDirectory = getTempDirectory()
    return path.join(tempDirectory, path.basename(filePath))
 }

test/unit/manifests/test-ingress-new.yml

@@ -1,50 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-   name: nginx-deployment
-   labels:
-      app: nginx
-spec:
-   replicas: 1
-   selector:
-      matchLabels:
-         app: nginx
-   template:
-      metadata:
-         labels:
-            app: nginx
-      spec:
-         containers:
-            - name: nginx
-              image: nginx:1.14.2
-              ports:
-                 - containerPort: 80
----
-apiVersion: v1
-kind: Service
-metadata:
-   name: nginx-service
-spec:
-   selector:
-      app: nginx
-   ports:
-      - protocol: TCP
-        port: 80
-        targetPort: 80
----
-apiVersion: networking.k8s.io/v1
-kind: Ingress
-metadata:
-   name: nginx-ingress
-   annotations:
-      nginx.ingress.kubernetes.io/rewrite-target: /
-spec:
-   rules:
-      - http:
-           paths:
-              - path: /testpath
-                backend:
-                   service:
-                      name: nginx-service
-                      port:
-                         number: 80