@spinnaker/kubernetes 2025.1.4 → 2025.2.1

package/src/loadBalancer/details/useKubernetesLoadBalancerDetails.ts

@@ -0,0 +1,52 @@
+import { useMemo } from 'react';
+
+import type { IManifest, IUseDetailsHookProps, UseDetailsHook, UseDetailsResult } from '@spinnaker/core';
+import { ManifestReader, useData, useDataSource } from '@spinnaker/core';
+
+import type { IKubernetesLoadBalancer } from '../../interfaces';
+
+export const useKubernetesLoadBalancerDetails: UseDetailsHook<IKubernetesLoadBalancer> = (
+  props: IUseDetailsHookProps,
+): UseDetailsResult<IKubernetesLoadBalancer> => {
+  const { loadBalancerParams, app, autoClose } = props;
+  const { name, accountId, region } = loadBalancerParams;
+
+  const dataSource = app.getDataSource('loadBalancers');
+  const {
+    data: loadBalancers,
+    loaded: isLoadBalancersLoaded,
+    refresh: refreshLoadBalancers,
+    error: loadBalancersError,
+  } = useDataSource<IKubernetesLoadBalancer[]>(dataSource);
+
+  const { result: manifest, status: manifestStatus, refresh: refreshManifest, error: manifestError } = useData(
+    () => ManifestReader.getManifest(accountId, region, name),
+    {} as IManifest,
+    [],
+  );
+
+  const loading = !isLoadBalancersLoaded || manifestStatus !== 'RESOLVED';
+
+  const error = loadBalancersError || manifestError || undefined;
+
+  const data = useMemo<IKubernetesLoadBalancer | undefined>(() => {
+    if (loading || error) {
+      return undefined;
+    }
+    const details = loadBalancers.find(
+      (lb: IKubernetesLoadBalancer) => lb.name === name && lb.account === accountId && lb.region === region,
+    );
+    if (!details) {
+      autoClose();
+      return undefined;
+    }
+    return { ...details, manifest };
+  }, [isLoadBalancersLoaded, loadBalancers, manifestStatus, manifest]);
+
+  const refetch = async () => {
+    refreshLoadBalancers();
+    refreshManifest();
+  };
+
+  return { data, loading, error, refetch };
+};

package/src/loadBalancer/index.ts

@@ -1 +1,4 @@
-export * from './details/details.controller';
+export * from './transformer';
+export * from './details/sections';
+export * from './details/KubernetesLoadBalancerActions';
+export * from './details/useKubernetesLoadBalancerDetails';

package/src/loadBalancer/transformer.ts

@@ -1,15 +1,10 @@
-import type { IQService } from 'angular';
-import { module } from 'angular';
 import { camelCase, chain } from 'lodash';
 
 import type { IInstanceCounts, IServerGroup } from '@spinnaker/core';
 
 import type { IKubernetesLoadBalancer } from '../interfaces';
 
-class KubernetesV2LoadBalancerTransformer {
-  public static $inject = ['$q'];
-  constructor(private $q: IQService) {}
-
+export class KubernetesLoadBalancerTransformer {
   public normalizeLoadBalancer(loadBalancer: IKubernetesLoadBalancer): PromiseLike<IKubernetesLoadBalancer> {
     loadBalancer.provider = loadBalancer.type;
     loadBalancer.instances = [];
@@ -20,7 +15,7 @@ class KubernetesV2LoadBalancerTransformer {
         instance.cloudProvider = loadBalancer.provider;
       });
     });
-    return this.$q.resolve(loadBalancer);
+    return Promise.resolve(loadBalancer);
   }
 
   private buildInstanceCounts(serverGroups: IServerGroup[]): IInstanceCounts {
@@ -52,9 +47,3 @@ class KubernetesV2LoadBalancerTransformer {
     return instanceCounts;
   }
 }
-
-export const KUBERNETES_LOAD_BALANCER_TRANSFORMER = 'spinnaker.kubernetes.loadBalancerTransformer';
-module(KUBERNETES_LOAD_BALANCER_TRANSFORMER, []).service(
-  'kubernetesV2LoadBalancerTransformer',
-  KubernetesV2LoadBalancerTransformer,
-);

package/src/manifest/delete/Delete.tsx

