@spinnaker/kayenta 0.0.0-2025.1-0

package/src/kayenta/navigation/canary.states.stub.ts

@@ -0,0 +1,28 @@
+import { StateDeclaration, UIRouter } from '@uirouter/core';
+
+import { ApplicationStateProvider } from '@spinnaker/core';
+
+export function registerKayentaStateStubs(applicationState: ApplicationStateProvider, uiRouter: UIRouter) {
+  const states: StateDeclaration[] = [
+    {
+      name: 'canary',
+      url: '/canary',
+      lazyLoad: () =>
+        import(/* webpackChunkName: "Lazy-Kayenta-Tabs" */ '../../lazy').then((m) =>
+          m.lazyInitializeKayenta(applicationState, uiRouter),
+        ),
+    },
+    { name: 'canary.canaryConfig', url: '/config' },
+    { name: 'canary.canaryConfig.configDetail', url: '/:id?copy&new' },
+    { name: 'canary.canaryConfig.configDefault', url: '' },
+    { name: 'canary.report', url: '/report?count' },
+    { name: 'canary.report.reportDetail', url: '/:configId/:runId' },
+    { name: 'canary.report.reportDefault', url: '' },
+  ];
+
+  ['home.project', 'home.applications'].forEach((prefix) => {
+    states
+      .map((state) => ({ ...state, name: `${prefix}.application.${state.name}` } as StateDeclaration))
+      .forEach((state) => uiRouter.stateRegistry.register(state as StateDeclaration));
+  });
+}

package/src/kayenta/navigation/canary.states.ts

