@spinnaker/core 2026.2.2 → 2026.3.0

package/src/pipeline/manualExecution/ManualPipelineExecutionModal.tsx

@@ -16,6 +16,7 @@ import type { ITriggerTemplateComponentProps } from './TriggerTemplate';
 import { Triggers } from './Triggers';
 import type { Application } from '../../application';
 import { AuthenticationService } from '../../authentication';
+import type { DeckRuntimeServices } from '../../bootstrap/DeckRuntimeServices';
 import { SETTINGS } from '../../config/settings';
 import type { IPipelineTemplateConfig } from '../config/templates';
 import { PipelineTemplateReader } from '../config/templates/PipelineTemplateReader';
@@ -157,11 +158,11 @@ export class ManualExecutionModal extends React.Component<IManualExecutionModalP
     this.destroy$.next();
   }
 
-  public static show(props: any): Promise<IPipelineCommand> {
+  public static show(props: any, runtimeServices: DeckRuntimeServices): Promise<IPipelineCommand> {
     const modalProps = {
       dialogClassName: 'manual-execution-dialog ' + 'modal-md',
     };
-    return ReactModal.show(ManualExecutionModal, props, modalProps);
+    return ReactModal.show(ManualExecutionModal, props, modalProps, runtimeServices);
   }
 
   private submit = (values: IPipelineCommand): void => {

package/src/pipeline/manualExecution/StageManualComponents.tsx

@@ -3,10 +3,7 @@ import React from 'react';
 import type { ITriggerTemplateComponentProps } from './TriggerTemplate';
 import type { IPipelineCommand } from '../../domain';
 
-/**
- * This is only necessary because manualPipelineExecution is still in angular
- * Once it is converted to React, this whole component can be removed
- */
+/** Renders each stage-specific manual execution component. */
 export class StageManualComponents extends React.Component<{
   command: IPipelineCommand;
   updateCommand: (path: string, value: any) => void;

package/src/pipeline/pipeline.dataSource.js

@@ -1,108 +1,110 @@
-import { module } from 'angular';
-
 import { DELIVERY_KEY } from '../application/nav/defaultCategories';
 import { ApplicationDataSourceRegistry } from '../application/service/ApplicationDataSourceRegistry';
-import { CLUSTER_SERVICE } from '../cluster/cluster.service';
 import { PipelineConfigService } from './config/services/PipelineConfigService';
 import { SETTINGS } from '../config/settings';
 import { EntityTagsReader } from '../entityTag/EntityTagsReader';
-import { EXECUTION_SERVICE } from './service/execution.service';
-
-export const CORE_PIPELINE_PIPELINE_DATASOURCE = 'spinnaker.core.pipeline.dataSource';
-export const name = CORE_PIPELINE_PIPELINE_DATASOURCE; // for backwards compatibility
-module(CORE_PIPELINE_PIPELINE_DATASOURCE, [EXECUTION_SERVICE, CLUSTER_SERVICE]).run([
-  '$q',
-  'executionService',
-  'clusterService',
-  function ($q, executionService, clusterService) {
-    const addExecutions = (application, executions) => {
-      executionService.transformExecutions(application, executions, application.executions.data);
-      return $q.when(executionService.addExecutionsToApplication(application, executions));
-    };
-
-    const loadExecutions = (application) => {
-      return executionService.getExecutions(application.name, application);
-    };
-
-    const loadPipelineConfigs = (application) => {
-      const pipelineLoader = PipelineConfigService.getPipelinesForApplication(application.name);
-      const strategyLoader = PipelineConfigService.getStrategiesForApplication(application.name);
-      return $q
-        .all([pipelineLoader, strategyLoader])
-        .then(([pipelineConfigs, strategyConfigs]) => ({ pipelineConfigs, strategyConfigs }));
-    };
-
-    const addPipelineConfigs = (application, data) => {
-      application.strategyConfigs = { data: data.strategyConfigs };
-      return $q.when(data.pipelineConfigs);
-    };
-
-    const loadRunningExecutions = (application) => {
-      return executionService.getRunningExecutions(application.name);
-    };
-
-    const addRunningExecutions = (application, data) => {
-      executionService.transformExecutions(application, data);
-      return $q.when(data);
-    };
-
-    const runningExecutionsLoaded = (application) => {
-      clusterService.addExecutionsToServerGroups(application);
-      executionService.mergeRunningExecutionsIntoExecutions(application);
-      application.getDataSource('serverGroups').dataUpdated();
-    };
-
-    const executionsLoaded = (application) => {
-      addExecutionTags(application);
-      executionService.removeCompletedExecutionsFromRunningData(application);
-    };
-
-    const addExecutionTags = (application) => {
-      EntityTagsReader.addTagsToExecutions(application);
-    };
-
-    const addPipelineTags = (application) => {
-      EntityTagsReader.addTagsToPipelines(application);
-    };
-
-    if (SETTINGS.feature.pipelines !== false) {
-      ApplicationDataSourceRegistry.registerDataSource({
-        optional: true,
-        primary: true,
-        icon: 'fa fa-xs fa-fw fa-list',
-        iconName: 'spMenuPipelines',
-        key: 'executions',
-        label: 'Pipelines',
-        category: DELIVERY_KEY,
-        sref: '.pipelines.executions',
-        activeState: '**.pipelines.**',
-        loader: loadExecutions,
-        onLoad: addExecutions,
-        afterLoad: executionsLoaded,
-        lazy: true,
-        badge: 'runningExecutions',
-        description: 'Orchestrated deployment management',
-        defaultData: [],
-      });
-
-      ApplicationDataSourceRegistry.registerDataSource({
-        key: 'pipelineConfigs',
-        loader: loadPipelineConfigs,
-        onLoad: addPipelineConfigs,
-        afterLoad: addPipelineTags,
-        lazy: true,
-        visible: false,
-        defaultData: [],
-      });
-
-      ApplicationDataSourceRegistry.registerDataSource({
-        key: 'runningExecutions',
-        visible: false,
-        loader: loadRunningExecutions,
-        onLoad: addRunningExecutions,
-        afterLoad: runningExecutionsLoaded,
-        defaultData: [],
-      });
+
+export function registerPipelineDataSources(promiseService, executionService, clusterService) {
+  const registerOnce = (config) => {
+    if (!ApplicationDataSourceRegistry.getDataSources().some(({ key }) => key === config.key)) {
+      ApplicationDataSourceRegistry.registerDataSource(config);
+    }
+  };
+
+  const addExecutions = (application, executions) => {
+    executionService.transformExecutions(application, executions, application.executions.data);
+    return promiseService.resolve(executionService.addExecutionsToApplication(application, executions));
+  };
+
+  const loadExecutions = (application) => {
+    return executionService.getExecutions(application.name, application);
+  };
+
+  const loadPipelineConfigs = (application) => {
+    const pipelineLoader = PipelineConfigService.getPipelinesForApplication(application.name);
+    const strategyLoader = PipelineConfigService.getStrategiesForApplication(application.name);
+    return promiseService
+      .all([pipelineLoader, strategyLoader])
+      .then(([pipelineConfigs, strategyConfigs]) => ({ pipelineConfigs, strategyConfigs }));
+  };
+
+  const addPipelineConfigs = (application, data) => {
+    application.strategyConfigs = { data: data.strategyConfigs };
+    return promiseService.resolve(data.pipelineConfigs);
+  };
+
+  const loadRunningExecutions = (application) => {
+    return executionService.getRunningExecutions(application.name);
+  };
+
+  const addRunningExecutions = (application, data) => {
+    executionService.transformExecutions(application, data);
+    return promiseService.resolve(data);
+  };
+
+  const runningExecutionsLoaded = (application) => {
+    executionService.mergeRunningExecutionsIntoExecutions(application);
+
+    const serverGroups = application.getDataSource('serverGroups');
+    if (!serverGroups) {
+      return;
     }
-  },
-]);
+
+    clusterService.addExecutionsToServerGroups(application);
+    serverGroups.dataUpdated();
+  };
+
+  const executionsLoaded = (application) => {
+    executionService.mergeRunningExecutionsIntoExecutions(application);
+    addExecutionTags(application);
+    executionService.removeCompletedExecutionsFromRunningData(application);
+  };
+
+  const addExecutionTags = (application) => {
+    EntityTagsReader.addTagsToExecutions(application);
+  };
+
+  const addPipelineTags = (application) => {
+    EntityTagsReader.addTagsToPipelines(application);
+  };
+
+  if (SETTINGS.feature.pipelines !== false) {
+    registerOnce({
+      optional: true,
+      primary: true,
+      icon: 'fa fa-xs fa-fw fa-list',
+      iconName: 'spMenuPipelines',
+      key: 'executions',
+      label: 'Pipelines',
+      category: DELIVERY_KEY,
+      sref: '.pipelines.executions',
+      activeState: '**.pipelines.**',
+      loader: loadExecutions,
+      onLoad: addExecutions,
+      afterLoad: executionsLoaded,
+      lazy: true,
+      badge: 'runningExecutions',
+      description: 'Orchestrated deployment management',
+      defaultData: [],
+    });
+
+    registerOnce({
+      key: 'pipelineConfigs',
+      loader: loadPipelineConfigs,
+      onLoad: addPipelineConfigs,
+      afterLoad: addPipelineTags,
+      lazy: true,
+      visible: false,
+      defaultData: [],
+    });
+
+    registerOnce({
+      key: 'runningExecutions',
+      visible: false,
+      loader: loadRunningExecutions,
+      onLoad: addRunningExecutions,
+      afterLoad: runningExecutionsLoaded,
+      defaultData: [],
+    });
+  }
+}

package/src/pipeline/pipeline.dataSource.spec.ts

@@ -1,66 +1,78 @@
-import type { IQProvider } from 'angular';
-import { mock } from 'angular';
-
 import type { Application } from '../application/application.model';
 import { ApplicationModelBuilder } from '../application/applicationModel.builder';
 import { ApplicationDataSourceRegistry } from '../application/service/ApplicationDataSourceRegistry';
 import { PipelineConfigService } from './config/services/PipelineConfigService';
-import { EXECUTION_SERVICE } from './service/execution.service';
+import { registerPipelineDataSources } from './pipeline.dataSource';
 
 describe('Pipeline Data Source', function () {
-  let application: Application, executionService: any, $scope: ng.IScope, $q: ng.IQService;
-
-  beforeEach(() => ApplicationDataSourceRegistry.clearDataSources());
+  const promiseService = {
+    all: (promises: PromiseLike<any>[]) => Promise.all(promises),
+    resolve: <T>(value: T | PromiseLike<T>) => Promise.resolve(value),
+  };
+  let application: Application, executionService: any;
+
+  beforeEach(() => {
+    ApplicationDataSourceRegistry.clearDataSources();
+    executionService = {
+      getExecutions: () => Promise.resolve([]),
+      getRunningExecutions: () => Promise.resolve([]),
+      getLocks: () => Promise.resolve([]),
+      transformExecutions: () => undefined,
+      addExecutionsToApplication: (_application: Application, executions: any[]) => executions,
+      mergeRunningExecutionsIntoExecutions: () => undefined,
+      removeCompletedExecutionsFromRunningData: () => undefined,
+    };
+    registerPipelineDataSources(promiseService, executionService, {
+      addExecutionsToServerGroups: () => undefined,
+    });
+  });
 
-  beforeEach(mock.module(require('./pipeline.dataSource').name, EXECUTION_SERVICE));
+  afterEach(() => ApplicationDataSourceRegistry.clearDataSources());
 
-  // https://docs.angularjs.org/guide/migration#migrate1.5to1.6-ng-services-$q
-  beforeEach(
-    mock.module(($qProvider: IQProvider) => {
-      $qProvider.errorOnUnhandledRejections(false);
-    }),
-  );
+  const waitForRefresh = (dataSource: any) =>
+    new Promise<void>((resolve) => dataSource.onNextRefresh(resolve, resolve));
 
-  beforeEach(
-    mock.inject(function (_executionService_: any, _$q_: ng.IQService, $rootScope: ng.IRootScopeService) {
-      $q = _$q_;
-      $scope = $rootScope.$new();
-      executionService = _executionService_;
-    }),
-  );
+  async function refreshDataSource(dataSource: any) {
+    const refreshComplete = waitForRefresh(dataSource);
+    dataSource.refresh();
+    await refreshComplete;
+  }
 
-  function configureApplication() {
+  async function configureApplication() {
     ApplicationDataSourceRegistry.registerDataSource({ key: 'serverGroups', defaultData: [] });
     application = ApplicationModelBuilder.createApplicationForTests(
       'app',
       ...ApplicationDataSourceRegistry.getDataSources(),
     );
+    const refreshes = application.dataSources.map(waitForRefresh);
     application.refresh();
-    $scope.$digest();
+    await Promise.all(refreshes);
   }
 
   describe('loading executions', function () {
     beforeEach(function () {
-      spyOn(executionService, 'getRunningExecutions').and.returnValue($q.when([]));
-      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue($q.when([]));
-      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue($q.when([]));
+      spyOn(executionService, 'getRunningExecutions').and.returnValue(Promise.resolve([]));
+      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue(Promise.resolve([]));
+      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue(Promise.resolve([]));
     });
 
-    it('loads executions and sets appropriate flags', function () {
-      spyOn(executionService, 'getExecutions').and.returnValue($q.when([{ status: 'SUCCEEDED', stages: [] }]));
-      configureApplication();
+    it('loads executions and sets appropriate flags', async function () {
+      spyOn(executionService, 'getExecutions').and.returnValue(Promise.resolve([{ status: 'SUCCEEDED', stages: [] }]));
+      await configureApplication();
+      const refreshComplete = waitForRefresh(application.getDataSource('executions'));
       application.getDataSource('executions').activate();
-      $scope.$digest();
+      await refreshComplete;
       expect(application.getDataSource('executions').loaded).toBe(true);
       expect(application.getDataSource('executions').loading).toBe(false);
       expect(application.getDataSource('executions').loadFailure).toBe(false);
     });
 
-    it('sets appropriate flags when execution load fails', function () {
-      spyOn(executionService, 'getExecutions').and.returnValue($q.reject(null));
-      configureApplication();
+    it('sets appropriate flags when execution load fails', async function () {
+      spyOn(executionService, 'getExecutions').and.returnValue(Promise.reject(null));
+      await configureApplication();
+      const refreshComplete = waitForRefresh(application.getDataSource('executions'));
       application.getDataSource('executions').activate();
-      $scope.$digest();
+      await refreshComplete;
       expect(application.getDataSource('executions').loaded).toBe(false);
       expect(application.getDataSource('executions').loading).toBe(false);
       expect(application.getDataSource('executions').loadFailure).toBe(true);
@@ -69,50 +81,51 @@ describe('Pipeline Data Source', function () {
 
   describe('reload executions', function () {
     beforeEach(function () {
-      spyOn(executionService, 'getRunningExecutions').and.returnValue($q.when([]));
-      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue($q.when([]));
-      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue($q.when([]));
+      spyOn(executionService, 'getRunningExecutions').and.returnValue(Promise.resolve([]));
+      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue(Promise.resolve([]));
+      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue(Promise.resolve([]));
     });
 
-    it('reloads executions and sets appropriate flags', function () {
-      spyOn(executionService, 'getExecutions').and.returnValue($q.when([]));
-      configureApplication();
+    it('reloads executions and sets appropriate flags', async function () {
+      spyOn(executionService, 'getExecutions').and.returnValue(Promise.resolve([]));
+      await configureApplication();
+      let refreshComplete = waitForRefresh(application.getDataSource('executions'));
       application.getDataSource('executions').activate();
-      $scope.$digest();
+      await refreshComplete;
       expect(application.getDataSource('executions').loaded).toBe(true);
       expect(application.getDataSource('executions').loading).toBe(false);
       expect(application.getDataSource('executions').loadFailure).toBe(false);
 
+      refreshComplete = waitForRefresh(application.getDataSource('executions'));
       application.getDataSource('executions').refresh();
       expect(application.getDataSource('executions').loading).toBe(true);
 
-      $scope.$digest();
+      await refreshComplete;
       expect(application.getDataSource('executions').loaded).toBe(true);
       expect(application.getDataSource('executions').loading).toBe(false);
       expect(application.getDataSource('executions').loadFailure).toBe(false);
     });
 
-    it('sets appropriate flags when executions reload fails; subscriber is responsible for error checking', function () {
-      spyOn(executionService, 'getExecutions').and.returnValue($q.reject(null));
+    it('sets appropriate flags when executions reload fails; subscriber is responsible for error checking', async function () {
+      spyOn(executionService, 'getExecutions').and.returnValue(Promise.reject(null));
       let errorsHandled = 0;
       let successesHandled = 0;
-      configureApplication();
+      await configureApplication();
+      const initialRefresh = waitForRefresh(application.getDataSource('executions'));
       application.getDataSource('executions').activate();
+      await initialRefresh;
 
       application.getDataSource('executions').onRefresh(
-        $scope,
         () => successesHandled++,
         () => errorsHandled++,
       );
 
-      application.getDataSource('executions').refresh();
-      $scope.$digest();
+      await refreshDataSource(application.getDataSource('executions'));
 
       expect(application.getDataSource('executions').loading).toBe(false);
       expect(application.getDataSource('executions').loadFailure).toBe(true);
 
-      application.getDataSource('executions').refresh();
-      $scope.$digest();
+      await refreshDataSource(application.getDataSource('executions'));
 
       expect(successesHandled).toBe(0);
       expect(errorsHandled).toBe(2);
@@ -121,45 +134,43 @@ describe('Pipeline Data Source', function () {
 
   describe('loading pipeline configs', function () {
     beforeEach(function () {
-      spyOn(executionService, 'getRunningExecutions').and.returnValue($q.when([]));
-      spyOn(executionService, 'getExecutions').and.returnValue($q.when([]));
+      spyOn(executionService, 'getRunningExecutions').and.returnValue(Promise.resolve([]));
+      spyOn(executionService, 'getExecutions').and.returnValue(Promise.resolve([]));
     });
 
-    it('loads configs and sets appropriate flags', function () {
-      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue($q.when([]));
-      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue($q.when([]));
-      configureApplication();
+    it('loads configs and sets appropriate flags', async function () {
+      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue(Promise.resolve([]));
+      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue(Promise.resolve([]));
+      await configureApplication();
       application.getDataSource('pipelineConfigs').activate();
 
+      const refreshComplete = waitForRefresh(application.getDataSource('pipelineConfigs'));
       application.getDataSource('pipelineConfigs').refresh();
       expect(application.getDataSource('pipelineConfigs').loading).toBe(true);
-      $scope.$digest();
+      await refreshComplete;
       expect(application.getDataSource('pipelineConfigs').loaded).toBe(true);
       expect(application.getDataSource('pipelineConfigs').loading).toBe(false);
       expect(application.getDataSource('pipelineConfigs').loadFailure).toBe(false);
     });
 
-    it('sets appropriate flags when pipeline config reload fails; subscriber is responsible for error checking', function () {
-      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue($q.when([]));
-      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue($q.reject([]));
+    it('sets appropriate flags when pipeline config reload fails; subscriber is responsible for error checking', async function () {
+      spyOn(PipelineConfigService, 'getPipelinesForApplication').and.returnValue(Promise.resolve([]));
+      spyOn(PipelineConfigService, 'getStrategiesForApplication').and.returnValue(Promise.reject([]));
       let errorsHandled = 0;
       let successesHandled = 0;
-      configureApplication();
+      await configureApplication();
       application.getDataSource('pipelineConfigs').activate();
 
       application.getDataSource('pipelineConfigs').onRefresh(
-        $scope,
         () => successesHandled++,
         () => errorsHandled++,
       );
-      application.getDataSource('pipelineConfigs').refresh();
-      $scope.$digest();
+      await refreshDataSource(application.getDataSource('pipelineConfigs'));
 
       expect(application.getDataSource('pipelineConfigs').loading).toBe(false);
       expect(application.getDataSource('pipelineConfigs').loadFailure).toBe(true);
 
-      application.getDataSource('pipelineConfigs').refresh();
-      $scope.$digest();
+      await refreshDataSource(application.getDataSource('pipelineConfigs'));
 
       expect(errorsHandled).toBe(2);
       expect(successesHandled).toBe(0);