ISPN-11492 and ISPN-11491 Cluster and Cache enable/disable rebalancing

src/app/CacheManagers/CacheManagers.tsx

@@ -29,6 +29,7 @@ import {useTranslation} from 'react-i18next';
 import {useConnectedUser} from "@app/services/userManagementHook";
 import {ConsoleServices} from "@services/ConsoleServices";
 import {ConsoleACL} from "@services/securityService";
+import {RebalancingCacheManager} from "@app/CacheManagers/RebalancingCacheManager";
 
 const CacheManagers = () => {
   const { connectedUser } = useConnectedUser();
@@ -207,6 +208,7 @@ const CacheManagers = () => {
               <Status status={cm.cache_manager_status} />
             </FlexItem>
             {buildSiteDisplay(cm.local_site)}
+            <RebalancingCacheManager/>
           </Flex>
         </Flex>
         {buildTabs()}

src/app/CacheManagers/RebalancingCacheManager.tsx

@@ -0,0 +1,51 @@
+import React from 'react';
+import {Divider, FlexItem, Spinner, Switch} from '@patternfly/react-core';
+import {useConnectedUser} from "@app/services/userManagementHook";
+import {ConsoleServices} from "@services/ConsoleServices";
+import {ConsoleACL} from "@services/securityService";
+import {useTranslation} from "react-i18next";
+import {useApiAlert} from "@app/utils/useApiAlert";
+import {useDataContainer} from "@app/services/dataContainerHooks";
+
+const RebalancingCacheManager = () => {
+  const { addAlert } = useApiAlert();
+  const { t } = useTranslation();
+  const { connectedUser } = useConnectedUser();
+  const { cm, loading, reload } = useDataContainer();
+
+  if (loading || !cm) {
+    return (
+      <FlexItem>
+        <Spinner size={'md'} />
+      </FlexItem>
+    );
+  }
+
+  if (ConsoleServices.security().hasConsoleACL(ConsoleACL.ADMIN, connectedUser)) {
+    return (
+      <React.Fragment>
+        <Divider isVertical />
+        <FlexItem>
+          <Switch
+            id="rebalancing-switch"
+            label={t('cache-managers.rebalancing-enabled')}
+            labelOff={t('cache-managers.rebalancing-disabled')}
+            isChecked={cm.rebalancing_enabled}
+            onChange={() => {
+              ConsoleServices.dataContainer().rebalancing(cm.name, !cm.rebalancing_enabled)
+                .then(r => {
+                  addAlert(r);
+                  reload();
+                })
+            }}
+          />
+        </FlexItem>
+      </React.Fragment>
+    );
+  }
+
+  // Return nothing if the connected user is not ADMIN
+  return (<FlexItem></FlexItem>);
+};
+
+export { RebalancingCacheManager };

src/app/Caches/DetailCache.tsx

@@ -43,6 +43,7 @@ import {ConsoleServices} from "@services/ConsoleServices";
 import {ConsoleACL} from "@services/securityService";
 import {useConnectedUser} from "@app/services/userManagementHook";
 import {useTranslation} from "react-i18next";
+import {RebalancingCache} from "@app/Caches/RebalancingCache";
 
 const DetailCache = (props: { cacheName: string }) => {
   const cacheName = props.cacheName;
@@ -104,17 +105,7 @@ const DetailCache = (props: { cacheName: string }) => {
   };
 
   const buildDetailContent = () => {
-    if (loading) {
-      return (
-        <Card>
-          <CardBody>
-            <Spinner size="xl" />
-          </CardBody>
-        </Card>
-      );
-    }
-
-    if (error.length > 0 || !cache) {
+    if (error.length > 0) {
       return (
         <Card>
           <CardBody>
@@ -142,6 +133,16 @@ const DetailCache = (props: { cacheName: string }) => {
       );
     }
 
+    if (loading || !cache) {
+      return (
+        <Card>
+          <CardBody>
+            <Spinner size="xl" />
+          </CardBody>
+        </Card>
+      );
+    }
+
     if(activeTabKey1 == 0
       && cache.editable
       && ConsoleServices.security().hasCacheConsoleACL(ConsoleACL.READ, cacheName, connectedUser)) {
@@ -162,6 +163,8 @@ const DetailCache = (props: { cacheName: string }) => {
   };
 
   const buildRebalancing = () => {
+    if (!cache) return ;
+
     if (!cache?.rehash_in_progress) {
       return (
         <ToolbarItem>
@@ -308,7 +311,7 @@ const DetailCache = (props: { cacheName: string }) => {
           </ToolbarItem>
         </ToolbarGroup>
         <ToolbarGroup>
-          {buildRebalancing()}
+          <RebalancingCache/>
           {buildBackupsManage()}
           {buildIndexManage()}
         </ToolbarGroup>
@@ -416,7 +419,12 @@ const DetailCache = (props: { cacheName: string }) => {
           activeKey={activeTabKey1}
           isSecondary={true}
           component={TabsComponent.nav}
-          onSelect={(event, tabIndex) => setActiveTabKey1(tabIndex)}
+          onSelect={(event, tabIndex) => {
+            setActiveTabKey1(tabIndex);
+            if (tabIndex == 0) {
+              loadCache(cacheName);
+            }
+          }}
         >
           {displayCacheEntries()}
           {displayConfiguration()}

src/app/Caches/RebalancingCache.tsx

@@ -0,0 +1,71 @@
+import React from 'react';
+import {Label, Spinner, Switch, ToolbarItem} from '@patternfly/react-core';
+import {useCacheDetail} from "@app/services/cachesHook";
+import {useConnectedUser} from "@app/services/userManagementHook";
+import {ConsoleServices} from "@services/ConsoleServices";
+import {ConsoleACL} from "@services/securityService";
+import {useTranslation} from "react-i18next";
+import {useApiAlert} from "@app/utils/useApiAlert";
+import {useDataContainer} from "@app/services/dataContainerHooks";
+
+const RebalancingCache = () => {
+  const { addAlert } = useApiAlert();
+  const { t } = useTranslation();
+  const { connectedUser } = useConnectedUser();
+  const { cache, cacheManager, loading, reload } = useCacheDetail();
+
+  // If rebalancing is not activated at cluster level, don't display anything
+  if (!cacheManager.rebalancing_enabled) {
+    return ( <ToolbarItem/>)
+  }
+
+  if (loading || !cache) {
+    return (
+      <ToolbarItem>
+        <Spinner size={'md'} />
+      </ToolbarItem>
+    );
+  }
+
+  /**
+   * When the rehash is in progress just display the value
+   */
+  if (cache?.rehash_in_progress) {
+    return (
+      <ToolbarItem>
+        <Spinner size={'md'} /> {t('caches.info.rebalancing')}
+      </ToolbarItem>
+    );
+  }
+
+  /**
+   * If the user is ADMIN, can enable and disable rebalancing
+   */
+  if (ConsoleServices.security().hasConsoleACL(ConsoleACL.ADMIN, connectedUser)) {
+    return (
+      <ToolbarItem>
+        <Switch
+          id="rebalancing-switch"
+          label={t('caches.info.rebalancing-enabled')}
+          labelOff={t('caches.info.rebalancing-disabled')}
+          isChecked={cache.rebalancing_enabled}
+          onChange={() => {
+            ConsoleServices.caches().rebalancing(cache.name, !cache.rebalancing_enabled)
+              .then(r => {
+                addAlert(r);
+                reload();
+              })
+          }}
+        />
+      </ToolbarItem>
+    );
+  }
+
+  return (
+    <ToolbarItem>
+      <Label>{t('caches.info.rebalanced')}</Label>
+    </ToolbarItem>
+  );
+};
+
+export { RebalancingCache };

src/app/assets/languages/en.json

@@ -104,7 +104,9 @@
     "allowed-role" : "Allowed role",
     "allowed-role-null" : "-",
     "no-tasks-status" : "No tasks yet",
-    "no-tasks-body" : "Create tasks with the CLI or a remote client."
+    "no-tasks-body" : "Create tasks with the CLI or a remote client.",
+    "rebalancing-enabled": "Rebalancing is on",
+    "rebalancing-disabled": "Rebalancing is off"
   },
   "caches" : {
     "configuration" : {
@@ -129,7 +131,8 @@
       "loading" : "Loading cache {{cacheName}} ...",
       "error" : "An error occurred while loading {{cacheName}}",
       "rebalanced" : "Rebalanced",
-      "rebalancing" : "Rebalancing"
+      "rebalancing-enabled" : "Rebalancing is on",
+      "rebalancing-disabled" : "Rebalancing is off"
     },
     "actions" : {
       "action-see-less" : "See fewer cache details",

src/app/providers/CacheDetailProvider.tsx

@@ -7,6 +7,7 @@ import {ContentType} from "@services/infinispanRefData";
 const initialContext = {
   error: '',
   loading: false,
+  cacheManager: (undefined as unknown) as CacheManager,
   cache: (undefined as unknown) as DetailedInfinispanCache,
   loadCache: (name: string) => {},
   reload: () => {},
@@ -23,6 +24,9 @@ export const CacheDetailContext = React.createContext(initialContext);
 const CacheDetailProvider = ({ children }) => {
   const {connectedUser} = useConnectedUser();
   const [cacheName, setCacheName] = useState('');
+  const [cacheManager, setCacheManager] = useState<CacheManager>(
+    initialContext.cacheManager
+  );
   const [cache, setCache] = useState<DetailedInfinispanCache>(
     initialContext.cache
   );
@@ -52,19 +56,28 @@ const CacheDetailProvider = ({ children }) => {
 
   const fetchCache = () => {
     if (loading) {
-        ConsoleServices.caches()
-          .retrieveFullDetail(cacheName)
-          .then((eitherDetail) => {
-            if (eitherDetail.isRight()) {
-              setCache(eitherDetail.value);
-            } else {
-              setError(eitherDetail.value.message);
-            }
-          })
-          .finally(() => {
-            setLoading(false);
-            setLoadingEntries(true);
-          });
+      ConsoleServices.dataContainer().getDefaultCacheManager()
+        .then(maybeCm => {
+           if (maybeCm.isRight()) {
+             setCacheManager(maybeCm.value);
+             ConsoleServices.caches()
+               .retrieveFullDetail(cacheName)
+               .then((eitherDetail) => {
+                 if (eitherDetail.isRight()) {
+                   setCache(eitherDetail.value);
+                 } else {
+                   setError(eitherDetail.value.message);
+                 }
+               })
+               .finally(() => {
+                 setLoading(false);
+                 setLoadingEntries(true);
+               });
+           } else {
+             setError(maybeCm.value.message);
+           }
+        })
+
     }
   };
 
@@ -117,6 +130,7 @@ const CacheDetailProvider = ({ children }) => {
     loadCache: useCallback(loadCache, []),
     reload: useCallback(() => setLoading(true), []),
     cache: cache,
+    cacheManager: cacheManager,
     cacheEntries: cacheEntries,
     loadingEntries: loadingEntries,
     errorEntries: errorEntries,

src/app/providers/CacheManagerContextProvider.tsx

@@ -9,6 +9,7 @@ const initialContext = {
   caches: [] as CacheInfo[],
   loadingCaches: true,
   errorCaches: '',
+  reload: () => {},
   reloadCaches: () => {},
 };
 
@@ -76,6 +77,10 @@ const ContainerDataProvider = ({ children }) => {
     }
   }, [cm, loadingCaches]);
 
+  const reload = () => {
+    setLoading(true);
+  };
+
   const reloadCaches = () => {
     setLoadingCaches(true);
   };
@@ -87,6 +92,7 @@ const ContainerDataProvider = ({ children }) => {
     cm: cm,
     loadingCaches: loadingCaches,
     errorCaches: errorCaches,
+    reload: useCallback(reload, []),
     reloadCaches: useCallback(reloadCaches, []),
   };
 

src/app/services/cachesHook.ts

@@ -54,9 +54,9 @@ export function useCacheEntries() {
 }
 
 export function useCacheDetail() {
-  const { cache, loading, error, loadCache, reload } = useContext(
+  const { cache, loading, error, loadCache, reload, cacheManager } = useContext(
     CacheDetailContext
   );
 
-  return { cache, loading, error, loadCache, reload };
+  return { cache, loading, error, loadCache, reload, cacheManager };
 }

src/app/services/dataContainerHooks.ts

@@ -2,11 +2,12 @@ import { useContext } from 'react';
 import { DataContainerContext } from '@app/providers/CacheManagerContextProvider';
 
 export function useDataContainer() {
-  const { cm, loading, error } = useContext(DataContainerContext);
+  const { cm, loading, error, reload } = useContext(DataContainerContext);
   return {
     loading,
     error,
     cm,
+    reload
   };
 }
 

src/services/cacheConfigUtils.ts

@@ -1,5 +1,5 @@
 import { ContentType, EncodingType } from '@services/infinispanRefData';
-import {Either, left, right} from "@services/either";
+import { Either, left, right } from '@services/either';
 
 export const Distributed = 'distributed-cache';
 export const Replicated = 'replicated-cache';
@@ -11,18 +11,17 @@ export const Scattered = 'scattered-cache';
  * Utility class to map cache configuration
  */
 export class CacheConfigUtils {
-
   /**
    * Validates a configuration of cache may have a correct format and detects if it's
    * a valid formatted json or a xml.
    *
    * @param config
    */
-  public static validateConfig (config: string): Either<string, 'xml' | 'json'> {
+  public static validateConfig(config: string): Either<string, 'xml' | 'json'> {
     const trimmedConf = config.trim();
 
     if (trimmedConf.length == 0) {
-      return left('Configuration can\'t be empty');
+      return left("Configuration can't be empty");
     }
     try {
       JSON.parse(trimmedConf);
@@ -36,7 +35,7 @@ export class CacheConfigUtils {
       }
     } catch (ex) {}
     return left('The provided configuration is not a valid XML or JSON.');
-  };
+  }
 
   /**
    * Map the encoding type of the cache