Update some storage class logic, naming

frontend/src/app/AppRoutes.tsx

@@ -73,7 +73,6 @@ const AppRoutes: React.FC = () => {
   const isJupyterEnabled = useCheckJupyterEnabled();
   const isHomeAvailable = useIsAreaAvailable(SupportedArea.HOME).status;
   const isConnectionTypesAvailable = useIsAreaAvailable(SupportedArea.CONNECTION_TYPES).status;
-  const isStorageClassesAvailable = useIsAreaAvailable(SupportedArea.STORAGE_CLASSES).status;
 
   if (!isAllowed) {
     return (
@@ -131,9 +130,7 @@ const AppRoutes: React.FC = () => {
             {isConnectionTypesAvailable ? (
               <Route path="/connectionTypes/*" element={<ConnectionTypeRoutes />} />
             ) : null}
-            {isStorageClassesAvailable && (
-              <Route path="/storageClasses/*" element={<StorageClassesPage />} />
-            )}
+            <Route path="/storageClasses/*" element={<StorageClassesPage />} />
             <Route path="/modelRegistrySettings/*" element={<ModelRegistrySettingsRoutes />} />
             <Route path="/groupSettings" element={<GroupSettingsPage />} />
           </>

frontend/src/k8sTypes.ts

@@ -55,7 +55,7 @@ export type StorageClassConfig = {
   description?: string;
 };
 
-export enum Annotation {
+export enum MetadataAnnotation {
   StorageClassIsDefault = 'storageclass.kubernetes.io/is-default-class',
   K8sDescription = 'kubernetes.io/description',
   OdhStorageClassConfig = 'opendatahub.io/sc-config',
@@ -64,10 +64,10 @@ export enum Annotation {
 type StorageClassAnnotations = Partial<{
   // if true, enables any persistent volume claim (PVC) that does not specify a specific storage class to automatically be provisioned.
   // Only one, if any, StorageClass per cluster can be set as default.
-  [Annotation.StorageClassIsDefault]: 'true' | 'false';
+  [MetadataAnnotation.StorageClassIsDefault]: 'true' | 'false';
   // the description provided by the cluster admin or Container Storage Interface (CSI) provider
-  [Annotation.K8sDescription]: string;
-  [Annotation.OdhStorageClassConfig]: string;
+  [MetadataAnnotation.K8sDescription]: string;
+  [MetadataAnnotation.OdhStorageClassConfig]: string;
 }>;
 
 export type K8sDSGResource = K8sResourceCommon & {

frontend/src/pages/projects/screens/spawner/storage/usePreferredStorageClass.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 import { AppContext } from '~/app/AppContext';
-import { Annotation, StorageClassKind } from '~/k8sTypes';
+import { SupportedArea, useIsAreaAvailable } from '~/concepts/areas';
+import { MetadataAnnotation, StorageClassKind } from '~/k8sTypes';
 
 const usePreferredStorageClass = (): StorageClassKind | undefined => {
   const {
@@ -9,13 +10,16 @@ const usePreferredStorageClass = (): StorageClassKind | undefined => {
     },
     storageClasses,
   } = React.useContext(AppContext);
+  const isStorageClassesAvailable = useIsAreaAvailable(SupportedArea.STORAGE_CLASSES).status;
 
   const defaultClusterStorageClasses = storageClasses.filter(
     (storageclass) =>
-      storageclass.metadata.annotations?.[Annotation.StorageClassIsDefault] === 'true',
+      storageclass.metadata.annotations?.[MetadataAnnotation.StorageClassIsDefault] === 'true',
   );
 
-  const configStorageClassName = notebookController?.storageClassName ?? '';
+  const configStorageClassName = !isStorageClassesAvailable
+    ? notebookController?.storageClassName ?? ''
+    : '';
 
   if (defaultClusterStorageClasses.length !== 0) {
     return undefined;

frontend/src/pages/storageClasses/StorageClassesPage.tsx

@@ -10,49 +10,47 @@ import {
   AlertActionCloseButton,
 } from '@patternfly/react-core';
 
-import { Annotation, StorageClassConfig } from '~/k8sTypes';
+import { MetadataAnnotation, StorageClassConfig } from '~/k8sTypes';
 import useStorageClasses from '~/concepts/k8s/useStorageClasses';
 import { ProjectObjectType, typedEmptyImage } from '~/concepts/design/utils';
 import ApplicationsPage from '~/pages/ApplicationsPage';
 import { updateStorageClassConfig } from '~/services/StorageClassService';
+import { getStorageClassConfig, isOpenshiftDefaultStorageClass } from './utils';
 
 const StorageClassesPage: React.FC = () => {
   const [storageClasses, storageClassesLoaded, storageClassesError] = useStorageClasses();
   const [isAlertOpen, setIsAlertOpen] = React.useState(false);
 
   const defaultStorageClass = storageClasses.find(
     (storageClass) =>
-      storageClass.metadata.annotations?.[Annotation.StorageClassIsDefault] === 'true',
+      isOpenshiftDefaultStorageClass(storageClass) ||
+      getStorageClassConfig(storageClass)?.isDefault,
   );
 
-  // Open default class alert when no default class exists
-  React.useEffect(() => {
-    setIsAlertOpen(!defaultStorageClass?.metadata.name);
-  }, [defaultStorageClass?.metadata.name]);
-
   // Add storage class config annotations automatically for all storage classes without them
   React.useEffect(() => {
-    storageClasses.forEach((storageClass, index) => {
+    storageClasses.forEach(async (storageClass, index) => {
       const { metadata } = storageClass;
       const { name: storageClassName } = metadata;
 
-      if (!metadata.annotations?.[Annotation.OdhStorageClassConfig]) {
-        const isDefault = defaultStorageClass?.metadata.uid === metadata.uid;
+      if (!metadata.annotations?.[MetadataAnnotation.OdhStorageClassConfig]) {
+        let isDefault = defaultStorageClass?.metadata.uid === metadata.uid;
+        let isEnabled = false;
+
+        if (!defaultStorageClass) {
+          isDefault = index === 0;
+          isEnabled = true;
+        }
+
         const storageClassConfig: StorageClassConfig = {
+          isDefault,
+          isEnabled,
           displayName: storageClassName,
-          ...(!defaultStorageClass
-            ? {
-                isEnabled: true,
-                isDefault: index === 0,
-              }
-            : {
-                isDefault,
-                isEnabled: isDefault,
-              }),
           lastModified: new Date().toISOString(),
         };
 
-        updateStorageClassConfig(storageClassName, storageClassConfig);
+        await updateStorageClassConfig(storageClassName, storageClassConfig);
+        setIsAlertOpen(!defaultStorageClass?.metadata.name);
       }
     });
   }, [defaultStorageClass, storageClasses]);

frontend/src/pages/storageClasses/utils.ts

@@ -0,0 +1,14 @@
+import { MetadataAnnotation, StorageClassConfig, StorageClassKind } from '~/k8sTypes';
+
+export const getStorageClassConfig = (
+  storageClass: StorageClassKind,
+): StorageClassConfig | undefined => {
+  const storageClassConfig: StorageClassConfig | undefined = JSON.parse(
+    storageClass.metadata.annotations?.[MetadataAnnotation.OdhStorageClassConfig] || '',
+  );
+
+  return storageClassConfig;
+};
+
+export const isOpenshiftDefaultStorageClass = (storageClass: StorageClassKind): boolean =>
+  storageClass.metadata.annotations?.[MetadataAnnotation.StorageClassIsDefault] === 'true';