@spinnaker/core 0.16.1 → 0.17.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@spinnaker/core",
   "license": "Apache-2.0",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
@@ -120,5 +120,5 @@
     "shx": "0.3.3",
     "typescript": "4.3.5"
   },
-  "gitHead": "17b98201c6de43729a39f6d205656d0c4be1db16"
+  "gitHead": "fd69b27a052ccb2a170efdbe0b971a8636c96447"
 }

package/src/domain/IPipeline.ts

@@ -16,6 +16,7 @@ export interface IPipeline {
   locked?: IPipelineLock;
   limitConcurrent: boolean;
   manualStartAlert?: IPipelineManualStartAlert;
+  maxConcurrentExecutions?: number;
   migrationStatus?: string;
   name: string;
   notifications?: INotification[];

package/src/help/help.contents.ts

@@ -364,6 +364,8 @@ const helpContents: { [key: string]: string } = {
   'pipeline.config.dependsOn': 'Declares which stages must be run <em>before</em> this stage begins.',
   'pipeline.config.parallel.cancel.queue':
     '<p>If concurrent pipeline execution is disabled, then the pipelines that are in the waiting queue will get canceled when the next execution starts. <br><br>Check this box if you want to keep them in the queue.</p>',
+  'pipeline.config.parallel.max.concurrent':
+    '<p>If concurrent pipeline execution is enabled, this variable sets the maximum number of concurrent pipelines executing. <br><br>If set to 0, then max is unlimited.</p>',
   'pipeline.config.timeout': `
       <p>Allows you to force the stage to fail if its running time exceeds a specific length.</p>
       <p><b>Note:</b> By default, Spinnaker will use sensible timeouts that depend on the stage type and the operations the stage needs to perform at runtime. These defaults can vary based on chosen configuration and other external factors.

package/src/help/helpContents.registry.spec.ts

@@ -21,4 +21,12 @@ describe('Help contents registry', () => {
       expect(HelpContentsRegistry.getHelpField('a')).toBe('b');
     });
   });
+
+  describe('max concurrent definition', () => {
+    it('provides the expected definition for max concurrent', () => {
+      const definition =
+        '<p>If concurrent pipeline execution is enabled, this variable sets the maximum number of concurrent pipelines executing. <br><br>If set to 0, then max is unlimited.</p>';
+      expect(HelpContentsRegistry.getHelpField('pipeline.config.parallel.max.concurrent')).toEqual(definition);
+    });
+  });
 });

package/src/pipeline/config/triggers/ExecutionOptionsPageContent.spec.tsx

@@ -0,0 +1,90 @@
+import { mount } from 'enzyme';
+import React from 'react';
+
+import { ExecutionOptionsPageContent } from './ExecutionOptionsPageContent';
+import type { IPipeline } from '../../../domain';
+
+describe('Execution Options Page Content', () => {
+  describe('Max Concurrent Options', () => {
+    let pipeline: IPipeline;
+    const setPipeline = (overrides: any = {}) => {
+      pipeline = {
+        application: 'test',
+        id: 'test1',
+        keepWaitingPipelines: false,
+        limitConcurrent: false,
+        maxConcurrentExecutions: 0,
+        name: 'test p 1', // @ts-ignore
+        parameterConfig: [], // @ts-ignore
+        stages: [], // @ts-ignore
+        triggers: [],
+        ...overrides,
+      };
+    };
+    const update = (changes: any = {}) => {
+      pipeline = {
+        ...pipeline,
+        ...changes,
+      };
+    };
+    describe('enabling max concurrent', () => {
+      it('sets keepWaitingPipelines to true if limitConcurrent and keepWaitingPipelines are both not truthy', () => {
+        setPipeline();
+        const wrapper = mount(<ExecutionOptionsPageContent pipeline={pipeline} updatePipelineConfig={update} />);
+        expect(pipeline.keepWaitingPipelines).toBeFalsy();
+        const checkbox = wrapper.find('input').at(0);
+        checkbox.simulate('change', { target: { checked: true } });
+        expect(pipeline.keepWaitingPipelines).toBeTruthy();
+      });
+
+      it('does not alter pipeline if limitConcurrent is true', () => {
+        setPipeline({ limitConcurrent: true });
+        const wrapper = mount(<ExecutionOptionsPageContent pipeline={pipeline} updatePipelineConfig={update} />);
+        expect(pipeline.keepWaitingPipelines).toBeFalsy();
+        const checkbox = wrapper.find('input').at(0);
+        checkbox.simulate('change', { target: { checked: true } });
+        expect(pipeline.keepWaitingPipelines).toBeFalsy();
+      });
+
+      it('does not alter pipeline if keepWaitingPipelines is true', () => {
+        setPipeline({ keepWaitingPipelines: true });
+        const wrapper = mount(<ExecutionOptionsPageContent pipeline={pipeline} updatePipelineConfig={update} />);
+        expect(pipeline.keepWaitingPipelines).toBeTruthy();
+        const checkbox = wrapper.find('input').at(0);
+        checkbox.simulate('change', { target: { checked: true } });
+        expect(pipeline.keepWaitingPipelines).toBeTruthy();
+      });
+
+      it('defaults the max concurrent value to 0', () => {
+        setPipeline();
+        const wrapper = mount(<ExecutionOptionsPageContent pipeline={pipeline} updatePipelineConfig={update} />);
+        const checkbox = wrapper.find('input').at(0);
+        checkbox.simulate('change', { target: { checked: true } });
+        const concurrentInput = wrapper.find('input[type="number"]').at(0);
+        expect(concurrentInput.prop('value')).toEqual(0);
+      });
+    });
+
+    it('updates the max concurrent config value when the input is changed', () => {
+      setPipeline();
+      const value = 22;
+      const wrapper = mount(<ExecutionOptionsPageContent pipeline={pipeline} updatePipelineConfig={update} />);
+      const checkbox = wrapper.find('input').at(0);
+      checkbox.simulate('change', { target: { checked: true } });
+      const concurrentInput = wrapper.find('input[type="number"]').at(0);
+      concurrentInput.simulate('change', { target: { value } });
+      expect(pipeline.maxConcurrentExecutions).toEqual(value);
+    });
+
+    it('sets the max concurrent value to a whole number if a float is entered', () => {
+      setPipeline();
+      const value = 3.3;
+      const wrapper = mount(<ExecutionOptionsPageContent pipeline={pipeline} updatePipelineConfig={update} />);
+      const checkbox = wrapper.find('input').at(0);
+      checkbox.simulate('change', { target: { checked: true } });
+      const concurrentInput = wrapper.find('input[type="number"]').at(0);
+      concurrentInput.simulate('change', { target: { value } });
+      expect(pipeline.maxConcurrentExecutions).toEqual(3);
+    });
+  });
+});

package/src/pipeline/config/triggers/ExecutionOptionsPageContent.tsx

@@ -1,8 +1,8 @@
-import React from 'react';
+import React, { useState } from 'react';
 
 import type { IPipeline } from '../../../domain';
 import { HelpField } from '../../../help';
-import { CheckboxInput, FormField } from '../../../presentation';
+import { CheckboxInput, FormField, NumberInput } from '../../../presentation';
 
 export interface IExecutionOptionsPageContentProps {
   pipeline: IPipeline;
@@ -11,6 +11,13 @@ export interface IExecutionOptionsPageContentProps {
 
 export function ExecutionOptionsPageContent(props: IExecutionOptionsPageContentProps) {
   const { pipeline, updatePipelineConfig } = props;
+  const [currentMaxConcurrent, setCurrentMaxConcurrent] = useState(pipeline.maxConcurrentExecutions || 0);
+  const handleMaxConcurrentChange = (changeEvent: any) => {
+    const value = Number.parseInt(changeEvent.target.value);
+    setCurrentMaxConcurrent(value);
+    updatePipelineConfig({ maxConcurrentExecutions: value });
+  };
+
   return (
     <div className="row">
       <div className="col-md-11 col-md-offset-1">
@@ -23,6 +30,10 @@ export function ExecutionOptionsPageContent(props: IExecutionOptionsPageContentP
           )}
           onChange={() => {
             updatePipelineConfig({ limitConcurrent: !pipeline.limitConcurrent });
+            if (!pipeline.limitConcurrent && !pipeline.keepWaitingPipelines) {
+              pipeline.keepWaitingPipelines = true;
+              updatePipelineConfig({ keepWaitingPipelines: true });
+            }
           }}
           value={pipeline.limitConcurrent}
         />
@@ -45,6 +56,20 @@ export function ExecutionOptionsPageContent(props: IExecutionOptionsPageContentP
             value={pipeline.keepWaitingPipelines}
           />
         )}
+        {!pipeline.limitConcurrent && (
+          <div>
+            <label className="col-md-3 sm-label-right">
+              Maximum concurrent pipeline executions <HelpField id={'pipeline.config.parallel.max.concurrent'} />
+            </label>
+            <div className="col-md-8">
+              <FormField
+                input={(inputProps) => <NumberInput {...inputProps} min={0} max={65534} />}
+                onChange={handleMaxConcurrentChange}
+                value={currentMaxConcurrent}
+              />
+            </div>
+          </div>
+        )}
       </div>
     </div>
   );