@spinnaker/titus 0.0.0-2025.1-0

package/src/pipeline/stages/scaleDownCluster/scaleDownClusterStage.html

@@ -0,0 +1,35 @@
+<div ng-controller="titusScaleDownClusterStageCtrl as scaleDownClusterStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Scale Down Options">
+    <div class="form-inline">
+      <p>
+        Keep the
+        <input
+          type="number"
+          min="0"
+          required
+          ng-model="stage.remainingFullSizeServerGroups"
+          class="form-control input-sm"
+          style="width: 50px"
+        />
+        <select class="form-control input-sm" ng-model="stage.preferLargerOverNewer" style="width: 100px">
+          <option value="true">largest</option>
+          <option value="false">newest</option>
+        </select>
+        {{scaleDownClusterStageCtrl.pluralize('server group', stage.remainingFullSizeServerGroups)}} at current size.
+      </p>
+      <p>The remaining server groups will be scaled down to zero instances.</p>
+    </div>
+  </stage-config-field>
+  <div class="form-group">
+    <div class="col-md-offset-3 col-md-6 checkbox">
+      <label>
+        <input type="checkbox" ng-model="stage.allowScaleDownActive" />
+        Allow scale down of active server groups
+      </label>
+    </div>
+  </div>
+</div>

package/src/pipeline/stages/scaleDownCluster/titusScaleDownClusterStage.js

@@ -0,0 +1,79 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, Registry } from '@spinnaker/core';
+
+export const TITUS_PIPELINE_STAGES_SCALEDOWNCLUSTER_TITUSSCALEDOWNCLUSTERSTAGE =
+  'spinnaker.titus.pipeline.stage.scaleDownClusterStage';
+export const name = TITUS_PIPELINE_STAGES_SCALEDOWNCLUSTER_TITUSSCALEDOWNCLUSTERSTAGE; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_SCALEDOWNCLUSTER_TITUSSCALEDOWNCLUSTERSTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'scaleDownCluster',
+      cloudProvider: 'titus',
+      templateUrl: require('./scaleDownClusterStage.html'),
+      executionConfigSections: ['scaleDownClusterConfig', 'taskStatus'],
+      accountExtractor: (stage) => [stage.context.credentials],
+      configAccountExtractor: (stage) => [stage.credentials],
+      validators: [
+        { type: 'requiredField', fieldName: 'cluster' },
+        {
+          type: 'requiredField',
+          fieldName: 'remainingFullSizeServerGroups',
+          fieldLabel: 'Keep [X] full size Server Groups',
+        },
+        { type: 'requiredField', fieldName: 'regions' },
+        { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+      ],
+      strategy: true,
+    });
+  })
+  .controller('titusScaleDownClusterStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const ctrl = this;
+
+      const stage = $scope.stage;
+
+      $scope.state = {
+        accounts: false,
+        regionsLoaded: false,
+      };
+
+      AccountService.listAccounts('titus').then(function (accounts) {
+        $scope.accounts = accounts;
+        $scope.state.accounts = true;
+      });
+
+      stage.regions = stage.regions || [];
+      stage.cloudProvider = 'titus';
+
+      if (!stage.credentials && $scope.application.defaultCredentials.titus) {
+        stage.credentials = $scope.application.defaultCredentials.titus;
+      }
+      if (!stage.regions.length && $scope.application.defaultRegions.titus) {
+        stage.regions.push($scope.application.defaultRegions.titus);
+      }
+
+      if (stage.remainingFullSizeServerGroups === undefined) {
+        stage.remainingFullSizeServerGroups = 1;
+      }
+
+      if (stage.allowScaleDownActive === undefined) {
+        stage.allowScaleDownActive = false;
+      }
+
+      ctrl.pluralize = function (str, val) {
+        if (val === 1) {
+          return str;
+        }
+        return str + 's';
+      };
+
+      if (stage.preferLargerOverNewer === undefined) {
+        stage.preferLargerOverNewer = 'false';
+      }
+      stage.preferLargerOverNewer = stage.preferLargerOverNewer.toString();
+    },
+  ]);

package/src/pipeline/stages/shrinkCluster/shrinkClusterStage.html

