v5.0.1 Release with Fleet Types (#358)

* extract resource type

* fleet details

* new release with fleet

* format

* type params

* format

* promote input

* format

* fleet type

* format pls

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [5.0.1] - 2024-03-12
+
+### Added
+
+-  #356 Add fleet support
+
 ## [5.0.0] - 2024-03-12
 
 ### Changed

README.md

@@ -125,6 +125,10 @@ Following are the key capabilities of this action:
     <td>skip-tls-verify</br></br>(Optional)</td>
     <td>Acceptable values: true/false</br>Default value: false</br>True if the insecure-skip-tls-verify option should be used</td>
   </tr>
+  <tr>
+    <td>resource-type (Optional)</td>
+    <td>Acceptable values: `Microsoft.ContainerService/managedClusters` (default), 'Microsoft.ContainerService/fleets'</td>
+  </tr>
 </table>
 
 ## Usage Examples

src/actions/deploy.ts

@@ -13,6 +13,12 @@ import {
 } from '../strategyHelpers/deploymentHelper'
 import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {parseTrafficSplitMethod} from '../types/trafficSplitMethod'
+export const ResourceTypeManagedCluster =
+   'Microsoft.ContainerService/managedClusters'
+export const ResourceTypeFleet = 'Microsoft.ContainerService/fleets'
+export type ClusterType =
+   | typeof ResourceTypeManagedCluster
+   | typeof ResourceTypeFleet
 
 export async function deploy(
    kubectl: Kubectl,
@@ -39,17 +45,25 @@ export async function deploy(
 
    // check manifest stability
    core.startGroup('Checking manifest stability')
-   const resourceType = (
-      core.getInput('resource-type') ||
-      'Microsoft.ContainerService/managedClusters'
-   ).toLowerCase()
+   const resourceTypeInput =
+      core.getInput('resource-type') || ResourceTypeManagedCluster
    const resourceTypes: Resource[] = getResources(
       deployedManifestFiles,
       models.DEPLOYMENT_TYPES.concat([
          KubernetesConstants.DiscoveryAndLoadBalancerResource.SERVICE
       ])
    )
-   await checkManifestStability(kubectl, resourceTypes, resourceType)
+
+   if (
+      resourceTypeInput !== ResourceTypeManagedCluster &&
+      resourceTypeInput !== ResourceTypeFleet
+   ) {
+      let errMsg = `Invalid resource type: ${resourceTypeInput}. Supported resource types are: ${ResourceTypeManagedCluster} (default), ${ResourceTypeFleet}`
+      core.setFailed(errMsg)
+      throw new Error(errMsg)
+   }
+
+   await checkManifestStability(kubectl, resourceTypes, resourceTypeInput)
    core.endGroup()
 
    // print ingresses

src/actions/promote.ts

@@ -38,6 +38,7 @@ import {
    TrafficSplitMethod
 } from '../types/trafficSplitMethod'
 import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
+import {ResourceTypeFleet, ResourceTypeManagedCluster} from './deploy'
 
 export async function promote(
    kubectl: Kubectl,
@@ -166,17 +167,23 @@ async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
 
    // checking stability of newly created deployments
    core.startGroup('Checking manifest stability')
-   const resourceType = (
-      core.getInput('resource-type') ||
-      'Microsoft.ContainerService/managedClusters'
-   ).toLowerCase()
+   const resourceType =
+      core.getInput('resource-type') || ResourceTypeManagedCluster
    const deployedManifestFiles = deployResult.manifestFiles
    const resources: Resource[] = getResources(
       deployedManifestFiles,
       models.DEPLOYMENT_TYPES.concat([
          models.DiscoveryAndLoadBalancerResource.SERVICE
       ])
    )
+   if (
+      resourceType !== ResourceTypeManagedCluster &&
+      resourceType !== ResourceTypeFleet
+   ) {
+      const errMsg = `Invalid resource type: ${resourceType}. Supported resource types are: ${ResourceTypeManagedCluster} (default), fleet`
+      core.setFailed(errMsg)
+      throw new Error(errMsg)
+   }
    await KubernetesManifestUtility.checkManifestStability(
       kubectl,
       resources,

src/strategyHelpers/deploymentHelper.ts

@@ -35,6 +35,7 @@ import {
 } from '../utilities/githubUtils'
 import {getDeploymentConfig} from '../utilities/dockerUtils'
 import {DeployResult} from '../types/deployResult'
+import {ClusterType} from '../actions/deploy'
 
 export async function deployManifests(
    files: string[],
@@ -139,7 +140,7 @@ function appendStableVersionLabelToResource(files: string[]): string[] {
 export async function checkManifestStability(
    kubectl: Kubectl,
    resources: Resource[],
-   resourceType: string
+   resourceType: ClusterType
 ): Promise<void> {
    await KubernetesManifestUtility.checkManifestStability(
       kubectl,

src/utilities/manifestStabilityUtils.test.ts

@@ -1,5 +1,8 @@
 import * as manifestStabilityUtils from './manifestStabilityUtils'
 import {Kubectl} from '../types/kubectl'
+import {ResourceTypeFleet, ResourceTypeManagedCluster} from '../actions/deploy'
+import {ExecOutput} from '@actions/exec'
+import {exitCode, stdout} from 'process'
 
 describe('manifestStabilityUtils', () => {
    const kc = new Kubectl('')
@@ -10,18 +13,40 @@ describe('manifestStabilityUtils', () => {
          namespace: 'default'
       }
    ]
-   const resourceType = 'microsoft.containerservice/fleets'
 
-   it('should return immediately if the resource type is microsoft.containerservice/fleets', async () => {
+   it('should return immediately if the resource type is fleet', async () => {
       const spy = jest.spyOn(manifestStabilityUtils, 'checkManifestStability')
       const checkRolloutStatusSpy = jest.spyOn(kc, 'checkRolloutStatus')
       await manifestStabilityUtils.checkManifestStability(
          kc,
          resources,
-         resourceType
+         ResourceTypeFleet
       )
 
       expect(checkRolloutStatusSpy).not.toHaveBeenCalled()
       expect(spy).toHaveReturned()
    })
+
+   it('should run fully if the resource type is managedCluster', async () => {
+      const spy = jest.spyOn(manifestStabilityUtils, 'checkManifestStability')
+      const checkRolloutStatusSpy = jest
+         .spyOn(kc, 'checkRolloutStatus')
+         .mockImplementation(() => {
+            return new Promise<ExecOutput>((resolve, reject) => {
+               resolve({
+                  exitCode: 0,
+                  stderr: '',
+                  stdout: ''
+               })
+            })
+         })
+      await manifestStabilityUtils.checkManifestStability(
+         kc,
+         resources,
+         ResourceTypeManagedCluster
+      )
+
+      expect(checkRolloutStatusSpy).toHaveBeenCalled()
+      expect(spy).toHaveReturned()
+   })
 })

src/utilities/manifestStabilityUtils.ts

@@ -3,20 +3,19 @@ import * as KubernetesConstants from '../types/kubernetesTypes'
 import {Kubectl, Resource} from '../types/kubectl'
 import {checkForErrors} from './kubectlUtils'
 import {sleep} from './timeUtils'
+import {ClusterType, ResourceTypeFleet} from '../actions/deploy'
 
 const IS_SILENT = false
 const POD = 'pod'
 
 export async function checkManifestStability(
    kubectl: Kubectl,
    resources: Resource[],
-   resourceType: string
+   clusterTyper: ClusterType
 ): Promise<void> {
    // Skip if resource type is microsoft.containerservice/fleets
-   if (resourceType === 'microsoft.containerservice/fleets') {
-      core.info(
-         'Skipping checkManifestStability for microsoft.containerservice/fleets'
-      )
+   if (clusterTyper === ResourceTypeFleet) {
+      core.info(`Skipping checkManifestStability for ${ResourceTypeFleet}`)
       return
    }
    let rolloutStatusHasErrors = false