@spinnaker/core 0.17.0 → 0.18.0

package/dist/pipeline/triggers/QuietPeriodBadge.d.ts

@@ -1,8 +1,2 @@
-import React from 'react';
-export interface IQuietPeriodBadgeProps {
-    start: Date;
-    end: Date;
-}
-export declare class QuietPeriodBadge extends React.Component<IQuietPeriodBadgeProps> {
-    render(): JSX.Element;
-}
+/// <reference types="react" />
+export declare function QuietPeriodBadge(): JSX.Element;

package/dist/pipeline/triggers/TriggersTag.d.ts

@@ -1,15 +1,6 @@
-import React from 'react';
+/// <reference types="react" />
 import type { IPipeline } from '../../domain/IPipeline';
 export interface ITriggersTagProps {
     pipeline: IPipeline;
 }
-export interface ITriggersTagState {
-    triggerCount: number;
-    activeTriggerCount: number;
-}
-export declare class TriggersTag extends React.Component<ITriggersTagProps, ITriggersTagState> {
-    private quietPeriodStart;
-    private quietPeriodEnd;
-    constructor(props: ITriggersTagProps);
-    render(): React.ReactElement<TriggersTag>;
-}
+export declare function TriggersTag(props: ITriggersTagProps): JSX.Element;

package/dist/pipeline/triggers/useQuietPeriod.hook.d.ts

@@ -0,0 +1,7 @@
+interface IQuietPeriod {
+    currentStatus: 'UNKNOWN' | 'BEFORE_QUIET_PERIOD' | 'DURING_QUIET_PERIOD' | 'AFTER_QUIET_PERIOD' | 'NO_QUIET_PERIOD';
+    startTime: number;
+    endTime: number;
+}
+export declare function useQuietPeriod(): IQuietPeriod;
+export {};

package/package.json

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

package/src/config/settings.ts

@@ -143,7 +143,6 @@ export interface ISpinnakerSettings {
     [key: string]: IProviderSettings; // allows custom providers not typed in here (good for testing too)
   };
   pubsubProviders: string[];
-  quietPeriod: [string | number, string | number];
   resetProvider: (provider: string) => () => void;
   resetToOriginal: () => void;
   searchVersion: 1 | 2;

package/src/pipeline/details/StageFailureMessage.tsx

@@ -74,7 +74,7 @@ export class StageFailureMessage extends React.Component<IStageFailureMessagePro
     const { message, messages, stage } = this.props;
     const { isFailed, failedTask, failedExecutionId, failedStageName, failedStageId } = this.state;
 
