@spinnaker/azure 2026.2.2 → 2026.3.0

package/src/pipeline/stages/destroyAsg/azureDestroyAsgStage.tsx

@@ -0,0 +1,128 @@
+import React from 'react';
+
+import { AccountService, Registry, StageConfigField, StageConstants } from '@spinnaker/core';
+
+import { AzureAccountRegionClusterSelector } from '../AzureAccountRegionClusterSelector';
+
+export function AzureDestroyAsgExecutionLabel({ stage }: any) {
+  const context = stage.masterStage?.context || stage.context || {};
+
+  return (
+    <span className="task-label">
+      {' '}
+      Destroy Server Group: {context.serverGroupName} ({context.region}){' '}
+    </span>
+  );
+}
+
+export class AzureDestroyAsgStageConfig extends React.Component<any> {
+  private mounted = false;
+
+  public componentDidMount(): void {
+    this.mounted = true;
+    this.applyDefaults();
+    this.loadRegionForAccount(this.props.stage.credentials);
+  }
+
+  public componentDidUpdate(previousProps: any): void {
+    if (previousProps.stage.credentials !== this.props.stage.credentials) {
+      this.updateStageField({ regions: [] });
+      this.loadRegionForAccount(this.props.stage.credentials);
+    }
+  }
+
+  public componentWillUnmount(): void {
+    this.mounted = false;
+  }
+
+  private updateStageField = (changes: any): void => {
+    Object.assign(this.props.stage, changes);
+    this.props.updateStageField(changes);
+  };
+
+  private applyDefaults(): void {
+    const { application, stage } = this.props;
+    stage.regions = stage.regions || [];
+    stage.cloudProvider = 'azure';
+    stage.interestingHealthProviderNames = stage.interestingHealthProviderNames || [];
+
+    if (!stage.credentials && application.defaultCredentials.azure) {
+      stage.credentials = application.defaultCredentials.azure;
+    }
+    if (!stage.target) {
+      stage.target = StageConstants.TARGET_LIST[0].val;
+    }
+  }
+
+  private loadRegionForAccount(credentials: string): void {
+    if (!credentials) {
+      return;
+    }
+
+    AccountService.getAccountDetails(credentials)
+      .then((details: any) => {
+        if (this.mounted && this.props.stage.credentials === credentials && details?.org) {
+          this.updateStageField({ regions: [details.org] });
+        }
+      })
+      .catch(() => {});
+  }
+
+  private accountUpdated = (credentials: string): void => {
+    this.loadRegionForAccount(credentials);
+  };
+
+  public render() {
+    this.applyDefaults();
+    const { application, pipeline, stage } = this.props;
+
+    return (
+      <div className="form-horizontal">
+        {!pipeline?.strategy && (
+          <AzureAccountRegionClusterSelector
+            application={application}
+            stage={stage}
+            updateStageField={this.updateStageField}
+            onAccountUpdate={this.accountUpdated}
+          />
+        )}
+        <StageConfigField label="Target">
+          <select
+            className="form-control input-sm"
+            value={stage.target}
+            onChange={(event) => this.updateStageField({ target: event.target.value })}
+          >
+            {StageConstants.TARGET_LIST.map((target: any) => (
+              <option key={target.val} value={target.val}>
+                {target.label}
+              </option>
+            ))}
+          </select>
+        </StageConfigField>
+      </div>
+    );
+  }
+}
+
+export function registerAzureDestroyAsgStage() {
+  Registry.pipeline.registerStage({
+    key: 'destroyServerGroup',
+    provides: 'destroyServerGroup',
+    cloudProvider: 'azure',
+    component: AzureDestroyAsgStageConfig,
+    executionLabelComponent: AzureDestroyAsgExecutionLabel,
+    accountExtractor: (stage: any) => [stage.context.credentials],
+    configAccountExtractor: (stage: any) => [stage.credentials],
+    validators: [
+      {
+        type: 'targetImpedance',
+        message:
+          'This pipeline will attempt to destroy a server group without deploying a new version into the same cluster.',
+      },
+      { type: 'requiredField', fieldName: 'cluster' },
+      { type: 'requiredField', fieldName: 'target' },
+      { type: 'requiredField', fieldName: 'regions' },
+      { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+    ],
+  } as any);
+}

package/src/pipeline/stages/disableAsg/azureDisableAsgStage.tsx

@@ -0,0 +1,92 @@
+import React from 'react';
+
+import { PlatformHealthOverride, Registry, StageConfigField, StageConstants } from '@spinnaker/core';
+
+import { AzureAccountRegionClusterSelector } from '../AzureAccountRegionClusterSelector';
+
+export function AzureDisableAsgExecutionLabel({ stage }: any) {
+  const context = stage.masterStage?.context || stage.context || {};
+
+  return (
+    <span className="task-label">
+      {' '}
+      Disable Server Group: {context.serverGroupName} ({context.region}){' '}
+    </span>
+  );
+}
+
+export function AzureDisableAsgStageConfig({ application, pipeline, stage, updateStageField }: any) {
+  const updateStage = (changes: any) => {
+    Object.assign(stage, changes);
+    updateStageField(changes);
+  };
+
+  stage.regions = stage.regions || [];
+  stage.cloudProvider = 'azure';
+  if (
+    stage.isNew &&
+    application.attributes.platformHealthOnlyShowOverride &&
+    stage.interestingHealthProviderNames === undefined
+  ) {
+    stage.interestingHealthProviderNames = [];
+  }
+  if (!stage.credentials && application.defaultCredentials.azure) {
+    stage.credentials = application.defaultCredentials.azure;
+  }
+  if (!stage.regions.length && application.defaultRegions.azure) {
+    stage.regions.push(application.defaultRegions.azure);
+  }
+  if (!stage.target) {
+    stage.target = StageConstants.TARGET_LIST[0].val;
+  }
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline?.strategy && (
+        <AzureAccountRegionClusterSelector application={application} stage={stage} updateStageField={updateStage} />
+      )}
+      <StageConfigField label="Target">
+        <select
+          className="form-control input-sm"
+          value={stage.target}
+          onChange={(e) => updateStage({ target: e.target.value })}
+        >
+          {StageConstants.TARGET_LIST.map((target: any) => (
+            <option key={target.val} value={target.val}>
+              {target.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <PlatformHealthOverride
+          interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+          platformHealthType="azureService"
+          onChange={(interestingHealthProviderNames) => updateStage({ interestingHealthProviderNames })}
+        />
+      )}
+    </div>
+  );
+}
+
+export function registerAzureDisableAsgStage() {
+  Registry.pipeline.registerStage({
+    key: 'disableServerGroup',
+    provides: 'disableServerGroup',
+    alias: 'disableAsg',
+    cloudProvider: 'azure',
+    component: AzureDisableAsgStageConfig,
+    executionLabelComponent: AzureDisableAsgExecutionLabel,
+    validators: [
+      {
+        type: 'targetImpedance',
+        message:
+          'This pipeline will attempt to disable a server group without deploying a new version into the same cluster.',
+      },
+      { type: 'requiredField', fieldName: 'cluster' },
+      { type: 'requiredField', fieldName: 'target' },
+      { type: 'requiredField', fieldName: 'regions' },
+      { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+    ],
+  } as any);
+}

package/src/pipeline/stages/enableAsg/azureEnableAsgStage.tsx

@@ -0,0 +1,87 @@
+import React from 'react';
+
+import { PlatformHealthOverride, Registry, StageConfigField, StageConstants } from '@spinnaker/core';
+
+import { AzureAccountRegionClusterSelector } from '../AzureAccountRegionClusterSelector';
+
+export function AzureEnableAsgExecutionLabel({ stage }: any) {
+  const context = stage.masterStage?.context || stage.context || {};
+
+  return (
+    <span className="task-label">
+      {' '}
+      Enable Server Group: {context.serverGroupName} ({context.region}){' '}
+    </span>
+  );
+}
+
+export function AzureEnableAsgStageConfig({ application, pipeline, stage, updateStageField }: any) {
+  const updateStage = (changes: any) => {
+    Object.assign(stage, changes);
+    updateStageField(changes);
+  };
+
+  stage.regions = stage.regions || [];
+  stage.cloudProvider = 'azure';
+  if (
+    stage.isNew &&
+    application.attributes.platformHealthOnlyShowOverride &&
+    stage.interestingHealthProviderNames === undefined
+  ) {
+    stage.interestingHealthProviderNames = [];
+  }
+  if (!stage.credentials && application.defaultCredentials.azure) {
+    stage.credentials = application.defaultCredentials.azure;
+  }
+  if (!stage.regions.length && application.defaultRegions.azure) {
+    stage.regions.push(application.defaultRegions.azure);
+  }
+  if (!stage.target) {
+    stage.target = StageConstants.TARGET_LIST[0].val;
+  }
+
+  return (
+    <div className="form-horizontal">
+      {!pipeline?.strategy && (
+        <AzureAccountRegionClusterSelector application={application} stage={stage} updateStageField={updateStage} />
+      )}
+      <StageConfigField label="Target">
+        <select
+          className="form-control input-sm"
+          value={stage.target}
+          onChange={(e) => updateStage({ target: e.target.value })}
+        >
+          {StageConstants.TARGET_LIST.map((target: any) => (
+            <option key={target.val} value={target.val}>
+              {target.label}
+            </option>
+          ))}
+        </select>
+      </StageConfigField>
+      {application.attributes.platformHealthOnlyShowOverride && (
+        <PlatformHealthOverride
+          interestingHealthProviderNames={stage.interestingHealthProviderNames || []}
+          platformHealthType="azureService"
+          onChange={(interestingHealthProviderNames) => updateStage({ interestingHealthProviderNames })}
+        />
+      )}
+    </div>
+  );
+}
+
+export function registerAzureEnableAsgStage() {
+  Registry.pipeline.registerStage({
+    key: 'enableServerGroup',
+    provides: 'enableServerGroup',
+    alias: 'enableAsg',
+    cloudProvider: 'azure',
+    component: AzureEnableAsgStageConfig,
+    executionLabelComponent: AzureEnableAsgExecutionLabel,
+    validators: [
+      { type: 'requiredField', fieldName: 'cluster' },
+      { type: 'requiredField', fieldName: 'target' },
+      { type: 'requiredField', fieldName: 'regions' },
+      { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+    ],
+  } as any);
+}

package/src/routerConsumers.spec.tsx

@@ -0,0 +1,69 @@
+import { AzureLoadBalancerModalComponent } from './loadBalancer/configure/AzureLoadBalancerModal';
+import { AzureCloneServerGroupModalComponent } from './serverGroup/configure/wizard/AzureCloneServerGroupModal';
+
+describe('Azure routed modal consumers', () => {
+  function stateService(includedState: string) {
+    return {
+      go: jasmine.createSpy('go'),
+      includes: jasmine.createSpy('includes').and.callFake((state: string) => state === includedState),
+    };
+  }
+
+  it('navigates from the load balancer modal through its injected state service', () => {
+    const state = stateService('**.loadBalancerDetails');
+    const modal = new AzureLoadBalancerModalComponent({
+      app: { defaultCredentials: {}, defaultRegions: {}, name: 'fnord' },
+      closeModal: jasmine.createSpy('closeModal'),
+      dismissModal: jasmine.createSpy('dismissModal'),
+      isNew: true,
+      stateService: state,
+    } as any) as any;
+    modal.mounted = true;
+    modal.state = {
+      loadBalancer: { credentials: 'test-account', name: 'fnord-main', region: 'westus' },
+    };
+
+    modal.onApplicationRefresh();
+
+    expect(state.go).toHaveBeenCalledWith('^.loadBalancerDetails', {
+      accountId: 'test-account',
+      name: 'fnord-main',
+      provider: 'azure',
+      region: 'westus',
+    });
+  });
+
+  it('navigates from the clone server group modal through its injected state service', () => {
+    const state = stateService('**.clusters.cluster.serverGroup');
+    const modal = new AzureCloneServerGroupModalComponent({
+      application: { name: 'fnord' },
+      command: { viewState: { requiresTemplateSelection: true } },
+      dismissModal: jasmine.createSpy('dismissModal'),
+      stateService: state,
+    } as any) as any;
+    modal.state = {
+      command: { credentials: 'test-account', region: 'westus' },
+      taskMonitor: {
+        task: {
+          execution: {
+            stages: [
+              {
+                context: { 'deploy.server.groups': { westus: 'fnord-main-v042' } },
+                type: 'cloneServerGroup',
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    modal.onApplicationRefresh();
+
+    expect(state.go).toHaveBeenCalledWith('^.^.serverGroup', {
+      accountId: 'test-account',
+      provider: 'azure',
+      region: 'westus',
+      serverGroup: 'fnord-main-v042',
+    });
+  });
+});