@@ -0,0 +1,34 @@
+import { module } from 'angular';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+import { react2angular } from 'react2angular';
+
+import type { Application } from '@spinnaker/core';
+import { withErrorBoundary } from '@spinnaker/core';
+import { useModal } from '@spinnaker/core';
+
+import { DeleteModal } from './DeleteModal';
+import type { IAnyKubernetesResource } from '../../interfaces';
+
+export interface IDeleteProps {
+  application: Application;
+  resource: IAnyKubernetesResource;
+  manifestController: string | undefined;
+}
+
+export function Delete(props: IDeleteProps) {
+  const { open, show, close } = useModal();
+  const handleClick = () => show();
+  return (
+    <>
+      <MenuItem onClick={handleClick}>Delete</MenuItem>
+      <DeleteModal isOpen={open} dismissModal={close} {...props} />
+    </>
+  );
+}
+
+export const KUBERNETES_DELETE = 'spinnaker.kubernetes.delete';
+module(KUBERNETES_DELETE, []).component(
+  'kubernetesDelete',
+  react2angular(withErrorBoundary(Delete, 'kubernetesDelete'), ['application', 'resource', 'manifestController']),
+);

package/src/manifest/delete/DeleteModal.tsx

@@ -0,0 +1,152 @@
+import { UISref } from '@uirouter/react';
+import { UIRouterContextComponent } from '@uirouter/react-hybrid';
+import type { FormikProps } from 'formik';
+import { Form } from 'formik';
+import React, { useState } from 'react';
+import { Button, Modal } from 'react-bootstrap';
+
+import type { Application, IModalComponentProps, IModalProps } from '@spinnaker/core';
+import {
+  ManifestWriter,
+  ModalClose,
+  robotToHuman,
+  SpinFormik,
+  SubmitButton,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+  useTaskMonitor,
+  ValidationMessage,
+} from '@spinnaker/core';
+
+import type { IDeleteOptions } from './delete.controller';
+import type { IAnyKubernetesResource } from '../../interfaces';
+import DeleteManifestOptionsForm from '../../pipelines/stages/deleteManifest/DeleteManifestOptionsForm';
+
+export interface IKubernetesDeleteModalProps
+  extends Pick<IModalProps, 'isOpen'>,
+    Pick<IModalComponentProps, 'dismissModal'> {
+  application: Application;
+  resource: IAnyKubernetesResource;
+  manifestController: string | undefined;
+}
+
+export interface IKubernetesDeleteValues extends IDeleteOptions {
+  reason?: string;
+}
+
+export function DeleteModal({
+  application,
+  resource,
+  manifestController,
+  isOpen,
+  dismissModal,
+}: IKubernetesDeleteModalProps) {
+  const initialValues: IKubernetesDeleteValues = {
+    cascading: true,
+  };
+  const [verified, setVerified] = useState<boolean>(false);
+  const taskMonitor = useTaskMonitor(
+    {
+      application,
+      title: `Deleting ${resource.name}`,
+      onTaskComplete: () => application.serverGroups.refresh(true),
+    },
+    dismissModal,
+  );
+
+  const submit = (values: IKubernetesDeleteValues): void => {
+    const payload = {
+      cloudProvider: 'kubernetes',
+      manifestName: resource.name,
+      location: resource.namespace,
+      account: resource.account,
+      reason: values.reason,
+      options: {
+        gracePeriodSeconds: values.gracePeriodSeconds,
+        orphanDependants: !values.cascading,
+      },
+    };
+    return taskMonitor.submit(() => ManifestWriter.deleteManifest(payload, application));
+  };
+
+  const onOptionChange = (formik: FormikProps<IKubernetesDeleteValues>, values: IKubernetesDeleteValues): void => {
+    formik.setFieldValue('gracePeriodSeconds', values.gracePeriodSeconds);
+    formik.setFieldValue('cascading', values.cascading);
+  };
+
+  return (
+    <UIRouterContextComponent>
+      <Modal show={isOpen} onHide={dismissModal}>
+        <TaskMonitorWrapper monitor={taskMonitor} />
+        <SpinFormik<IKubernetesDeleteValues>
+          initialValues={initialValues}
+          onSubmit={submit}
+          render={(formik) => (
+            <>
+              <ModalClose dismiss={dismissModal} />
+              <Modal.Header>
+                <Modal.Title>
+                  Delete {robotToHuman(resource.name)} in {resource.namespace}
+                </Modal.Title>
+              </Modal.Header>
+              {manifestController && (
+                <div className="alert alert-warning">
+                  Manifest is controlled by{' '}
+                  <UISref
+                    to="^.serverGroupManager"
+                    params={{
+                      accountId: resource.account,
+                      region: resource.region,
+                      serverGroupManager: manifestController,
+                      provider: 'kubernetes',
+                    }}
+                  >
+                    <a> {robotToHuman(manifestController)} </a>
+                  </UISref>{' '}
+                  and may be recreated after deletion.
+                </div>
+              )}
+              <Modal.Body>
+                <Form className="form-horizontal">
+                  <DeleteManifestOptionsForm
+                    onOptionsChange={(options: IDeleteOptions) => onOptionChange(formik, options)}
+                    options={{
+                      gracePeriodSeconds: formik.values.gracePeriodSeconds,
+                      cascading: formik.values.cascading,
+                    }}
+                  />
+                  <TaskReason reason={formik.values.reason} onChange={(val) => formik.setFieldValue('reason', val)} />
+                </Form>
+                {formik.status?.error && (
+                  <div className="sp-margin-xl-top">
+                    <ValidationMessage
+                      type="error"
+                      message={
+                        <span className="flex-container-v">
+                          <span className="text-bold">Something went wrong:</span>
+                          {formik.status.error.message && <span>{formik.status.error.message}</span>}
+                        </span>
+                      }
+                    />
+                  </div>
+                )}
+              </Modal.Body>
+              <Modal.Footer>
+                <UserVerification account={resource.account} onValidChange={setVerified} />
+                <Button onClick={dismissModal}>Cancel</Button>
+                <SubmitButton
+                  onClick={() => submit(formik.values)}
+                  isDisabled={!formik.isValid || formik.isSubmitting || !verified}
+                  isFormSubmit={true}
+                  submitting={formik.isSubmitting}
+                  label={`Delete ${resource.name}`}
+                />
+              </Modal.Footer>
+            </>
+          )}
+        />
+      </Modal>
+    </UIRouterContextComponent>
+  );
+}

