dashboard-shell-shell 3.0.2-test.20250913 → 3.0.5-logTest.2

package/utils/fleet.ts

@@ -1,13 +1,16 @@
+import { isEmpty, isEqual } from 'lodash';
 import {
   BundleDeploymentResource,
   BundleResourceKey,
   BundleDeployment,
   BundleDeploymentStatus,
-  BundleStatus,
   Condition,
 } from '@shell/types/resources/fleet';
-import { STATES_ENUM } from '@shell/plugins/dashboard-store/resource-class';
-import { FLEET as FLEET_LABELS } from '@shell/config/labels-annotations';
+import { mapStateToEnum, STATES_ENUM, STATES } from '@shell/plugins/dashboard-store/resource-class';
+import { FLEET as FLEET_LABELS, CAPI } from '@shell/config/labels-annotations';
+import { NAME as EXPLORER_NAME } from '@shell/config/product/explorer';
+import { FleetDashboardState, FleetResourceState, Target, TargetMode } from '@shell/types/fleet';
+import { FLEET, VIRTUAL_HARVESTER_PROVIDER } from '@shell/config/types';
 
 interface Resource extends BundleDeploymentResource {
   state: string,
@@ -17,15 +20,6 @@ type Labels = {
   [key: string]: string,
 }
 
-interface StatesCounter { [state: string]: number }
-
-function incr(counter: StatesCounter, state: string) {
-  if (!counter[state]) {
-    counter[state] = 0;
-  }
-  counter[state]++;
-}
-
 function resourceKey(r: BundleResourceKey): string {
   return `${ r.kind }/${ r.namespace }/${ r.name }`;
 }
@@ -38,7 +32,139 @@ function conditionIsTrue(conditions: Condition[] | undefined, type: string): boo
   return !!conditions.find((c) => c.type === type && c.status.toLowerCase() === 'true');
 }
 