@@ -0,0 +1,182 @@
+import { Transition, UIRouter } from '@uirouter/core';
+import * as Creators from 'kayenta/actions/creators';
+import Canary, { canaryStore } from 'kayenta/canary';
+import ConfigDetailLoader from 'kayenta/edit/configDetailLoader';
+import CanaryConfigEdit from 'kayenta/edit/edit';
+import CanaryConfigSave from 'kayenta/edit/save';
+import SelectConfig from 'kayenta/edit/selectConfig';
+import ResultDetailLoader from 'kayenta/report/detail/detailLoader';
+import ExecutionListLoadStates from 'kayenta/report/list/loadStates';
+import Report from 'kayenta/report/report';
+import { $rootScope } from 'ngimport';
+
+import { ApplicationStateProvider, INestedState } from '@spinnaker/core';
+
+import '../canary.dataSource.bridge';
+import { CanarySettings } from '../canary.settings';
+
+export function registerStates($uiRouter: UIRouter, applicationStateProvider: ApplicationStateProvider) {
+  const configDetail: INestedState = {
+    name: 'configDetail',
+    url: '/:id?copy&new',
+    views: {
+      detail: {
+        component: ConfigDetailLoader,
+        $type: 'react',
+      },
+      footer: {
+        component: CanaryConfigSave,
+        $type: 'react',
+      },
+    },
+    params: {
+      copy: { type: 'boolean', value: false, squash: true },
+      new: { type: 'boolean', value: false, squash: true },
+    },
+    resolve: [
+      {
+        token: 'configNameStream',
+        deps: [UIRouter],
+        resolveFn: (uiRouter: any) => uiRouter.globals.params$,
+      },
+    ],
+  };
+
+  const configDefault: INestedState = {
+    name: 'configDefault',
+    url: '',
+    views: {
+      detail: {
+        component: SelectConfig,
+        $type: 'react',
+      },
+    },
+  };
+
+  const config: INestedState = {
+    name: 'canaryConfig',
+    url: '/config',
+    views: {
+      canary: {
+        component: CanaryConfigEdit,
+        $type: 'react',
+      },
+    },
+    children: [configDefault, configDetail],
+    redirectTo: (transition) => transition.to().name + '.configDefault',
+  };
+
+  const reportDetail: INestedState = {
+    name: 'reportDetail',
+    url: '/:configId/:runId',
+    views: {
+      detail: {
+        component: ResultDetailLoader,
+        $type: 'react',
+      },
+    },
+    resolve: [
+      {
+        token: 'resultIdStream',
+        deps: [UIRouter],
+        resolveFn: (uiRouter: any) => uiRouter.globals.params$,
+      },
+    ],
+  };
+
+  const reportDefault: INestedState = {
+    name: 'reportDefault',
+    url: '',
+    views: {
+      detail: {
+        component: ExecutionListLoadStates,
+        $type: 'react',
+      },
+    },
+  };
+
+  const report: INestedState = {
+    name: 'report',
+    url: '/report?count',
+    views: {
+      canary: {
+        component: Report,
+        $type: 'react',
+      },
+    },
+    params: {
+      count: {
+        type: 'int',
+        value: CanarySettings.defaultExecutionCount ?? CanarySettings.executionsCountOptions?.[0] ?? 20,
+        squash: true,
+      },
+    },
+    children: [reportDetail, reportDefault],
+    redirectTo: (transition) => transition.to().name + '.reportDefault',
+  };
+
+  const canaryRoot: INestedState = {
+    abstract: true,
+    name: 'canary',
+    url: '/canary',
+    views: {
+      insight: {
+        component: Canary,
+        $type: 'react',
+      },
+    },
+    data: {
+      pageTitleSection: {
+        title: 'Canary',
+      },
+    },
+    children: [config, report],
+  };
+
+  applicationStateProvider.addChildState(canaryRoot);
+}
+
+export function registerTransitionHooks($uiRouter: UIRouter) {
+  // When leaving a config detail state, clear that config.
+  $uiRouter.transitionService.onBefore(
+    {
+      from: '**.configDetail.**',
+      to: (state) => !state.name.includes('configDetail'),
+    },
+    () => {
+      canaryStore.dispatch(Creators.clearSelectedConfig());
+    },
+  );
+
+  // Prompts confirmation for page navigation if config hasn't been saved.
+  // Should be possible with a $uiRouter transition hook, but it's not.
+  $rootScope.$on('$stateChangeStart', (event) => {
+    const state = canaryStore.getState();
+    const warningMessage = 'You have unsaved changes.\nAre you sure you want to navigate away from this page?';
+    if (state.selectedConfig && !state.selectedConfig.isInSyncWithServer) {
+      if (!window.confirm(warningMessage)) {
+        event.preventDefault();
+      }
+    }
+  });
+
+  // Prompts confirmation for page reload if config hasn't been saved.
+  $uiRouter.transitionService.onEnter({ to: '**.configDetail.**' }, () => {
+    window.onbeforeunload = () => {
+      const state = canaryStore.getState();
+      // Must return `null` if reload should be allowed.
+      return (state.selectedConfig && !state.selectedConfig.isInSyncWithServer) || null;
+    };
+  });
+
+  // Clears reload hook when leaving canary config view.
+  $uiRouter.transitionService.onExit({ from: '**.configDetail.**' }, () => {
+    window.onbeforeunload = undefined;
+  });
+
+  $uiRouter.transitionService.onSuccess({ to: '**.report.**' }, (transition: Transition) => {
+    if (transition.params('from').count !== transition.params('to').count) {
+      canaryStore.dispatch(Creators.setExecutionsCount({ count: transition.params('to').count }));
+    }
+  });
+}

package/src/kayenta/reducers/app.ts

@@ -0,0 +1,56 @@
+import { Action, combineReducers, Reducer } from 'redux';
+import { combineActions, handleActions } from 'redux-actions';
+
+import * as Actions from '../actions';
+import { CanarySettings } from '../canary.settings';
+import { ConfigJsonModalTabState } from '../edit/configJsonModal';
+
+export interface IAppState {
+  deleteConfigModalOpen: boolean;
+  configJsonModalOpen: boolean;
+  configJsonModalTabState: ConfigJsonModalTabState;
+  disableConfigEdit: boolean;
+  executionsCount: number;
+}
+
+const executionsCount = handleActions(
+  {
+    [Actions.SET_EXECUTIONS_COUNT]: (_state: IAppState, action: Action & any) => action.payload.count,
+  },
+  CanarySettings.defaultExecutionCount ?? CanarySettings.executionsCountOptions?.[0] ?? 20,
+);
+
+const deleteConfigModalOpen = handleActions(
+  {
+    [Actions.DELETE_CONFIG_MODAL_OPEN]: () => true,
+    [combineActions(Actions.DELETE_CONFIG_MODAL_CLOSE, Actions.DELETE_CONFIG_SUCCESS)]: () => false,
+  },
+  false,
+);
+
+const configJsonModalOpen = handleActions(
+  {
+    [Actions.CONFIG_JSON_MODAL_OPEN]: () => true,
+    [combineActions(Actions.CONFIG_JSON_MODAL_CLOSE, Actions.SELECT_CONFIG)]: () => false,
+  },
+  false,
+);
+
+const configJsonModalTabState = handleActions(
+  {
+    [Actions.SET_CONFIG_JSON_MODAL_TAB_STATE]: (_state: ConfigJsonModalTabState, action: Action & any) =>
+      action.payload.state,
+    [Actions.CONFIG_JSON_MODAL_OPEN]: () => ConfigJsonModalTabState.Edit,
+  },
+  ConfigJsonModalTabState.Edit,
+);
+
+const disableConfigEdit = handleActions<boolean>({}, false);
+
+export const app: Reducer<IAppState> = combineReducers<IAppState>({
+  executionsCount,
+  deleteConfigModalOpen,
+  configJsonModalOpen,
+  configJsonModalTabState,
+  disableConfigEdit,
+});

