feat(md): store resource kinds without version number, and fallback t…

…o it if version is missing

app/scripts/modules/core/src/managed/EnvironmentsList.tsx

@@ -6,11 +6,7 @@ import { Application } from 'core/application';
 import { ManagedResourceObject } from './ManagedResourceObject';
 import { IManagedArtifactSummary, IManagedEnvironmentSummary, IManagedResourceSummary } from '../domain';
 import { EnvironmentRow } from './environment/EnvironmentRow';
-import { isResourceKindSupported } from './resources/resourceRegistry';
-
-function shouldDisplayResource(resource: IManagedResourceSummary) {
-  return isResourceKindSupported(resource.kind);
-}
+import { resourceManager } from './resources/resourceRegistry';
 
 interface IEnvironmentsListProps {
   application: Application;
@@ -39,7 +35,7 @@ export function EnvironmentsList({
           >
             {resources
               .map((resourceId) => resourcesById[resourceId])
-              .filter(shouldDisplayResource)
+              .filter((resource) => resourceManager.isResourceSupported(resource.kind))
               .sort((a, b) => `${a.kind}${a.displayName}`.localeCompare(`${b.kind}${b.displayName}`))
               .map((resource) => {
                 const artifactVersionsByState =

app/scripts/modules/core/src/managed/ManagedResourceObject.tsx

@@ -12,7 +12,7 @@ import { StatusBubble } from './StatusBubble';
 import { getArtifactVersionDisplayName } from './displayNames';
 import { IManagedArtifactSummary, IManagedEnvironmentSummary, IManagedResourceSummary } from '../domain/IManagedEntity';
 import { viewConfigurationByStatus } from './managedResourceStatusConfig';
-import { getExperimentalDisplayLink, getResourceIcon } from './resources/resourceRegistry';
+import { resourceManager } from './resources/resourceRegistry';
 
 export interface IManagedResourceObjectProps {
   application: Application;
@@ -74,7 +74,7 @@ export const ManagedResourceObject = memo(
     const routingInfo = getNativeResourceRoutingInfo(resource) ?? { state: '', params: {} };
     const routeProps = useSref(routingInfo.state, routingInfo.params);
 
-    const displayLink = getExperimentalDisplayLink(resource);
+    const displayLink = resourceManager.getExperimentalDisplayLink(resource);
     const displayLinkProps = displayLink && { href: displayLink, target: '_blank', rel: 'noopener noreferrer' };
 
     const linkProps = routeProps.href ? routeProps : displayLinkProps;
@@ -116,7 +116,7 @@ export const ManagedResourceObject = memo(
 
     return (
       <ObjectRow
-        icon={getResourceIcon(kind)}
+        icon={resourceManager.getResourceIcon(kind)}
         title={linkProps ? <a {...linkProps}>{displayName}</a> : displayName}
         depth={depth}
         content={resourceStatus}

app/scripts/modules/core/src/managed/artifactDetail/ArtifactDetail.tsx

@@ -21,15 +21,15 @@ import { PreDeploymentStepCard } from './PreDeploymentStepCard';
 import { Application } from '../../application';
 import { EnvironmentRow } from '../environment/EnvironmentRow';
 import { CollapsibleElement, Markdown, useEventListener } from '../../presentation';
-import { isResourceKindSupported } from '../resources/resourceRegistry';
+import { resourceManager } from '../resources/resourceRegistry';
 import { logCategories, useLogEvent } from '../utils/logging';
 
 import './ArtifactDetail.less';
 
 const SUPPORTED_PRE_DEPLOYMENT_TYPES = ['BUILD', 'BAKE'];
 
 function shouldDisplayResource(reference: string, resource: IManagedResourceSummary) {
-  return isResourceKindSupported(resource.kind) && reference === resource.artifact?.reference;
+  return resourceManager.isResourceSupported(resource.kind) && reference === resource.artifact?.reference;
 }
 
 const VersionMetadataItem = ({ label, value }: { label: string; value: JSX.Element | string }) => (

app/scripts/modules/core/src/managed/managed.module.js

@@ -3,9 +3,6 @@
 import { module } from 'angular';
 
 import { MANAGED_STATES } from './managed.states';
-import { registerNativeResourceKinds } from './resources/registerNativeResourceKinds';
 
 export const CORE_MANAGED_MANAGED_MODULE = 'spinnaker.managed';
-module(CORE_MANAGED_MANAGED_MODULE, [MANAGED_STATES]).config(() => {
-  registerNativeResourceKinds();
-});
+module(CORE_MANAGED_MANAGED_MODULE, [MANAGED_STATES]).config(() => {});

app/scripts/modules/core/src/managed/resources/resourceRegistry.ts

@@ -3,8 +3,6 @@ import { IconNames } from '../../presentation';
 
 const UNKNOWN_RESOURCE_ICON = 'placeholder';
 
-const resourceConfigsByKind: { [kind: string]: IResourceKindConfig } = {};
-
 export interface IResourceKindConfig {
   kind: string;
   iconName: IconNames;
@@ -15,13 +13,66 @@ export interface IResourceKindConfig {
   experimentalDisplayLink?: (resource: IManagedResourceSummary) => string;
 }
 
-export const isResourceKindSupported = (kind: string) => resourceConfigsByKind.hasOwnProperty(kind);
+class ResourcesManager {
+  private resourceConfigs: { [kind: string]: IResourceKindConfig } = {};
+
+  constructor(resources: IResourceKindConfig[]) {
+    for (const resource of resources) {
+      this.registerResource(resource);
+    }
+  }
+
+  private normalizeKind(kind: string): string {
+    // Removes the version of the resource
+    return kind.split('@')[0];
+  }
+
+  public getResource(kind: string): IResourceKindConfig | undefined {
+    // We first try to return an exact match, otherwise, we return the resource without the version
+    return this.resourceConfigs[kind] || this.resourceConfigs[this.normalizeKind(kind)];
+  }
 
-export const registerResourceKind = (config: IResourceKindConfig) => {
-  resourceConfigsByKind[config.kind] = config;
-};
+  public isResourceSupported(kind: string) {
+    return Boolean(this.getResource(kind));
+  }
+
+  public registerResource(config: IResourceKindConfig) {
+    // We register both the resource with the version and without the version
+    this.resourceConfigs[config.kind] = config;
+    this.resourceConfigs[this.normalizeKind(config.kind)] = config;
+  }
+
+  public getResourceIcon(kind: string) {
+    return this.getResource(kind)?.iconName ?? UNKNOWN_RESOURCE_ICON;
+  }
+
+  public getExperimentalDisplayLink(resource: IManagedResourceSummary): string | undefined {
+    return this.getResource(resource.kind)?.experimentalDisplayLink?.(resource);
+  }
+}
 
-export const getResourceIcon = (kind: string) => resourceConfigsByKind[kind]?.iconName ?? UNKNOWN_RESOURCE_ICON;
+const DEFAULT_RESOURCES: IResourceKindConfig[] = [
+  {
+    kind: 'titus/cluster',
+    iconName: 'cluster',
+  },
+  {
+    kind: 'ec2/cluster',
+    iconName: 'cluster',
+  },
+  {
+    kind: 'ec2/security-group',
+    iconName: 'securityGroup',
+  },
+  {
+    kind: 'ec2/classic-load-balancer',
+    iconName: 'loadBalancer',
+  },
+  {
+    kind: 'ec2/application-load-balancer',
+    iconName: 'loadBalancer',
+  },
+];
 
-export const getExperimentalDisplayLink = (resource: IManagedResourceSummary) =>
-  resourceConfigsByKind[resource.kind]?.experimentalDisplayLink?.(resource) ?? null;
+// TODO: this should not be global - convert it to React Context
+export const resourceManager = new ResourcesManager(DEFAULT_RESOURCES);

app/scripts/modules/core/src/plugins/deck.plugin.ts

@@ -2,7 +2,7 @@ import { toPairs } from 'lodash';
 
 import { IStageTypeConfig } from 'core/domain';
 import { HelpContentsRegistry } from 'core/help';
-import { IResourceKindConfig, registerResourceKind } from 'core/managed';
+import { IResourceKindConfig, resourceManager } from 'core/managed';
 import { Registry } from 'core/registry';
 import { SearchResultType, searchResultTypeRegistry } from 'core/search';
 
@@ -25,7 +25,7 @@ export interface IDeckPlugin {
 export function registerPluginExtensions(plugin: IDeckPlugin): PromiseLike<any> {
   plugin.stages?.forEach((stage) => Registry.pipeline.registerStage(stage));
   plugin.preconfiguredJobStages?.forEach((stage) => Registry.pipeline.registerPreconfiguredJobStage(stage));
-  plugin.resourceKinds?.forEach((kind) => registerResourceKind(kind));
+  plugin.resourceKinds?.forEach((kind) => resourceManager.registerResource(kind));
   toPairs(plugin.help ?? {}).forEach(([key, value]) => HelpContentsRegistry.register(key, value));
   plugin.search?.forEach((search) => searchResultTypeRegistry.register(search));