+class Application {
+  excludeHarvesterRule = {
+    clusterSelector: {
+      matchExpressions: [{
+        key:      CAPI.PROVIDER,
+        operator: 'NotIn',
+        values:   [
+          VIRTUAL_HARVESTER_PROVIDER
+        ],
+      }],
+    },
+  };
+
+  getTargetMode(targets: Target[], namespace: string): TargetMode {
+    if (namespace === 'fleet-local') {
+      return 'local';
+    }
+
+    if (!targets.length) {
+      return 'none';
+    }
+
+    let mode: TargetMode = 'all';
+
+    for (const target of targets) {
+      const {
+        clusterName,
+        clusterSelector,
+        clusterGroup,
+        clusterGroupSelector,
+      } = target;
+
+      if (clusterGroup || clusterGroupSelector) {
+        return 'advanced';
+      }
+
+      if (clusterName) {
+        mode = 'clusters';
+      }
+
+      if (!isEmpty(clusterSelector)) {
+        mode = 'clusters';
+      }
+    }
+
+    const normalized = [...targets].map((target) => {
+      delete target.name;
+
+      return target;
+    });
+
+    // Check if targets contains only harvester rule after name normalizing
+    if (isEqual(normalized, [this.excludeHarvesterRule])) {
+      mode = 'all';
+    }
+
+    return mode;
+  }
+}
+
 class Fleet {
+  resourceIcons = {
+    [FLEET.GIT_REPO]: 'icon icon-github',
+    [FLEET.HELM_OP]:  'icon icon-helm',
+  };
+
+  dashboardIcons = {
+    [FLEET.GIT_REPO]: 'icon icon-git',
+    [FLEET.HELM_OP]:  'icon icon-helm',
+  };
+
+  dashboardStates: FleetDashboardState[] = [
+    {
+      index:           0,
+      id:              'error',
+      label:           'Error',
+      color:           '#F64747',
+      icon:            'icon icon-error',
+      stateBackground: 'bg-error'
+    },
+    {
+      index:           1,
+      id:              'warning',
+      label:           'Warning',
+      color:           '#DAC342',
+      icon:            'icon icon-warning',
+      stateBackground: 'bg-warning'
+    },
+    {
+      index:           2,
+      id:              'success',
+      label:           'Active',
+      color:           '#5D995D',
+      icon:            'icon icon-checkmark',
+      stateBackground: 'bg-success'
+    },
+    {
+      index:           3,
+      id:              'info',
+      label:           'Pending',
+      color:           '#3d98d3',
+      icon:            'icon icon-warning',
+      stateBackground: 'bg-info'
+    },
+  ];
+
+  Application = new Application();
+
+  GIT_HTTPS_REGEX = /^https?:\/\/github\.com\/(.*?)(\.git)?\/*$/;
+  GIT_SSH_REGEX = /^git@github\.com:.*\.git$/;
+  HTTP_REGEX = /^(https?:\/\/[^\s]+)$/;
+  OCI_REGEX = /^oci:\/\//;
+
+  quacksLikeAHash(str: string) {
+    if (str.match(/^[a-f0-9]{40,}$/i)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  parseSSHUrl(url: string) {
+    const parts = (url || '').split(':');
+
+    const sshUserAndHost = parts[0];
+    const repoPath = parts[1]?.replace('.git', '');
+
+    return {
+      sshUserAndHost,
+      repoPath
+    };
+  }
+
   resourceId(r: BundleResourceKey): string {
     return r.namespace ? `${ r.namespace }/${ r.name }` : r.name;
   }
@@ -57,6 +183,19 @@ class Fleet {
     return `${ r.apiVersion.split('/', 2)[0] }.${ type }`;
   }
 
+  detailLocation(r: Resource, mgmtClusterName: string): any {
+    return mapStateToEnum(r.state) === STATES_ENUM.MISSING ? undefined : {
+      name:   `c-cluster-product-resource${ r.namespace ? '-namespace' : '' }-id`,
+      params: {
+        product:   EXPLORER_NAME,
+        cluster:   mgmtClusterName,
+        resource:  this.resourceType(r),
+        namespace: r.namespace,
+        id:        r.name,
+      },
+    };
+  }
+
   /**
    * resourcesFromBundleDeploymentStatus extracts the list of resources deployed by a BundleDeployment
    */
@@ -94,68 +233,6 @@ class Fleet {
     return modified.concat(Object.values(resources));
   }
 
-  /**
-   * resourcesFromBundleStatus extracts the list of resources deployed by a Bundle
-   */
-  resourcesFromBundleStatus(status: BundleStatus): Resource[] {
-    // The state of every resource is spread all over the bundle status.
-    // resourceKey contains one entry per resource AND cluster (built by Fleet from all the child BundleDeployments).
-    // However, those entries do not contain the cluster that they belong to, leading to duplicate entries
-
-    // 1. Fold resourceKey by using a unique key, initializing counters for multiple occurrences of the same resource
-    const resources = (status.resourceKey || []).reduce((res, r) => {
-      const k = resourceKey(r);
-
-      if (!res[k]) {
-        res[k] = { r, count: {} };
-      }
-      incr(res[k].count, STATES_ENUM.READY);
-
-      return res;
-    }, {} as { [resourceKey: string]: { r: BundleResourceKey, count: StatesCounter } });
-
-    // 2. Non-ready resources are counted differently and may also appear in resourceKey, depending on their state
-    for (const bundle of status.summary?.nonReadyResources || []) {
-      for (const r of bundle.modifiedStatus || []) {
-        const k = resourceKey(r);
-
-        if (!resources[k]) {
-          resources[k] = { r, count: {} };
-        }
-
-        if (r.missing) {
-          incr(resources[k].count, STATES_ENUM.MISSING);
-        } else if (r.delete) {
-          resources[k].count[STATES_ENUM.READY]--;
-          incr(resources[k].count, STATES_ENUM.ORPHANED);
-        } else {
-          resources[k].count[STATES_ENUM.READY]--;
-          incr(resources[k].count, STATES_ENUM.MODIFIED);
-        }
-      }
-      for (const r of bundle.nonReadyStatus || []) {
-        const k = resourceKey(r);
-        const state = r.summary?.state || STATES_ENUM.UNKNOWN;
-
-        resources[k].count[STATES_ENUM.READY]--;
-        incr(resources[k].count, state);
-      }
-    }
-
-    // 3. Unfold back to an array of resources for display
-    return Object.values(resources).reduce((res, e) => {
-      const { r, count } = e;
-
-      for (const state in count) {
-        for (let x = 0; x < count[state]; x++) {
-          res.push(Object.assign({ state }, r));
-        }
-      }
-
-      return res;
-    }, [] as Resource[]);
-  }
-
   clusterIdFromBundleDeploymentLabels(labels?: Labels): string {
     const clusterNamespace = labels?.[FLEET_LABELS.CLUSTER_NAMESPACE];
     const clusterName = labels?.[FLEET_LABELS.CLUSTER];
@@ -184,6 +261,59 @@ class Fleet {
       return STATES_ENUM.READY;
     }
   }
+
+  getResourcesDefaultState(labelGetter: (key: string, args: any, fallback: any) => Record<string, any>, stateKey: string): Record<string, FleetResourceState> {
+    return [
+      STATES_ENUM.READY,
+      STATES_ENUM.NOT_READY,
+      STATES_ENUM.WAIT_APPLIED,
+      STATES_ENUM.MODIFIED,
+      STATES_ENUM.MISSING,
+      STATES_ENUM.ORPHANED,
+      STATES_ENUM.UNKNOWN,
+    ].reduce((acc: Record<string, any>, state) => {
+      acc[state] = {
+        count:  0,
+        color:  STATES[state].color,
+        label:  labelGetter(`${ stateKey }.${ state }`, null, STATES[state].label ),
+        status: state
+      };
+
+      return acc;
+    }, {});
+  }
+
+  getBundlesDefaultState(labelGetter: (key: string, args: any, fallback: any) => Record<string, any>, stateKey: string): Record<string, FleetResourceState> {
+    return [
+      STATES_ENUM.READY,
+      STATES_ENUM.INFO,
+      STATES_ENUM.WARNING,
+      STATES_ENUM.NOT_READY,
+      STATES_ENUM.ERROR,
+      STATES_ENUM.ERR_APPLIED,
+      STATES_ENUM.WAIT_APPLIED,
+      STATES_ENUM.UNKNOWN,
+    ].reduce((acc: Record<string, any>, state) => {
+      acc[state] = {
+        count:  0,
+        color:  STATES[state].color,
+        label:  labelGetter(`${ stateKey }.${ state }`, null, STATES[state].label ),
+        status: state
+      };
+
+      return acc;
+    }, {});
+  }
+
+  getDashboardStateId(resource: { stateColor: string }): string {
+    return resource?.stateColor?.replace('text-', '') || 'warning';
+  }
+
+  getDashboardState(resource: { stateColor: string }): FleetDashboardState | {} {
+    const stateId = this.getDashboardStateId(resource);
+
+    return this.dashboardStates.find(({ id }) => stateId === id) || {};
+  }
 }
 
 const instance = new Fleet();

