@spinnaker/azure 2026.2.2 → 2026.3.0

package/src/securityGroup/securityGroup.write.service.spec.ts

@@ -0,0 +1,105 @@
+import { InfrastructureCaches, TaskExecutor } from '@spinnaker/core';
+
+import { AzureSecurityGroupWriter, buildDeleteCommand, buildUpsertCommand } from './securityGroup.write.service';
+
+describe('AzureSecurityGroupWriter', () => {
+  const application = { name: 'fnord' } as any;
+  const securityGroup = {
+    accountId: 'azure-account',
+    cloudProvider: 'azure',
+    name: 'azure-sg',
+    region: 'westus',
+    rules: [{ protocol: 'tcp', port: 443 }],
+    vpcId: 'sg-vnet',
+  } as any;
+
+  it('builds an upsert command without overwriting explicit params', () => {
+    const params = { cloudProvider: 'explicit-provider', rules: [], type: 'customUpsertType' };
+
+    const command = buildUpsertCommand(securityGroup, params);
+
+    expect(command).toEqual(
+      jasmine.objectContaining({
+        accountId: 'azure-account',
+        cloudProvider: 'explicit-provider',
+        name: 'azure-sg',
+        region: 'westus',
+        rules: [],
+        securityGroupName: 'azure-sg',
+        type: 'customUpsertType',
+        vpcId: 'sg-vnet',
+      }),
+    );
+    expect(params).toEqual({ cloudProvider: 'explicit-provider', rules: [], type: 'customUpsertType' });
+  });
+
+  it('builds a delete command with the Azure security group payload', () => {
+    const command = buildDeleteCommand(securityGroup, application, { cloudProvider: 'azure', vpcId: 'explicit-vnet' });
+
+    expect(command).toEqual(
+      jasmine.objectContaining({
+        appName: 'fnord',
+        cloudProvider: 'azure',
+        credentials: 'azure-account',
+        regions: ['westus'],
+        securityGroupName: 'azure-sg',
+        type: 'deleteSecurityGroup',
+        vpcId: 'explicit-vnet',
+      }),
+    );
+  });
+
+  it('builds a delete command from legacy account identity fields', () => {
+    const command = buildDeleteCommand(
+      { ...securityGroup, accountId: undefined, accountName: 'legacy-account' },
+      application,
+      { cloudProvider: 'azure' },
+    );
+
+    expect(command.credentials).toBe('legacy-account');
+  });
+
+  it('executes an upsert task and clears the security group cache', () => {
+    const task = Promise.resolve({}) as any;
+    const executeTask = spyOn(TaskExecutor, 'executeTask').and.returnValue(task);
+    const clearCache = spyOn(InfrastructureCaches, 'clearCache');
+
+    const result = AzureSecurityGroupWriter.upsertSecurityGroup(securityGroup, application, 'Create', {
+      cloudProvider: 'azure',
+    });
+
+    expect(result).toBe(task);
+    expect(executeTask).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        application,
+        description: 'Create Firewall: azure-sg',
+        job: [jasmine.objectContaining({ cloudProvider: 'azure', securityGroupName: 'azure-sg' })],
+      }),
+    );
+    expect(clearCache).toHaveBeenCalledWith('securityGroups');
+  });
+
+  it('executes a delete task and clears the security group cache', () => {
+    const task = Promise.resolve({}) as any;
+    const executeTask = spyOn(TaskExecutor, 'executeTask').and.returnValue(task);
+    const clearCache = spyOn(InfrastructureCaches, 'clearCache');
+
+    const result = AzureSecurityGroupWriter.deleteSecurityGroup(securityGroup, application, { vpcId: 'explicit-vnet' });
+
+    expect(result).toBe(task);
+    expect(executeTask).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        application,
+        description: 'Delete Firewalls: azure-sg',
+        job: [
+          jasmine.objectContaining({
+            securityGroupName: 'azure-sg',
+            type: 'deleteSecurityGroup',
+            vpcId: 'explicit-vnet',
+          }),
+        ],
+      }),
+    );
+    expect(clearCache).toHaveBeenCalledWith('securityGroups');
+  });
+});

package/src/securityGroup/securityGroup.write.service.ts