package/src/kayenta/reducers/asyncRequest.ts

@@ -0,0 +1,5 @@
+export enum AsyncRequestState {
+  Requesting = 'requesting',
+  Fulfilled = 'fulfilled',
+  Failed = 'failed',
+}

package/src/kayenta/reducers/data.ts

@@ -0,0 +1,169 @@
+import {
+  ICanaryConfig,
+  ICanaryConfigSummary,
+  ICanaryExecutionStatusResult,
+  IJudge,
+  IKayentaAccount,
+  IMetricsServiceMetadata,
+} from 'kayenta/domain';
+import { without } from 'lodash';
+import { Action, combineReducers, Reducer } from 'redux';
+import { handleActions } from 'redux-actions';
+
+import { Application } from '@spinnaker/core';
+
+import * as Actions from '../actions';
+import { AsyncRequestState } from './asyncRequest';
+
+interface IMetricsServiceMetadataState {
+  load: AsyncRequestState;
+  data: IMetricsServiceMetadata[];
+}
+
+interface IExecutionsState {
+  load: AsyncRequestState;
+  data: ICanaryExecutionStatusResult[];
+}
+
+interface IKayentaAccountsState {
+  load: AsyncRequestState;
+  data: IKayentaAccount[];
+}
+
+export interface IDataState {
+  application: Application;
+  configSummaries: ICanaryConfigSummary[];
+  configs: ICanaryConfig[];
+  judges: IJudge[];
+  metricsServiceMetadata: IMetricsServiceMetadataState;
+  executions: IExecutionsState;
+  kayentaAccounts: IKayentaAccountsState;
+}
+
+export const application = handleActions(
+  {
+    [Actions.INITIALIZE]: (_state: Application, action: Action & any) => action.state.data.application,
+  },
+  null,
+);
+
+export const configSummaries = handleActions(
+  {
+    [Actions.INITIALIZE]: (_state: ICanaryConfigSummary, action: Action & any) => action.state.data.configSummaries,
+    [Actions.UPDATE_CONFIG_SUMMARIES]: (_state: ICanaryConfigSummary, action: Action & any) =>
+      action.payload.configSummaries,
+  },
+  [],
+);
+
+const configs = handleActions(
+  {
+    [Actions.LOAD_CONFIG_SUCCESS]: (state: ICanaryConfig[], action: Action & any): ICanaryConfig[] => {
+      if (state.some((config) => config.id === action.payload.config.id)) {
+        return without(
+          state,
+          state.find((config) => config.id === action.payload.config.id),
+        ).concat([action.payload.config]);
+      } else {
+        return state.concat([action.payload.config]);
+      }
+    },
+  },
+  [],
+);
+
+const judges = handleActions(
+  {
+    [Actions.INITIALIZE]: (_state: IJudge[], action: Action & any): IJudge[] => action.state.data.judges,
+    [Actions.UPDATE_JUDGES]: (_state: IJudge[], action: Action & any): IJudge[] => action.payload.judges,
+  },
+  null,
+);
+
+const executions = combineReducers<IExecutionsState>({
+  data: handleActions(
+    {
+      [Actions.LOAD_EXECUTIONS_SUCCESS]: (_state: ICanaryExecutionStatusResult[], action: Action & any) =>
+        action.payload.executions,
+    },
+    [],
+  ),
+  load: handleActions(
+    {
+      [Actions.LOAD_EXECUTIONS_REQUEST]: () => AsyncRequestState.Requesting,
+      [Actions.LOAD_EXECUTIONS_SUCCESS]: () => AsyncRequestState.Fulfilled,
+      [Actions.LOAD_EXECUTIONS_FAILURE]: () => AsyncRequestState.Failed,
+    },
+    AsyncRequestState.Fulfilled,
+  ),
+});
+
+const metricsServiceMetadata = combineReducers<IMetricsServiceMetadataState>({
+  load: handleActions(
+    {
+      [Actions.LOAD_METRICS_SERVICE_METADATA_REQUEST]: () => AsyncRequestState.Requesting,
+      [Actions.LOAD_METRICS_SERVICE_METADATA_SUCCESS]: () => AsyncRequestState.Fulfilled,
+      [Actions.LOAD_METRICS_SERVICE_METADATA_FAILURE]: () => AsyncRequestState.Failed,
+    },
+    AsyncRequestState.Fulfilled,
+  ),
+  data: handleActions(
+    {
+      [Actions.LOAD_METRICS_SERVICE_METADATA_SUCCESS]: (_state: IMetricsServiceMetadata[], action: Action & any) =>
+        action.payload.data,
+      [Actions.UPDATE_PROMETHEUS_METRIC_TYPE]: (state: IMetricsServiceMetadata, action: Action & any) => {
+        // When the user clears the Prometheus metric type dropdown,
+        // clear the backing set of metric descriptors, since they
+        // no longer apply to the filter.
+        return action.payload.metricName ? state : [];
+      },
+      [Actions.UPDATE_STACKDRIVER_METRIC_TYPE]: (state: IMetricsServiceMetadata, action: Action & any) => {
+        // When the user clears the Stackdriver metric type dropdown,
+        // clear the backing set of metric descriptors, since they
+        // no longer apply to the filter.
+        return action.payload.metricType ? state : [];
+      },
+      [Actions.UPDATE_DATADOG_METRIC_TYPE]: (state: IMetricsServiceMetadata, action: Action & any) => {
+        // When the user clears the Datadog metric type dropdown,
+        // clear the backing set of metric descriptors, since they
+        // no longer apply to the filter.
+        return action.payload.metricType ? state : [];
+      },
+      [Actions.UPDATE_NEWRELIC_SELECT]: (state: IMetricsServiceMetadata, action: Action & any) => {
+        return action.payload.select ? state : [];
+      },
+      [Actions.UPDATE_GRAPHITE_METRIC_NAME]: (state: IMetricsServiceMetadata, action: Action & any) => {
+        return action.payload.metricName ? state : [];
+      },
+      [Actions.EDIT_METRIC_BEGIN]: () => [],
+    },
+    [],
+  ),
+});
+
+const kayentaAccounts = combineReducers<IKayentaAccountsState>({
+  load: handleActions<AsyncRequestState>(
+    {
+      [Actions.LOAD_KAYENTA_ACCOUNTS_REQUEST]: () => AsyncRequestState.Requesting,
+      [Actions.LOAD_KAYENTA_ACCOUNTS_SUCCESS]: () => AsyncRequestState.Fulfilled,
+      [Actions.LOAD_KAYENTA_ACCOUNTS_FAILURE]: () => AsyncRequestState.Failed,
+    },
+    AsyncRequestState.Requesting,
+  ),
+  data: handleActions<IKayentaAccount[]>(
+    {
+      [Actions.LOAD_KAYENTA_ACCOUNTS_SUCCESS]: (_state, action: Action & any) => action.payload.accounts,
+    },
+    [],
+  ),
+});
+
+export const data: Reducer<IDataState> = combineReducers<IDataState>({
+  application,
+  configSummaries,
+  judges,
+  configs,
+  executions,
+  metricsServiceMetadata,
+  kayentaAccounts,
+});