@@ -0,0 +1,34 @@
+<div ng-controller="titusShrinkClusterStageCtrl as shrinkClusterStageCtrl" class="form-horizontal">
+  <div ng-if="!pipeline.strategy">
+    <account-region-cluster-selector application="application" component="stage" accounts="accounts">
+    </account-region-cluster-selector>
+  </div>
+  <stage-config-field label="Shrink Options">
+    <div class="form-inline">
+      Shrink to
+      <input
+        type="number"
+        min="0"
+        required
+        ng-model="stage.shrinkToSize"
+        class="form-control input-sm"
+        style="width: 50px"
+      />
+      {{shrinkClusterStageCtrl.pluralize('server group', stage.shrinkToSize)}}, keeping the
+      <select class="form-control input-sm" ng-model="stage.retainLargerOverNewer" style="width: 100px">
+        <option value="true">largest</option>
+        <option value="false">newest</option>
+      </select>
+    </div>
+  </stage-config-field>
+  <div class="form-group">
+    <div class="col-md-offset-3 col-md-6 checkbox">
+      <label>
+        <input type="checkbox" ng-model="stage.allowDeleteActive" />
+        Allow deletion of active server groups
+      </label>
+    </div>
+  </div>
+  <stage-platform-health-override application="application" stage="stage" platform-health-type="'Titus'">
+  </stage-platform-health-override>
+</div>

package/src/pipeline/stages/shrinkCluster/titusShrinkClusterStage.js

@@ -0,0 +1,73 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { AccountService, Registry } from '@spinnaker/core';
+
+export const TITUS_PIPELINE_STAGES_SHRINKCLUSTER_TITUSSHRINKCLUSTERSTAGE =
+  'spinnaker.titus.pipeline.stage.shrinkClusterStage';
+export const name = TITUS_PIPELINE_STAGES_SHRINKCLUSTER_TITUSSHRINKCLUSTERSTAGE; // for backwards compatibility
+module(TITUS_PIPELINE_STAGES_SHRINKCLUSTER_TITUSSHRINKCLUSTERSTAGE, [])
+  .config(function () {
+    Registry.pipeline.registerStage({
+      provides: 'shrinkCluster',
+      cloudProvider: 'titus',
+      templateUrl: require('./shrinkClusterStage.html'),
+      accountExtractor: (stage) => [stage.context.credentials],
+      configAccountExtractor: (stage) => [stage.credentials],
+      validators: [
+        { type: 'requiredField', fieldName: 'cluster' },
+        { type: 'requiredField', fieldName: 'shrinkToSize', fieldLabel: 'shrink to [X] Server Groups' },
+        { type: 'requiredField', fieldName: 'regions' },
+        { type: 'requiredField', fieldName: 'credentials', fieldLabel: 'account' },
+      ],
+    });
+  })
+  .controller('titusShrinkClusterStageCtrl', [
+    '$scope',
+    function ($scope) {
+      const ctrl = this;
+
+      const stage = $scope.stage;
+
+      $scope.state = {
+        accounts: false,
+        regionsLoaded: false,
+      };
+
+      AccountService.listAccounts('titus').then(function (accounts) {
+        $scope.accounts = accounts;
+        $scope.state.accounts = true;
+      });
+
+      stage.regions = stage.regions || [];
+      stage.cloudProvider = 'titus';
+
+      if (!stage.credentials && $scope.application.defaultCredentials.titus) {
+        stage.credentials = $scope.application.defaultCredentials.titus;
+      }
+      if (!stage.regions.length && $scope.application.defaultRegions.titus) {
+        stage.regions.push($scope.application.defaultRegions.titus);
+      }
+
+      if (stage.shrinkToSize === undefined) {
+        stage.shrinkToSize = 1;
+      }
+
+      if (stage.allowDeleteActive === undefined) {
+        stage.allowDeleteActive = false;
+      }
+
+      ctrl.pluralize = function (str, val) {
+        if (val === 1) {
+          return str;
+        }
+        return str + 's';
+      };
+
+      if (stage.retainLargerOverNewer === undefined) {
+        stage.retainLargerOverNewer = 'false';
+      }
+      stage.retainLargerOverNewer = stage.retainLargerOverNewer.toString();
+    },
+  ]);

package/src/reactShims/index.ts

@@ -0,0 +1 @@
+export * from './titus.react.injector';

package/src/reactShims/titus.react.injector.ts

