Spelling correction

.gitignore

@@ -3,5 +3,3 @@ node_modules
 .DS_Store
 .idea
 lib/
-
-coverage/

README.md

@@ -4,15 +4,6 @@ This action is used to deploy manifests to Kubernetes clusters. It requires that
 
 If you are looking to automate your workflows to deploy to [Azure Web Apps](https://azure.microsoft.com/en-us/services/app-service/web/) and [Azure Web App for Containers](https://azure.microsoft.com/en-us/services/app-service/containers/), consider using [`Azure/webapps-deploy`](https://github.com/Azure/webapps-deploy) action.
 
-This action requires the following permissions from your workflow:
-
-```yaml
-permissions:
-   id-token: write
-   contents: read
-   actions: read
-```
-
 ## Action capabilities
 
 Following are the key capabilities of this action:
@@ -105,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>
@@ -135,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
@@ -229,7 +196,7 @@ To promote/reject the canary created by the above snippet, the following YAML sn
         dir/manifestsDirectory
      strategy: canary
      traffic-split-method: smi
-     action: reject # substitute promote if you want to promote
+     action: reject # substitute reject if you want to reject
 ```
 
 ### Blue-Green deployment with different route methods

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

@@ -6,7 +6,6 @@
    "scripts": {
       "build": "ncc build src/run.ts -o lib",
       "test": "jest",
-      "coverage": "jest --coverage=true",
       "format": "prettier --write .",
       "format-check": "prettier --check ."
    },
@@ -24,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/actions/deploy.ts

@@ -6,6 +6,7 @@ import {
    getResources,
    updateManifestFiles
 } from '../utilities/manifestUpdateUtils'
+import {routeBlueGreen} from '../strategyHelpers/blueGreen/blueGreenHelper'
 import {
    annotateAndLabelResources,
    checkManifestStability,
@@ -13,15 +14,17 @@ import {
 } from '../strategyHelpers/deploymentHelper'
 import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {parseTrafficSplitMethod} from '../types/trafficSplitMethod'
+import {parseRouteStrategy} from '../types/routeStrategy'
 
 export async function deploy(
    kubectl: Kubectl,
    manifestFilePaths: string[],
-   deploymentStrategy: DeploymentStrategy
+   deploymentStrategy: DeploymentStrategy,
+   annotations: {[key: string]: string} = {}
 ) {
    // update manifests
    const inputManifestFiles: string[] = updateManifestFiles(manifestFilePaths)
-   core.debug(`Input manifest files: ${inputManifestFiles}`)
+   core.debug('Input manifest files: ' + inputManifestFiles)
 
    // deploy manifests
    core.startGroup('Deploying manifests')
@@ -32,10 +35,11 @@ export async function deploy(
       inputManifestFiles,
       deploymentStrategy,
       kubectl,
-      trafficSplitMethod
+      trafficSplitMethod,
+      annotations
    )
-   core.debug(`Deployed manifest files: ${deployedManifestFiles}`)
    core.endGroup()
+   core.debug('Deployed manifest files: ' + deployedManifestFiles)
 
    // check manifest stability
    core.startGroup('Checking manifest stability')
@@ -48,6 +52,15 @@ export async function deploy(
    await checkManifestStability(kubectl, resourceTypes)
    core.endGroup()
 
+   if (deploymentStrategy == DeploymentStrategy.BLUE_GREEN) {
+      core.startGroup('Routing blue green')
+      const routeStrategy = parseRouteStrategy(
+         core.getInput('route-method', {required: true})
+      )
+      await routeBlueGreen(kubectl, inputManifestFiles, routeStrategy)
+      core.endGroup()
+   }
+
    // print ingresses
    core.startGroup('Printing ingresses')
    const ingressResources: Resource[] = getResources(deployedManifestFiles, [
@@ -67,7 +80,7 @@ export async function deploy(
    try {
       allPods = JSON.parse((await kubectl.getAllPods()).stdout)
    } catch (e) {
-      core.debug(`Unable to parse pods: ${e}`)
+      core.debug('Unable to parse pods: ' + e)
    }
    await annotateAndLabelResources(
       deployedManifestFiles,

src/actions/promote.ts

@@ -9,26 +9,26 @@ import {
 import * as models from '../types/kubernetesTypes'
 import * as KubernetesManifestUtility from '../utilities/manifestStabilityUtils'
 import {
-   deleteGreenObjects,
+   BlueGreenManifests,
+   deleteWorkloadsAndServicesWithLabel,
+   deleteWorkloadsWithLabel,
    getManifestObjects,
+   GREEN_LABEL_VALUE,
    NONE_LABEL_VALUE
 } from '../strategyHelpers/blueGreen/blueGreenHelper'
-
-import {BlueGreenManifests} from '../types/blueGreenTypes'
-
+import {
+   promoteBlueGreenService,
+   routeBlueGreenService
+} from '../strategyHelpers/blueGreen/serviceBlueGreenHelper'
 import {
    promoteBlueGreenIngress,
-   promoteBlueGreenService,
-   promoteBlueGreenSMI
-} from '../strategyHelpers/blueGreen/promote'
-
+   routeBlueGreenIngress
+} from '../strategyHelpers/blueGreen/ingressBlueGreenHelper'
 import {
-   routeBlueGreenService,
-   routeBlueGreenIngressUnchanged,
+   cleanupSMI,
+   promoteBlueGreenSMI,
    routeBlueGreenSMI
-} from '../strategyHelpers/blueGreen/route'
-
-import {cleanupSMI} from '../strategyHelpers/blueGreen/smiBlueGreenHelper'
+} from '../strategyHelpers/blueGreen/smiBlueGreenHelper'
 import {Kubectl, Resource} from '../types/kubectl'
 import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {
@@ -40,14 +40,15 @@ import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
 export async function promote(
    kubectl: Kubectl,
    manifests: string[],
-   deploymentStrategy: DeploymentStrategy
+   deploymentStrategy: DeploymentStrategy,
+   annotations: {[key: string]: string} = {}
 ) {
    switch (deploymentStrategy) {
       case DeploymentStrategy.CANARY:
          await promoteCanary(kubectl, manifests)
          break
       case DeploymentStrategy.BLUE_GREEN:
-         await promoteBlueGreen(kubectl, manifests)
+         await promoteBlueGreen(kubectl, manifests, annotations)
          break
       default:
          throw Error('Invalid promote deployment strategy')
@@ -97,13 +98,18 @@ async function promoteCanary(kubectl: Kubectl, manifests: string[]) {
       )
    } catch (ex) {
       core.warning(
-         `Exception occurred while deleting canary and baseline workloads: ${ex}`
+         'Exception occurred while deleting canary and baseline workloads: ' +
+            ex
       )
    }
    core.endGroup()
 }
 
-async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
+async function promoteBlueGreen(
+   kubectl: Kubectl,
+   manifests: string[],
+   annotations: {[key: string]: string} = {}
+) {
    // update container images and pull secrets
    const inputManifestFiles: string[] = updateManifestFiles(manifests)
    const manifestObjects: BlueGreenManifests =
@@ -113,24 +119,20 @@ async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
       core.getInput('route-method', {required: true})
    )
 
-   core.startGroup('Deleting old deployment and making new stable deployment')
-
-   const {deployResult} = await (async () => {
-      switch (routeStrategy) {
-         case RouteStrategy.INGRESS:
-            return await promoteBlueGreenIngress(kubectl, manifestObjects)
-         case RouteStrategy.SMI:
-            return await promoteBlueGreenSMI(kubectl, manifestObjects)
-         default:
-            return await promoteBlueGreenService(kubectl, manifestObjects)
+   core.startGroup('Deleting old deployment and making new one')
+   let result
+   if (routeStrategy == RouteStrategy.INGRESS) {
+      result = await promoteBlueGreenIngress(kubectl, manifestObjects)
+   } else if (routeStrategy == RouteStrategy.SMI) {
+      result = await promoteBlueGreenSMI(kubectl, manifestObjects)
+   } else {
+      result = await promoteBlueGreenService(kubectl, manifestObjects)
    }
-   })()
-
    core.endGroup()
 
    // checking stability of newly created deployments
    core.startGroup('Checking manifest stability')
-   const deployedManifestFiles = deployResult.manifestFiles
+   const deployedManifestFiles = result.newFilePaths
    const resources: Resource[] = getResources(
       deployedManifestFiles,
       models.DEPLOYMENT_TYPES.concat([
@@ -144,26 +146,30 @@ async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
       'Routing to new deployments and deleting old workloads and services'
    )
    if (routeStrategy == RouteStrategy.INGRESS) {
-      await routeBlueGreenIngressUnchanged(
+      await routeBlueGreenIngress(
          kubectl,
+         null,
          manifestObjects.serviceNameMap,
          manifestObjects.ingressEntityList
       )
-
-      await deleteGreenObjects(
+      await deleteWorkloadsAndServicesWithLabel(
          kubectl,
-         [].concat(
+         GREEN_LABEL_VALUE,
          manifestObjects.deploymentEntityList,
          manifestObjects.serviceEntityList
       )
-      )
    } else if (routeStrategy == RouteStrategy.SMI) {
       await routeBlueGreenSMI(
          kubectl,
          NONE_LABEL_VALUE,
-         manifestObjects.serviceEntityList
+         manifestObjects.serviceEntityList,
+         annotations
+      )
+      await deleteWorkloadsWithLabel(
+         kubectl,
+         GREEN_LABEL_VALUE,
+         manifestObjects.deploymentEntityList
       )
-      await deleteGreenObjects(kubectl, manifestObjects.deploymentEntityList)
       await cleanupSMI(kubectl, manifestObjects.serviceEntityList)
    } else {
       await routeBlueGreenService(
@@ -171,7 +177,11 @@ async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
          NONE_LABEL_VALUE,
          manifestObjects.serviceEntityList
       )
-      await deleteGreenObjects(kubectl, manifestObjects.deploymentEntityList)
+      await deleteWorkloadsWithLabel(
+         kubectl,
+         GREEN_LABEL_VALUE,
+         manifestObjects.deploymentEntityList
+      )
    }
    core.endGroup()
 }

src/actions/reject.ts

@@ -2,13 +2,9 @@ import * as core from '@actions/core'
 import * as canaryDeploymentHelper from '../strategyHelpers/canary/canaryHelper'
 import * as SMICanaryDeploymentHelper from '../strategyHelpers/canary/smiCanaryHelper'
 import {Kubectl} from '../types/kubectl'
-import {BlueGreenManifests} from '../types/blueGreenTypes'
-import {
-   rejectBlueGreenIngress,
-   rejectBlueGreenService,
-   rejectBlueGreenSMI
-} from '../strategyHelpers/blueGreen/reject'
-import {getManifestObjects} from '../strategyHelpers/blueGreen/blueGreenHelper'
+import {rejectBlueGreenService} from '../strategyHelpers/blueGreen/serviceBlueGreenHelper'
+import {rejectBlueGreenIngress} from '../strategyHelpers/blueGreen/ingressBlueGreenHelper'
+import {rejectBlueGreenSMI} from '../strategyHelpers/blueGreen/smiBlueGreenHelper'
 import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {
    parseTrafficSplitMethod,
@@ -19,14 +15,15 @@ import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
 export async function reject(
    kubectl: Kubectl,
    manifests: string[],
-   deploymentStrategy: DeploymentStrategy
+   deploymentStrategy: DeploymentStrategy,
+   annotations: {[key: string]: string} = {}
 ) {
    switch (deploymentStrategy) {
       case DeploymentStrategy.CANARY:
          await rejectCanary(kubectl, manifests)
          break
       case DeploymentStrategy.BLUE_GREEN:
-         await rejectBlueGreen(kubectl, manifests)
+         await rejectBlueGreen(kubectl, manifests, annotations)
          break
       default:
          throw 'Invalid delete deployment strategy'
@@ -58,20 +55,22 @@ async function rejectCanary(kubectl: Kubectl, manifests: string[]) {
    core.endGroup()
 }
 
-async function rejectBlueGreen(kubectl: Kubectl, manifests: string[]) {
+async function rejectBlueGreen(
+   kubectl: Kubectl,
+   manifests: string[],
+   annotations: {[key: string]: string} = {}
+) {
+   core.startGroup('Rejecting deployment with blue green strategy')
+
    const routeStrategy = parseRouteStrategy(
       core.getInput('route-method', {required: true})
    )
-   core.startGroup('Rejecting deployment with blue green strategy')
-   core.info(`using routeMethod ${routeStrategy}`)
-   const manifestObjects: BlueGreenManifests = getManifestObjects(manifests)
-
    if (routeStrategy == RouteStrategy.INGRESS) {
-      await rejectBlueGreenIngress(kubectl, manifestObjects)
+      await rejectBlueGreenIngress(kubectl, manifests)
    } else if (routeStrategy == RouteStrategy.SMI) {
-      await rejectBlueGreenSMI(kubectl, manifestObjects)
+      await rejectBlueGreenSMI(kubectl, manifests, annotations)
    } else {
-      await rejectBlueGreenService(kubectl, manifestObjects)
+      await rejectBlueGreenService(kubectl, manifests)
    }
    core.endGroup()
 }

src/inputUtils.ts

@@ -1,16 +0,0 @@
-import * as core from '@actions/core'
-import {parseAnnotations} from './types/annotations'
-
-export const inputAnnotations = parseAnnotations(
-   core.getInput('annotations', {required: false})
-)
-
-export function getBufferTime(): number {
-   const inputBufferTime = parseInt(
-      core.getInput('version-switch-buffer') || '0'
-   )
-   if (inputBufferTime < 0 || inputBufferTime > 300)
-      throw Error('Version switch buffer must be between 0 and 300 (inclusive)')
-
-   return inputBufferTime
-}

src/run.ts

@@ -6,7 +6,7 @@ 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() {
    // verify kubeconfig is set
@@ -19,6 +19,9 @@ export async function run() {
    const action: Action | undefined = parseAction(
       core.getInput('action', {required: true})
    )
+   const annotations = parseAnnotations(
+      core.getInput('annotations', {required: false})
+   )
    const strategy = parseDeploymentStrategy(core.getInput('strategy'))
    const manifestsInput = core.getInput('manifests', {required: true})
    const manifestFilePaths = manifestsInput
@@ -27,35 +30,23 @@ 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) {
       case Action.DEPLOY: {
-         await deploy(kubectl, fullManifestFilePaths, strategy)
+         await deploy(kubectl, fullManifestFilePaths, strategy, annotations)
          break
       }
       case Action.PROMOTE: {
-         await promote(kubectl, fullManifestFilePaths, strategy)
+         await promote(kubectl, fullManifestFilePaths, strategy, annotations)
          break
       }
       case Action.REJECT: {
-         await reject(kubectl, fullManifestFilePaths, strategy)
+         await reject(kubectl, fullManifestFilePaths, strategy, annotations)
          break
       }
       default: {

src/strategyHelpers/blueGreen/blueGreenHelper.test.ts

@@ -1,196 +0,0 @@
-import {
-   deployWithLabel,
-   deleteGreenObjects,
-   fetchResource,
-   getDeploymentMatchLabels,
-   getManifestObjects,
-   getNewBlueGreenObject,
-   GREEN_LABEL_VALUE,
-   isServiceRouted
-} from './blueGreenHelper'
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
-import * as bgHelper from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-import {K8sObject} from '../../types/k8sObject'
-import * as manifestUpdateUtils from '../../utilities/manifestUpdateUtils'
-import {ExecOutput} from '@actions/exec'
-
-jest.mock('../../types/kubectl')
-
-const kubectl = new 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('correctly deletes services and workloads according to label', async () => {
-      jest.spyOn(bgHelper, 'deleteObjects').mockReturnValue({} as Promise<void>)
-
-      const value = await deleteGreenObjects(
-         kubectl,
-         [].concat(
-            testObjects.deploymentEntityList,
-            testObjects.serviceEntityList
-         )
-      )
-
-      expect(value).toHaveLength(2)
-      expect(value).toContainEqual({
-         name: 'nginx-service-green',
-         kind: 'Service'
-      })
-      expect(value).toContainEqual({
-         name: 'nginx-deployment-green',
-         kind: 'Deployment'
-      })
-   })
-
-   test('parses objects correctly from one file (getManifestObjects)', () => {
-      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('parses other kinds of objects (getManifestObjects)', () => {
-      const otherObjectsCollection = getManifestObjects([
-         'test/unit/manifests/anomaly-objects-test.yml'
-      ])
-      expect(
-         otherObjectsCollection.unroutedServiceEntityList[0].metadata.name
-      ).toBe('unrouted-service')
-      expect(otherObjectsCollection.otherObjects[0].metadata.name).toBe(
-         'foobar-rollout'
-      )
-   })
-
-   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 makes labeled workloads', async () => {
-      const cwlResult: BlueGreenDeployment = await deployWithLabel(
-         kubectl,
-         testObjects.deploymentEntityList,
-         GREEN_LABEL_VALUE
-      )
-      expect(cwlResult.deployResult.manifestFiles[0]).toBe('')
-   })
-
-   test('correctly makes new blue green object (getNewBlueGreenObject and addBlueGreenLabelsAndAnnotations)', () => {
-      const modifiedDeployment = getNewBlueGreenObject(
-         testObjects.deploymentEntityList[0],
-         GREEN_LABEL_VALUE
-      )
-
-      expect(modifiedDeployment.metadata.name).toBe('nginx-deployment-green')
-      expect(modifiedDeployment.metadata.labels['k8s.deploy.color']).toBe(
-         'green'
-      )
-
-      const modifiedSvc = getNewBlueGreenObject(
-         testObjects.serviceEntityList[0],
-         GREEN_LABEL_VALUE
-      )
-
-      expect(modifiedSvc.metadata.name).toBe('nginx-service-green')
-      expect(modifiedSvc.metadata.labels['k8s.deploy.color']).toBe('green')
-   })
-
-   test('correctly fetches k8s objects', async () => {
-      const mockExecOutput = {
-         stderr: '',
-         stdout: JSON.stringify(testObjects.deploymentEntityList[0]),
-         exitCode: 0
-      }
-
-      jest
-         .spyOn(kubectl, 'getResource')
-         .mockImplementation(() => Promise.resolve(mockExecOutput))
-      const fetched = await fetchResource(
-         kubectl,
-         'nginx-deployment',
-         'Deployment'
-      )
-      expect(fetched.metadata.name).toBe('nginx-deployment')
-   })
-
-   test('exits when fails to fetch k8s objects', async () => {
-      const mockExecOutput = {
-         stdout: 'this should not matter',
-         exitCode: 0,
-         stderr: 'this is a fake error'
-      } as ExecOutput
-      jest
-         .spyOn(kubectl, 'getResource')
-         .mockImplementation(() => Promise.resolve(mockExecOutput))
-      let fetched = await fetchResource(
-         kubectl,
-         'nginx-deployment',
-         'Deployment'
-      )
-      expect(fetched).toBe(null)
-
-      jest.spyOn(kubectl, 'getResource').mockImplementation()
-      fetched = await fetchResource(kubectl, 'nginx-deployment', 'Deployment')
-      expect(fetched).toBe(null)
-   })
-
-   test('returns null when fetch fails to unset k8s objects', async () => {
-      const mockExecOutput = {
-         stdout: 'this should not matter',
-         exitCode: 0,
-         stderr: 'this is a fake error'
-      } as ExecOutput
-      jest
-         .spyOn(manifestUpdateUtils, 'UnsetClusterSpecificDetails')
-         .mockImplementation(() => {
-            throw new Error('test error')
-         })
-      expect(
-         await fetchResource(kubectl, 'nginx-deployment', 'Deployment')
-      ).toBe(null)
-   })
-
-   test('gets deployment labels', () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = GREEN_LABEL_VALUE
-      const mockPodObject: K8sObject = {
-         kind: 'Pod',
-         metadata: {name: 'testPod', labels: mockLabels},
-         spec: {}
-      }
-      expect(
-         getDeploymentMatchLabels(mockPodObject)[
-            bgHelper.BLUE_GREEN_VERSION_LABEL
-         ]
-      ).toBe(GREEN_LABEL_VALUE)
-      expect(
-         getDeploymentMatchLabels(testObjects.deploymentEntityList[0])['app']
-      ).toBe('nginx')
-   })
-})

src/strategyHelpers/blueGreen/blueGreenHelper.ts

@@ -1,9 +1,6 @@
 import * as core from '@actions/core'
 import * as fs from 'fs'
 import * as yaml from 'js-yaml'
-
-import {DeployResult} from '../../types/deployResult'
-import {K8sObject, K8sDeleteObject} from '../../types/k8sObject'
 import {Kubectl} from '../../types/kubectl'
 import {
    isDeploymentEntity,
@@ -11,18 +8,19 @@ import {
    isServiceEntity,
    KubernetesWorkload
 } from '../../types/kubernetesTypes'
-import {
-   BlueGreenDeployment,
-   BlueGreenManifests
-} from '../../types/blueGreenTypes'
 import * as fileHelper from '../../utilities/fileUtils'
-import {updateSpecLabels} from '../../utilities/manifestSpecLabelUtils'
-import {checkForErrors} from '../../utilities/kubectlUtils'
+import {routeBlueGreenService} from './serviceBlueGreenHelper'
+import {routeBlueGreenIngress} from './ingressBlueGreenHelper'
+import {routeBlueGreenSMI} from './smiBlueGreenHelper'
 import {
    UnsetClusterSpecificDetails,
    updateObjectLabels,
    updateSelectorLabels
 } from '../../utilities/manifestUpdateUtils'
+import {updateSpecLabels} from '../../utilities/manifestSpecLabelUtils'
+import {checkForErrors} from '../../utilities/kubectlUtils'
+import {sleep} from '../../utilities/timeUtils'
+import {RouteStrategy} from '../../types/routeStrategy'
 
 export const GREEN_LABEL_VALUE = 'green'
 export const NONE_LABEL_VALUE = 'None'
@@ -30,46 +28,142 @@ export const BLUE_GREEN_VERSION_LABEL = 'k8s.deploy.color'
 export const GREEN_SUFFIX = '-green'
 export const STABLE_SUFFIX = '-stable'
 
-export async function deleteGreenObjects(
+export interface BlueGreenManifests {
+   serviceEntityList: any[]
+   serviceNameMap: Map<string, string>
+   unroutedServiceEntityList: any[]
+   deploymentEntityList: any[]
+   ingressEntityList: any[]
+   otherObjects: any[]
+}
+
+export async function routeBlueGreen(
    kubectl: Kubectl,
-   toDelete: K8sObject[]
-): Promise<K8sDeleteObject[]> {
-   // const resourcesToDelete: K8sDeleteObject[] = []
-   const resourcesToDelete: K8sDeleteObject[] = toDelete.map((obj) => {
-      return {
-         name: getBlueGreenResourceName(obj.metadata.name, GREEN_SUFFIX),
-         kind: obj.kind
+   inputManifestFiles: string[],
+   routeStrategy: RouteStrategy,
+   annotations: {[key: string]: string} = {}
+) {
+   // sleep for buffer time
+   const bufferTime: number = parseInt(
+      core.getInput('version-switch-buffer') || '0'
+   )
+   if (bufferTime < 0 || bufferTime > 300)
+      throw Error('Version switch buffer must be between 0 and 300 (inclusive)')
+   const startSleepDate = new Date()
+   core.info(
+      `Starting buffer time of ${bufferTime} minute(s) at ${startSleepDate.toISOString()}`
+   )
+   await sleep(bufferTime * 1000 * 60)
+   const endSleepDate = new Date()
+   core.info(
+      `Stopping buffer time of ${bufferTime} minute(s) at ${endSleepDate.toISOString()}`
+   )
+
+   const manifestObjects: BlueGreenManifests =
+      getManifestObjects(inputManifestFiles)
+   core.debug('Manifest objects: ' + JSON.stringify(manifestObjects))
+
+   // route to new deployments
+   if (routeStrategy == RouteStrategy.INGRESS) {
+      await routeBlueGreenIngress(
+         kubectl,
+         GREEN_LABEL_VALUE,
+         manifestObjects.serviceNameMap,
+         manifestObjects.ingressEntityList
+      )
+   } else if (routeStrategy == RouteStrategy.SMI) {
+      await routeBlueGreenSMI(
+         kubectl,
+         GREEN_LABEL_VALUE,
+         manifestObjects.serviceEntityList,
+         annotations
+      )
+   } else {
+      await routeBlueGreenService(
+         kubectl,
+         GREEN_LABEL_VALUE,
+         manifestObjects.serviceEntityList
+      )
+   }
+}
+
+export async function deleteWorkloadsWithLabel(
+   kubectl: Kubectl,
+   deleteLabel: string,
+   deploymentEntityList: any[]
+) {
+   const resourcesToDelete = []
+   deploymentEntityList.forEach((inputObject) => {
+      const name = inputObject.metadata.name
+      const kind = inputObject.kind
+
+      if (deleteLabel === NONE_LABEL_VALUE) {
+         // delete stable deployments
+         const resourceToDelete = {name, kind}
+         resourcesToDelete.push(resourceToDelete)
+      } else {
+         // delete new green deployments
+         const resourceToDelete = {
+            name: getBlueGreenResourceName(name, GREEN_SUFFIX),
+            kind: kind
+         }
+         resourcesToDelete.push(resourceToDelete)
       }
    })
 
-   core.debug(`deleting green objects: ${JSON.stringify(resourcesToDelete)}`)
-
    await deleteObjects(kubectl, resourcesToDelete)
-   return resourcesToDelete
 }
 
-export async function deleteObjects(
+export async function deleteWorkloadsAndServicesWithLabel(
    kubectl: Kubectl,
-   deleteList: K8sDeleteObject[]
+   deleteLabel: string,
+   deploymentEntityList: any[],
+   serviceEntityList: any[]
 ) {
+   // need to delete services and deployments
+   const deletionEntitiesList = deploymentEntityList.concat(serviceEntityList)
+   const resourcesToDelete = []
+
+   deletionEntitiesList.forEach((inputObject) => {
+      const name = inputObject.metadata.name
+      const kind = inputObject.kind
+
+      if (deleteLabel === NONE_LABEL_VALUE) {
+         // delete stable objects
+         const resourceToDelete = {name, kind}
+         resourcesToDelete.push(resourceToDelete)
+      } else {
+         // delete green labels
+         const resourceToDelete = {
+            name: getBlueGreenResourceName(name, GREEN_SUFFIX),
+            kind: kind
+         }
+         resourcesToDelete.push(resourceToDelete)
+      }
+   })
+
+   await deleteObjects(kubectl, resourcesToDelete)
+}
+
+export async function deleteObjects(kubectl: Kubectl, deleteList: any[]) {
    // delete services and deployments
    for (const delObject of deleteList) {
       try {
          const result = await kubectl.delete([delObject.kind, delObject.name])
          checkForErrors([result])
       } catch (ex) {
-         core.debug(`failed to delete object ${delObject.name}: ${ex}`)
+         // Ignore failures of delete if it doesn't exist
       }
    }
 }
 
 // other common functions
 export function getManifestObjects(filePaths: string[]): BlueGreenManifests {
-   const deploymentEntityList: K8sObject[] = []
-   const routedServiceEntityList: K8sObject[] = []
-   const unroutedServiceEntityList: K8sObject[] = []
-   const ingressEntityList: K8sObject[] = []
-   const otherEntitiesList: K8sObject[] = []
+   const deploymentEntityList = []
+   const routedServiceEntityList = []
+   const unroutedServiceEntityList = []
+   const ingressEntityList = []
+   const otherEntitiesList = []
    const serviceNameMap = new Map<string, string>()
 
    filePaths.forEach((filePath: string) => {
@@ -114,10 +208,10 @@ export function isServiceRouted(
    serviceObject: any[],
    deploymentEntityList: any[]
 ): boolean {
+   let shouldBeRouted: boolean = false
    const serviceSelector: any = getServiceSelector(serviceObject)
-
-   return (
-      serviceSelector &&
+   if (serviceSelector) {
+      if (
          deploymentEntityList.some((depObject) => {
             // finding if there is a deployment in the given manifests the service targets
             const matchLabels: any = getDeploymentMatchLabels(depObject)
@@ -126,29 +220,39 @@ export function isServiceRouted(
                isServiceSelectorSubsetOfMatchLabel(serviceSelector, matchLabels)
             )
          })
-   )
+      ) {
+         shouldBeRouted = true
+      }
+   }
+
+   return shouldBeRouted
 }
 
-export async function deployWithLabel(
+export async function createWorkloadsWithLabel(
    kubectl: Kubectl,
    deploymentObjectList: any[],
    nextLabel: string
-): Promise<BlueGreenDeployment> {
-   const newObjectsList = deploymentObjectList.map((inputObject) =>
-      getNewBlueGreenObject(inputObject, nextLabel)
-   )
-
+) {
+   const newObjectsList = []
+   deploymentObjectList.forEach((inputObject) => {
+      // creating deployment with label
+      const newBlueGreenObject = getNewBlueGreenObject(inputObject, nextLabel)
       core.debug(
-      `objects deployed with label are ${JSON.stringify(newObjectsList)}`
+         'New blue-green object is: ' + JSON.stringify(newBlueGreenObject)
       )
-   const deployResult = await deployObjects(kubectl, newObjectsList)
-   return {deployResult, objects: newObjectsList}
+      newObjectsList.push(newBlueGreenObject)
+   })
+
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   const result = await kubectl.apply(manifestFiles)
+
+   return {result: result, newFilePaths: manifestFiles}
 }
 
 export function getNewBlueGreenObject(
    inputObject: any,
    labelValue: string
-): K8sObject {
+): object {
    const newObject = JSON.parse(JSON.stringify(inputObject))
 
    // Updating name only if label is green label is given
@@ -176,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)
    }
@@ -235,14 +339,14 @@ export async function fetchResource(
    kubectl: Kubectl,
    kind: string,
    name: string
-): Promise<K8sObject> {
+) {
    const result = await kubectl.getResource(kind, name)
    if (result == null || !!result.stderr) {
       return null
    }
 
    if (!!result.stdout) {
-      const resource = JSON.parse(result.stdout) as K8sObject
+      const resource = JSON.parse(result.stdout)
 
       try {
          UnsetClusterSpecificDetails(resource)
@@ -254,13 +358,3 @@ export async function fetchResource(
       }
    }
 }
-
-export async function deployObjects(
-   kubectl: Kubectl,
-   objectsList: any[]
-): Promise<DeployResult> {
-   const manifestFiles = fileHelper.writeObjectsToFile(objectsList)
-   const execResult = await kubectl.apply(manifestFiles)
-
-   return {execResult, manifestFiles}
-}

src/strategyHelpers/blueGreen/deploy.test.ts

@@ -1,75 +0,0 @@
-import {getManifestObjects} from './blueGreenHelper'
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
-import {deployBlueGreen, deployBlueGreenIngress} from './deploy'
-import * as routeTester from './route'
-import {Kubectl} from '../../types/kubectl'
-import {RouteStrategy} from '../../types/routeStrategy'
-import * as TSutils from '../../utilities/trafficSplitUtils'
-
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-
-jest.mock('../../types/kubectl')
-
-describe('deploy tests', () => {
-   let testObjects
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      testObjects = getManifestObjects(ingressFilepath)
-   })
-
-   test('correctly determines deploy type and acts accordingly', async () => {
-      const kubectl = new Kubectl('')
-      const mockBgDeployment: BlueGreenDeployment = {
-         deployResult: {
-            execResult: {exitCode: 0, stderr: '', stdout: ''},
-            manifestFiles: []
-         },
-         objects: []
-      }
-
-      jest
-         .spyOn(routeTester, 'routeBlueGreenForDeploy')
-         .mockImplementation(() => Promise.resolve(mockBgDeployment))
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
-
-      const ingressResult = await deployBlueGreen(
-         kubectl,
-         ingressFilepath,
-         RouteStrategy.INGRESS
-      )
-
-      expect(ingressResult.objects.length).toBe(2)
-
-      const result = await deployBlueGreen(
-         kubectl,
-         ingressFilepath,
-         RouteStrategy.SERVICE
-      )
-
-      expect(result.objects.length).toBe(2)
-
-      const smiResult = await deployBlueGreen(
-         kubectl,
-         ingressFilepath,
-         RouteStrategy.SMI
-      )
-
-      expect(smiResult.objects.length).toBe(3)
-   })
-
-   test('correctly deploys blue/green ingress', async () => {
-      const kc = new Kubectl('')
-      const value = await deployBlueGreenIngress(kc, ingressFilepath)
-      const nol = value.objects.map((obj) => {
-         if (obj.kind === 'Service') {
-            expect(obj.metadata.name).toBe('nginx-service-green')
-         }
-         if (obj.kind === 'Deployment') {
-            expect(obj.metadata.name).toBe('nginx-deployment-green')
-         }
-      })
-   })
-})

src/strategyHelpers/blueGreen/deploy.ts

@@ -1,136 +0,0 @@
-import * as core from '@actions/core'
-
-import {Kubectl} from '../../types/kubectl'
-import {
-   BlueGreenDeployment,
-   BlueGreenManifests
-} from '../../types/blueGreenTypes'
-
-import {RouteStrategy} from '../../types/routeStrategy'
-
-import {
-   deployWithLabel,
-   getManifestObjects,
-   GREEN_LABEL_VALUE,
-   deployObjects
-} from './blueGreenHelper'
-import {setupSMI} from './smiBlueGreenHelper'
-
-import {routeBlueGreenForDeploy} from './route'
-
-export async function deployBlueGreen(
-   kubectl: Kubectl,
-   files: string[],
-   routeStrategy: RouteStrategy
-): Promise<BlueGreenDeployment> {
-   const blueGreenDeployment = await (async () => {
-      switch (routeStrategy) {
-         case RouteStrategy.INGRESS:
-            return await deployBlueGreenIngress(kubectl, files)
-         case RouteStrategy.SMI:
-            return await deployBlueGreenSMI(kubectl, files)
-         default:
-            return await deployBlueGreenService(kubectl, files)
-      }
-   })()
-
-   core.startGroup('Routing blue green')
-   await routeBlueGreenForDeploy(kubectl, files, routeStrategy)
-   core.endGroup()
-
-   return blueGreenDeployment
-}
-
-export async function deployBlueGreenSMI(
-   kubectl: Kubectl,
-   filePaths: string[]
-): Promise<BlueGreenDeployment> {
-   // get all kubernetes objects defined in manifest files
-   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
-
-   // create services and other objects
-   const newObjectsList = [].concat(
-      manifestObjects.otherObjects,
-      manifestObjects.serviceEntityList,
-      manifestObjects.ingressEntityList,
-      manifestObjects.unroutedServiceEntityList
-   )
-
-   await deployObjects(kubectl, newObjectsList)
-
-   // make extraservices and trafficsplit
-   await setupSMI(kubectl, manifestObjects.serviceEntityList)
-
-   // create new deloyments
-   const blueGreenDeployment: BlueGreenDeployment = await deployWithLabel(
-      kubectl,
-      manifestObjects.deploymentEntityList,
-      GREEN_LABEL_VALUE
-   )
-   return {
-      deployResult: blueGreenDeployment.deployResult,
-      objects: [].concat(blueGreenDeployment.objects, newObjectsList)
-   }
-}
-
-export async function deployBlueGreenIngress(
-   kubectl: Kubectl,
-   filePaths: string[]
-): Promise<BlueGreenDeployment> {
-   // get all kubernetes objects defined in manifest files
-   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
-
-   // create deployments with green label value
-   const servicesAndDeployments = [].concat(
-      manifestObjects.deploymentEntityList,
-      manifestObjects.serviceEntityList
-   )
-   const workloadDeployment: BlueGreenDeployment = await deployWithLabel(
-      kubectl,
-      servicesAndDeployments,
-      GREEN_LABEL_VALUE
-   )
-
-   const otherObjects = [].concat(
-      manifestObjects.otherObjects,
-      manifestObjects.unroutedServiceEntityList
-   )
-   await deployObjects(kubectl, otherObjects)
-   core.debug(
-      `new objects after processing services and other objects: \n
-         ${JSON.stringify(servicesAndDeployments)}`
-   )
-
-   return {
-      deployResult: workloadDeployment.deployResult,
-      objects: [].concat(workloadDeployment.objects, otherObjects)
-   }
-}
-
-export async function deployBlueGreenService(
-   kubectl: Kubectl,
-   filePaths: string[]
-): Promise<BlueGreenDeployment> {
-   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
-
-   // create deployments with green label value
-   const blueGreenDeployment: BlueGreenDeployment = await deployWithLabel(
-      kubectl,
-      manifestObjects.deploymentEntityList,
-      GREEN_LABEL_VALUE
-   )
-
-   // create other non deployment and non service entities
-   const newObjectsList = [].concat(
-      manifestObjects.otherObjects,
-      manifestObjects.ingressEntityList,
-      manifestObjects.unroutedServiceEntityList
-   )
-
-   await deployObjects(kubectl, newObjectsList)
-   // returning deployment details to check for rollout stability
-   return {
-      deployResult: blueGreenDeployment.deployResult,
-      objects: [].concat(blueGreenDeployment.objects, newObjectsList)
-   }
-}

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.test.ts

@@ -1,123 +0,0 @@
-import {getManifestObjects, GREEN_LABEL_VALUE} from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
-import {
-   getUpdatedBlueGreenIngress,
-   isIngressRouted,
-   validateIngresses
-} from './ingressBlueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-
-const betaFilepath = ['test/unit/manifests/test-ingress.yml']
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-const kubectl = new Kubectl('')
-jest.mock('../../types/kubectl')
-
-describe('ingress blue green helpers', () => {
-   let testObjects
-   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
-      )
-      expect(updatedIng.metadata.name).toBe('nginx-ingress')
-      expect(updatedIng.metadata.labels['k8s.deploy.color']).toBe('green')
-      expect(updatedIng.spec.rules[0].http.paths[0].backend.service.name).toBe(
-         'nginx-service-green'
-      )
-
-      const oldIngObjects = getManifestObjects(betaFilepath)
-      const oldIng = getUpdatedBlueGreenIngress(
-         oldIngObjects.ingressEntityList[0],
-         oldIngObjects.serviceNameMap,
-         GREEN_LABEL_VALUE
-      )
-      expect(updatedIng.metadata.labels['k8s.deploy.color']).toBe('green')
-      expect(updatedIng.spec.rules[0].http.paths[0].backend.service.name).toBe(
-         'nginx-service-green'
-      )
-   })
-
-   test('it should validate ingresses', async () => {
-      // what if nothing gets returned from fetchResource?
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation()
-      let validResponse = await validateIngresses(
-         kubectl,
-         testObjects.ingressEntityList,
-         testObjects.serviceNameMap
-      )
-      expect(validResponse.areValid).toBe(false)
-
-      // test valid ingress
-      let mockIngress = JSON.parse(
-         JSON.stringify(testObjects.ingressEntityList[0])
-      )
-      mockIngress.spec.rules[0].http.paths[0].backend.service.name =
-         'nginx-service-green'
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = GREEN_LABEL_VALUE
-      mockIngress.metadata.labels = mockLabels
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockIngress))
-      validResponse = await validateIngresses(
-         kubectl,
-         testObjects.ingressEntityList,
-         testObjects.serviceNameMap
-      )
-      expect(validResponse.areValid).toBe(true)
-
-      // test invalid labels
-      mockIngress.metadata.labels[bgHelper.BLUE_GREEN_VERSION_LABEL] =
-         bgHelper.NONE_LABEL_VALUE
-      mockIngress.spec.rules[0].http.paths[0].backend.service.name =
-         'nginx-service'
-      validResponse = await validateIngresses(
-         kubectl,
-         testObjects.ingressEntityList,
-         testObjects.serviceNameMap
-      )
-      expect(validResponse.areValid).toBe(false)
-
-      // test missing fields
-      mockIngress = {}
-      validResponse = await validateIngresses(
-         kubectl,
-         testObjects.ingressEntityList,
-         testObjects.serviceNameMap
-      )
-      expect(validResponse.areValid).toBe(false)
-   })
-})

src/strategyHelpers/blueGreen/ingressBlueGreenHelper.ts

@@ -1,37 +1,220 @@
-import * as core from '@actions/core'
-import {K8sIngress} from '../../types/k8sObject'
+import {Kubectl} from '../../types/kubectl'
+import * as fileHelper from '../../utilities/fileUtils'
 import {
    addBlueGreenLabelsAndAnnotations,
    BLUE_GREEN_VERSION_LABEL,
+   BlueGreenManifests,
+   createWorkloadsWithLabel,
+   deleteWorkloadsAndServicesWithLabel,
+   fetchResource,
+   getManifestObjects,
+   getNewBlueGreenObject,
    GREEN_LABEL_VALUE,
-   fetchResource
+   NONE_LABEL_VALUE
 } from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
+import * as core from '@actions/core'
 
-const BACKEND = 'backend'
+const BACKEND = 'BACKEND'
+
+export async function deployBlueGreenIngress(
+   kubectl: Kubectl,
+   filePaths: string[]
+) {
+   // get all kubernetes objects defined in manifest files
+   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
+
+   // create deployments with green label value
+   const result = createWorkloadsWithLabel(
+      kubectl,
+      manifestObjects.deploymentEntityList,
+      GREEN_LABEL_VALUE
+   )
+
+   // create new services and other objects
+   let newObjectsList = []
+   manifestObjects.serviceEntityList.forEach((inputObject) => {
+      const newBlueGreenObject = getNewBlueGreenObject(
+         inputObject,
+         GREEN_LABEL_VALUE
+      )
+      newObjectsList.push(newBlueGreenObject)
+   })
+   newObjectsList = newObjectsList
+      .concat(manifestObjects.otherObjects)
+      .concat(manifestObjects.unroutedServiceEntityList)
+
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   await kubectl.apply(manifestFiles)
+
+   return result
+}
+
+export async function promoteBlueGreenIngress(
+   kubectl: Kubectl,
+   manifestObjects
+) {
+   //checking if anything to promote
+   if (
+      !validateIngressesState(
+         kubectl,
+         manifestObjects.ingressEntityList,
+         manifestObjects.serviceNameMap
+      )
+   ) {
+      throw 'Ingress not in promote state'
+   }
+
+   // create stable deployments with new configuration
+   const result = createWorkloadsWithLabel(
+      kubectl,
+      manifestObjects.deploymentEntityList,
+      NONE_LABEL_VALUE
+   )
+
+   // create stable services with new configuration
+   const newObjectsList = []
+   manifestObjects.serviceEntityList.forEach((inputObject) => {
+      const newBlueGreenObject = getNewBlueGreenObject(
+         inputObject,
+         NONE_LABEL_VALUE
+      )
+      newObjectsList.push(newBlueGreenObject)
+   })
+
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   await kubectl.apply(manifestFiles)
+
+   return result
+}
+
+export async function rejectBlueGreenIngress(
+   kubectl: Kubectl,
+   filePaths: string[]
+) {
+   // get all kubernetes objects defined in manifest files
+   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
+
+   // route ingress to stables services
+   await routeBlueGreenIngress(
+      kubectl,
+      null,
+      manifestObjects.serviceNameMap,
+      manifestObjects.ingressEntityList
+   )
+
+   // delete green services and deployments
+   await deleteWorkloadsAndServicesWithLabel(
+      kubectl,
+      GREEN_LABEL_VALUE,
+      manifestObjects.deploymentEntityList,
+      manifestObjects.serviceEntityList
+   )
+}
+
+export async function routeBlueGreenIngress(
+   kubectl: Kubectl,
+   nextLabel: string,
+   serviceNameMap: Map<string, string>,
+   ingressEntityList: any[]
+) {
+   let newObjectsList = []
+
+   if (!nextLabel) {
+      newObjectsList = ingressEntityList.filter((ingress) =>
+         isIngressRouted(ingress, serviceNameMap)
+      )
+   } else {
+      ingressEntityList.forEach((inputObject) => {
+         if (isIngressRouted(inputObject, serviceNameMap)) {
+            const newBlueGreenIngressObject = getUpdatedBlueGreenIngress(
+               inputObject,
+               serviceNameMap,
+               GREEN_LABEL_VALUE
+            )
+            newObjectsList.push(newBlueGreenIngressObject)
+         } else {
+            newObjectsList.push(inputObject)
+         }
+      })
+   }
+
+   core.debug('New objects: ' + JSON.stringify(newObjectsList))
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   await kubectl.apply(manifestFiles)
+}
+
+export function validateIngressesState(
+   kubectl: Kubectl,
+   ingressEntityList: any[],
+   serviceNameMap: Map<string, string>
+): boolean {
+   let areIngressesTargetingNewServices: boolean = true
+   ingressEntityList.forEach(async (inputObject) => {
+      if (isIngressRouted(inputObject, serviceNameMap)) {
+         //querying existing ingress
+         const existingIngress = await fetchResource(
+            kubectl,
+            inputObject.kind,
+            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
+         }
+      }
+   })
+
+   return areIngressesTargetingNewServices
+}
+
+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) => {
+      if (key === 'serviceName' && serviceNameMap.has(value)) {
+         isIngressRouted = true
+      }
+
+      return value
+   })
+
+   return isIngressRouted
+}
 
 export function getUpdatedBlueGreenIngress(
    inputObject: any,
    serviceNameMap: Map<string, string>,
    type: string
-): K8sIngress {
+): object {
+   if (!type) {
+      return inputObject
+   }
+
    const newObject = JSON.parse(JSON.stringify(inputObject))
    // add green labels and values
    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
@@ -44,77 +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
-}
-
-export 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') &&
-            serviceNameMap.has(value.name))
-      isIngressRouted =
-         isIngressRouted || (key === 'serviceName' && serviceNameMap.has(value))
-
-      return value
-   })
-
-   return isIngressRouted
-}
-
-export async function validateIngresses(
-   kubectl: Kubectl,
-   ingressEntityList: any[],
-   serviceNameMap: Map<string, string>
-): Promise<{areValid: boolean; invalidIngresses: string[]}> {
-   let areValid: boolean = true
-   const invalidIngresses = []
-
-   for (const inputObject of ingressEntityList) {
-      if (isIngressRouted(inputObject, serviceNameMap)) {
-         //querying existing ingress
-         const existingIngress = await fetchResource(
-            kubectl,
-            inputObject.kind,
-            inputObject.metadata.name
-         )
-
-         const isValid =
-            !!existingIngress &&
-            existingIngress?.metadata?.labels[BLUE_GREEN_VERSION_LABEL] ===
-               GREEN_LABEL_VALUE
-         if (!isValid) {
-            core.debug(
-               `Invalid ingress detected (must be in green state): ${JSON.stringify(
-                  inputObject
-               )}`
-            )
-            invalidIngresses.push(inputObject.metadata.name)
-         }
-         // to be valid, ingress should exist and should be green
-         areValid = areValid && isValid
-      }
-   }
-   return {areValid, invalidIngresses}
-}

src/strategyHelpers/blueGreen/promote.test.ts

@@ -1,158 +0,0 @@
-import * as core from '@actions/core'
-import {getManifestObjects} from './blueGreenHelper'
-import {
-   promoteBlueGreenIngress,
-   promoteBlueGreenService,
-   promoteBlueGreenSMI
-} from './promote'
-import {TrafficSplitObject} from '../../types/k8sObject'
-import * as servicesTester from './serviceBlueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import {MAX_VAL, MIN_VAL, TRAFFIC_SPLIT_OBJECT} from './smiBlueGreenHelper'
-import * as smiTester from './smiBlueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
-
-let testObjects
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-jest.mock('../../types/kubectl')
-const kubectl = new Kubectl('')
-
-describe('promote tests', () => {
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      testObjects = getManifestObjects(ingressFilepath)
-   })
-
-   test('promote blue/green ingress', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.GREEN_LABEL_VALUE
-
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
-         Promise.resolve({
-            kind: 'Ingress',
-            spec: {},
-            metadata: {labels: mockLabels, name: 'nginx-ingress-green'}
-         })
-      )
-      const value = await promoteBlueGreenIngress(kubectl, testObjects)
-
-      const objects = value.objects
-      expect(objects).toHaveLength(2)
-
-      for (const obj of objects) {
-         if (obj.kind === 'Service') {
-            expect(obj.metadata.name).toBe('nginx-service')
-         } else if (obj.kind == 'Deployment') {
-            expect(obj.metadata.name).toBe('nginx-deployment')
-         }
-         expect(obj.metadata.labels['k8s.deploy.color']).toBe('None')
-      }
-   })
-
-   test('fail to promote invalid blue/green ingress', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
-         Promise.resolve({
-            kind: 'Ingress',
-            spec: {},
-            metadata: {labels: mockLabels, name: 'nginx-ingress-green'}
-         })
-      )
-
-      await expect(
-         promoteBlueGreenIngress(kubectl, testObjects)
-      ).rejects.toThrowError()
-   })
-
-   test('promote blue/green service', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.GREEN_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
-         Promise.resolve({
-            kind: 'Service',
-            spec: {selector: mockLabels},
-            metadata: {labels: mockLabels, name: 'nginx-service-green'}
-         })
-      )
-
-      let value = await promoteBlueGreenService(kubectl, testObjects)
-
-      expect(value.objects).toHaveLength(1)
-      expect(
-         value.objects[0].metadata.labels[bgHelper.BLUE_GREEN_VERSION_LABEL]
-      ).toBe(bgHelper.NONE_LABEL_VALUE)
-      expect(value.objects[0].metadata.name).toBe('nginx-deployment')
-   })
-
-   test('fail to promote invalid blue/green service', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
-         Promise.resolve({
-            kind: 'Service',
-            spec: {},
-            metadata: {labels: mockLabels, name: 'nginx-ingress-green'}
-         })
-      )
-      jest
-         .spyOn(servicesTester, 'validateServicesState')
-         .mockImplementationOnce(() => Promise.resolve(false))
-
-      await expect(
-         promoteBlueGreenService(kubectl, testObjects)
-      ).rejects.toThrowError()
-   })
-
-   test('promote blue/green SMI', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-
-      const mockTsObject: TrafficSplitObject = {
-         apiVersion: 'v1alpha3',
-         kind: TRAFFIC_SPLIT_OBJECT,
-         metadata: {
-            name: 'nginx-service-trafficsplit',
-            labels: new Map<string, string>(),
-            annotations: new Map<string, string>()
-         },
-         spec: {
-            service: 'nginx-service',
-            backends: [
-               {
-                  service: 'nginx-service-stable',
-                  weight: MIN_VAL
-               },
-               {
-                  service: 'nginx-service-green',
-                  weight: MAX_VAL
-               }
-            ]
-         }
-      }
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockTsObject))
-
-      const deployResult = await promoteBlueGreenSMI(kubectl, testObjects)
-
-      expect(deployResult.objects).toHaveLength(1)
-      expect(deployResult.objects[0].metadata.name).toBe('nginx-deployment')
-      expect(
-         deployResult.objects[0].metadata.labels[
-            bgHelper.BLUE_GREEN_VERSION_LABEL
-         ]
-      ).toBe(bgHelper.NONE_LABEL_VALUE)
-   })
-
-   test('promote blue/green SMI with bad trafficsplit', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[bgHelper.BLUE_GREEN_VERSION_LABEL] = bgHelper.NONE_LABEL_VALUE
-      jest
-         .spyOn(smiTester, 'validateTrafficSplitsState')
-         .mockImplementation(() => Promise.resolve(false))
-
-      expect(promoteBlueGreenSMI(kubectl, testObjects)).rejects.toThrowError()
-   })
-})

src/strategyHelpers/blueGreen/promote.ts

@@ -1,81 +0,0 @@
-import * as core from '@actions/core'
-
-import {Kubectl} from '../../types/kubectl'
-
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
-import {deployWithLabel, NONE_LABEL_VALUE} from './blueGreenHelper'
-
-import {validateIngresses} from './ingressBlueGreenHelper'
-import {validateServicesState} from './serviceBlueGreenHelper'
-import {validateTrafficSplitsState} from './smiBlueGreenHelper'
-
-export async function promoteBlueGreenIngress(
-   kubectl: Kubectl,
-   manifestObjects
-): Promise<BlueGreenDeployment> {
-   //checking if anything to promote
-   const {areValid, invalidIngresses} = await validateIngresses(
-      kubectl,
-      manifestObjects.ingressEntityList,
-      manifestObjects.serviceNameMap
-   )
-   if (!areValid) {
-      throw new Error(
-         `Ingresses are not in promote state: ${invalidIngresses.toString()}`
-      )
-   }
-
-   // create stable deployments with new configuration
-   const result: BlueGreenDeployment = await deployWithLabel(
-      kubectl,
-      [].concat(
-         manifestObjects.deploymentEntityList,
-         manifestObjects.serviceEntityList
-      ),
-      NONE_LABEL_VALUE
-   )
-
-   // create stable services with new configuration
-   return result
-}
-
-export async function promoteBlueGreenService(
-   kubectl: Kubectl,
-   manifestObjects
-): Promise<BlueGreenDeployment> {
-   // checking if services are in the right state ie. targeting green deployments
-   if (
-      !(await validateServicesState(kubectl, manifestObjects.serviceEntityList))
-   ) {
-      throw new Error('Found services not in promote state')
-   }
-
-   // creating stable deployments with new configurations
-   return await deployWithLabel(
-      kubectl,
-      manifestObjects.deploymentEntityList,
-      NONE_LABEL_VALUE
-   )
-}
-
-export async function promoteBlueGreenSMI(
-   kubectl: Kubectl,
-   manifestObjects
-): Promise<BlueGreenDeployment> {
-   // checking if there is something to promote
-   if (
-      !(await validateTrafficSplitsState(
-         kubectl,
-         manifestObjects.serviceEntityList
-      ))
-   ) {
-      throw Error('Not in promote state SMI')
-   }
-
-   // create stable deployments with new configuration
-   return await deployWithLabel(
-      kubectl,
-      manifestObjects.deploymentEntityList,
-      NONE_LABEL_VALUE
-   )
-}

src/strategyHelpers/blueGreen/reject.test.ts

@@ -1,66 +0,0 @@
-import {getManifestObjects} from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import {BlueGreenRejectResult} from '../../types/blueGreenTypes'
-
-import * as TSutils from '../../utilities/trafficSplitUtils'
-import {
-   rejectBlueGreenIngress,
-   rejectBlueGreenService,
-   rejectBlueGreenSMI
-} from './reject'
-
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-const kubectl = new Kubectl('')
-
-jest.mock('../../types/kubectl')
-
-describe('reject tests', () => {
-   let testObjects
-
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      testObjects = getManifestObjects(ingressFilepath)
-   })
-
-   test('reject blue/green ingress', async () => {
-      const value = await rejectBlueGreenIngress(kubectl, testObjects)
-
-      const bgDeployment = value.routeResult
-      const deleteResult = value.deleteResult
-
-      expect(deleteResult).toHaveLength(2)
-      for (const obj of deleteResult) {
-         if (obj.kind == 'Service') {
-            expect(obj.name).toBe('nginx-service-green')
-         }
-         if (obj.kind == 'Deployment') {
-            expect(obj.name).toBe('nginx-deployment-green')
-         }
-      }
-
-      expect(bgDeployment.objects).toHaveLength(1)
-      expect(bgDeployment.objects[0].metadata.name).toBe('nginx-ingress')
-   })
-
-   test('reject blue/green service', async () => {
-      const value = await rejectBlueGreenService(kubectl, testObjects)
-
-      const bgDeployment = value.routeResult
-      const deleteResult = value.deleteResult
-
-      expect(deleteResult).toHaveLength(1)
-      expect(deleteResult[0].name).toBe('nginx-deployment-green')
-
-      expect(bgDeployment.objects).toHaveLength(1)
-      expect(bgDeployment.objects[0].metadata.name).toBe('nginx-service')
-   })
-
-   test('reject blue/green SMI', async () => {
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
-      const rejectResult = await rejectBlueGreenSMI(kubectl, testObjects)
-      expect(rejectResult.deleteResult).toHaveLength(4)
-   })
-})

src/strategyHelpers/blueGreen/reject.ts

@@ -1,81 +0,0 @@
-import {K8sDeleteObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
-import {
-   BlueGreenDeployment,
-   BlueGreenManifests,
-   BlueGreenRejectResult
-} from '../../types/blueGreenTypes'
-import {deleteGreenObjects, NONE_LABEL_VALUE} from './blueGreenHelper'
-import {routeBlueGreenSMI} from './route'
-import {cleanupSMI} from './smiBlueGreenHelper'
-import {routeBlueGreenIngressUnchanged, routeBlueGreenService} from './route'
-
-export async function rejectBlueGreenIngress(
-   kubectl: Kubectl,
-   manifestObjects: BlueGreenManifests
-): Promise<BlueGreenRejectResult> {
-   // get all kubernetes objects defined in manifest files
-   // route ingress to stables services
-   const routeResult = await routeBlueGreenIngressUnchanged(
-      kubectl,
-      manifestObjects.serviceNameMap,
-      manifestObjects.ingressEntityList
-   )
-
-   // delete green services and deployments
-   const deleteResult = await deleteGreenObjects(
-      kubectl,
-      [].concat(
-         manifestObjects.deploymentEntityList,
-         manifestObjects.serviceEntityList
-      )
-   )
-
-   return {routeResult, deleteResult}
-}
-
-export async function rejectBlueGreenService(
-   kubectl: Kubectl,
-   manifestObjects: BlueGreenManifests
-): Promise<BlueGreenRejectResult> {
-   // route to stable objects
-   const routeResult = await routeBlueGreenService(
-      kubectl,
-      NONE_LABEL_VALUE,
-      manifestObjects.serviceEntityList
-   )
-
-   // delete new deployments with green suffix
-   const deleteResult = await deleteGreenObjects(
-      kubectl,
-      manifestObjects.deploymentEntityList
-   )
-
-   return {routeResult, deleteResult}
-}
-
-export async function rejectBlueGreenSMI(
-   kubectl: Kubectl,
-   manifestObjects: BlueGreenManifests
-): Promise<BlueGreenRejectResult> {
-   // route trafficsplit to stable deployments
-   const routeResult = await routeBlueGreenSMI(
-      kubectl,
-      NONE_LABEL_VALUE,
-      manifestObjects.serviceEntityList
-   )
-
-   // delete rejected new bluegreen deployments
-   const deletedObjects = await deleteGreenObjects(
-      kubectl,
-      manifestObjects.deploymentEntityList
-   )
-
-   // delete trafficsplit and extra services
-   const cleanupResult = await cleanupSMI(
-      kubectl,
-      manifestObjects.serviceEntityList
-   )
-
-   return {routeResult, deleteResult: [].concat(deletedObjects, cleanupResult)}
-}

src/strategyHelpers/blueGreen/route.test.ts

@@ -1,119 +0,0 @@
-import * as core from '@actions/core'
-import {K8sIngress, TrafficSplitObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-import * as TSutils from '../../utilities/trafficSplitUtils'
-import {RouteStrategy} from '../../types/routeStrategy'
-import {getBufferTime} from '../../inputUtils'
-import * as inputUtils from '../../inputUtils'
-import {BlueGreenManifests} from '../../types/blueGreenTypes'
-
-import {
-   BLUE_GREEN_VERSION_LABEL,
-   getManifestObjects,
-   GREEN_LABEL_VALUE
-} from './blueGreenHelper'
-import {
-   routeBlueGreenIngress,
-   routeBlueGreenService,
-   routeBlueGreenForDeploy
-} from './route'
-
-jest.mock('../../types/kubectl')
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-const kc = new Kubectl('')
-
-describe('route function tests', () => {
-   let testObjects: BlueGreenManifests
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-
-      testObjects = getManifestObjects(ingressFilepath)
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
-   })
-
-   test('correctly prepares blue/green ingresses for deployment', async () => {
-      const unroutedIngCopy: K8sIngress = JSON.parse(
-         JSON.stringify(testObjects.ingressEntityList[0])
-      )
-      unroutedIngCopy.metadata.name = 'nginx-ingress-unrouted'
-      unroutedIngCopy.spec.rules[0].http.paths[0].backend.service.name =
-         'fake-service'
-      testObjects.ingressEntityList.push(unroutedIngCopy)
-      const value = await routeBlueGreenIngress(
-         kc,
-         testObjects.serviceNameMap,
-         testObjects.ingressEntityList
-      )
-
-      expect(value.objects).toHaveLength(2)
-      expect(value.objects[0].metadata.name).toBe('nginx-ingress')
-      expect(
-         (value.objects[0] as K8sIngress).spec.rules[0].http.paths[0].backend
-            .service.name
-      ).toBe('nginx-service-green')
-
-      expect(value.objects[1].metadata.name).toBe('nginx-ingress-unrouted')
-      // unrouted services shouldn't get their service name changed
-      expect(
-         (value.objects[1] as K8sIngress).spec.rules[0].http.paths[0].backend
-            .service.name
-      ).toBe('fake-service')
-   })
-
-   test('correctly prepares blue/green services for deployment', async () => {
-      const value = await routeBlueGreenService(
-         kc,
-         GREEN_LABEL_VALUE,
-         testObjects.serviceEntityList
-      )
-
-      expect(value.objects).toHaveLength(1)
-      expect(value.objects[0].metadata.name).toBe('nginx-service')
-
-      expect(value.objects[0].metadata.labels[BLUE_GREEN_VERSION_LABEL]).toBe(
-         GREEN_LABEL_VALUE
-      )
-   })
-
-   test('correctly identifies route pattern and acts accordingly', async () => {
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve('v1alpha3'))
-
-      const ingressResult = await routeBlueGreenForDeploy(
-         kc,
-         ingressFilepath,
-         RouteStrategy.INGRESS
-      )
-
-      expect(ingressResult.objects.length).toBe(1)
-      expect(ingressResult.objects[0].metadata.name).toBe('nginx-ingress')
-
-      const serviceResult = await routeBlueGreenForDeploy(
-         kc,
-         ingressFilepath,
-         RouteStrategy.SERVICE
-      )
-
-      expect(serviceResult.objects.length).toBe(1)
-      expect(serviceResult.objects[0].metadata.name).toBe('nginx-service')
-
-      const smiResult = await routeBlueGreenForDeploy(
-         kc,
-         ingressFilepath,
-         RouteStrategy.SMI
-      )
-
-      expect(smiResult.objects).toHaveLength(1)
-      expect(smiResult.objects[0].metadata.name).toBe(
-         'nginx-service-trafficsplit'
-      )
-      expect(
-         (smiResult.objects as TrafficSplitObject[])[0].spec.backends
-      ).toHaveLength(2)
-   })
-})

src/strategyHelpers/blueGreen/route.ts

@@ -1,141 +0,0 @@
-import {sleep} from '../../utilities/timeUtils'
-import {RouteStrategy} from '../../types/routeStrategy'
-import {Kubectl} from '../../types/kubectl'
-import {
-   BlueGreenDeployment,
-   BlueGreenManifests
-} from '../../types/blueGreenTypes'
-import {
-   getManifestObjects,
-   GREEN_LABEL_VALUE,
-   deployObjects
-} from './blueGreenHelper'
-
-import {
-   getUpdatedBlueGreenIngress,
-   isIngressRouted
-} from './ingressBlueGreenHelper'
-import {getUpdatedBlueGreenService} from './serviceBlueGreenHelper'
-import {createTrafficSplitObject} from './smiBlueGreenHelper'
-
-import * as core from '@actions/core'
-import {K8sObject, TrafficSplitObject} from '../../types/k8sObject'
-import {getBufferTime} from '../../inputUtils'
-
-export async function routeBlueGreenForDeploy(
-   kubectl: Kubectl,
-   inputManifestFiles: string[],
-   routeStrategy: RouteStrategy
-): Promise<BlueGreenDeployment> {
-   // sleep for buffer time
-   const bufferTime: number = getBufferTime()
-   const startSleepDate = new Date()
-   core.info(
-      `Starting buffer time of ${bufferTime} minute(s) at ${startSleepDate.toISOString()}`
-   )
-   await sleep(bufferTime * 1000 * 60)
-   const endSleepDate = new Date()
-   core.info(
-      `Stopping buffer time of ${bufferTime} minute(s) at ${endSleepDate.toISOString()}`
-   )
-
-   const manifestObjects: BlueGreenManifests =
-      getManifestObjects(inputManifestFiles)
-
-   // route to new deployments
-   if (routeStrategy == RouteStrategy.INGRESS) {
-      return await routeBlueGreenIngress(
-         kubectl,
-         manifestObjects.serviceNameMap,
-         manifestObjects.ingressEntityList
-      )
-   } else if (routeStrategy == RouteStrategy.SMI) {
-      return await routeBlueGreenSMI(
-         kubectl,
-         GREEN_LABEL_VALUE,
-         manifestObjects.serviceEntityList
-      )
-   } else {
-      return await routeBlueGreenService(
-         kubectl,
-         GREEN_LABEL_VALUE,
-         manifestObjects.serviceEntityList
-      )
-   }
-}
-
-export async function routeBlueGreenIngress(
-   kubectl: Kubectl,
-   serviceNameMap: Map<string, string>,
-   ingressEntityList: any[]
-): Promise<BlueGreenDeployment> {
-   // const newObjectsList = []
-   const newObjectsList: K8sObject[] = ingressEntityList.map((obj) => {
-      if (isIngressRouted(obj, serviceNameMap)) {
-         const newBlueGreenIngressObject = getUpdatedBlueGreenIngress(
-            obj,
-            serviceNameMap,
-            GREEN_LABEL_VALUE
-         )
-         return newBlueGreenIngressObject
-      } else {
-         core.debug(`unrouted ingress detected ${obj.metadata.name}`)
-         return obj
-      }
-   })
-
-   const deployResult = await deployObjects(kubectl, newObjectsList)
-
-   return {deployResult, objects: newObjectsList}
-}
-
-export async function routeBlueGreenIngressUnchanged(
-   kubectl: Kubectl,
-   serviceNameMap: Map<string, string>,
-   ingressEntityList: any[]
-): Promise<BlueGreenDeployment> {
-   const objects = ingressEntityList.filter((ingress) =>
-      isIngressRouted(ingress, serviceNameMap)
-   )
-
-   const deployResult = await deployObjects(kubectl, objects)
-   return {deployResult, objects}
-}
-
-export async function routeBlueGreenService(
-   kubectl: Kubectl,
-   nextLabel: string,
-   serviceEntityList: any[]
-): Promise<BlueGreenDeployment> {
-   const objects = serviceEntityList.map((serviceObject) =>
-      getUpdatedBlueGreenService(serviceObject, nextLabel)
-   )
-
-   const deployResult = await deployObjects(kubectl, objects)
-
-   return {deployResult, objects}
-}
-
-export async function routeBlueGreenSMI(
-   kubectl: Kubectl,
-   nextLabel: string,
-   serviceEntityList: any[]
-): Promise<BlueGreenDeployment> {
-   // let tsObjects: TrafficSplitObject[] = []
-
-   const tsObjects: TrafficSplitObject[] = await Promise.all(
-      serviceEntityList.map(async (serviceObject) => {
-         const tsObject: TrafficSplitObject = await createTrafficSplitObject(
-            kubectl,
-            serviceObject.metadata.name,
-            nextLabel
-         )
-
-         return tsObject
-      })
-   )
-
-   const deployResult = await deployObjects(kubectl, tsObjects)
-
-   return {deployResult, objects: tsObjects}
-}

src/strategyHelpers/blueGreen/serviceBlueGreenHelper.test.ts

@@ -1,65 +0,0 @@
-import * as core from '@actions/core'
-import {
-   BLUE_GREEN_VERSION_LABEL,
-   getManifestObjects,
-   GREEN_LABEL_VALUE
-} from './blueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
-import {Kubectl} from '../../types/kubectl'
-import {
-   getServiceSpecLabel,
-   getUpdatedBlueGreenService,
-   validateServicesState
-} from './serviceBlueGreenHelper'
-
-let testObjects
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-jest.mock('../../types/kubectl')
-const kubectl = new Kubectl('')
-
-describe('blue/green service helper tests', () => {
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-      testObjects = getManifestObjects(ingressFilepath)
-   })
-
-   test('getUpdatedBlueGreenService', () => {
-      const newService = getUpdatedBlueGreenService(
-         testObjects.serviceEntityList[0],
-         GREEN_LABEL_VALUE
-      )
-      expect(newService.metadata.labels[BLUE_GREEN_VERSION_LABEL]).toBe(
-         GREEN_LABEL_VALUE
-      )
-      expect(newService.spec.selector[BLUE_GREEN_VERSION_LABEL]).toBe(
-         GREEN_LABEL_VALUE
-      )
-   })
-
-   test('validateServicesState', async () => {
-      const mockLabels = new Map<string, string>()
-      mockLabels[BLUE_GREEN_VERSION_LABEL] = bgHelper.GREEN_LABEL_VALUE
-      const mockSelectors = new Map<string, string>()
-      mockSelectors[BLUE_GREEN_VERSION_LABEL] = GREEN_LABEL_VALUE
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation(() =>
-         Promise.resolve({
-            kind: 'Service',
-            spec: {selector: mockSelectors},
-            metadata: {labels: mockLabels, name: 'nginx-service-green'}
-         })
-      )
-      expect(
-         await validateServicesState(kubectl, testObjects.serviceEntityList)
-      ).toBe(true)
-   })
-
-   test('getServiceSpecLabel', () => {
-      testObjects.serviceEntityList[0].spec.selector[BLUE_GREEN_VERSION_LABEL] =
-         GREEN_LABEL_VALUE
-
-      expect(getServiceSpecLabel(testObjects.serviceEntityList[0])).toBe(
-         GREEN_LABEL_VALUE
-      )
-   })
-})

src/strategyHelpers/blueGreen/serviceBlueGreenHelper.ts

@@ -1,18 +1,106 @@
-import * as core from '@actions/core'
-import {K8sServiceObject} from '../../types/k8sObject'
 import {Kubectl} from '../../types/kubectl'
+import * as fileHelper from '../../utilities/fileUtils'
 import {
    addBlueGreenLabelsAndAnnotations,
    BLUE_GREEN_VERSION_LABEL,
+   BlueGreenManifests,
+   createWorkloadsWithLabel,
+   deleteWorkloadsWithLabel,
    fetchResource,
-   GREEN_LABEL_VALUE
+   getManifestObjects,
+   GREEN_LABEL_VALUE,
+   NONE_LABEL_VALUE
 } from './blueGreenHelper'
 
+export async function deployBlueGreenService(
+   kubectl: Kubectl,
+   filePaths: string[]
+) {
+   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
+
+   // create deployments with green label value
+   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 result
+}
+
+export async function promoteBlueGreenService(
+   kubectl: Kubectl,
+   manifestObjects
+) {
+   // checking if services are in the right state ie. targeting green deployments
+   if (
+      !(await validateServicesState(kubectl, manifestObjects.serviceEntityList))
+   ) {
+      throw 'Not inP promote state'
+   }
+
+   // creating stable deployments with new configurations
+   return await createWorkloadsWithLabel(
+      kubectl,
+      manifestObjects.deploymentEntityList,
+      NONE_LABEL_VALUE
+   )
+}
+
+export async function rejectBlueGreenService(
+   kubectl: Kubectl,
+   filePaths: string[]
+) {
+   // get all kubernetes objects defined in manifest files
+   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
+
+   // route to stable objects
+   await routeBlueGreenService(
+      kubectl,
+      NONE_LABEL_VALUE,
+      manifestObjects.serviceEntityList
+   )
+
+   // delete new deployments with green suffix
+   await deleteWorkloadsWithLabel(
+      kubectl,
+      GREEN_LABEL_VALUE,
+      manifestObjects.deploymentEntityList
+   )
+}
+
+export async function routeBlueGreenService(
+   kubectl: Kubectl,
+   nextLabel: string,
+   serviceEntityList: any[]
+) {
+   const newObjectsList = []
+   serviceEntityList.forEach((serviceObject) => {
+      const newBlueGreenServiceObject = getUpdatedBlueGreenService(
+         serviceObject,
+         nextLabel
+      )
+      newObjectsList.push(newBlueGreenServiceObject)
+   })
+
+   // configures the services
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   await kubectl.apply(manifestFiles)
+}
+
 // add green labels to configure existing service
-export function getUpdatedBlueGreenService(
+function getUpdatedBlueGreenService(
    inputObject: any,
    labelValue: string
-): K8sServiceObject {
+): object {
    const newObject = JSON.parse(JSON.stringify(inputObject))
 
    // Adding labels and annotations.
@@ -34,16 +122,25 @@ export async function validateServicesState(
          serviceObject.metadata.name
       )
 
-      let isServiceGreen =
-         !!existingService &&
-         getServiceSpecLabel(existingService as K8sServiceObject) ==
-            GREEN_LABEL_VALUE
-      areServicesGreen = areServicesGreen && isServiceGreen
+      if (!!existingService) {
+         const currentLabel: string = getServiceSpecLabel(existingService)
+         if (currentLabel != GREEN_LABEL_VALUE) {
+            // service should be targeting deployments with green label
+            areServicesGreen = false
+         }
+      } else {
+         // service targeting deployment doesn't exist
+         areServicesGreen = false
+      }
    }
 
    return areServicesGreen
 }
 
-export function getServiceSpecLabel(inputObject: K8sServiceObject): string {
+export function getServiceSpecLabel(inputObject: any): string {
+   if (inputObject?.spec?.selector[BLUE_GREEN_VERSION_LABEL]) {
       return inputObject.spec.selector[BLUE_GREEN_VERSION_LABEL]
+   }
+
+   return ''
 }

src/strategyHelpers/blueGreen/smiBlueGreenHelper.test.ts

@@ -1,203 +0,0 @@
-import * as core from '@actions/core'
-import {TrafficSplitObject} from '../../types/k8sObject'
-import {Kubectl} from '../../types/kubectl'
-import * as fileHelper from '../../utilities/fileUtils'
-import * as TSutils from '../../utilities/trafficSplitUtils'
-
-import {BlueGreenManifests} from '../../types/blueGreenTypes'
-import {
-   BLUE_GREEN_VERSION_LABEL,
-   getManifestObjects,
-   GREEN_LABEL_VALUE,
-   NONE_LABEL_VALUE
-} from './blueGreenHelper'
-
-import {
-   cleanupSMI,
-   createTrafficSplitObject,
-   getGreenSMIServiceResource,
-   getStableSMIServiceResource,
-   MAX_VAL,
-   MIN_VAL,
-   setupSMI,
-   TRAFFIC_SPLIT_OBJECT,
-   TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX,
-   validateTrafficSplitsState
-} from './smiBlueGreenHelper'
-import * as bgHelper from './blueGreenHelper'
-
-jest.mock('../../types/kubectl')
-
-const kc = new Kubectl('')
-const ingressFilepath = ['test/unit/manifests/test-ingress-new.yml']
-const mockTsObject: TrafficSplitObject = {
-   apiVersion: 'v1alpha3',
-   kind: TRAFFIC_SPLIT_OBJECT,
-   metadata: {
-      name: 'nginx-service-trafficsplit',
-      labels: new Map<string, string>(),
-      annotations: new Map<string, string>()
-   },
-   spec: {
-      service: 'nginx-service',
-      backends: [
-         {
-            service: 'nginx-service-stable',
-            weight: MIN_VAL
-         },
-         {
-            service: 'nginx-service-green',
-            weight: MAX_VAL
-         }
-      ]
-   }
-}
-
-describe('SMI Helper tests', () => {
-   let testObjects: BlueGreenManifests
-   beforeEach(() => {
-      //@ts-ignore
-      Kubectl.mockClear()
-
-      jest
-         .spyOn(TSutils, 'getTrafficSplitAPIVersion')
-         .mockImplementation(() => Promise.resolve(''))
-
-      testObjects = getManifestObjects(ingressFilepath)
-      jest
-         .spyOn(fileHelper, 'writeObjectsToFile')
-         .mockImplementationOnce(() => [''])
-   })
-
-   test('setupSMI tests', async () => {
-      const smiResults = await setupSMI(kc, testObjects.serviceEntityList)
-
-      let found = 0
-      for (const obj of smiResults.objects) {
-         if (obj.metadata.name === 'nginx-service-stable') {
-            expect(obj.metadata.labels[BLUE_GREEN_VERSION_LABEL]).toBe(
-               NONE_LABEL_VALUE
-            )
-            expect(obj.spec.selector.app).toBe('nginx')
-            found++
-         }
-
-         if (obj.metadata.name === 'nginx-service-green') {
-            expect(obj.metadata.labels[BLUE_GREEN_VERSION_LABEL]).toBe(
-               GREEN_LABEL_VALUE
-            )
-            found++
-         }
-
-         if (obj.metadata.name === 'nginx-service-trafficsplit') {
-            found++
-            // expect stable weight to be max val
-            const casted = obj as TrafficSplitObject
-            expect(casted.spec.backends).toHaveLength(2)
-            for (const be of casted.spec.backends) {
-               if (be.service === 'nginx-service-stable') {
-                  expect(be.weight).toBe(MAX_VAL)
-               }
-               if (be.service === 'nginx-service-green') {
-                  expect(be.weight).toBe(MIN_VAL)
-               }
-            }
-         }
-      }
-
-      expect(found).toBe(3)
-   })
-
-   test('createTrafficSplitObject tests', async () => {
-      const noneTsObject: TrafficSplitObject = await createTrafficSplitObject(
-         kc,
-         testObjects.serviceEntityList[0].metadata.name,
-         NONE_LABEL_VALUE
-      )
-      expect(noneTsObject.metadata.name).toBe('nginx-service-trafficsplit')
-      for (let be of noneTsObject.spec.backends) {
-         if (be.service === 'nginx-service-stable') {
-            expect(be.weight).toBe(MAX_VAL)
-         }
-         if (be.service === 'nginx-service-green') {
-            expect(be.weight).toBe(MIN_VAL)
-         }
-      }
-
-      const greenTsObject: TrafficSplitObject = await createTrafficSplitObject(
-         kc,
-         testObjects.serviceEntityList[0].metadata.name,
-         GREEN_LABEL_VALUE
-      )
-      expect(greenTsObject.metadata.name).toBe('nginx-service-trafficsplit')
-      for (const be of greenTsObject.spec.backends) {
-         if (be.service === 'nginx-service-stable') {
-            expect(be.weight).toBe(MIN_VAL)
-         }
-         if (be.service === 'nginx-service-green') {
-            expect(be.weight).toBe(MAX_VAL)
-         }
-      }
-   })
-
-   test('getSMIServiceResource test', () => {
-      const stableResult = getStableSMIServiceResource(
-         testObjects.serviceEntityList[0]
-      )
-      const greenResult = getGreenSMIServiceResource(
-         testObjects.serviceEntityList[0]
-      )
-
-      expect(stableResult.metadata.name).toBe('nginx-service-stable')
-      expect(stableResult.metadata.labels[BLUE_GREEN_VERSION_LABEL]).toBe(
-         NONE_LABEL_VALUE
-      )
-
-      expect(greenResult.metadata.name).toBe('nginx-service-green')
-      expect(greenResult.metadata.labels[BLUE_GREEN_VERSION_LABEL]).toBe(
-         GREEN_LABEL_VALUE
-      )
-   })
-
-   test('validateTrafficSplitsState', async () => {
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockTsObject))
-
-      let valResult = await validateTrafficSplitsState(
-         kc,
-         testObjects.serviceEntityList
-      )
-
-      expect(valResult).toBe(true)
-
-      const mockTsCopy = JSON.parse(JSON.stringify(mockTsObject))
-      mockTsCopy.spec.backends[0].weight = MAX_VAL
-      jest
-         .spyOn(bgHelper, 'fetchResource')
-         .mockImplementation(() => Promise.resolve(mockTsCopy))
-
-      valResult = await validateTrafficSplitsState(
-         kc,
-         testObjects.serviceEntityList
-      )
-      expect(valResult).toBe(false)
-
-      jest.spyOn(bgHelper, 'fetchResource').mockImplementation()
-      valResult = await validateTrafficSplitsState(
-         kc,
-         testObjects.serviceEntityList
-      )
-      expect(valResult).toBe(false)
-   })
-
-   test('cleanupSMI test', async () => {
-      const deleteObjects = await cleanupSMI(kc, testObjects.serviceEntityList)
-      expect(deleteObjects).toHaveLength(3)
-      expect(deleteObjects[0].name).toBe('nginx-service-trafficsplit')
-      expect(deleteObjects[1].name).toBe('nginx-service-green')
-      expect(deleteObjects[1].kind).toBe('Service')
-      expect(deleteObjects[2].name).toBe('nginx-service-stable')
-      expect(deleteObjects[2].kind).toBe('Service')
-   })
-})

src/strategyHelpers/blueGreen/smiBlueGreenHelper.ts

@@ -1,35 +1,104 @@
-import * as core from '@actions/core'
 import {Kubectl} from '../../types/kubectl'
 import * as kubectlUtils from '../../utilities/trafficSplitUtils'
+import * as fileHelper from '../../utilities/fileUtils'
 import {
+   BlueGreenManifests,
+   createWorkloadsWithLabel,
    deleteObjects,
-   deployObjects,
+   deleteWorkloadsWithLabel,
    fetchResource,
    getBlueGreenResourceName,
+   getManifestObjects,
    getNewBlueGreenObject,
    GREEN_LABEL_VALUE,
    GREEN_SUFFIX,
    NONE_LABEL_VALUE,
    STABLE_SUFFIX
 } from './blueGreenHelper'
-import {BlueGreenDeployment} from '../../types/blueGreenTypes'
-import {
-   K8sDeleteObject,
-   K8sObject,
-   TrafficSplitObject
-} from '../../types/k8sObject'
-import {DeployResult} from '../../types/deployResult'
-import {inputAnnotations} from '../../inputUtils'
 
-export const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-trafficsplit'
-export const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit'
-export const MIN_VAL = 0
-export const MAX_VAL = 100
+const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-trafficsplit'
+const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit'
+const MIN_VAL = 0
+const MAX_VAL = 100
+
+export async function deployBlueGreenSMI(
+   kubectl: Kubectl,
+   filePaths: string[],
+   annotations: {[key: string]: string} = {}
+) {
+   // get all kubernetes objects defined in manifest files
+   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
+
+   // create services and other objects
+   const newObjectsList = manifestObjects.otherObjects
+      .concat(manifestObjects.serviceEntityList)
+      .concat(manifestObjects.ingressEntityList)
+      .concat(manifestObjects.unroutedServiceEntityList)
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   await kubectl.apply(manifestFiles)
+
+   // make extraservices and trafficsplit
+   await setupSMI(kubectl, manifestObjects.serviceEntityList, annotations)
+
+   // create new deloyments
+   return await createWorkloadsWithLabel(
+      kubectl,
+      manifestObjects.deploymentEntityList,
+      GREEN_LABEL_VALUE
+   )
+}
+
+export async function promoteBlueGreenSMI(kubectl: Kubectl, manifestObjects) {
+   // checking if there is something to promote
+   if (
+      !(await validateTrafficSplitsState(
+         kubectl,
+         manifestObjects.serviceEntityList
+      ))
+   ) {
+      throw Error('Not in promote state SMI')
+   }
+
+   // create stable deployments with new configuration
+   return await createWorkloadsWithLabel(
+      kubectl,
+      manifestObjects.deploymentEntityList,
+      NONE_LABEL_VALUE
+   )
+}
+
+export async function rejectBlueGreenSMI(
+   kubectl: Kubectl,
+   filePaths: string[],
+   annotations: {[key: string]: string} = {}
+) {
+   // get all kubernetes objects defined in manifest files
+   const manifestObjects: BlueGreenManifests = getManifestObjects(filePaths)
+
+   // route trafficsplit to stable deployments
+   await routeBlueGreenSMI(
+      kubectl,
+      NONE_LABEL_VALUE,
+      manifestObjects.serviceEntityList,
+      annotations
+   )
+
+   // delete rejected new bluegreen deployments
+   await deleteWorkloadsWithLabel(
+      kubectl,
+      GREEN_LABEL_VALUE,
+      manifestObjects.deploymentEntityList
+   )
+
+   // delete trafficsplit and extra services
+   await cleanupSMI(kubectl, manifestObjects.serviceEntityList)
+}
 
 export async function setupSMI(
    kubectl: Kubectl,
-   serviceEntityList: any[]
-): Promise<BlueGreenDeployment> {
+   serviceEntityList: any[],
+   annotations: {[key: string]: string} = {}
+) {
    const newObjectsList = []
    const trafficObjectList = []
 
@@ -37,66 +106,56 @@ export async function setupSMI(
       // create a trafficsplit for service
       trafficObjectList.push(serviceObject)
       // set up the services for trafficsplit
-      const newStableService = getStableSMIServiceResource(serviceObject)
-      const newGreenService = getGreenSMIServiceResource(serviceObject)
+      const newStableService = getSMIServiceResource(
+         serviceObject,
+         STABLE_SUFFIX
+      )
+      const newGreenService = getSMIServiceResource(serviceObject, GREEN_SUFFIX)
       newObjectsList.push(newStableService)
       newObjectsList.push(newGreenService)
    })
 
-   const tsObjects: TrafficSplitObject[] = []
-   // route to stable service
-   for (const svc of trafficObjectList) {
-      const tsObject = await createTrafficSplitObject(
-         kubectl,
-         svc.metadata.name,
-         NONE_LABEL_VALUE
-      )
-      tsObjects.push(tsObject as TrafficSplitObject)
-   }
-
-   const objectsToDeploy = [].concat(newObjectsList, tsObjects)
-
    // create services
-   const smiDeploymentResult: DeployResult = await deployObjects(
-      kubectl,
-      objectsToDeploy
-   )
+   const manifestFiles = fileHelper.writeObjectsToFile(newObjectsList)
+   await kubectl.apply(manifestFiles)
 
-   return {
-      objects: objectsToDeploy,
-      deployResult: smiDeploymentResult
-   }
+   // route to stable service
+   trafficObjectList.forEach((inputObject) => {
+      createTrafficSplitObject(
+         kubectl,
+         inputObject.metadata.name,
+         NONE_LABEL_VALUE,
+         annotations
+      )
+   })
 }
 
 let trafficSplitAPIVersion = ''
 
-export async function createTrafficSplitObject(
+async function createTrafficSplitObject(
    kubectl: Kubectl,
    name: string,
-   nextLabel: string
-): Promise<TrafficSplitObject> {
+   nextLabel: string,
+   annotations: {[key: string]: string} = {}
+): Promise<any> {
    // cache traffic split api version
    if (!trafficSplitAPIVersion)
       trafficSplitAPIVersion = await kubectlUtils.getTrafficSplitAPIVersion(
          kubectl
       )
 
-   // retrieve annotations for TS object
-   const annotations = inputAnnotations
-
    // decide weights based on nextlabel
    const stableWeight: number =
       nextLabel === GREEN_LABEL_VALUE ? MIN_VAL : MAX_VAL
    const greenWeight: number =
       nextLabel === GREEN_LABEL_VALUE ? MAX_VAL : MIN_VAL
 
-   const trafficSplitObject: TrafficSplitObject = {
+   const trafficSplitObject = JSON.stringify({
       apiVersion: trafficSplitAPIVersion,
-      kind: TRAFFIC_SPLIT_OBJECT,
+      kind: 'TrafficSplit',
       metadata: {
          name: getBlueGreenResourceName(name, TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX),
-         annotations: annotations,
-         labels: new Map<string, string>()
+         annotations: annotations
       },
       spec: {
          service: name,
@@ -111,24 +170,52 @@ export async function createTrafficSplitObject(
             }
          ]
       }
-   }
+   })
 
-   return trafficSplitObject
+   // create traffic split object
+   const trafficSplitManifestFile = fileHelper.writeManifestToFile(
+      trafficSplitObject,
+      TRAFFIC_SPLIT_OBJECT,
+      getBlueGreenResourceName(name, TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX)
+   )
+
+   await kubectl.apply(trafficSplitManifestFile)
 }
 
-export function getStableSMIServiceResource(inputObject: K8sObject): K8sObject {
+export function getSMIServiceResource(
+   inputObject: any,
+   suffix: string
+): object {
    const newObject = JSON.parse(JSON.stringify(inputObject))
+
+   if (suffix === STABLE_SUFFIX) {
       // adding stable suffix to service name
       newObject.metadata.name = getBlueGreenResourceName(
          inputObject.metadata.name,
          STABLE_SUFFIX
       )
       return getNewBlueGreenObject(newObject, NONE_LABEL_VALUE)
+   } else {
+      // green label will be added for these
+      return getNewBlueGreenObject(newObject, GREEN_LABEL_VALUE)
+   }
 }
 
-export function getGreenSMIServiceResource(inputObject: K8sObject): K8sObject {
-   const newObject = JSON.parse(JSON.stringify(inputObject))
-   return getNewBlueGreenObject(newObject, GREEN_LABEL_VALUE)
+export async function routeBlueGreenSMI(
+   kubectl: Kubectl,
+   nextLabel: string,
+   serviceEntityList: any[],
+   annotations: {[key: string]: string} = {}
+) {
+   for (const serviceObject of serviceEntityList) {
+      // route trafficsplit to given label
+      await createTrafficSplitObject(
+         kubectl,
+         serviceObject.metadata.name,
+         nextLabel,
+         annotations
+      )
+   }
 }
 
 export async function validateTrafficSplitsState(
@@ -144,38 +231,32 @@ export async function validateTrafficSplitsState(
          TRAFFIC_SPLIT_OBJECT,
          getBlueGreenResourceName(name, TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX)
       )
-      core.debug(
-         `ts object extracted was ${JSON.stringify(trafficSplitObject)}`
-      )
+
       if (!trafficSplitObject) {
-         core.debug(`no traffic split exits for ${name}`)
+         // no traffic split exits
          trafficSplitsInRightState = false
-         continue
       }
 
+      trafficSplitObject = JSON.parse(JSON.stringify(trafficSplitObject))
       trafficSplitObject.spec.backends.forEach((element) => {
          // checking if trafficsplit in right state to deploy
          if (element.service === getBlueGreenResourceName(name, GREEN_SUFFIX)) {
-            trafficSplitsInRightState =
-               trafficSplitsInRightState && element.weight == MAX_VAL
+            if (element.weight != MAX_VAL) trafficSplitsInRightState = false
          }
 
          if (
             element.service === getBlueGreenResourceName(name, STABLE_SUFFIX)
          ) {
-            trafficSplitsInRightState =
-               trafficSplitsInRightState && element.weight == MIN_VAL
+            if (element.weight != MIN_VAL) trafficSplitsInRightState = false
          }
       })
    }
+
    return trafficSplitsInRightState
 }
 
-export async function cleanupSMI(
-   kubectl: Kubectl,
-   serviceEntityList: any[]
-): Promise<K8sDeleteObject[]> {
-   const deleteList: K8sDeleteObject[] = []
+export async function cleanupSMI(kubectl: Kubectl, serviceEntityList: any[]) {
+   const deleteList = []
 
    serviceEntityList.forEach((serviceObject) => {
       deleteList.push({
@@ -205,6 +286,4 @@ export async function cleanupSMI(
 
    // delete all objects
    await deleteObjects(kubectl, deleteList)
-
-   return deleteList
 }

src/strategyHelpers/canary/smiCanaryHelper.ts

@@ -8,7 +8,6 @@ import * as kubectlUtils from '../../utilities/trafficSplitUtils'
 import * as canaryDeploymentHelper from './canaryHelper'
 import {isDeploymentEntity, isServiceEntity} from '../../types/kubernetesTypes'
 import {checkForErrors} from '../../utilities/kubectlUtils'
-import {inputAnnotations} from '../../inputUtils'
 
 const TRAFFIC_SPLIT_OBJECT_NAME_SUFFIX = '-workflow-rollout'
 const TRAFFIC_SPLIT_OBJECT = 'TrafficSplit'
@@ -289,7 +288,8 @@ async function getTrafficSplitObject(
    name: string,
    stableWeight: number,
    baselineWeight: number,
-   canaryWeight: number
+   canaryWeight: number,
+   annotations: {[key: string]: string} = {}
 ): Promise<string> {
    // cached version
    if (!trafficSplitAPIVersion) {
@@ -303,7 +303,7 @@ async function getTrafficSplitObject(
       kind: 'TrafficSplit',
       metadata: {
          name: getTrafficSplitResourceName(name),
-         annotations: inputAnnotations
+         annotations: annotations
       },
       spec: {
          backends: [

src/strategyHelpers/deploymentHelper.ts

@@ -10,19 +10,16 @@ import {Kubectl, Resource} from '../types/kubectl'
 import {deployPodCanary} from './canary/podCanaryHelper'
 import {deploySMICanary} from './canary/smiCanaryHelper'
 import {DeploymentConfig} from '../types/deploymentConfig'
-import {
-   deployBlueGreen,
-   deployBlueGreenIngress,
-   deployBlueGreenService
-} from './blueGreen/deploy'
-import {deployBlueGreenSMI} from './blueGreen/deploy'
+import {deployBlueGreenService} from './blueGreen/serviceBlueGreenHelper'
+import {deployBlueGreenIngress} from './blueGreen/ingressBlueGreenHelper'
+import {deployBlueGreenSMI} from './blueGreen/smiBlueGreenHelper'
 import {DeploymentStrategy} from '../types/deploymentStrategy'
 import * as core from '@actions/core'
 import {
    parseTrafficSplitMethod,
    TrafficSplitMethod
 } from '../types/trafficSplitMethod'
-import {parseRouteStrategy} from '../types/routeStrategy'
+import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
 import {ExecOutput} from '@actions/exec'
 import {
    getWorkflowAnnotationKeyLabel,
@@ -44,7 +41,8 @@ export async function deployManifests(
    files: string[],
    deploymentStrategy: DeploymentStrategy,
    kubectl: Kubectl,
-   trafficSplitMethod: TrafficSplitMethod
+   trafficSplitMethod: TrafficSplitMethod,
+   annotations: {[key: string]: string} = {}
 ): Promise<string[]> {
    switch (deploymentStrategy) {
       case DeploymentStrategy.CANARY: {
@@ -61,19 +59,17 @@ export async function deployManifests(
          const routeStrategy = parseRouteStrategy(
             core.getInput('route-method', {required: true})
          )
-         const blueGreenDeployment = await deployBlueGreen(
-            kubectl,
-            files,
-            routeStrategy
-         )
-         core.debug(
-            `objects deployed for ${routeStrategy}: ${JSON.stringify(
-               blueGreenDeployment.objects
-            )} `
+
+         const {result, newFilePaths} = await Promise.resolve(
+            (routeStrategy == RouteStrategy.INGRESS &&
+               deployBlueGreenIngress(kubectl, files)) ||
+               (routeStrategy == RouteStrategy.SMI &&
+                  deployBlueGreenSMI(kubectl, files, annotations)) ||
+               deployBlueGreenService(kubectl, files)
          )
 
-         checkForErrors([blueGreenDeployment.deployResult.execResult])
-         return blueGreenDeployment.deployResult.manifestFiles
+         checkForErrors([result])
+         return newFilePaths
       }
 
       case DeploymentStrategy.BASIC: {
@@ -147,7 +143,7 @@ export async function annotateAndLabelResources(
    const workflowFilePath = await getWorkflowFilePath(githubToken)
 
    const deploymentConfig = await getDeploymentConfig()
-   const annotationKeyLabel = getWorkflowAnnotationKeyLabel()
+   const annotationKeyLabel = getWorkflowAnnotationKeyLabel(workflowFilePath)
 
    await annotateResources(
       files,

src/types/annotations.ts

@@ -1,8 +1,8 @@
 export function parseAnnotations(str: string) {
    if (str == '') {
-      return new Map<string, string>()
+      return {}
    } else {
-      const annotation = JSON.parse(str)
-      return new Map<string, string>(annotation)
+      const annotaion = JSON.parse(str)
+      return new Map(annotaion)
    }
 }

src/types/blueGreenTypes.ts

@@ -1,21 +0,0 @@
-import {DeployResult} from './deployResult'
-import {K8sObject, K8sDeleteObject} from './k8sObject'
-
-export interface BlueGreenDeployment {
-   deployResult: DeployResult
-   objects: K8sObject[]
-}
-
-export interface BlueGreenManifests {
-   serviceEntityList: K8sObject[]
-   serviceNameMap: Map<string, string>
-   unroutedServiceEntityList: K8sObject[]
-   deploymentEntityList: K8sObject[]
-   ingressEntityList: K8sObject[]
-   otherObjects: K8sObject[]
-}
-
-export interface BlueGreenRejectResult {
-   deleteResult: K8sDeleteObject[]
-   routeResult: BlueGreenDeployment
-}

src/types/deployResult.ts

@@ -1,6 +0,0 @@
-import {ExecOutput} from '@actions/exec'
-
-export interface DeployResult {
-   execResult: ExecOutput
-   manifestFiles: string[]
-}

src/types/k8sObject.ts

@@ -1,57 +0,0 @@
-export interface K8sObject {
-   metadata: {
-      name: string
-      labels: Map<string, string>
-   }
-   kind: string
-   spec: any
-}
-
-export interface K8sServiceObject extends K8sObject {
-   spec: {
-      selector: Map<string, string>
-   }
-}
-
-export interface K8sDeleteObject {
-   name: string
-   kind: string
-}
-
-export interface K8sIngress extends K8sObject {
-   spec: {
-      rules: [
-         {
-            http: {
-               paths: [
-                  {
-                     backend: {
-                        service: {
-                           name: string
-                        }
-                     }
-                  }
-               ]
-            }
-         }
-      ]
-   }
-}
-
-export interface TrafficSplitObject extends K8sObject {
-   apiVersion: string
-   metadata: {
-      name: string
-      labels: Map<string, string>
-      annotations: Map<string, string>
-   }
-   spec: {
-      service: string
-      backends: TrafficSplitBackend[]
-   }
-}
-
-export interface TrafficSplitBackend {
-   service: string
-   weight: number
-}

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(7)
+      expect(testSearch).toHaveLength(5)
       expectedManifests.forEach((fileName) => {
          expect(testSearch).toContain(fileName)
       })
@@ -54,7 +53,7 @@ describe('File utils', () => {
 
       expect(
          getFilesFromDirectories([outerPath, fileAtOuter, innerPath])
-      ).toHaveLength(7)
+      ).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))
 }

src/utilities/workflowAnnotationUtils.test.ts

@@ -1,6 +1,24 @@
-import {cleanLabel} from '../utilities/workflowAnnotationUtils'
+import {
+   cleanLabel,
+   prefixObjectKeys
+} from '../utilities/workflowAnnotationUtils'
 
 describe('WorkflowAnnotationUtils', () => {
+   describe('prefixObjectKeys', () => {
+      it('should prefix an object with a given prefix', () => {
+         const obj = {
+            foo: 'bar',
+            baz: 'qux'
+         }
+         const prefix = 'prefix.'
+         const expected = {
+            'prefix.foo': 'bar',
+            'prefix.baz': 'qux'
+         }
+         expect(prefixObjectKeys(obj, prefix)).toEqual(expected)
+      })
+   })
+
    describe('cleanLabel', () => {
       it('should clean label', () => {
          const alreadyClean = 'alreadyClean'
@@ -11,10 +29,5 @@ describe('WorkflowAnnotationUtils', () => {
          )
          expect(cleanLabel('with⚒️emoji')).toEqual('withemoji')
       })
-      it('should remove slashes from label', () => {
-         expect(
-            cleanLabel('Workflow Name / With Slashes / And Spaces')
-         ).toEqual('Workflow_Name_-_With_Slashes_-_And_Spaces')
-      })
    })
 })

src/utilities/workflowAnnotationUtils.ts

@@ -1,6 +1,13 @@
 import {DeploymentConfig} from '../types/deploymentConfig'
 
-const ANNOTATION_PREFIX = 'actions.github.com'
+const ANNOTATION_PREFIX = 'actions.github.com/'
+
+export function prefixObjectKeys(obj: any, prefix: string): any {
+   return Object.keys(obj).reduce((newObj, key) => {
+      newObj[prefix + key] = obj[key]
+      return newObj
+   }, {})
+}
 
 export function getWorkflowAnnotations(
    lastSuccessRunSha: string,
@@ -24,11 +31,21 @@ export function getWorkflowAnnotations(
       helmChartPaths: deploymentConfig.helmChartFilePaths,
       provider: 'GitHub'
    }
-   return JSON.stringify(annotationObject)
+   const prefixedAnnotationObject = prefixObjectKeys(
+      annotationObject,
+      ANNOTATION_PREFIX
+   )
+   return JSON.stringify(prefixedAnnotationObject)
 }
 
-export function getWorkflowAnnotationKeyLabel(): string {
-   return `${ANNOTATION_PREFIX}/k8s-deploy`
+export function getWorkflowAnnotationKeyLabel(
+   workflowFilePath: string
+): string {
+   const hashKey = require('crypto')
+      .createHash('MD5')
+      .update(`${process.env.GITHUB_REPOSITORY}/${workflowFilePath}`)
+      .digest('hex')
+   return `githubWorkflow_${hashKey}`
 }
 
 /**
@@ -37,11 +54,7 @@ export function getWorkflowAnnotationKeyLabel(): string {
  * @returns cleaned label
  */
 export function cleanLabel(label: string): string {
-   let removedInvalidChars = label
-      .replace(/\s/gi, '_')
-      .replace(/[\/\\\|]/gi, '-')
-      .replace(/[^-A-Za-z0-9_.]/gi, '')
-
+   const removedInvalidChars = label.replace(/[^-A-Za-z0-9_.]/gi, '')
    const regex = /([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]/
    return regex.exec(removedInvalidChars)[0] || ''
 }

test/unit/manifests/anomaly-objects-test.yml

@@ -1,23 +0,0 @@
----
-apiVersion: v1
-kind: Service
-metadata:
-   name: unrouted-service
-spec:
-   selector:
-      app: fake-application
-   ports:
-      - protocol: TCP
-        port: 80
-        targetPort: 80
----
-kind: TrafficSplit
-metadata:
-   name: foobar-rollout
-spec:
-   service: foobar
-   backends:
-      - service: foobar-v1
-        weight: 1000
-      - service: foobar-v2
-        weight: 500

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