package/src/manifest/editor/json/JsonEditor.tsx

@@ -1,6 +1,5 @@
 import 'brace/mode/json';
 import 'brace/theme/textmate';
-import { $log } from 'ngimport';
 import React from 'react';
 import AceEditor from 'react-ace';
 
@@ -17,12 +16,12 @@ export class JsonEditor extends React.Component<IJsonEditorProps> {
       const obj = JSON.parse(raw);
       this.props.onChange
         ? this.props.onChange(raw, obj)
-        : $log.warn('No `onChange` handler provided for JSON editor.');
+        : console.warn('No `onChange` handler provided for JSON editor.');
     } catch (e) {
       this.props.onChange
         ? this.props.onChange(raw, null)
-        : $log.warn('No `onChange` handler provided for JSON editor.');
-      $log.warn(`Error loading JSON from string ${raw}: `, e);
+        : console.warn('No `onChange` handler provided for JSON editor.');
+      console.warn(`Error loading JSON from string ${raw}: `, e);
     }
   };
 

package/src/manifest/rollout/PauseRollout.tsx

@@ -0,0 +1,46 @@
+import { module } from 'angular';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+import { react2angular } from 'react2angular';
+
+import type { Application } from '@spinnaker/core';
+import { ConfirmationModalService, ManifestWriter, robotToHuman, withErrorBoundary } from '@spinnaker/core';
+
+import type { IAnyKubernetesResource } from '../../interfaces';
+
+export interface IPauseRolloutProps {
+  application: Application;
+  resource: IAnyKubernetesResource;
+}
+
+export function PauseRollout({ application, resource }: IPauseRolloutProps) {
+  const handleClick = () => {
+    ConfirmationModalService.confirm({
+      account: resource.account,
+      askForReason: true,
+      header: `Pause rollout of ${robotToHuman(resource.name)} in ${resource.namespace}`,
+      submitMethod: (params: { reason?: string }) => {
+        const payload = {
+          cloudProvider: 'kubernetes',
+          manifestName: resource.name,
+          location: resource.namespace,
+          account: resource.account,
+          reason: params.reason,
+        };
+        return ManifestWriter.pauseRolloutManifest(payload, application);
+      },
+      taskMonitorConfig: {
+        application,
+        title: `Pause rollout of ${resource.name} in ${resource.namespace}`,
+        onTaskComplete: () => application.serverGroups.refresh(true),
+      },
+    });
+  };
+  return <MenuItem onClick={handleClick}>Pause Rollout</MenuItem>;
+}
+
+export const KUBERNETES_PAUSE_ROLLOUT = 'spinnaker.kubernetes.pause.rollout';
+module(KUBERNETES_PAUSE_ROLLOUT, []).component(
+  'kubernetesPauseRollout',
+  react2angular(withErrorBoundary(PauseRollout, 'kubernetesPauseRollout'), ['application', 'resource']),
+);