@@ -0,0 +1,17 @@
+import IInjectorService = angular.auto.IInjectorService;
+
+import { ReactInject } from '@spinnaker/core';
+
+// prettier-ignore
+export class TitusReactInject extends ReactInject {
+  public get titusServerGroupTransformer() { return this.$injector.get('titusServerGroupTransformer') as any; }
+  public get titusServerGroupCommandBuilder() { return this.$injector.get('titusServerGroupCommandBuilder') as any; }
+  public get titusServerGroupConfigurationService() { return this.$injector.get('titusServerGroupConfigurationService') as any; }
+  public get titusSecurityGroupReader() { return this.$injector.get('titusSecurityGroupReader') as any; }
+
+  public initialize($injector: IInjectorService) {
+    this.$injector = $injector;
+  }
+}
+
+export const TitusReactInjector: TitusReactInject = new TitusReactInject();

package/src/reactShims/titus.react.module.ts

@@ -0,0 +1,10 @@
+import { module } from 'angular';
+import { TitusReactInjector } from './titus.react.injector';
+
+export const TITUS_REACT_MODULE = 'spinnaker.titus.react';
+module(TITUS_REACT_MODULE, []).run([
+  '$injector',
+  function ($injector: any) {
+    TitusReactInjector.initialize($injector);
+  },
+]);

package/src/securityGroup/securityGroup.read.service.js

@@ -0,0 +1,15 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const TITUS_SECURITYGROUP_SECURITYGROUP_READ_SERVICE = 'spinnaker.titus.securityGroup.reader';
+export const name = TITUS_SECURITYGROUP_SECURITYGROUP_READ_SERVICE; // for backwards compatibility
+module(TITUS_SECURITYGROUP_SECURITYGROUP_READ_SERVICE, []).factory('titusSecurityGroupReader', function () {
+  function resolveIndexedSecurityGroup(indexedSecurityGroups, container, securityGroupId) {
+    return indexedSecurityGroups[container.awsAccount][container.region][securityGroupId];
+  }
+
+  return {
+    resolveIndexedSecurityGroup: resolveIndexedSecurityGroup,
+  };
+});

package/src/serverGroup/configure/ServerGroupCommandBuilder.js