@@ -0,0 +1,73 @@
+import { FirewallLabels, InfrastructureCaches, TaskExecutor } from '@spinnaker/core';
+import type { Application, ISecurityGroup, ITask } from '@spinnaker/core';
+
+type AzureSecurityGroupCommand = Record<string, any>;
+
+function getSecurityGroupAccount(securityGroup: ISecurityGroup & AzureSecurityGroupCommand): string {
+  return securityGroup.accountId || securityGroup.account || securityGroup.accountName || securityGroup.credentials;
+}
+
+export function buildUpsertCommand(
+  securityGroup: ISecurityGroup & AzureSecurityGroupCommand,
+  params: AzureSecurityGroupCommand = {},
+): AzureSecurityGroupCommand {
+  return {
+    ...securityGroup,
+    ...params,
+    securityGroupName: securityGroup.name,
+  };
+}
+
+export function buildDeleteCommand(
+  securityGroup: ISecurityGroup & AzureSecurityGroupCommand,
+  application: Application,
+  params: AzureSecurityGroupCommand = {},
+): AzureSecurityGroupCommand {
+  return {
+    ...params,
+    type: 'deleteSecurityGroup',
+    securityGroupName: securityGroup.name,
+    regions: [securityGroup.region],
+    credentials: getSecurityGroupAccount(securityGroup),
+    appName: application.name,
+  };
+}
+
+export const AzureSecurityGroupWriter = {
+  upsertSecurityGroup(
+    securityGroup: ISecurityGroup & AzureSecurityGroupCommand,
+    application: Application,
+    descriptor: string,
+    params: AzureSecurityGroupCommand = {},
+  ): Promise<ITask> {
+    const command = buildUpsertCommand(securityGroup, params);
+
+    const operation = TaskExecutor.executeTask({
+      job: [command],
+      application,
+      description: `${descriptor} ${FirewallLabels.get('Firewall')}: ${securityGroup.name}`,
+    });
+
+    InfrastructureCaches.clearCache('securityGroups');
+
+    return operation;
+  },
+
+  deleteSecurityGroup(
+    securityGroup: ISecurityGroup & AzureSecurityGroupCommand,
+    application: Application,
+    params: AzureSecurityGroupCommand = {},
+  ): Promise<ITask> {
+    const command = buildDeleteCommand(securityGroup, application, params);
+
+    const operation = TaskExecutor.executeTask({
+      job: [command],
+      application,
+      description: `Delete ${FirewallLabels.get('Firewalls')}: ${securityGroup.name}`,
+    });
+
+    InfrastructureCaches.clearCache('securityGroups');
+
+    return operation;
+  },
+};

package/src/serverGroup/configure/serverGroupCommandBuilder.service.js

@@ -1,175 +1,176 @@
-'use strict';
-
-import * as angular from 'angular';
 import _ from 'lodash';
 
 import { NameUtils } from '@spinnaker/core';