package/src/manifest/rollout/ResumeRollout.tsx

@@ -0,0 +1,46 @@
+import { module } from 'angular';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+import { react2angular } from 'react2angular';
+
+import type { Application } from '@spinnaker/core';
+import { ConfirmationModalService, ManifestWriter, robotToHuman, withErrorBoundary } from '@spinnaker/core';
+
+import type { IAnyKubernetesResource } from '../../interfaces';
+
+export interface IResumeRolloutProps {
+  application: Application;
+  resource: IAnyKubernetesResource;
+}
+
+export function ResumeRollout({ application, resource }: IResumeRolloutProps) {
+  const handleClick = () => {
+    ConfirmationModalService.confirm({
+      account: resource.account,
+      askForReason: true,
+      header: `Resume rollout of ${robotToHuman(resource.name)} in ${resource.namespace}`,
+      submitMethod: (params: { reason?: string }) => {
+        const payload = {
+          cloudProvider: 'kubernetes',
+          manifestName: resource.name,
+          location: resource.namespace,
+          account: resource.account,
+          reason: params.reason,
+        };
+        return ManifestWriter.pauseRolloutManifest(payload, application);
+      },
+      taskMonitorConfig: {
+        application,
+        title: `Resume rollout of ${resource.name} in ${resource.namespace}`,
+        onTaskComplete: () => application.serverGroups.refresh(true),
+      },
+    });
+  };
+  return <MenuItem onClick={handleClick}>Resume Rollout</MenuItem>;
+}
+
+export const KUBERNETES_RESUME_ROLLOUT = 'spinnaker.kubernetes.resume.rollout';
+module(KUBERNETES_RESUME_ROLLOUT, []).component(
+  'kubernetesResumeRollout',
+  react2angular(withErrorBoundary(ResumeRollout, 'kubernetesResumeRollout'), ['application', 'resource']),
+);

package/src/manifest/rollout/RollingRestart.tsx

@@ -1,7 +1,10 @@
+import { module } from 'angular';
 import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+import { react2angular } from 'react2angular';
 
 import type { Application } from '@spinnaker/core';
-import { ConfirmationModalService, ManifestWriter } from '@spinnaker/core';
+import { ConfirmationModalService, ManifestWriter, withErrorBoundary } from '@spinnaker/core';
 
 import type { IKubernetesServerGroupManager } from '../../interfaces';
 