@@ -0,0 +1,247 @@
+'use strict';
+
+import * as angular from 'angular';
+
+import { cloneDeep, set } from 'lodash';
+import { NameUtils } from '@spinnaker/core';
+import { TitusProviderSettings } from '../../titus.settings';
+
+export const TITUS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER =
+  'spinnaker.titus.serverGroupCommandBuilder.service';
+export const name = TITUS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER; // for backwards compatibility
+angular.module(TITUS_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER, []).factory('titusServerGroupCommandBuilder', [
+  '$q',
+  function ($q) {
+    function getDefaultIamProfile(application) {
+      const defaultIamProfile = TitusProviderSettings.defaults.iamProfile || '{{application}}InstanceProfile';
+      return defaultIamProfile.replace('{{application}}', application.name);
+    }
+
+    function buildNewServerGroupCommand(application, defaults) {
+      defaults = defaults || {};
+
+      const defaultCredentials = defaults.account || TitusProviderSettings.defaults.account;
+      const defaultRegion = defaults.region || TitusProviderSettings.defaults.region;
+      const defaultZone = defaults.zone || TitusProviderSettings.defaults.zone;
+      const defaultIamProfile = getDefaultIamProfile(application);
+
+      const command = {
+        application: application.name,
+        credentials: defaultCredentials,
+        region: defaultRegion,
+        zone: defaultZone,
+        network: 'default',
+        inService: true,
+        resources: {
+          cpu: 1,
+          networkMbps: 128,
+          disk: 10000,
+          memory: 512,
+          gpu: 0,
+        },
+        efs: {
+          mountPerm: 'RW',
+        },
+        strategy: '',
+        capacity: {
+          min: 1,
+          max: 1,
+          desired: 1,
+        },
+        targetHealthyDeployPercentage: 100,
+        env: {},
+        labels: {},
+        containerAttributes: {
+          'titusParameter.agent.assignIPv6Address': 'true',
+        },
+        cloudProvider: 'titus',
+        selectedProvider: 'titus',
+        iamProfile: defaultIamProfile,
+        constraints: {
+          hard: {},
+          soft: {},
+        },
+        serviceJobProcesses: {},
+        viewState: {
+          defaultIamProfile,
+          useSimpleCapacity: true,
+          usePreferredZones: true,
+          mode: defaults.mode || 'create',
+        },
+        securityGroups: [],
+        imageId: defaults.imageId,
+        migrationPolicy: { type: 'systemDefault' },
+        digest: '',
+        organization: '',
+        tag: '',
+        registry: '',
+        repository: '',
+      };
+
+      return $q.when(command);
+    }
+
+    // Only used to prepare view requiring template selecting
+    function buildNewServerGroupCommandForPipeline() {
+      return $q.when({
+        viewState: {
+          requiresTemplateSelection: true,
+        },
+      });
+    }
+
+    function buildServerGroupCommandFromExisting(application, serverGroup, mode) {
+      mode = mode || 'clone';
+
+      const serverGroupName = NameUtils.parseServerGroupName(serverGroup.name);
+
+      const isTestEnv = serverGroup.awsAccount === 'test';
+      const isIPv6Set =
+        serverGroup.containerAttributes &&
+        serverGroup.containerAttributes['titusParameter.agent.assignIPv6Address'] !== undefined;
+
+      // If IPv6 hasn't been explicitly set by the user, auto-assign based on the environment.
+      const assignIPv6Address = isIPv6Set
+        ? serverGroup.containerAttributes['titusParameter.agent.assignIPv6Address']
+        : isTestEnv
+        ? 'true'
+        : 'false';
+
+      const containerAttributes = {
+        ...serverGroup.containerAttributes,
+        'titusParameter.agent.assignIPv6Address': assignIPv6Address,
+      };
+
+      const command = {
+        application: application.name,
+        disruptionBudget: serverGroup.disruptionBudget,
+        strategy: '',
+        stack: serverGroupName.stack,
+        freeFormDetails: serverGroupName.freeFormDetails,
+        account: serverGroup.account,
+        credentials: serverGroup.account,
+        region: serverGroup.region,
+        env: serverGroup.env,
+        labels: serverGroup.labels,
+        containerAttributes,
+        entryPoint: serverGroup.entryPoint,
+        iamProfile: serverGroup.iamProfile,
+        capacityGroup: serverGroup.capacityGroup,
+        migrationPolicy: serverGroup.migrationPolicy ? serverGroup.migrationPolicy : { type: 'systemDefault' },
+        securityGroups: serverGroup.securityGroups || [],
+        constraints: {
+          hard: (serverGroup.constraints && serverGroup.constraints.hard) || {},
+          soft: (serverGroup.constraints && serverGroup.constraints.soft) || {},
+        },
+        serviceJobProcesses: Object.assign({}, serverGroup.serviceJobProcesses),
+        inService: serverGroup.disabled ? false : true,
+        source: {
+          account: serverGroup.account,
+          region: serverGroup.region,
+          asgName: serverGroup.name,
+        },
+        resources: {
+          cpu: serverGroup.resources.cpu,
+          gpu: serverGroup.resources.gpu,
+          memory: serverGroup.resources.memory,
+          disk: serverGroup.resources.disk,
+          networkMbps: serverGroup.resources.networkMbps,
+        },
+        targetGroups: serverGroup.targetGroups,
+        capacity: {
+          min: serverGroup.capacity.min,
+          max: serverGroup.capacity.max,
+          desired: serverGroup.capacity.desired,
+        },
+        targetHealthyDeployPercentage: 100,
+        cloudProvider: 'titus',
+        selectedProvider: 'titus',
+        viewState: {
+          defaultIamProfile: getDefaultIamProfile(application),
+          useSimpleCapacity: serverGroup.capacity.min === serverGroup.capacity.max,
+          mode: mode,
+        },
+        organization: '',
+        tag: '',
+        digest: '',
+        registry: '',
+        repository: '',
+      };
+
+      if (serverGroup.efs) {
+        command.efs = {
+          mountPoint: serverGroup.efs.mountPoint,
+          mountPerm: serverGroup.efs.mountPerm,
+          efsId: serverGroup.efs.efsId,
+        };
+      } else {
+        command.efs = {
+          mountPerm: 'RW',
+        };
+      }
+
+      if (mode !== 'editPipeline') {
+        command.imageId =
+          serverGroup.image.dockerImageName +
+          ':' +
+          (serverGroup.image.dockerImageVersion
+            ? serverGroup.image.dockerImageVersion
+            : serverGroup.image.dockerImageDigest);
+      }
+
+      return $q.when(command);
+    }
+
+    function buildServerGroupCommandFromPipeline(application, originalCluster) {
+      const pipelineCluster = cloneDeep(originalCluster);
+      const commandOptions = {
+        account: pipelineCluster.account,
+        imageId: pipelineCluster.imageId,
+        region: pipelineCluster.region,
+      };
+
+      return buildNewServerGroupCommand(application, commandOptions).then(function (command) {
+        command.constraints = {
+          hard:
+            (originalCluster.constraints && originalCluster.constraints.hard) ||
+            (originalCluster.hardConstraints &&
+              originalCluster.hardConstraints.reduce((a, c) => set(a, c, 'true'), {})) ||
+            {},
+          soft:
+            (originalCluster.constraints && originalCluster.constraints.soft) ||
+            (originalCluster.softConstraints &&
+              originalCluster.softConstraints.reduce((a, c) => set(a, c, 'true'), {})) ||
+            {},
+        };
+        delete pipelineCluster.hardConstraints;
+        delete pipelineCluster.softConstraints;
+
+        const viewState = {
+          disableImageSelection: true,
+          useSimpleCapacity: originalCluster.capacity.min === originalCluster.capacity.max,
+          mode: 'editPipeline',
+          submitButtonLabel: 'Done',
+          defaultIamProfile: getDefaultIamProfile(application),
+        };
+
+        const viewOverrides = {
+          region: pipelineCluster.region,
+          credentials: pipelineCluster.account,
+          iamProfile: pipelineCluster.iamProfile,
+          viewState: viewState,
+        };
+
+        pipelineCluster.strategy = pipelineCluster.strategy || '';
+        const extendedCommand = angular.extend({}, command, pipelineCluster, viewOverrides);
+        return extendedCommand;
+      });
+    }
+
+    return {
+      buildNewServerGroupCommand,
+      buildNewServerGroupCommandForPipeline,
+      buildServerGroupCommandFromExisting,
+      buildServerGroupCommandFromPipeline,
+    };
+  },
+]);

