build

* release v5.0.3

* format

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [5.0.3] - 2025-04-16
+
+### Added
+
+- #398 case-insensitive resource type
+
 ## [5.0.2] - 2025-04-15
 
 ### Added

lib/index.js

@@ -11914,7 +11914,7 @@ const deploymentHelper_1 = __nccwpck_require__(5959);
 const trafficSplitMethod_1 = __nccwpck_require__(5187);
 exports.ResourceTypeManagedCluster = 'Microsoft.ContainerService/managedClusters';
 exports.ResourceTypeFleet = 'Microsoft.ContainerService/fleets';
-function deploy(kubectl, manifestFilePaths, deploymentStrategy) {
+function deploy(kubectl, manifestFilePaths, deploymentStrategy, resourceType) {
     return __awaiter(this, void 0, void 0, function* () {
         // update manifests
         const inputManifestFiles = (0, manifestUpdateUtils_1.updateManifestFiles)(manifestFilePaths);
@@ -11927,17 +11927,10 @@ function deploy(kubectl, manifestFilePaths, deploymentStrategy) {
         core.endGroup();
         // check manifest stability
         core.startGroup('Checking manifest stability');
-        const resourceTypeInput = core.getInput('resource-type') || exports.ResourceTypeManagedCluster;
         const resourceTypes = (0, manifestUpdateUtils_1.getResources)(deployedManifestFiles, models.DEPLOYMENT_TYPES.concat([
             KubernetesConstants.DiscoveryAndLoadBalancerResource.SERVICE
         ]));
-        if (resourceTypeInput !== exports.ResourceTypeManagedCluster &&
-            resourceTypeInput !== exports.ResourceTypeFleet) {
-            let errMsg = `Invalid resource type: ${resourceTypeInput}. Supported resource types are: ${exports.ResourceTypeManagedCluster} (default), ${exports.ResourceTypeFleet}`;
-            core.setFailed(errMsg);
-            throw new Error(errMsg);
-        }
-        yield (0, deploymentHelper_1.checkManifestStability)(kubectl, resourceTypes, resourceTypeInput);
+        yield (0, deploymentHelper_1.checkManifestStability)(kubectl, resourceTypes, resourceType);
         core.endGroup();
         // print ingresses
         core.startGroup('Printing ingresses');
@@ -12022,15 +12015,14 @@ const smiBlueGreenHelper_1 = __nccwpck_require__(8886);
 const deploymentStrategy_1 = __nccwpck_require__(4951);
 const trafficSplitMethod_1 = __nccwpck_require__(5187);
 const routeStrategy_1 = __nccwpck_require__(2041);
-const deploy_1 = __nccwpck_require__(3800);
-function promote(kubectl, manifests, deploymentStrategy) {
+function promote(kubectl, manifests, deploymentStrategy, resourceType) {
     return __awaiter(this, void 0, void 0, function* () {
         switch (deploymentStrategy) {
             case deploymentStrategy_1.DeploymentStrategy.CANARY:
                 yield promoteCanary(kubectl, manifests);
                 break;
             case deploymentStrategy_1.DeploymentStrategy.BLUE_GREEN:
-                yield promoteBlueGreen(kubectl, manifests);
+                yield promoteBlueGreen(kubectl, manifests, resourceType);
                 break;
             default:
                 throw Error('Invalid promote deployment strategy');
@@ -12082,7 +12074,7 @@ function promoteCanary(kubectl, manifests) {
         core.endGroup();
     });
 }
-function promoteBlueGreen(kubectl, manifests) {
+function promoteBlueGreen(kubectl, manifests, resourceType) {
     return __awaiter(this, void 0, void 0, function* () {
         // update container images and pull secrets
         const inputManifestFiles = (0, manifestUpdateUtils_1.updateManifestFiles)(manifests);
@@ -12102,17 +12094,10 @@ function promoteBlueGreen(kubectl, manifests) {
         core.endGroup();
         // checking stability of newly created deployments
         core.startGroup('Checking manifest stability');
-        const resourceType = core.getInput('resource-type') || deploy_1.ResourceTypeManagedCluster;
         const deployedManifestFiles = deployResult.manifestFiles;
         const resources = (0, manifestUpdateUtils_1.getResources)(deployedManifestFiles, models.DEPLOYMENT_TYPES.concat([
             models.DiscoveryAndLoadBalancerResource.SERVICE
         ]));
-        if (resourceType !== deploy_1.ResourceTypeManagedCluster &&
-            resourceType !== deploy_1.ResourceTypeFleet) {
-            const errMsg = `Invalid resource type: ${resourceType}. Supported resource types are: ${deploy_1.ResourceTypeManagedCluster} (default), fleet`;
-            core.setFailed(errMsg);
-            throw new Error(errMsg);
-        }
         yield KubernetesManifestUtility.checkManifestStability(kubectl, resources, resourceType);
         core.endGroup();
         core.startGroup('Routing to new deployments and deleting old workloads and services');
@@ -12289,8 +12274,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.inputAnnotations = void 0;
 exports.getBufferTime = getBufferTime;
+exports.parseResourceTypeInput = parseResourceTypeInput;
 const core = __importStar(__nccwpck_require__(7484));
 const annotations_1 = __nccwpck_require__(4639);
+const deploy_1 = __nccwpck_require__(3800);
 exports.inputAnnotations = (0, annotations_1.parseAnnotations)(core.getInput('annotations', { required: false }));
 function getBufferTime() {
     const inputBufferTime = parseInt(core.getInput('version-switch-buffer') || '0');
@@ -12298,6 +12285,15 @@ function getBufferTime() {
         throw Error('Version switch buffer must be between 0 and 300 (inclusive)');
     return inputBufferTime;
 }
+function parseResourceTypeInput(rawInput) {
+    switch (rawInput.toLowerCase()) {
+        case deploy_1.ResourceTypeFleet.toLowerCase():
+            return deploy_1.ResourceTypeFleet;
+        case deploy_1.ResourceTypeManagedCluster.toLowerCase():
+            return deploy_1.ResourceTypeManagedCluster;
+    }
+    throw new Error(`Invalid resource type: ${rawInput}. Supported resource types are: ${deploy_1.ResourceTypeManagedCluster} (default), ${deploy_1.ResourceTypeFleet}`);
+}
 
 
 /***/ }),
@@ -12360,6 +12356,7 @@ const action_1 = __nccwpck_require__(1695);
 const deploymentStrategy_1 = __nccwpck_require__(4951);
 const fileUtils_1 = __nccwpck_require__(8911);
 const privatekubectl_1 = __nccwpck_require__(7706);
+const inputUtils_1 = __nccwpck_require__(1802);
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
         // verify kubeconfig is set
@@ -12380,17 +12377,27 @@ function run() {
         const resourceGroup = core.getInput('resource-group') || '';
         const resourceName = core.getInput('name') || '';
         const skipTlsVerify = core.getBooleanInput('skip-tls-verify');
+        let resourceType;
+        try {
+            // included in the trycatch to allow raw input to go out of scope after parsing
+            const resourceTypeInput = core.getInput('resource-type');
+            resourceType = (0, inputUtils_1.parseResourceTypeInput)(resourceTypeInput);
+        }
+        catch (e) {
+            core.setFailed(e);
+            return;
+        }
         const kubectl = isPrivateCluster
             ? new privatekubectl_1.PrivateKubectl(kubectlPath, namespace, skipTlsVerify, resourceGroup, resourceName)
             : new kubectl_1.Kubectl(kubectlPath, namespace, skipTlsVerify);
         // run action
         switch (action) {
             case action_1.Action.DEPLOY: {
-                yield (0, deploy_1.deploy)(kubectl, fullManifestFilePaths, strategy);
+                yield (0, deploy_1.deploy)(kubectl, fullManifestFilePaths, strategy, resourceType);
                 break;
             }
             case action_1.Action.PROMOTE: {
-                yield (0, promote_1.promote)(kubectl, fullManifestFilePaths, strategy);
+                yield (0, promote_1.promote)(kubectl, fullManifestFilePaths, strategy, resourceType);
                 break;
             }
             case action_1.Action.REJECT: {
@@ -15880,10 +15887,10 @@ const timeUtils_1 = __nccwpck_require__(798);
 const deploy_1 = __nccwpck_require__(3800);
 const IS_SILENT = false;
 const POD = 'pod';
-function checkManifestStability(kubectl, resources, clusterTyper) {
+function checkManifestStability(kubectl, resources, resourceType) {
     return __awaiter(this, void 0, void 0, function* () {
         // Skip if resource type is microsoft.containerservice/fleets
-        if (clusterTyper === deploy_1.ResourceTypeFleet) {
+        if (resourceType === deploy_1.ResourceTypeFleet) {
             core.info(`Skipping checkManifestStability for ${deploy_1.ResourceTypeFleet}`);
             return;
         }

src/actions/deploy.ts

@@ -13,17 +13,15 @@ import {
 } from '../strategyHelpers/deploymentHelper'
 import {DeploymentStrategy} from '../types/deploymentStrategy'
 import {parseTrafficSplitMethod} from '../types/trafficSplitMethod'
+import {ClusterType} from '../inputUtils'
 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,
    manifestFilePaths: string[],
-   deploymentStrategy: DeploymentStrategy
+   deploymentStrategy: DeploymentStrategy,
+   resourceType: ClusterType
 ) {
    // update manifests
    const inputManifestFiles: string[] = updateManifestFiles(manifestFilePaths)
@@ -45,8 +43,6 @@ export async function deploy(
 
    // check manifest stability
    core.startGroup('Checking manifest stability')
-   const resourceTypeInput =
-      core.getInput('resource-type') || ResourceTypeManagedCluster
    const resourceTypes: Resource[] = getResources(
       deployedManifestFiles,
       models.DEPLOYMENT_TYPES.concat([
@@ -54,16 +50,7 @@ export async function deploy(
       ])
    )
 
-   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)
+   await checkManifestStability(kubectl, resourceTypes, resourceType)
    core.endGroup()
 
    // print ingresses

src/actions/promote.ts

@@ -38,19 +38,20 @@ import {
    TrafficSplitMethod
 } from '../types/trafficSplitMethod'
 import {parseRouteStrategy, RouteStrategy} from '../types/routeStrategy'
-import {ResourceTypeFleet, ResourceTypeManagedCluster} from './deploy'
+import {ClusterType} from '../inputUtils'
 
 export async function promote(
    kubectl: Kubectl,
    manifests: string[],
-   deploymentStrategy: DeploymentStrategy
+   deploymentStrategy: DeploymentStrategy,
+   resourceType: ClusterType
 ) {
    switch (deploymentStrategy) {
       case DeploymentStrategy.CANARY:
          await promoteCanary(kubectl, manifests)
          break
       case DeploymentStrategy.BLUE_GREEN:
-         await promoteBlueGreen(kubectl, manifests)
+         await promoteBlueGreen(kubectl, manifests, resourceType)
          break
       default:
          throw Error('Invalid promote deployment strategy')
@@ -140,7 +141,11 @@ async function promoteCanary(kubectl: Kubectl, manifests: string[]) {
    core.endGroup()
 }
 
-async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
+async function promoteBlueGreen(
+   kubectl: Kubectl,
+   manifests: string[],
+   resourceType: ClusterType
+) {
    // update container images and pull secrets
    const inputManifestFiles: string[] = updateManifestFiles(manifests)
    const manifestObjects: BlueGreenManifests =
@@ -167,8 +172,6 @@ async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
 
    // checking stability of newly created deployments
    core.startGroup('Checking manifest stability')
-   const resourceType =
-      core.getInput('resource-type') || ResourceTypeManagedCluster
    const deployedManifestFiles = deployResult.manifestFiles
    const resources: Resource[] = getResources(
       deployedManifestFiles,
@@ -176,14 +179,6 @@ async function promoteBlueGreen(kubectl: Kubectl, manifests: string[]) {
          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/inputUtils.test.ts

@@ -0,0 +1,34 @@
+import {parseResourceTypeInput} from './inputUtils'
+import {
+   ClusterType,
+   ResourceTypeFleet,
+   ResourceTypeManagedCluster
+} from './actions/deploy'
+
+describe('InputUtils', () => {
+   describe('parseResourceTypeInput', () => {
+      it('should extract fleet exact match resource type', () => {
+         expect(
+            parseResourceTypeInput('Microsoft.ContainerService/fleets')
+         ).toEqual(ResourceTypeFleet)
+      })
+      it('should match fleet case-insensitively', () => {
+         expect(
+            parseResourceTypeInput('Microsoft.containerservice/fleets')
+         ).toEqual(ResourceTypeFleet)
+      })
+      it('should match managed cluster case-insensitively', () => {
+         expect(
+            parseResourceTypeInput('Microsoft.containerservice/MAnaGedClusterS')
+         ).toEqual(ResourceTypeManagedCluster)
+      })
+      it('should error on unexpected values', () => {
+         expect(() => {
+            parseResourceTypeInput('icrosoft.ContainerService/ManagedCluster')
+         }).toThrow()
+         expect(() => {
+            parseResourceTypeInput('wrong-value')
+         }).toThrow()
+      })
+   })
+})

src/inputUtils.ts

@@ -1,5 +1,6 @@
 import * as core from '@actions/core'
 import {parseAnnotations} from './types/annotations'
+import {ResourceTypeFleet, ResourceTypeManagedCluster} from './actions/deploy'
 
 export const inputAnnotations = parseAnnotations(
    core.getInput('annotations', {required: false})
@@ -14,3 +15,18 @@ export function getBufferTime(): number {
 
    return inputBufferTime
 }
+
+export function parseResourceTypeInput(rawInput: string): ClusterType {
+   switch (rawInput.toLowerCase()) {
+      case ResourceTypeFleet.toLowerCase():
+         return ResourceTypeFleet
+      case ResourceTypeManagedCluster.toLowerCase():
+         return ResourceTypeManagedCluster
+   }
+   throw new Error(
+      `Invalid resource type: ${rawInput}. Supported resource types are: ${ResourceTypeManagedCluster} (default), ${ResourceTypeFleet}`
+   )
+}
+export type ClusterType =
+   | typeof ResourceTypeManagedCluster
+   | typeof ResourceTypeFleet

src/run.ts

@@ -1,12 +1,18 @@
 import * as core from '@actions/core'
 import {getKubectlPath, Kubectl} from './types/kubectl'
-import {deploy} from './actions/deploy'
+import {
+   deploy,
+   ResourceTypeFleet,
+   ResourceTypeManagedCluster
+} from './actions/deploy'
+import {ClusterType} from './inputUtils'
 import {promote} from './actions/promote'
 import {reject} from './actions/reject'
 import {Action, parseAction} from './types/action'
 import {parseDeploymentStrategy} from './types/deploymentStrategy'
 import {getFilesFromDirectoriesAndURLs} from './utilities/fileUtils'
 import {PrivateKubectl} from './types/privatekubectl'
+import {parseResourceTypeInput} from './inputUtils'
 
 export async function run() {
    // verify kubeconfig is set
@@ -36,6 +42,16 @@ export async function run() {
    const resourceName = core.getInput('name') || ''
    const skipTlsVerify = core.getBooleanInput('skip-tls-verify')
 
+   let resourceType: ClusterType
+   try {
+      // included in the trycatch to allow raw input to go out of scope after parsing
+      const resourceTypeInput = core.getInput('resource-type')
+      resourceType = parseResourceTypeInput(resourceTypeInput)
+   } catch (e) {
+      core.setFailed(e)
+      return
+   }
+
    const kubectl = isPrivateCluster
       ? new PrivateKubectl(
            kubectlPath,
@@ -49,11 +65,11 @@ export async function run() {
    // run action
    switch (action) {
       case Action.DEPLOY: {
-         await deploy(kubectl, fullManifestFilePaths, strategy)
+         await deploy(kubectl, fullManifestFilePaths, strategy, resourceType)
          break
       }
       case Action.PROMOTE: {
-         await promote(kubectl, fullManifestFilePaths, strategy)
+         await promote(kubectl, fullManifestFilePaths, strategy, resourceType)
          break
       }
       case Action.REJECT: {

src/strategyHelpers/deploymentHelper.ts

@@ -35,7 +35,7 @@ import {
 } from '../utilities/githubUtils'
 import {getDeploymentConfig} from '../utilities/dockerUtils'
 import {DeployResult} from '../types/deployResult'
-import {ClusterType} from '../actions/deploy'
+import {ClusterType} from '../inputUtils'
 
 export async function deployManifests(
    files: string[],

src/utilities/manifestStabilityUtils.ts

@@ -3,7 +3,8 @@ 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'
+import {ResourceTypeFleet} from '../actions/deploy'
+import {ClusterType} from '../inputUtils'
 
 const IS_SILENT = false
 const POD = 'pod'
@@ -11,10 +12,10 @@ const POD = 'pod'
 export async function checkManifestStability(
    kubectl: Kubectl,
    resources: Resource[],
-   clusterTyper: ClusterType
+   resourceType: ClusterType
 ): Promise<void> {
    // Skip if resource type is microsoft.containerservice/fleets
-   if (clusterTyper === ResourceTypeFleet) {
+   if (resourceType === ResourceTypeFleet) {
       core.info(`Skipping checkManifestStability for ${ResourceTypeFleet}`)
       return
    }