dashboard-shell-shell 3.0.2-rc.105 → 3.0.5-test.1

package/utils/create-yaml.js

@@ -70,13 +70,14 @@ export const ACTIVELY_REMOVE = [
 
 const INDENT = 2;
 
-export function createYamlWithOptions(schemas, type, data, options) {
+export function createYamlWithOptions(schemas, type, data, options, commentFieldsOptions) {
   return createYaml(
     schemas,
     type,
     data,
     true, 0, '', null,
-    options
+    options,
+    commentFieldsOptions
   );
 }
 
@@ -89,6 +90,7 @@ export function createYaml(
   path = '',
   rootType = null,
   dataOptions = {},
+  commentFieldsOptions = null
 ) {
   data = data || {};
 
@@ -133,6 +135,10 @@ export function createYaml(
 
   const regularFields = [];
 
+  if ( !commentFieldsOptions ) {
+    commentFieldsOptions = data?.commentFieldsOptions;
+  }
+
   if (processAlwaysAdd) {
     // Add all the parents of each key so that spec.template.foo.blah
     // causes 'spec', 'template' and 'foo' keys to be created
@@ -230,6 +236,18 @@ export function createYaml(
       out = 'type:';
     }
 
+    commentFieldsOptions = addCommentSubFieldsOptions(commentFieldsOptions, data, path, key);
+
+    // If commentFieldOptions is defined on the model and the currentPath matches the path and key
+    // defined in one of the options, then comment out that line.
+    if ( Array.isArray(commentFieldsOptions) && commentFieldsOptions.length ) {
+      const currentPath = path ? `${ path }.${ key }` : key;
+
+      if ( commentFieldsOptions.some((option) => `${ option.path }.${ option.key }` === currentPath) ) {
+        out = `#${ out }`;
+      }
+    }
+
     // if a key on data is not listed in the schema's resourceFields, just convert it to yaml, add indents where needed, and return
     if ( !field ) {
       if (data[key]) {
@@ -275,7 +293,7 @@ export function createYaml(
         out += `#  key: ${ mapOf }`;
       } else {
         // If not a simple type ie some sort of object/array, recursively build out commented fields (note data = null here) per the type's (mapOf's) schema
-        const chunk = createYaml(schemas, mapOf, null, processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
+        const chunk = createYaml(schemas, mapOf, null, processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions, commentFieldsOptions);
         let indented = indent(chunk);
 
         // convert "#    foo" to "#foo"
@@ -296,7 +314,34 @@ export function createYaml(
           if ( cleaned?.[key] ) {
             const parsedData = jsyaml.dump(cleaned[key]);
 
-            out += `\n${ indent(parsedData.trim()) }`;
+            let chunk;
+
+            // If commentFieldOptions is defined on the model and the array has the property (`key`)
+            // defined in one of the options, then comment out that line.
+            if ( Array.isArray(commentFieldsOptions) && commentFieldsOptions.length ) {
+              let lines = parsedData.split('\n');
+
+              commentFieldsOptions.forEach((option) => {
+                // Assuming the path for the current array matches the option's path
+                // and the specific key to comment out exists in the array
+                if ( `${ path }.${ key }` === option.path && data[key][option.key] !== undefined ) {
+                  // Comment out the line containing the target line
+                  lines = lines.map((line, i) => {
+                    if ( i === Number(option.key) ) {
+                      return `#${ line }`;
+                    }
+
+                    return line;
+                  });
+                }
+              });
+
+              chunk = lines.join('\n').trim();
+            } else {
+              chunk = parsedData.trim();
+            }
+
+            out += `\n${ indent(chunk) }`;
           }
         } catch (e) {
           console.error(`Error: Unable to parse array data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
@@ -306,7 +351,7 @@ export function createYaml(
       if ( SIMPLE_TYPES.includes(arrayOf) ) {
         out += `\n#  - ${ arrayOf }`;
       } else {
-        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
+        const chunk = createYaml(schemas, arrayOf, null, false, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions, commentFieldsOptions);
         let indented = indent(chunk, 2);
 
         // turn "#        foo" into "#  - foo"
@@ -357,19 +402,45 @@ export function createYaml(
 
     const subDef = schemaDefinitions?.[type] || findBy(schemas, 'id', type);
 
-    if ( subDef) {
+    if ( subDef ) {
       let chunk;
 
       if (subDef?.resourceFields && !isEmpty(subDef?.resourceFields)) {
-        chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions);
+        chunk = createYaml(schemas, type, data[key], processAlwaysAdd, depth + 1, (path ? `${ path }.${ key }` : key), rootType, dataOptions, commentFieldsOptions);
       } else if (data[key]) {
         // if there are no fields defined on the schema but there are in the data, just format data as yaml and add to output yaml
         try {
           const parsed = jsyaml.dump(data[key]);
 
-          chunk = parsed.trim();
+          // If commentFieldOptions is defined on the model and `data[key]` has the property (`key`)
+          // defined in one of the options, then comment out that line.
+          if ( Array.isArray(commentFieldsOptions) && commentFieldsOptions.length ) {
+            let lines = parsed.split('\n');
+
+            commentFieldsOptions.forEach((option) => {
+              // Assuming the path for the current data[key] matches the option's path
+              // and the specific key to comment out exists in the data[key]
+              if ( `${ path }.${ key }` === option.path && data[key][option.key] !== undefined ) {
+                const targetKeyString = `${ option.key }:`;
+
+                // Comment out the line containing the target key
+                lines = lines.map((line) => {
+                  if ( line.trim().startsWith(targetKeyString) ) {
+                    return `# ${ line }`;
+                  }
+
+                  return line;
+                });
+              }
+            });
+
+            chunk = lines.join('\n').trim();
+          } else {
+            // If commentFieldsOptions do not exist, use the original `parsed` string
+            chunk = parsed.trim();
+          }
         } catch (e) {
-          console.error(`Error: Unale to parse data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
+          console.error(`Error: Unable to parse data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
         }
       }
 
@@ -380,6 +451,29 @@ export function createYaml(
 
     return out;
   }
+
+  /**
+   * Extends original commentFieldsOptions to cover nested objects
+   */
+  function addCommentSubFieldsOptions(options, data, path, key) {
+    if (!!options) {
+      if ( Array.isArray(options) && options.length ) {
+        const currentPath = path ? `${ path }.${ key }` : key;
+
+        if ( options.some((option) => `${ option.path }.${ option.key }` === currentPath) ) {
+          options = [
+            ...options,
+            ...Object.keys(data[key]).map((k) => ({
+              path: `${ path }.${ key }`,
+              key:  k
+            }))
+          ];
+        }
+      }
+    }
+
+    return options;
+  }
 }
 
 function comment(lines) {

package/utils/crypto/encryption.ts

@@ -0,0 +1,103 @@
+/**
+ * Helpers for string encryption and decryption
+ */
+
+// We just use a static salt
+const SALT = new TextEncoder().encode('rancher-dashboard');
+
+/**
+ * Type for the result of encryption
+ */
+export type EncryptedString = {
+  cipher: string;
+  iv: string;
+};
+
+/**
+ * Generate an encryption key from a password
+ *
+ * @param password Password to use for the key
+ * @returns Encryption key
+ */
+export async function deriveKey(password: string): Promise<CryptoKey> {
+  const passwordBytes = stringToBytes(password);
+
+  const initialKey = await crypto.subtle.importKey(
+    'raw',
+    passwordBytes,
+    { name: 'PBKDF2' },
+    false,
+    ['deriveKey']
+  );
+
+  return await crypto.subtle.deriveKey(
+    {
+      name:       'PBKDF2',
+      salt:       SALT,
+      iterations: 100000,
+      hash:       'SHA-256'
+    },
+    initialKey,
+    {
+      name:   'AES-GCM',
+      length: 256
+    },
+    false,
+    [
+      'encrypt',
+      'decrypt'
+    ]
+  );
+}
+
+/**
+ * Encrypt data
+ *
+ * @param content String to be encrypted
+ * @param key Encryption key
+ * @returns Encrypted data
+ */
+export async function encrypt(content: string, key: CryptoKey): Promise<EncryptedString> {
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const contentBytes = stringToBytes(content);
+  const cipher = new Uint8Array(
+    await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, contentBytes)
+  );
+
+  return {
+    iv:     bytesToBase64(iv),
+    cipher: bytesToBase64(cipher),
+  };
+}
+
+/**
+ * Decrypt encrypted data
+ * @param encryptedData Encrypted data with `cipher` and `iv` field
+ * @param key Key to use for decryption
+ * @returns Decrypted value as a string
+ */
+export async function decrypt(encryptedData: EncryptedString, key: CryptoKey): Promise<string> {
+  const iv = base64ToBytes(encryptedData.iv);
+  const cipher = base64ToBytes(encryptedData.cipher);
+  const contentBytes = new Uint8Array(
+    await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, cipher)
+  );
+
+  return bytesToString(contentBytes);
+}
+
+function bytesToString(bytes: any): string {
+  return new TextDecoder().decode(bytes);
+}
+
+function stringToBytes(str: string): Uint8Array {
+  return new TextEncoder().encode(str);
+}
+
+function bytesToBase64(arr: Uint8Array) {
+  return btoa(Array.from(arr, (b: number) => String.fromCharCode(b)).join(''));
+}
+
+function base64ToBytes(base64: string): Uint8Array {
+  return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+}

package/utils/cspAdaptor.ts

@@ -0,0 +1,51 @@
+// For testing these could be changed to something like...
+
+import { CATALOG } from '@shell/config/types';
+import { FilterArgs, PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { VuexStore } from '@shell/types/store/vuex';
+
+const CSP_ADAPTER_APPS = ['rancher-csp-adapter', 'rancher-csp-billing-adapter'];
+// For testing above line could be replaced with below line...
+// const cspAdaptorApp = ['rancher-webhooka', 'rancher-webhook'];
+
+/**
+ * Helpers in order to
+ */
+class CspAdapterUtils {
+  static canPagination($store: VuexStore): boolean {
+    return $store.getters[`management/paginationEnabled`]({ id: CATALOG.APP, context: 'branding' });
+  }
+
+  static fetchCspAdaptorApp($store: VuexStore): Promise<any> {
+    // For the login page, the schemas won't be loaded - we don't need the apps in this case
+    if ($store.getters['management/canList'](CATALOG.APP)) {
+      if (CspAdapterUtils.canPagination($store)) {
+        // Restrict the amount of apps we need to fetch
+        return $store.dispatch('management/findPage', {
+          type: CATALOG.APP,
+          opt:  { // Of type ActionFindPageArgs
+            pagination: new FilterArgs({
+              filters: PaginationParamFilter.createMultipleFields(CSP_ADAPTER_APPS.map(
+                (t) => new PaginationFilterField({
+                  field: 'metadata.name',
+                  value: t,
+                })
+              )),
+            })
+          }
+        });
+      }
+
+      return $store.dispatch('management/findAll', { type: CATALOG.APP });
+    }
+
+    return Promise.resolve([]);
+  }
+
+  static hasCspAdapter({ $store, apps }: { $store: VuexStore, apps: any[]}): Object {
+    // In theory this should contain the filtered apps when pagination is on, and all apps when off. Keep filtering though in both cases just in case
+    return apps?.find((a) => CSP_ADAPTER_APPS.includes(a.metadata?.name));
+  }
+}
+
+export default CspAdapterUtils;

package/utils/error.js

@@ -50,7 +50,6 @@ export class ApiError extends Error {
 
 export function stringify(err) {
   let str;
-  console.log('00043', err);
   if ( typeof err === 'string' ) {
     str = err;
   } else if ( err && typeof err === 'object' ) {
@@ -90,7 +89,6 @@ export function stringify(err) {
 }
 
 export function exceptionToErrorsArray(err) {
-  console.log('00055', err);
   if ( err?.response?.data ) {
     const body = err.response.data;
 
@@ -138,6 +136,10 @@ export const normalizeError = (err) => {
   };
 };
 export function translateError(error) {
+  error = typeof error === 'string' 
+  ? error
+  : error?.message || error?.toString() || '';
+  
   const originError = error;
   error = error?.toLowerCase().replace(/admission webhook(.*?)denied the request:/g, (match, p1) => {
     return '';
@@ -197,12 +199,9 @@ export function translateError(error) {
     
     if (matches) {
       if (matches.length == 1) {
-         console.log('00045', error);
         error = error.replace(regex, translation.replacement);
       } else {
         error = translation.pattern.replace(/\$(.+)/g, (_, index) => matches[parseInt(index)]);
-
-         console.log('00046', error);
       }
     }
   }

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();