@@ -15,32 +18,37 @@ interface IRollingRestartParameters {
   cloudProvider: string;
   location: string;
   manifestName: string;
+  reason?: string;
 }
 
 export function RollingRestart({ application, serverGroupManager }: IRollingRestartProps) {
   function rollingRestart() {
-    const rollingRestartParameters: IRollingRestartParameters = {
-      account: serverGroupManager.account,
-      cloudProvider: 'kubernetes',
-      location: serverGroupManager.namespace,
-      manifestName: serverGroupManager.name,
-    };
     ConfirmationModalService.confirm({
       account: serverGroupManager.account,
       askForReason: true,
       header: `Initiate rolling restart of ${serverGroupManager.name}`,
-      submitMethod: () => {
+      submitMethod: (params: { reason?: string }) => {
+        const rollingRestartParameters: IRollingRestartParameters = {
+          account: serverGroupManager.account,
+          cloudProvider: 'kubernetes',
+          location: serverGroupManager.namespace,
+          manifestName: serverGroupManager.name,
+          reason: params.reason,
+        };
         return ManifestWriter.rollingRestartManifest(rollingRestartParameters, application);
       },
       taskMonitorConfig: {
         application,
         title: `Rolling restart of ${serverGroupManager.name}`,
+        onTaskComplete: () => application.serverGroups.refresh(true),
       },
     });
   }
-  return (
-    <li>
-      <a onClick={rollingRestart}>Rolling Restart</a>
-    </li>
-  );
+  return <MenuItem onClick={rollingRestart}>Rolling Restart</MenuItem>;
 }
+
+export const KUBERNETES_ROLLING_RESTART = 'spinnaker.kubernetes.v2.rolling.restart';
+module(KUBERNETES_ROLLING_RESTART, []).component(
+  'kubernetesRollingRestart',
+  react2angular(withErrorBoundary(RollingRestart, 'kubernetesRollingRestart'), ['application', 'serverGroupManager']),
+);

package/src/manifest/rollout/UndoRollout.tsx

@@ -0,0 +1,33 @@
+import { module } from 'angular';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+import { react2angular } from 'react2angular';
+
+import type { Application } from '@spinnaker/core';
+import { withErrorBoundary } from '@spinnaker/core';
+import { useModal } from '@spinnaker/core';
+
+import { UndoRolloutModal } from './UndoRolloutModal';
+import type { IAnyKubernetesResource } from '../../interfaces';
+
+export interface IUndoRolloutProps {
+  application: Application;
+  resource: IAnyKubernetesResource;
+}
+
+export function UndoRollout(props: IUndoRolloutProps) {
+  const { open, show, close } = useModal();
+  const handleClick = () => show();
+  return (
+    <>
+      <MenuItem onClick={handleClick}>Undo Rolloutaaaa</MenuItem>
+      <UndoRolloutModal isOpen={open} dismissModal={close} {...props} />
+    </>
+  );
+}
+
+export const KUBERNETES_UNDO_ROLLOUT = 'spinnaker.kubernetes.undo.rollout';
+module(KUBERNETES_UNDO_ROLLOUT, []).component(
+  'kubernetesUndoRollout',
+  react2angular(withErrorBoundary(UndoRollout, 'kubernetesUndoRollout'), ['application', 'resource']),
+);

package/src/manifest/rollout/UndoRolloutModal.tsx

@@ -0,0 +1,123 @@
+import { Form } from 'formik';
+import { orderBy } from 'lodash';
+import React, { useState } from 'react';
+import { Button, Modal } from 'react-bootstrap';
+import type { Option } from 'react-select';
+
+import type { Application, IModalComponentProps, IModalProps, IServerGroupManager } from '@spinnaker/core';
+import {
+  ManifestWriter,
+  ModalClose,
+  NameUtils,
+  ReactSelectInput,
+  robotToHuman,
+  SpinFormik,
+  SubmitButton,
+  TaskMonitorWrapper,
+  TaskReason,
+  UserVerification,
+  useTaskMonitor,
+} from '@spinnaker/core';
+
+import type { IAnyKubernetesResource } from '../../interfaces';
+import type { IRolloutRevision } from './undo.controller';
+
+export interface IKubernetesUndoRolloutModalProps
+  extends Pick<IModalProps, 'isOpen'>,
+    Pick<IModalComponentProps, 'dismissModal'> {
+  application: Application;
+  resource: IAnyKubernetesResource;
+}
+
+export interface IKubernetesUndoRolloutValues {
+  revision?: number;
+  reason?: string;
+}
+
+const fetchRevisions = (serverGroupManager: IServerGroupManager): IRolloutRevision[] => {
+  const [, ...rest] = orderBy(serverGroupManager.serverGroups, ['moniker.sequence'], ['desc']);
+  return rest.map((serverGroup, index) => ({
+    label: `${NameUtils.getSequence(serverGroup.moniker.sequence)}${index > 0 ? '' : ' - previous revision'}`,
+    revision: serverGroup.moniker.sequence,
+  }));
+};
+
+export function UndoRolloutModal({ application, resource, isOpen, dismissModal }: IKubernetesUndoRolloutModalProps) {
+  const initialValues: IKubernetesUndoRolloutValues = {};
+  const revisions = fetchRevisions(resource as IServerGroupManager);
+  const [verified, setVerified] = useState<boolean>(false);
+  const taskMonitor = useTaskMonitor(
+    {
+      application,
+      title: `Undo rollout of ${resource.name} in ${resource.namespace}`,
+      onTaskComplete: () => application.serverGroups.refresh(true),
+    },
+    dismissModal,
+  );
+
+  const submit = (values: IKubernetesUndoRolloutValues): void => {
+    const payload = {
+      cloudProvider: 'kubernetes',
+      manifestName: resource.name,
+      location: resource.namespace,
+      account: resource.account,
+      reason: values.reason,
+      revision: values.revision,
+    };
+    return taskMonitor.submit(() => ManifestWriter.undoRolloutManifest(payload, application));
+  };
+
+  return (
+    <Modal show={isOpen} onHide={dismissModal}>
+      <TaskMonitorWrapper monitor={taskMonitor} />
+      <SpinFormik<IKubernetesUndoRolloutValues>
+        initialValues={initialValues}
+        onSubmit={submit}
+        render={(formik) => (
+          <>
+            <ModalClose dismiss={dismissModal} />
+            <Modal.Header>
+              <Modal.Title>
+                Undo rollout of {robotToHuman(resource.name)} in {resource.namespace}
+              </Modal.Title>
+            </Modal.Header>
+            <Modal.Body>
+              <Form className="form-horizontal">
+                <div className="form-group form-inline">
+                  <label className="col-md-3 sm-label-right">
+                    <span className="label-text">Revision </span>
+                  </label>
+                  <div className="col-md-7">
+                    <ReactSelectInput<number>
+                      clearable={false}
+                      value={formik.values.revision}
+                      options={revisions.map((revision) => ({
+                        label: revision.label,
+                        value: revision.revision,
+                      }))}
+                      onChange={(option: Option<number>) => {
+                        formik.setFieldValue('revision', option.target.value);
+                      }}
+                    />
+                  </div>
+                </div>
+                <TaskReason reason={formik.values.reason} onChange={(val) => formik.setFieldValue('reason', val)} />
+              </Form>
+            </Modal.Body>
+            <Modal.Footer>
+              <UserVerification account={resource.account} onValidChange={setVerified} />
+              <Button onClick={dismissModal}>Cancel</Button>
+              <SubmitButton
+                onClick={() => submit(formik.values)}
+                isDisabled={!formik.isValid || formik.isSubmitting || !verified}
+                isFormSubmit={true}
+                submitting={formik.isSubmitting}
+                label={`Undo rollout of ${resource.name}`}
+              />
+            </Modal.Footer>
+          </>
+        )}
+      />
+    </Modal>
+  );
+}

package/src/manifest/rollout/undo.controller.ts

@@ -14,7 +14,7 @@ interface IUndoRolloutCommand {
   revision: number;
 }
 
-interface IRolloutRevision {
+export interface IRolloutRevision {
   label: string;
   revision: number;
 }

package/src/manifest/scale/Scale.tsx

@@ -0,0 +1,34 @@
+import { module } from 'angular';
+import React from 'react';
+import { MenuItem } from 'react-bootstrap';
+import { react2angular } from 'react2angular';
+
+import type { Application } from '@spinnaker/core';
+import { withErrorBoundary } from '@spinnaker/core';
+import { useModal } from '@spinnaker/core';
+
+import { ScaleModal } from './ScaleModal';
+import type { IAnyKubernetesResource } from '../../interfaces';
+
+export interface IScaleProps {
+  application: Application;
+  resource: IAnyKubernetesResource;
+  currentReplicas: number;
+}
+
+export function Scale(props: IScaleProps) {
+  const { open, show, close } = useModal();
+  const handleClick = () => show();
+  return (
+    <>
+      <MenuItem onClick={handleClick}>Scale</MenuItem>
+      <ScaleModal isOpen={open} dismissModal={close} {...props} />
+    </>
+  );
+}
+
+export const KUBERNETES_SCALE = 'spinnaker.kubernetes.scale';
+module(KUBERNETES_SCALE, []).component(
+  'kubernetesScale',
+  react2angular(withErrorBoundary(Scale, 'kubernetesScale'), ['application', 'resource', 'currentReplicas']),
+);