package/src/kayenta/reducers/editingTemplate.ts

@@ -0,0 +1,54 @@
+import * as Actions from 'kayenta/actions';
+import { Action, combineReducers } from 'redux';
+import { combineActions, handleActions } from 'redux-actions';
+
+export interface IEditingTemplateState {
+  name: string;
+  editedName: string;
+  editedValue: string;
+  isNew: boolean;
+}
+
+const name = handleActions<string>(
+  {
+    [Actions.EDIT_TEMPLATE_BEGIN]: (_state, action: Action & any) => action.payload.name,
+    [Actions.EDIT_TEMPLATE_CANCEL]: () => null,
+    [Actions.ADD_TEMPLATE]: () => '',
+  },
+  null,
+);
+
+const editedName = handleActions<string>(
+  {
+    [combineActions(Actions.EDIT_TEMPLATE_BEGIN, Actions.EDIT_TEMPLATE_NAME)]: (_state, action: Action & any) =>
+      action.payload.name,
+    [Actions.EDIT_TEMPLATE_CANCEL]: () => null,
+    [Actions.ADD_TEMPLATE]: () => '',
+  },
+  null,
+);
+
+const editedValue = handleActions<string>(
+  {
+    [combineActions(Actions.EDIT_TEMPLATE_VALUE, Actions.EDIT_TEMPLATE_BEGIN)]: (_state, action: Action & any) =>
+      action.payload.value,
+    [Actions.EDIT_TEMPLATE_CANCEL]: () => null,
+    [Actions.ADD_TEMPLATE]: () => '',
+  },
+  null,
+);
+
+const isNew = handleActions<boolean>(
+  {
+    [Actions.ADD_TEMPLATE]: () => true,
+    [Actions.EDIT_TEMPLATE_CANCEL]: () => false,
+  },
+  false,
+);
+
+export const editingTemplate = combineReducers<IEditingTemplateState>({
+  name,
+  editedName,
+  editedValue,
+  isNew,
+});

