@rancher/shell 0.5.3 → 2.0.0

package/utils/auth.js

@@ -1,8 +1,13 @@
 import { Popup, popupWindowOptions } from '@shell/utils/window';
 import { parse as parseUrl, addParam } from '@shell/utils/url';
-import { BACK_TO, SPA, _EDIT, _FLAGGED } from '@shell/config/query-params';
-import { MANAGEMENT } from '@shell/config/types';
+import {
+  BACK_TO, SPA, _EDIT, _FLAGGED, TIMED_OUT
+} from '@shell/config/query-params';
+import { MANAGEMENT, NORMAN } from '@shell/config/types';
 import { allHash } from '@shell/utils/promise';
+import { getProductFromRoute, getResourceFromRoute } from '@shell/utils/router';
+import { NAME as EXPLORER } from '@shell/config/product/explorer';
+import { findBy } from '@shell/utils/array';
 
 export function openAuthPopup(url, provider) {
   const popup = new Popup(() => {
@@ -64,10 +69,10 @@ export function returnTo(opt, vm) {
 export const authProvidersInfo = async(store) => {
   const rows = await store.dispatch(`management/findAll`, { type: MANAGEMENT.AUTH_CONFIG });
   const nonLocal = rows.filter((x) => x.name !== 'local');
-  // Generic OIDC is returned via API but not supported (and will be removed or fixed in future)
-  const supportedNonLocal = nonLocal.filter((x) => x.id !== 'oidc');
   const enabled = nonLocal.filter((x) => x.enabled === true );
 
+  const supportedNonLocal = nonLocal.filter((x) => x.id !== 'genericoidc');
+
   const enabledLocation = enabled.length === 1 ? {
     name:   'c-cluster-auth-config-id',
     params: { id: enabled[0].id },
@@ -161,3 +166,146 @@ export const canViewResource = (store, resource) => {
 
   return !!validResource;
 };
+
+// ************************************************************
+//
+// BELOW ARE METHODS THAT ARE A PART OF THE AUTHENTICATED MIDDLEWARE REMOVAL. THIS IS A TEMPORARY HOME FOR THESE UTILS AND SHOULD BE REWRITTEN, MOVED OR DELETED.
+//
+// TODO: Remove and refactor everything below for more clarity and better organization. https://github.com/rancher/dashboard/issues/11111
+//
+// ************************************************************
+
+/**
+ * Attempt to set the product in our datastore if the route matches a known product. Otherwise show an error page instead.
+ */
+export function setProduct(store, to) {
+  let product = getProductFromRoute(to);
+
+  // since all products are hardcoded as routes (ex: c-local-explorer), if we match the wildcard route it means that the product does not exist
+  if ((product && (!to.matched.length || (to.matched.length && to.matched[0].path === '/c/:cluster/:product'))) ||
+  // if the product grabbed from the route is not registered, then we don't have it!
+  (product && !store.getters['type-map/isProductRegistered'](product))) {
+    const error = new Error(store.getters['i18n/t']('nav.failWhale.productNotFound', { productNotFound: product }, true));
+
+    store.dispatch('loadingError', error);
+
+    throw new Error('loadingError', new Error(store.getters['i18n/t']('nav.failWhale.productNotFound', { productNotFound: product }, true)));
+  }
+
+  if ( !product ) {
+    product = EXPLORER;
+  }
+
+  const oldProduct = store.getters['productId'];
+  const oldStore = store.getters['currentProduct']?.inStore;
+
+  if ( product !== oldProduct ) {
+    store.commit('setProduct', product);
+  }
+
+  const neuStore = store.getters['currentProduct']?.inStore;
+
+  if ( neuStore !== oldStore ) {
+    // If the product store changes, clear the catalog.
+    // There might be management catalog items in it vs cluster.
+    store.commit('catalog/reset');
+  }
+}
+
+/**
+ * Check that the resource is valid, if not redirect to fail whale
+ *
+ * This requires that
+ * - product is set
+ * - product's store is set and setup (so we can check schema's within it)
+ * - product's store has the schemaFor getter (extension stores might not have it)
+ * - there's a resource associated with route (meta or param)
+ */
+export function validateResource(store, to) {
+  const product = store.getters['currentProduct'];
+  const resource = getResourceFromRoute(to);
+
+  // In order to check a resource is valid we need these
+  if (!product || !resource) {
+    return false;
+  }
+
+  if (canViewResource(store, resource)) {
+    return false;
+  }
+
+  // Unknown resource, redirect to fail whale
+
+  const error = new Error(store.getters['i18n/t']('nav.failWhale.resourceNotFound', { resource }, true));
+
+  store.dispatch('loadingError', error);
+
+  throw error;
+}
+
+/**
+ * Attempt to load the current user's principal
+ */
+export async function findMe(store) {
+  // First thing we do in loadManagement is fetch principals anyway.... so don't ?me=true here
+  const principals = await store.dispatch('rancher/findAll', {
+    type: NORMAN.PRINCIPAL,
+    opt:  {
+      url:                  '/v3/principals',
+      redirectUnauthorized: false,
+    }
+  });
+
+  const me = findBy(principals, 'me', true);
+
+  return me;
+}
+
+/**
+ * Attempt to login with default credentials. Note: I think that this may actually be outdated since we don't use these default credentials anymore on setup.
+ */
+export async function tryInitialSetup(store, password = 'admin') {
+  try {
+    const res = await store.dispatch('auth/login', {
+      provider: 'local',
+      body:     {
+        username: 'admin',
+        password
+      },
+    });
+
+    return res._status === 200;
+  } catch (e) {
+    console.error('Error trying initial setup', e); // eslint-disable-line no-console
+
+    return false;
+  }
+}
+
+/**
+ * Record in our state management that we're indeed logged in
+ */
+export function isLoggedIn(store, me) {
+  store.commit('auth/hasAuth', true);
+  store.commit('auth/loggedInAs', me.id);
+}
+
+/**
+ * Record in our state management that we're not logged in and then redirect to the login page
+ */
+export function notLoggedIn(store, redirect, route) {
+  store.commit('auth/hasAuth', true);
+
+  if ( route.name === 'index' ) {
+    return redirect('/auth/login');
+  } else {
+    return redirect(`/auth/login?${ TIMED_OUT }`);
+  }
+}
+
+/**
+ * Record in our state management that we don't have any auth providers
+ */
+export function noAuth(store) {
+  store.commit('auth/hasAuth', false);
+}

package/utils/axios.js

@@ -84,9 +84,9 @@ const setupProgress = (axios) => {
   };
 
   const $loading = () => {
-    const $nuxt = typeof window !== 'undefined' && window['$nuxt'];
+    const $globalApp = window.$globalApp;
 
-    return ($nuxt && $nuxt.$loading && $nuxt.$loading.set) ? $nuxt.$loading : noopLoading;
+    return ($globalApp && $globalApp.$loading && $globalApp.$loading.set) ? $globalApp.$loading : noopLoading;
   };
 
   let currentRequests = 0;

package/utils/banners.js

@@ -0,0 +1,103 @@
+/**
+ *
+ * Helper utilities for the fixed banners that can be configured to show on pages
+ *
+ */
+
+import { MANAGEMENT } from '@shell/config/types';
+import { SETTING } from '@shell/config/settings';
+
+const BANNER_HEADER = 'bannerHeader';
+const BANNER_FOOTER = 'bannerFooter';
+const BANNER_LOGIN = 'bannerConsent';
+
+const INDIVIDUAL_BANNERS = {
+  'ui-banner-header':        BANNER_HEADER,
+  'ui-banner-footer':        BANNER_FOOTER,
+  'ui-banner-login-consent': BANNER_LOGIN,
+};
+
+const BANNER_SHOW_KEY_MAP = {
+  [BANNER_HEADER]: 'showHeader',
+  [BANNER_FOOTER]: 'showFooter',
+  [BANNER_LOGIN]:  'showConsent',
+};
+
+/**
+ * Get the individual banner settings
+ */
+export function getIndividualBanners(store) {
+  const banners = {};
+
+  // Go through all settings looking for the individual settings
+  const allSettings = store.getters['management/all'](MANAGEMENT.SETTING);
+
+  allSettings.forEach((setting) => {
+    if (setting.value && !!INDIVIDUAL_BANNERS[setting.id]) {
+      const settingId = INDIVIDUAL_BANNERS[setting.id];
+
+      banners[settingId] = setting;
+    }
+  });
+
+  return banners;
+}
+
+/**
+ * Overlay settings from the individual banner settings onto the single banner setting
+ */
+export function overlayIndividualBanners(parsedBanner, banners) {
+  Object.keys(banners).forEach((id) => {
+    try {
+      const parsedIndividualBanner = JSON.parse(banners[id].value);
+      const shownID = BANNER_SHOW_KEY_MAP[id];
+
+      parsedBanner[id] = parsedIndividualBanner;
+      parsedBanner[shownID] = 'true'; // If there is an individual banner setting, then banner is shown
+    } catch {}
+  });
+}
+
+/**
+ * Converts a pixel value to an em value based on the default font size.
+ * @param {number} elementFontSize - The font size of the element in pixels.
+ * @param {number} [defaultFontSize=14] - The default font size in pixels.
+ * @returns {string} The converted value in em units.
+ */
+function pxToEm(elementFontSize, defaultFontSize = 14) {
+  const lineHeightInPx = 2 * parseInt(elementFontSize);
+  const lineHeightInEm = lineHeightInPx / defaultFontSize;
+
+  return `${ lineHeightInEm }em`;
+}
+
+/**
+ * Get banner font sizes - used to add margins when header and footer banners are present
+ **/
+export function getGlobalBannerFontSizes(store) {
+  const settings = store.getters['management/all'](MANAGEMENT.SETTING);
+  const bannerSettings = settings?.find((s) => s.id === SETTING.BANNERS);
+  const individualBannerSettings = getIndividualBanners(store);
+
+  if (bannerSettings) {
+    const parsed = JSON.parse(bannerSettings.value);
+
+    overlayIndividualBanners(parsed, individualBannerSettings);
+
+    const {
+      showFooter, showHeader, bannerFooter, bannerHeader, banner
+    } = parsed;
+
+    // add defaults to accommodate older JSON structures for banner definitions without breaking the UI
+    // https://github.com/rancher/dashboard/issues/10140
+    const bannerHeaderFontSize = bannerHeader?.fontSize || banner?.fontSize || '14px';
+    const bannerFooterFontSize = bannerFooter?.fontSize || banner?.fontSize || '14px';
+
+    return {
+      headerFont: showHeader === 'true' ? pxToEm(bannerHeaderFontSize) : '0px',
+      footerFont: showFooter === 'true' ? pxToEm(bannerFooterFontSize) : '0px'
+    };
+  }
+
+  return undefined;
+}

package/utils/cluster.js

@@ -85,7 +85,7 @@ export function abbreviateClusterName(input) {
     break;
   }
   default:
-    result = segments.slice(0, 3).map((segment) => segment[0]).join('');
+    result = segments.slice(0, 2).map((segment) => segment[0]).join('') + segments.slice(-1)[0].slice(-1);
   }
 
   return result;

package/utils/config.js

@@ -0,0 +1,4 @@
+export default (context, inject) => {
+  // eslint-disable-next-line no-undef
+  inject('config', { rancherEnv: process.env.rancherEnv, dashboardVersion: process.env.version });
+};

package/utils/create-yaml.js

@@ -2,6 +2,7 @@ import { indent as _indent } from '@shell/utils/string';
 import { addObject, findBy, removeObject, removeObjects } from '@shell/utils/array';
 import jsyaml from 'js-yaml';
 import { cleanUp, isEmpty } from '@shell/utils/object';
+import { parseType } from '@shell/models/schema';
 
 export const SIMPLE_TYPES = [
   'string',
@@ -87,26 +88,47 @@ export function createYaml(
   depth = 0,
   path = '',
   rootType = null,
-  dataOptions = {}
+  dataOptions = {},
 ) {
-  const schema = findBy(schemas, 'id', type);
+  data = data || {};
 
-  if ( !rootType ) {
-    rootType = type;
-  }
+  let schema, rootSchema, schemaDefinitions, schemaResourceFields;
 
-  if ( !schema ) {
-    return `Error loading schema for ${ type }`;
-  }
+  if (depth === 0) {
+    // `type` is a schema id
+    schema = findBy(schemas, 'id', type);
 
-  data = data || {};
+    if ( !schema ) { // schema is only needed at the root level.
+      return `Error loading schema for ${ type }`;
+    }
+
+    rootSchema = schema;
+
+    schemaDefinitions = rootSchema.schemaDefinitions;
+    schemaResourceFields = rootSchema.resourceFields;
 
-  if ( depth === 0 ) {
     const attr = schema.attributes || {};
 
     // Default to data.apiVersion/kind to accommodate spoofed types that aggregate multiple types
     data.apiVersion = (attr.group ? `${ attr.group }/${ attr.version }` : attr.version) || data.apiVersion;
     data.kind = attr.kind || data.kind;
+  } else {
+    rootSchema = findBy(schemas, 'id', rootType);
+
+    if (rootSchema.requiresResourceFields) { // See `requiresResourceFields` definition
+      schemaDefinitions = rootSchema.schemaDefinitions;
+      schemaResourceFields = schemaDefinitions[type]?.resourceFields;
+    } else {
+      schema = findBy(schemas, 'id', type);
+      if ( !schema ) { // schema is only needed at the root level.
+        return `Error loading schema for ${ type }`;
+      }
+      schemaResourceFields = schema.resourceFields;
+    }
+  }
+
+  if ( !rootType ) {
+    rootType = type;
   }
 
   const regularFields = [];
@@ -131,14 +153,14 @@ export function createYaml(
       const key = parts[parts.length - 1];
       const prefix = parts.slice(0, -1).join('.');
 
-      if ( prefix === path && schema.resourceFields && schema.resourceFields[key] ) {
+      if ( prefix === path && schemaResourceFields && schemaResourceFields[key] ) {
         addObject(regularFields, key);
       }
     }
   }
 
   // Include all fields in schema's resourceFields as comments
-  const commentFields = Object.keys(schema.resourceFields || {});
+  const commentFields = Object.keys(schemaResourceFields || {});
 
   commentFields.forEach((key) => {
     if ( typeof data[key] !== 'undefined' || (depth === 0 && key === '_type') ) {
@@ -170,7 +192,7 @@ export function createYaml(
     const key = parts[parts.length - 1];
     const prefix = parts.slice(0, -1).join('.');
 
-    if ( prefix === path && schema.resourceFields && schema.resourceFields[key] ) {
+    if ( prefix === path && schemaResourceFields && schemaResourceFields[key] ) {
       removeObject(commentFields, key);
     }
   }
@@ -182,8 +204,6 @@ export function createYaml(
   const comments = commentFields.map((k) => {
     // Don't add a namespace comment for types that aren't namespaced.
     if ( path === 'metadata' && k === 'namespace' ) {
-      const rootSchema = findBy(schemas, 'id', rootType);
-
       if ( rootSchema && !rootSchema.attributes?.namespaced ) {
         return null;
       }
@@ -202,7 +222,7 @@ export function createYaml(
   // ---------------
 
   function stringifyField(key) {
-    const field = schema.resourceFields?.[key];
+    const field = schemaResourceFields?.[key];
     let out = `${ key }:`;
 
     // '_type' in steve maps to kubernetes 'type' field; show 'type' field in yaml
@@ -233,8 +253,8 @@ export function createYaml(
     }
 
     const type = typeMunge(field.type);
-    const mapOf = typeRef('map', type);
-    const arrayOf = typeRef('array', type);
+    const mapOf = typeRef('map', type, field);
+    const arrayOf = typeRef('array', type, field);
     const referenceTo = typeRef('reference', type);
 
     // type == map[mapOf]
@@ -254,7 +274,7 @@ export function createYaml(
       if ( SIMPLE_TYPES.includes(mapOf) ) {
         out += `#  key: ${ mapOf }`;
       } else {
-        // If not a simple type ie some sort of object/array, recusively build out commented fields (note data = null here) per the type's (mapOf's) schema
+        // 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);
         let indented = indent(chunk);
 
@@ -279,7 +299,7 @@ export function createYaml(
             out += `\n${ indent(parsedData.trim()) }`;
           }
         } catch (e) {
-          console.error(`Error: Unale to parse array data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
+          console.error(`Error: Unable to parse array data for yaml of type: ${ type }`, e); // eslint-disable-line no-console
         }
       }
 
@@ -335,7 +355,7 @@ export function createYaml(
       }
     }
 
-    const subDef = findBy(schemas, 'id', type);
+    const subDef = schemaDefinitions?.[type] || findBy(schemas, 'id', type);
 
     if ( subDef) {
       let chunk;
@@ -411,12 +431,19 @@ function getBlockIndentation(blockHeader) {
   return indentation?.[0] || '';
 }
 
-export function typeRef(type, str) {
-  const re = new RegExp(`^${ type }\\[(.*)\\]$`);
-  const match = str.match(re);
+/**
+ * Check for a specific type and if valid return it's sub type or self
+ * @param {string} type required type
+ * @param {string} str actual type
+ * @param {ResourceField} field resourceField entry to the actual type
+ *
+ * @returns the sub type, or if not found the type
+ */
+export function typeRef(type, str, field = null) {
+  const [foundType, foundSubType] = parseType(str, field);
 
-  if ( match ) {
-    return typeMunge(match[1]);
+  if (type === foundType) {
+    return typeMunge(foundSubType || foundType);
   }
 }
 
@@ -460,7 +487,7 @@ export function saferDump(obj) {
  *
  * @returns the result of jsyaml.dump with the addition of multiline indicators
  */
-export function dumpBlock(data, options = {}) {
+export function dumpBlock(data, options = { lineWidth: -1 }) {
   const parsed = jsyaml.dump(data, options);
 
   let out = parsed;

package/utils/error.js

@@ -104,3 +104,28 @@ export function exceptionToErrorsArray(err) {
     return [err];
   }
 }
+
+/**
+ * Imported from path-to-regexp
+ * @param {*} err
+ * @returns
+ */
+export const normalizeError = (err) => {
+  let message;
+
+  if (!(err.message || typeof err === 'string')) {
+    try {
+      message = JSON.stringify(err, null, 2);
+    } catch (e) {
+      message = `[${ err.constructor.name }]`;
+    }
+  } else {
+    message = err.message || err;
+  }
+
+  return {
+    ...err,
+    message,
+    statusCode: (err.statusCode || err.status || (err.response && err.response.status) || 500)
+  };
+};

package/utils/formatter.js

@@ -2,10 +2,12 @@
 import { SECRET_TYPES } from '@shell/config/secret';
 
 export function formatEncryptionSecretNames(secrets, chartNamespace) {
-  return secrets.filter(
-    (secret) => (secret.data || {})['encryption-provider-config.yaml'] &&
+  return secrets
+    .filter((secret) => (secret.data || {})['encryption-provider-config.yaml'] &&
       secret.metadata.namespace === chartNamespace &&
       !secret.metadata?.state?.error &&
       secret._type === SECRET_TYPES.OPAQUE
-  ).map((secret) => secret.metadata.name).sort();
+    )
+    .map((secret) => secret.metadata.name)
+    .sort();
 }

package/utils/git.ts

@@ -9,7 +9,7 @@ interface Repo {
   name: string,
 }
 
-interface Commit {
+export interface Commit {
   message: string,
   htmlUrl: string,
   sha?: string,

package/utils/install-redirect.js

@@ -26,7 +26,7 @@ export default function(product, chartName, defaultResourceOrRoute, install = tr
     } else if (install) {
       // The product is not installed, redirect to the details chart
 
-      await store.dispatch('catalog/load', { force: true });
+      await store.dispatch('catalog/load');
 
       const chart = store.getters['catalog/chart']({ chartName });