-import { AZURE_IMAGE_IMAGE_READER } from '../../image/image.reader';
-import { AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER } from '../serverGroup.transformer';
-
-export const AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE =
-  'spinnaker.azure.serverGroupCommandBuilder.service';
-export const name = AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE; // for backwards compatibility
-angular
-  .module(AZURE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE, [
-    AZURE_IMAGE_IMAGE_READER,
-    AZURE_SERVERGROUP_SERVERGROUP_TRANSFORMER,
-  ])
-  .factory('azureServerGroupCommandBuilder', [
-    '$q',
-    'azureImageReader',
-    'azureServerGroupTransformer',
-    function ($q, azureImageReader, azureServerGroupTransformer) {
-      function buildNewServerGroupCommand(application, defaults) {
-        defaults = defaults || {};
-
-        const defaultCredentials = defaults.account || application.defaultCredentials.azure;
-        const defaultRegion = defaults.region || application.defaultRegions.azure;
-
-        return azureImageReader.findImages({ provider: 'azure' }).then(function (images) {
-          return {
-            application: application.name,
-            credentials: defaultCredentials,
-            region: defaultRegion,
-            images,
-            loadBalancers: [],
-            selectedVnetSubnets: [],
-            strategy: '',
-            sku: {
-              capacity: 1,
-            },
-            zonesEnabled: false,
-            zones: [],
-            instanceTags: {},
-            dataDisks: [],
-            selectedProvider: 'azure',
-            viewState: {
-              instanceProfile: 'custom',
-              allImageSelection: null,
-              useAllImageSelection: false,
-              useSimpleCapacity: true,
-              usePreferredZones: true,
-              mode: defaults.mode || 'create',
-              disableStrategySelection: true,
-              loadBalancersConfigured: false,
-              networkSettingsConfigured: false,
-              securityGroupsConfigured: false,
-            },
-            enableInboundNAT: false,
-          };
-        });
-      }
+import { AzureImageReader } from '../../image/image.reader';
+import { AzureServerGroupTransformer } from '../serverGroup.transformer';
 
-      // Only used to prepare view requiring template selecting
-      function buildNewServerGroupCommandForPipeline() {
-        return $q.when({
-          viewState: {
-            requiresTemplateSelection: true,
-          },
-        });
-      }
+export class AzureServerGroupCommandBuilder {
+  constructor(promiseService) {
+    this.promiseService = promiseService;
+    this.azureImageReader = new AzureImageReader();
+    this.azureServerGroupTransformer = new AzureServerGroupTransformer();
+  }
 
-      function buildServerGroupCommandFromExisting(application, serverGroup, mode) {
-        mode = mode || 'clone';
-
-        const serverGroupName = NameUtils.parseServerGroupName(serverGroup.name);
-
-        const command = {
-          application: application.name,
-          strategy: '',
-          stack: serverGroupName.stack,
-          freeFormDetails: serverGroupName.freeFormDetails,
-          credentials: serverGroup.account,
-          loadBalancers: serverGroup.loadBalancers,
-          selectedSubnets: serverGroup.selectedVnetSubnets,
-          selectedVnet: serverGroup.selectedVnet,
-          securityGroups: serverGroup.securityGroups,
-          loadBalancerName: serverGroup.loadBalancerName,
-          loadBalancerType: serverGroup.loadBalancerType,
-          securityGroupName: serverGroup.securityGroupName,
-          region: serverGroup.region,
-          vnet: serverGroup.vnet,
-          vnetResourceGroup: serverGroup.vnetResourceGroup,
-          subnet: serverGroup.subnet,
-          zones: serverGroup.zones,
-          zonesEnabled: serverGroup.zones && serverGroup.zones.length > 0,
-          instanceTags: {},
-          dataDisks: serverGroup.dataDisks,
-          sku: serverGroup.sku,
-          capacity: {
-            min: serverGroup.capacity.min,
-            max: serverGroup.capacity.max,
-            desired: serverGroup.capacity.desired,
-          },
-          tags: [],
-          instanceType: serverGroup.sku.name,
-          selectedProvider: 'azure',
-          source: {
-            account: serverGroup.account,
-            region: serverGroup.region,
-            serverGroupName: serverGroup.name,
-            asgName: serverGroup.name,
-          },
-          viewState: {
-            allImageSelection: null,
-            useAllImageSelection: false,
-            useSimpleCapacity: true,
-            usePreferredZones: false,
-            listImplicitSecurityGroups: false,
-            mode: mode,
-            disableStrategySelection: true,
-          },
-          enableInboundNAT: serverGroup.enableInboundNAT,
-        };
-
-        if (typeof serverGroup.customScriptsSettings !== 'undefined') {
-          command.customScriptsSettings = {};
-          command.customScriptsSettings.commandToExecute = serverGroup.customScriptsSettings.commandToExecute;
-          if (!_.isEmpty(serverGroup.customScriptsSettings.fileUris)) {
-            azureServerGroupTransformer.parseCustomScriptsSettings(serverGroup, command);
-          }
-        }
-
-        return $q.when(command);
-      }
+  resolve(value) {
+    return this.promiseService.resolve(value);
+  }
 
-      function buildServerGroupCommandFromPipeline(application, originalCluster) {
-        const pipelineCluster = _.cloneDeep(originalCluster);
-        const region = pipelineCluster.region;
-
-        const commandOptions = { account: pipelineCluster.account, region: region };
-        return buildNewServerGroupCommand(application, commandOptions).then(function (command) {
-          const viewState = {
-            disableImageSelection: true,
-            useSimpleCapacity: true,
-            mode: 'editPipeline',
-            submitButtonLabel: 'Done',
-            instanceProfile: originalCluster.viewState.instanceProfile,
-            instanceTypeDetails: originalCluster.viewState.instanceTypeDetails,
-          };
-
-          const viewOverrides = {
-            region: region,
-            credentials: pipelineCluster.account,
-            viewState: viewState,
-          };
-          if (originalCluster.viewState.instanceTypeDetails) {
-            viewOverrides.instanceType = originalCluster.viewState.instanceTypeDetails.name;
-          }
-
-          pipelineCluster.strategy = pipelineCluster.strategy || '';
-
-          const extendedCommand = angular.extend({}, command, pipelineCluster, viewOverrides);
-
-          return extendedCommand;
-        });
-      }
+  buildNewServerGroupCommand(application, defaults) {
+    defaults = defaults || {};
+
+    const defaultCredentials = defaults.account || application.defaultCredentials.azure;
+    const defaultRegion = defaults.region || application.defaultRegions.azure;
 
+    return this.azureImageReader.findImages({ provider: 'azure' }).then(function (images) {
       return {
-        buildNewServerGroupCommand: buildNewServerGroupCommand,
-        buildNewServerGroupCommandForPipeline: buildNewServerGroupCommandForPipeline,
-        buildServerGroupCommandFromExisting: buildServerGroupCommandFromExisting,
-        buildServerGroupCommandFromPipeline: buildServerGroupCommandFromPipeline,
+        application: application.name,
+        credentials: defaultCredentials,
+        region: defaultRegion,
+        images,
+        loadBalancers: [],
+        selectedVnetSubnets: [],
+        strategy: '',
+        sku: {
+          capacity: 1,
+        },
+        zonesEnabled: false,
+        zones: [],
+        instanceTags: {},
+        dataDisks: [],
+        selectedProvider: 'azure',
+        viewState: {
+          instanceProfile: 'custom',
+          allImageSelection: null,
+          useAllImageSelection: false,
+          useSimpleCapacity: true,
+          usePreferredZones: true,
+          mode: defaults.mode || 'create',
+          disableStrategySelection: true,
+          loadBalancersConfigured: false,
+          networkSettingsConfigured: false,
+          securityGroupsConfigured: false,
+        },
+        enableInboundNAT: false,
+      };
+    });
+  }
+
+  // Only used to prepare view requiring template selecting
+  buildNewServerGroupCommandForPipeline() {
+    return this.resolve({
+      viewState: {
+        requiresTemplateSelection: true,
+      },
+    });
+  }
+
+  buildServerGroupCommandFromExisting(application, serverGroup, mode) {
+    mode = mode || 'clone';
+
+    const serverGroupName = NameUtils.parseServerGroupName(serverGroup.name);
+
+    const command = {
+      application: application.name,
+      strategy: '',
+      stack: serverGroupName.stack,
+      freeFormDetails: serverGroupName.freeFormDetails,
+      credentials: serverGroup.account,
+      loadBalancers: serverGroup.loadBalancers,
+      selectedSubnets: serverGroup.selectedVnetSubnets,
+      selectedVnet: serverGroup.selectedVnet,
+      securityGroups: serverGroup.securityGroups,
+      loadBalancerName: serverGroup.loadBalancerName,
+      loadBalancerType: serverGroup.loadBalancerType,
+      securityGroupName: serverGroup.securityGroupName,
+      region: serverGroup.region,
+      vnet: serverGroup.vnet,
+      vnetResourceGroup: serverGroup.vnetResourceGroup,
+      subnet: serverGroup.subnet,
+      zones: serverGroup.zones,
+      zonesEnabled: serverGroup.zones && serverGroup.zones.length > 0,
+      instanceTags: {},
+      dataDisks: serverGroup.dataDisks,
+      sku: serverGroup.sku,
+      capacity: {
+        min: serverGroup.capacity.min,
+        max: serverGroup.capacity.max,
+        desired: serverGroup.capacity.desired,
+      },
+      tags: [],
+      instanceType: serverGroup.sku.name,
+      selectedProvider: 'azure',
+      source: {
+        account: serverGroup.account,
+        region: serverGroup.region,
+        serverGroupName: serverGroup.name,
+        asgName: serverGroup.name,
+      },
+      viewState: {
+        allImageSelection: null,
+        useAllImageSelection: false,
+        useSimpleCapacity: true,
+        usePreferredZones: false,
+        listImplicitSecurityGroups: false,
+        mode: mode,
+        disableStrategySelection: true,
+      },
+      enableInboundNAT: serverGroup.enableInboundNAT,
+    };
+
+    if (typeof serverGroup.customScriptsSettings !== 'undefined') {
+      command.customScriptsSettings = {};
+      command.customScriptsSettings.commandToExecute = serverGroup.customScriptsSettings.commandToExecute;
+      if (!_.isEmpty(serverGroup.customScriptsSettings.fileUris)) {
+        this.azureServerGroupTransformer.parseCustomScriptsSettings(serverGroup, command);
+      }
+    }
+
+    return this.azureImageReader.findImages({ provider: 'azure' }).then((images) => {
+      const sourceImage = serverGroup.image || {};
+      const imageName = sourceImage.imageName || serverGroup.imageName || serverGroup.amiName;
+      const selectedImage = images.find((image) => image.imageName === imageName);
+
+      command.images = images;
+      if (sourceImage.isCustom || sourceImage.uri) {
+        command.image = { ...sourceImage, isCustom: true, region: sourceImage.region || serverGroup.region };
+      } else if (imageName) {
+        command.imageName = imageName;
+        command.selectedImage = selectedImage || sourceImage;
+      }
+
+      return command;
+    });
+  }
+
+  buildServerGroupCommandFromPipeline(application, originalCluster) {
+    const pipelineCluster = _.cloneDeep(originalCluster);
+    const region = pipelineCluster.region;
+
+    const commandOptions = { account: pipelineCluster.account, region: region };
+    return this.buildNewServerGroupCommand(application, commandOptions).then(function (command) {
+      const viewState = {
+        disableImageSelection: true,
+        useSimpleCapacity: true,
+        mode: 'editPipeline',
+        submitButtonLabel: 'Done',
+        instanceProfile: originalCluster.viewState.instanceProfile,
+        instanceTypeDetails: originalCluster.viewState.instanceTypeDetails,
+      };
+
+      const viewOverrides = {
+        region: region,
+        credentials: pipelineCluster.account,
+        viewState: viewState,
       };
-    },
-  ]);
+      if (originalCluster.viewState.instanceTypeDetails) {
+        viewOverrides.instanceType = originalCluster.viewState.instanceTypeDetails.name;
+      }
+
+      pipelineCluster.strategy = pipelineCluster.strategy || '';
+
+      const extendedCommand = _.extend({}, command, pipelineCluster, viewOverrides);
+
+      return extendedCommand;
+    });
+  }
+}