package/utils/grafana.js

@@ -24,6 +24,7 @@ export function computeDashboardUrl(monitoringVersion, embedUrl, clusterId, para
   }
   newUrl = addParam(newUrl, 'orgId', url.query.orgId);
   newUrl = addParam(newUrl, 'kiosk', null);
+  newUrl = addParam(newUrl, '_dash.hideTimePicker', 'true');
 
   Object.entries(params).forEach((entry) => {
     newUrl = addParam(newUrl, entry[0], entry[1]);

package/utils/kontainer.ts

@@ -17,11 +17,9 @@ export function syncUpstreamConfig(configPrefix: string, normanCluster: {[key: s
 
   if (!isEmpty(upstreamConfig)) {
     Object.keys(upstreamConfig).forEach((key) => {
-      if (typeof upstreamConfig[key] === 'object') {
-        if (isEmpty(rancherConfig[key]) && !isEmpty(upstreamConfig[key])) {
-          set(rancherConfig, key, upstreamConfig[key]);
-        }
-      } else if ((rancherConfig[key] === null || rancherConfig[key] === undefined) && upstreamConfig[key] !== null && upstreamConfig[key] !== undefined) {
+      const empty = typeof upstreamConfig[key] === 'object' && isEmpty(upstreamConfig[key]);
+
+      if ((rancherConfig[key] === null || rancherConfig[key] === undefined) && upstreamConfig[key] !== null && upstreamConfig[key] !== undefined && !empty) {
         set(rancherConfig, key, upstreamConfig[key]);
       }
     });

package/utils/object.js

@@ -510,10 +510,6 @@ export function deepToRaw(obj, cache = new WeakSet()) {
  *                  with arrays in obj2 when both properties are arrays
  *                  false: default lodash merge behavior - recursively merges
  *                  array members
- * @param {boolean} [options.replaceObjectProps=false] - true: merges objects in
- *                  obj1 with objects in obj2, overwriting duplicate props
- *                  false: default lodash merge behavior - recursively merges
- *                  object props
  */
 export function mergeWithReplace(
   obj1 = {},
@@ -521,7 +517,6 @@ export function mergeWithReplace(
   {
     mutateOriginal = false,
     replaceArray = true,
-    replaceObjectProps = false,
   } = {}
 ) {
   const destination = mutateOriginal ? obj1 : {};
@@ -530,12 +525,41 @@ export function mergeWithReplace(
     if (replaceArray && Array.isArray(obj1Value) && Array.isArray(obj2Value)) {
       return obj2Value;
     }
-
-    if (replaceObjectProps && isObject(obj1Value) && isObject(obj2Value)) {
-      return {
-        ...obj1Value,
-        ...obj2Value,
-      };
-    }
   });
 }
+/**
+ * Converts Object into a string of a format "key1, val1, key2, val2"
+ * @param {Object} input - KV object to convert
+ * @returns string
+ */
+export const convertKVToString = (input) => {
+  if (!input || typeof input !== 'object') return '';
+
+  return Object.entries(input)
+    .flatMap(([key, value]) => [key, String(value)])
+    .join(',');
+};
+
+/**
+ * Converts kv string into object
+ * @param {string} input - a string of a format "key1, val1, key2, val2"
+ * @returns
+ */
+export const convertStringToKV = ( input ) => {
+  if (!input?.trim()) return {};
+
+  const parts = input.split(',').map((part) => part.trim());
+  const result = {};
+
+  for (let i = 0; i < parts.length - 1; i += 2) {
+    const key = parts[i];
+    const value = parts[i + 1];
+
+    // Accept empty keys but ignore undefined values
+    if (typeof key === 'string') {
+      result[key] = value ?? '';
+    }
+  }
+
+  return result;
+};

package/utils/pagination-utils.ts

@@ -1,4 +1,4 @@
-import { PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
+import { PaginationFeature, PaginationSettings, PaginationSettingsStore } from '@shell/types/resources/settings';
 import {
   NAMESPACE_FILTER_ALL_USER as ALL_USER,
   NAMESPACE_FILTER_ALL as ALL,
@@ -15,17 +15,22 @@ import { isEqual } from '@shell/utils/object';
 import { STEVE_CACHE } from '@shell/store/features';
 import { getPerformanceSetting } from '@shell/utils/settings';
 import { PAGINATION_SETTINGS_STORE_DEFAULTS } from '@shell/plugins/steve/steve-pagination-utils';
+import { MANAGEMENT } from '@shell/config/types';
 
 /**
  * Helper functions for server side pagination
  */
 class PaginationUtils {
+  /**
+   * In places where we're using paginated features but not in a page... this is what the max results should be
+   */
+  readonly defaultPageSize = 100000;
   /**
    * When a ns filter isn't one or more projects/namespaces... what are the valid values?
    *
    * This basically blocks 'Not in a Project'.. which would involve a projectsornamespaces param with every ns not in a project.
    */
-  validNsProjectFilters = [ALL, ALL_SYSTEM, ALL_USER, ALL_SYSTEM, NAMESPACE_FILTER_KINDS.NAMESPACE, NAMESPACE_FILTER_KINDS.PROJECT, NAMESPACED_YES, NAMESPACED_NO];
+  readonly validNsProjectFilters = [ALL, ALL_SYSTEM, ALL_USER, ALL_SYSTEM, NAMESPACE_FILTER_KINDS.NAMESPACE, NAMESPACE_FILTER_KINDS.PROJECT, NAMESPACED_YES, NAMESPACED_NO];
 
   private getSettings({ rootGetters }: any): PaginationSettings {
     const perf = getPerformanceSetting(rootGetters);
@@ -50,6 +55,23 @@ class PaginationUtils {
     return rootGetters['features/get']?.(STEVE_CACHE);
   }
 
+  /**
+   * Determine if the downstream cluster has vai enabled
+   *
+   * Almost all the time the downstream cluster vai state will align with upstream (it manages it)
+   * ... unless it's harvester then weird things happen
+   */
+  async isDownstreamSteveCacheEnabled({ dispatch }: any, clusterId: string): Promise<boolean> {
+    const url = `/k8s/clusters/${ clusterId }/v1/${ MANAGEMENT.FEATURE }s/${ STEVE_CACHE }`;
+    const entry = await dispatch('cluster/request', { url });
+
+    if (entry.status.lockedValue !== null) {
+      return entry.status.lockedValue;
+    }
+
+    return (entry.spec.value !== null) ? entry.spec.value : entry.status.default;
+  }
+
   /**
    * Is pagination enabled at a global level or for a specific resource
    */
@@ -62,7 +84,7 @@ class PaginationUtils {
     const settings = this.getSettings({ rootGetters });
 
     // No setting, not enabled
-    if (!settings?.enabled) {
+    if (!settings) {
       return false;
     }
 
@@ -124,6 +146,31 @@ class PaginationUtils {
     return false;
   }
 
+  listAutoRefreshToggleEnabled({ rootGetters }: any): boolean {
+    return this.isFeatureEnabled({ rootGetters }, 'listAutoRefreshToggle');
+  }
+
+  isListManualRefreshEnabled({ rootGetters }: any): boolean {
+    return this.isFeatureEnabled({ rootGetters }, 'listManualRefresh');
+  }
+
+  private isFeatureEnabled({ rootGetters }: any, featureName: PaginationFeature): boolean {
+    // Cache must be enabled to support pagination api
+    if (!this.isSteveCacheEnabled({ rootGetters })) {
+      return false;
+    }
+
+    const settings = this.getSettings({ rootGetters });
+
+    return !!settings.features?.[featureName]?.enabled;
+  }
+
+  resourceChangesDebounceMs({ rootGetters }: any): number | undefined {
+    const settings = this.getSettings({ rootGetters });
+
+    return settings.resourceChangesDebounceMs;
+  }
+
   validateNsProjectFilters(nsProjectFilters: string[]) {
     return nsProjectFilters?.every((f) => this.validateNsProjectFilter(f));
   }