package/src/kayenta/reducers/group.ts

@@ -0,0 +1,82 @@
+import { get } from 'lodash';
+import { Action, combineReducers, Reducer } from 'redux';
+import { combineActions, handleActions } from 'redux-actions';
+
+import * as Actions from '../actions';
+import { ICanaryMetricConfig, IGroupWeights } from '../domain/ICanaryConfig';
+
+export interface IGroupState {
+  list: string[];
+  selected: string;
+  groupWeights: { [group: string]: number };
+  edit: string;
+}
+
+function groupsFromMetrics(metrics: ICanaryMetricConfig[] = []) {
+  const results = metrics
+    .reduce((groups, metric) => {
+      return groups.concat(metric.groups.filter((g: string) => !groups.includes(g)));
+    }, [])
+    .sort();
+  if (!results.length) {
+    results.push('Group 1');
+  }
+  return results;
+}
+
+const list = handleActions(
+  {
+    [Actions.SELECT_CONFIG]: (_state: string[], action: Action & any) =>
+      groupsFromMetrics(action.payload.config.metrics),
+    [Actions.ADD_METRIC]: (state: string[], action: Action & any) => {
+      const groups = action.payload.metric.groups;
+      return state.concat(groups.filter((g: string) => !state.includes(g)));
+    },
+    [Actions.ADD_GROUP]: (state: string[]) => {
+      let n = 1;
+      let name = null;
+      do {
+        name = 'Group ' + n;
+        n++;
+      } while (state.includes(name));
+      return state.concat([name]);
+    },
+  },
+  [],
+);
+
+const selected = handleActions(
+  {
+    [Actions.SELECT_GROUP]: (_state: string, action: Action & any) => action.payload.name,
+    [Actions.SELECT_CONFIG]: () => '',
+  },
+  '',
+);
+
+const groupWeights = handleActions(
+  {
+    [Actions.SELECT_CONFIG]: (_state: IGroupWeights, action: Action & any) =>
+      get(action, 'payload.config.classifier.groupWeights', {}),
+    [Actions.UPDATE_GROUP_WEIGHT]: (state: IGroupWeights, action: Action & any) => ({
+      ...state,
+      [action.payload.group]: action.payload.weight,
+    }),
+  },
+  {},
+);
+
+const edit = handleActions(
+  {
+    [Actions.EDIT_GROUP_BEGIN]: (_state: string, action: Action & any) => action.payload.group,
+    [Actions.EDIT_GROUP_UPDATE]: (_state: string, action: Action & any) => action.payload.edit,
+    [combineActions(Actions.SELECT_GROUP, Actions.EDIT_GROUP_CONFIRM)]: () => null,
+  },
+  null,
+);
+
+export const group: Reducer<IGroupState> = combineReducers<IGroupState>({
+  list,
+  selected,
+  groupWeights,
+  edit,
+});