package/src/serverGroup/configure/serverGroupCommandBuilder.service.spec.js

@@ -0,0 +1,63 @@
+import { nativePromiseService } from '@spinnaker/core';
+
+import { AzureImageReader } from '../../image/image.reader';
+import { AzureServerGroupCommandBuilder } from './serverGroupCommandBuilder.service';
+
+describe('AzureServerGroupCommandBuilder', function () {
+  function serverGroup(overrides = {}) {
+    return {
+      name: 'fnord-web-v001',
+      account: 'test',
+      region: 'westus',
+      loadBalancers: [],
+      selectedVnetSubnets: [],
+      selectedVnet: { name: 'vnet-a' },
+      securityGroups: [],
+      zones: [],
+      dataDisks: [],
+      sku: { name: 'Standard_DS1_v2', capacity: 1 },
+      capacity: { min: 1, max: 1, desired: 1 },
+      ...overrides,
+    };
+  }
+
+  it('builds clone commands with image options and the current marketplace image selected', async function () {
+    const images = [
+      { imageName: 'ubuntu-west', amis: { westus: ['ami-west'] } },
+      { imageName: 'ubuntu-east', amis: { eastus: ['ami-east'] } },
+    ];
+    spyOn(AzureImageReader.prototype, 'findImages').and.returnValue(Promise.resolve(images));
+
+    const command = await new AzureServerGroupCommandBuilder(nativePromiseService).buildServerGroupCommandFromExisting(
+      { name: 'fnord' },
+      serverGroup({ image: { imageName: 'ubuntu-west' } }),
+    );
+
+    expect(AzureImageReader.prototype.findImages).toHaveBeenCalledWith({ provider: 'azure' });
+    expect(command.images).toBe(images);
+    expect(command.imageName).toBe('ubuntu-west');
+    expect(command.selectedImage).toBe(images[0]);
+  });
+
+  it('builds clone commands with image options and the current custom image preserved', async function () {
+    const images = [{ imageName: 'ubuntu-west', amis: { westus: ['ami-west'] } }];
+    spyOn(AzureImageReader.prototype, 'findImages').and.returnValue(Promise.resolve(images));
+
+    const command = await new AzureServerGroupCommandBuilder(nativePromiseService).buildServerGroupCommandFromExisting(
+      { name: 'fnord' },
+      serverGroup({
+        image: { isCustom: true, imageName: 'custom-image', ostype: 'Linux', uri: 'https://image.vhd' },
+      }),
+    );
+
+    expect(command.images).toBe(images);
+    expect(command.image).toEqual({
+      isCustom: true,
+      imageName: 'custom-image',
+      ostype: 'Linux',
+      uri: 'https://image.vhd',
+      region: 'westus',
+    });
+    expect(command.selectedImage).toBeUndefined();
+  });
+});