-    let stageMessages = message || !messages.length ? [message] : messages;
+    let stageMessages = message && !messages.length ? [message] : messages;
     if (stageMessages.length > 0) {
       const exceptionTitle = isFailed ? (messages.length ? 'Exceptions' : 'Exception') : 'Warning';
 

package/src/pipeline/triggers/QuietPeriodBadge.tsx

@@ -2,11 +2,7 @@ import type { DateTimeFormatOptions } from 'luxon';
 import React from 'react';
 
 import { Tooltip } from '../../presentation';
-
-export interface IQuietPeriodBadgeProps {
-  start: Date;
-  end: Date;
-}
+import { useQuietPeriod } from './useQuietPeriod.hook';
 
 const locale = 'en-US';
 const dateOptions: DateTimeFormatOptions = {
@@ -18,37 +14,30 @@ const dateOptions: DateTimeFormatOptions = {
   minute: '2-digit',
 };
 
-export class QuietPeriodBadge extends React.Component<IQuietPeriodBadgeProps> {
-  public render() {
-    const { start, end } = this.props;
-
-    if (!start || !end) {
-      return null;
-    }
+export function QuietPeriodBadge() {
+  const quietPeriod = useQuietPeriod();
+  if (quietPeriod.currentStatus === 'NO_QUIET_PERIOD' || quietPeriod.currentStatus === 'UNKNOWN') {
+    return null;
+  }
 
-    const now = new Date();
-    const afterQuietPeriod = now > end;
-    if (afterQuietPeriod) {
-      return null;
-    }
+  const start = new Date(quietPeriod.startTime);
+  const end = new Date(quietPeriod.endTime);
 
-    const inQuietPeriod = start < now && !afterQuietPeriod;
+  const message =
+    quietPeriod.currentStatus === 'DURING_QUIET_PERIOD'
+      ? 'This pipeline will not be automatically triggered until the end of the quiet period. '
+      : 'This pipeline will not be automatically triggered during the quiet period. ';
 
-    const quietPeriodRange = (
+  const template = (
+    <span>
+      {message}
       <span>{`(${start.toLocaleString(locale, dateOptions)} - ${end.toLocaleString(locale, dateOptions)})`}</span>
-    );
-    const tooltipTemplate = inQuietPeriod ? (
-      <span>
-        This pipeline will not be automatically triggered until the end of the quiet period. {quietPeriodRange}
-      </span>
-    ) : (
-      <span>This pipeline will not be automatically triggered during the quiet period. {quietPeriodRange}</span>
-    );
-
-    return (
-      <Tooltip template={tooltipTemplate}>
-        <i className="fa icon-calendar-warning" style={{ color: 'red' }} />
-      </Tooltip>
-    );
-  }
+    </span>
+  );
+
+  return (
+    <Tooltip template={template}>
+      <i className="fa icon-calendar-warning" style={{ color: 'red' }} />
+    </Tooltip>
+  );
 }

package/src/pipeline/triggers/TriggersTag.tsx

@@ -1,79 +1,49 @@
-import { filter } from 'lodash';
-import React from 'react';
+import * as React from 'react';
 
 import { QuietPeriodBadge } from './QuietPeriodBadge';
-import { SETTINGS } from '../../config';
+import type { ITrigger } from '../../domain';
 import type { IPipeline } from '../../domain/IPipeline';
+import { useQuietPeriod } from './useQuietPeriod.hook';
 
 export interface ITriggersTagProps {
   pipeline: IPipeline;
 }
 
-export interface ITriggersTagState {
-  triggerCount: number;
-  activeTriggerCount: number;
-}
-
-export class TriggersTag extends React.Component<ITriggersTagProps, ITriggersTagState> {
-  private quietPeriodStart: Date;
-  private quietPeriodEnd: Date;
-
-  constructor(props: ITriggersTagProps) {
-    super(props);
-
-    let triggerCount = 0;
-    let activeTriggerCount = 0;
-    let quietPeriodEnabled = false;
-
-    const pipeline = this.props.pipeline;
-    if (pipeline && pipeline.triggers && pipeline.triggers.length) {
-      triggerCount = pipeline.triggers.length;
-      activeTriggerCount = filter(pipeline.triggers, { enabled: true }).length;
-      quietPeriodEnabled = Boolean(pipeline.respectQuietPeriod);
-    }
-
-    const hasQuietPeriod = SETTINGS.feature.quietPeriod && SETTINGS.quietPeriod && SETTINGS.quietPeriod.length === 2;
-
-    if (hasQuietPeriod && quietPeriodEnabled) {
-      this.quietPeriodStart = new Date(SETTINGS.quietPeriod[0]);
-      this.quietPeriodEnd = new Date(SETTINGS.quietPeriod[1]);
-    }
-
-    this.state = {
-      triggerCount,
-      activeTriggerCount,
-    };
+function getTriggerLabel(totalTriggers: number, activeTriggers: number) {
+  if (totalTriggers === 1) {
+    return `Trigger: ${activeTriggers ? 'enabled' : 'disabled'}`;
+  } else if (totalTriggers === activeTriggers) {
+    return `All triggers: enabled`;
+  } else if (activeTriggers === 0) {
+    return `All triggers: disabled`;
+  } else {
+    return `Some triggers: enabled`;
   }
+}
 
-  public render(): React.ReactElement<TriggersTag> {
-    const { pipeline } = this.props;
-    const { triggerCount, activeTriggerCount } = this.state;
-
-    if (triggerCount > 0) {
-      const now = new Date();
-      const inQuietPeriod = this.quietPeriodStart < now && now < this.quietPeriodEnd;
+export function TriggersTag(props: ITriggersTagProps) {
+  const quietPeriod = useQuietPeriod();
 
-      const triggers =
-        triggerCount === 1
-          ? 'Trigger'
-          : activeTriggerCount === triggerCount || inQuietPeriod
-          ? 'All triggers'
-          : 'Some triggers';
-      const displayTriggers = `${triggers}: ${activeTriggerCount === 0 || inQuietPeriod ? 'disabled' : 'enabled'}`;
+  const { pipeline } = props;
+  const triggers = pipeline?.triggers ?? [];
+  const isTriggerDisabled = (t: ITrigger) =>
+    !t.enabled ||
+    (pipeline.respectQuietPeriod && quietPeriod.currentStatus === 'DURING_QUIET_PERIOD' && t.type !== 'pipeline');
+  const activeTriggers = triggers.filter((t: ITrigger) => !isTriggerDisabled(t));
 
-      return (
-        <div
-          className={`triggers-toggle ${activeTriggerCount ? '' : 'disabled'}`}
-          style={{ visibility: pipeline.disabled ? 'hidden' : 'visible' }}
-        >
-          <span>
-            <span>
-              <QuietPeriodBadge start={this.quietPeriodStart} end={this.quietPeriodEnd} /> {displayTriggers}
-            </span>
-          </span>
-        </div>
-      );
-    }
+  if (triggers.length === 0) {
     return <div />;
   }
+
+  return (
+    <div
+      className={`triggers-toggle ${activeTriggers.length > 0 ? '' : 'disabled'}`}
+      style={{ visibility: pipeline.disabled ? 'hidden' : 'visible' }}
+    >
+      <span className="flex-container-h margin-between-sm baseline">
+        {pipeline.respectQuietPeriod && <QuietPeriodBadge />}
+        <span>{getTriggerLabel(triggers.length, activeTriggers.length)}</span>
+      </span>
+    </div>
+  );
 }

package/src/pipeline/triggers/useQuietPeriod.hook.ts

@@ -0,0 +1,43 @@
+import { REST } from '../../api';
+import { useLatestPromise } from '../../presentation';
+
+// Shape from back end
+interface IQuietPeriodConfig {
+  startTime: number;
+  endTime: number;
+  enabled: boolean;
+  // Do not use in UI -- point-in-time data from back-end
+  inQuietPeriod: boolean;
+}
+
+class QuietPeriodService {
+  private static _quietPeriodConfig: PromiseLike<IQuietPeriodConfig>;
+  static async quietPeriodConfig(): Promise<IQuietPeriodConfig> {
+    this._quietPeriodConfig = this._quietPeriodConfig ?? REST('/capabilities/quietPeriod').get<IQuietPeriodConfig>();
+    return await this._quietPeriodConfig;
+  }
+}
+
+interface IQuietPeriod {
+  currentStatus: 'UNKNOWN' | 'BEFORE_QUIET_PERIOD' | 'DURING_QUIET_PERIOD' | 'AFTER_QUIET_PERIOD' | 'NO_QUIET_PERIOD';
+  startTime: number;
+  endTime: number;
+}
+
+export function useQuietPeriod(): IQuietPeriod {
+  const result = useLatestPromise(() => QuietPeriodService.quietPeriodConfig(), []);
+  if (result.status !== 'RESOLVED') {
+    return { currentStatus: 'UNKNOWN', startTime: undefined, endTime: undefined };
+  }
+
+  const { startTime, endTime, enabled } = result.result;
+  if (!enabled || !startTime || startTime < 0 || !endTime || endTime < 0) {
+    return { currentStatus: 'NO_QUIET_PERIOD', startTime: undefined, endTime: undefined };
+  }
+
+  const now = Date.now();
+  const currentStatus =
+    now < startTime ? 'BEFORE_QUIET_PERIOD' : now > endTime ? 'AFTER_QUIET_PERIOD' : 'DURING_QUIET_PERIOD';
+
+  return { currentStatus, startTime, endTime };
+}