package/src/serverGroup/configure/serverGroup.configure.titus.module.js

@@ -0,0 +1,9 @@
+'use strict';
+
+import { module } from 'angular';
+
+import { TITUS_SERVER_GROUP_CONFIGURATION_SERVICE } from './serverGroupConfiguration.service';
+
+export const TITUS_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_TITUS_MODULE = 'spinnaker.serverGroup.configure.titus';
+export const name = TITUS_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_TITUS_MODULE; // for backwards compatibility
+module(TITUS_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_TITUS_MODULE, [TITUS_SERVER_GROUP_CONFIGURATION_SERVICE]);

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

@@ -0,0 +1,63 @@
+'use strict';
+
+import { NameUtils } from 'core/naming';
+
+import { TitusProviderSettings } from '../../titus.settings';
+
+describe('titusServerGroupCommandBuilder', function () {
+  beforeEach(window.module(require('./ServerGroupCommandBuilder').name));
+
+  beforeEach(
+    window.inject(function (titusServerGroupCommandBuilder, $q, $rootScope) {
+      this.titusServerGroupCommandBuilder = titusServerGroupCommandBuilder;
+      this.$scope = $rootScope;
+      this.$q = $q;
+    }),
+  );
+
+  afterEach(TitusProviderSettings.resetToOriginal);
+
+  describe('buildNewServerGroupCommand', function () {
+    it('should initializes to default values', function () {
+      var command = null;
+      TitusProviderSettings.defaults.iamProfile = '{{application}}InstanceProfile';
+      this.titusServerGroupCommandBuilder.buildNewServerGroupCommand({ name: 'titusApp' }).then(function (result) {
+        command = result;
+      });
+
+      this.$scope.$digest();
+      expect(command.iamProfile).toBe('titusAppInstanceProfile');
+      expect(command.viewState.mode).toBe('create');
+    });
+  });
+
+  describe('buildServerGroupCommandFromExisting', function () {
+    it('should set iam profile if available otherwise use the default', function () {
+      spyOn(NameUtils, 'parseServerGroupName').and.returnValue(this.$q.when('titusApp-test-test'));
+
+      var baseServerGroup = {
+        account: 'prod',
+        region: 'us-west-1',
+        cluster: 'titus-test-test',
+        type: 'titus',
+        loudProvider: 'titus',
+        iamProfile: 'titusAppInstanceProfile',
+        resources: {},
+        capacity: {},
+        image: {},
+      };
+
+      var command = null;
+      this.titusServerGroupCommandBuilder
+        .buildServerGroupCommandFromExisting({ name: 'titusApp' }, baseServerGroup)
+        .then(function (result) {
+          command = result;
+        });
+
+      this.$scope.$digest();
+
+      expect(command.iamProfile).toBe('titusAppInstanceProfile');
+      expect(command.viewState.mode).toBe('clone');
+    });
+  });
+});