@rancher/shell 0.3.4 → 0.3.6

package/utils/__tests__/grafana.test.ts

@@ -0,0 +1,44 @@
+import { getClusterPrefix } from '@shell/utils/grafana';
+
+describe('fx: getClusterPrefix', () => {
+  it('old monitoring version, downstream cluster', () => {
+    const prefix = getClusterPrefix('101.0.0+up19.0.3', 'c-abcd');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/c-abcd');
+  });
+  it('old monitoring version, local cluster', () => {
+    const prefix = getClusterPrefix('101.0.0+up19.0.3', 'local');
+
+    expect(prefix).toStrictEqual('');
+  });
+  it('new monitoring version, downstream cluster', () => {
+    const prefix = getClusterPrefix('102.0.0+up40.1.2', 'c-abcd');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/c-abcd');
+  });
+  it('new monitoring version, local cluster', () => {
+    const prefix = getClusterPrefix('102.0.0+up40.1.2', 'local');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/local');
+  });
+  it('future monitoring version, downstream cluster', () => {
+    const prefix = getClusterPrefix('103.0.0+up41.0.0', 'c-abcd');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/c-abcd');
+  });
+  it('future monitoring version, local cluster', () => {
+    const prefix = getClusterPrefix('103.0.0+up41.0.0', 'local');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/local');
+  });
+  it('empty monitoring version, downstream cluster', () => {
+    const prefix = getClusterPrefix('', 'c-abcd');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/c-abcd');
+  });
+  it('empty monitoring version, local cluster', () => {
+    const prefix = getClusterPrefix('', 'local');
+
+    expect(prefix).toStrictEqual('/k8s/clusters/local');
+  });
+});

package/utils/__tests__/string.test.ts

@@ -0,0 +1,12 @@
+import { decodeHtml } from '@shell/utils/string';
+
+describe('fx: decodeHtml', () => {
+  it('should decode HTML values from escaped string into valid markup', () => {
+    const text = '<i>whatever</i>';
+    const expectation = `<i>whatever</i>`;
+
+    const result = decodeHtml(text);
+
+    expect(result).toStrictEqual(expectation);
+  });
+});

package/utils/auth.js

@@ -2,6 +2,7 @@ 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 { allHash } from '@shell/utils/promise';
 
 export function openAuthPopup(url, provider) {
   const popup = new Popup(() => {
@@ -79,3 +80,67 @@ export const authProvidersInfo = async(store) => {
     enabled
   };
 };
+
+export const checkSchemasForFindAllHash = (types, store) => {
+  const hash = {};
+
+  for (const [key, value] of Object.entries(types)) {
+    const schema = store.getters[`${ value.inStoreType }/schemaFor`](value.type);
+
+    // It could be that user has permissions for GET but not list
+    // e.g. Standard user with GitRepo permissions try to fetch list of fleetworkspaces
+    // user has ability to GET but not fleet workspaces
+    // so optionally define a function that require it to pass before /findAll
+    const validSchema = value.schemaValidator ? value.schemaValidator(schema) : !!schema;
+
+    if (validSchema) {
+      hash[key] = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type } );
+    }
+  }
+
+  return allHash(hash);
+};
+
+export const checkPermissions = (types, getters) => {
+  const hash = {};
+
+  for (const [key, value] of Object.entries(types)) {
+    const schema = getters['management/schemaFor'](value.type);
+
+    if (!schema) {
+      hash[key] = false;
+
+      continue;
+    }
+
+    // It could be that user has permissions for GET but not list
+    // e.g. Standard user with GitRepo permissions try to fetch list of fleetworkspaces
+    // user has ability to GET but not fleet workspaces
+    // so optionally define a function that require it to pass before /findAll
+    if (value.schemaValidator) {
+      hash[key] = value.schemaValidator(schema);
+
+      continue;
+    }
+
+    if (value.resourceMethods && schema) {
+      hash[key] = value.resourceMethods.every((method) => {
+        return (schema.resourceMethods || []).includes(method);
+      });
+
+      continue;
+    }
+
+    if (value.collectionMethods && schema) {
+      hash[key] = value.collectionMethods.every((method) => {
+        return (schema.collectionMethods || []).includes(method);
+      });
+
+      continue;
+    }
+
+    hash[key] = !!schema;
+  }
+
+  return allHash(hash);
+};

package/utils/axios.js

@@ -0,0 +1,190 @@
+import Axios from 'axios';
+import defu from 'defu';
+import axiosRetry from 'axios-retry';
+
+// Axios.prototype cannot be modified
+const axiosExtra = {
+  setBaseURL(baseURL) {
+    this.defaults.baseURL = baseURL;
+  },
+  setHeader(name, value, scopes = 'common') {
+    for (const scope of Array.isArray(scopes) ? scopes : [scopes]) {
+      if (!value) {
+        delete this.defaults.headers[scope][name];
+
+        return;
+      }
+      this.defaults.headers[scope][name] = value;
+    }
+  },
+  setToken(token, type, scopes = 'common') {
+    const value = !token ? null : (type ? `${ type } ` : '') + token;
+
+    this.setHeader('Authorization', value, scopes);
+  },
+  onRequest(fn) {
+    this.interceptors.request.use(config => fn(config) || config);
+  },
+  onResponse(fn) {
+    this.interceptors.response.use(response => fn(response) || response);
+  },
+  onRequestError(fn) {
+    this.interceptors.request.use(undefined, error => fn(error) || Promise.reject(error));
+  },
+  onResponseError(fn) {
+    this.interceptors.response.use(undefined, error => fn(error) || Promise.reject(error));
+  },
+  onError(fn) {
+    this.onRequestError(fn);
+    this.onResponseError(fn);
+  },
+  create(options) {
+    return createAxiosInstance(defu(options, this.defaults));
+  }
+};
+
+// Request helpers ($get, $post, ...)
+for (const method of ['request', 'delete', 'get', 'head', 'options', 'post', 'put', 'patch']) {
+  axiosExtra[`$${ method }`] = function() {
+    return this[method].apply(this, arguments).then(res => res && res.data);
+  };
+}
+
+const extendAxiosInstance = (axios) => {
+  for (const key in axiosExtra) {
+    axios[key] = axiosExtra[key].bind(axios);
+  }
+};
+
+const createAxiosInstance = (axiosOptions) => {
+  // Create new axios instance
+  const axios = Axios.create(axiosOptions);
+
+  axios.CancelToken = Axios.CancelToken;
+  axios.isCancel = Axios.isCancel;
+
+  // Extend axios proto
+  extendAxiosInstance(axios);
+
+  // Setup interceptors
+
+  setupProgress(axios);
+  axiosRetry(axios, { retries: 0 });
+
+  return axios;
+};
+
+const setupProgress = (axios) => {
+  if (process.server) {
+    return;
+  }
+
+  // A noop loading inteterface for when $nuxt is not yet ready
+  const noopLoading = {
+    finish: () => { },
+    start:  () => { },
+    fail:   () => { },
+    set:    () => { }
+  };
+
+  const $loading = () => {
+    const $nuxt = typeof window !== 'undefined' && window['$nuxt'];
+
+    return ($nuxt && $nuxt.$loading && $nuxt.$loading.set) ? $nuxt.$loading : noopLoading;
+  };
+
+  let currentRequests = 0;
+
+  axios.onRequest((config) => {
+    if (config && config.progress === false) {
+      return;
+    }
+
+    currentRequests++;
+  });
+
+  axios.onResponse((response) => {
+    if (response && response.config && response.config.progress === false) {
+      return;
+    }
+
+    currentRequests--;
+    if (currentRequests <= 0) {
+      currentRequests = 0;
+      $loading().finish();
+    }
+  });
+
+  axios.onError((error) => {
+    if (error && error.config && error.config.progress === false) {
+      return;
+    }
+
+    currentRequests--;
+
+    if (Axios.isCancel(error)) {
+      return;
+    }
+
+    $loading().fail();
+    $loading().finish();
+  });
+
+  const onProgress = (e) => {
+    if (!currentRequests) {
+      return;
+    }
+    const progress = ((e.loaded * 100) / (e.total * currentRequests));
+
+    $loading().set(Math.min(100, progress));
+  };
+
+  axios.defaults.onUploadProgress = onProgress;
+  axios.defaults.onDownloadProgress = onProgress;
+};
+
+export default (ctx, inject) => {
+  // runtimeConfig
+  const runtimeConfig = (ctx.$config && ctx.$config.axios) || {};
+  // baseURL
+  const baseURL = process.browser ? (runtimeConfig.browserBaseURL || runtimeConfig.baseURL || '/') : (runtimeConfig.baseURL || process.env._AXIOS_BASE_URL_ || 'https://localhost:8005/');
+
+  // Create fresh objects for all default header scopes
+  // Axios creates only one which is shared across SSR requests!
+  // https://github.com/mzabriskie/axios/blob/master/lib/defaults.js
+  const headers = {
+    common: { Accept: 'application/json, text/plain, */*' },
+    delete: {},
+    get:    {},
+    head:   {},
+    post:   {},
+    put:    {},
+    patch:  {}
+  };
+
+  const axiosOptions = {
+    baseURL,
+    headers
+  };
+
+  // Proxy SSR request headers headers
+  if (process.server && ctx.req && ctx.req.headers) {
+    const reqHeaders = { ...ctx.req.headers };
+
+    for (const h of ['accept', 'host', 'cf-ray', 'cf-connecting-ip', 'content-length', 'content-md5', 'content-type']) {
+      delete reqHeaders[h];
+    }
+    axiosOptions.headers.common = { ...reqHeaders, ...axiosOptions.headers.common };
+  }
+
+  if (process.server) {
+    // Don't accept brotli encoding because Node can't parse it
+    axiosOptions.headers.common['accept-encoding'] = 'gzip, deflate';
+  }
+
+  const axios = createAxiosInstance(axiosOptions);
+
+  // Inject axios to the context as $axios
+  ctx.$axios = axios;
+  inject('axios', axios);
+};

package/utils/cookie-universal-nuxt.js

@@ -0,0 +1,10 @@
+import cookieUniversal from 'cookie-universal';
+
+export default ({ req, res }, inject) => {
+  const options = {
+    alias:     'cookies',
+    parseJSON: true
+  };
+
+  inject(options.alias, cookieUniversal(req, res, options.parseJSON));
+};

package/utils/dom.js

@@ -0,0 +1,15 @@
+export function getParent(el, parentSelector) {
+  el = el?.parentElement;
+
+  if (!el) {
+    return null;
+  }
+
+  const matchFn = el.matches || el.matchesSelector;
+
+  if (!matchFn.call(el, parentSelector)) {
+    return getParent(el, parentSelector);
+  }
+
+  return el;
+}

package/utils/grafana.js

@@ -1,11 +1,22 @@
 import { haveV2Monitoring } from '@shell/utils/monitoring';
 import { parse as parseUrl, addParam } from '@shell/utils/url';
+import { compare } from '@shell/utils/version';
+import { CATALOG } from '@shell/config/types';
 
-export function computeDashboardUrl(embedUrl, clusterId, params) {
+const MONITORING_VERSION_NEW_URL_PATTERN = '102.0.0+up40.1.2';
+
+export function getClusterPrefix(monitoringVersion, clusterId) {
+  if (compare(monitoringVersion, MONITORING_VERSION_NEW_URL_PATTERN) >= 0) {
+    return `/k8s/clusters/${ clusterId }`;
+  }
+
+  return clusterId === 'local' ? '' : `/k8s/clusters/${ clusterId }`;
+}
+
+export function computeDashboardUrl(monitoringVersion, embedUrl, clusterId, params) {
   const url = parseUrl(embedUrl);
-  const clusterPrefix = clusterId === 'local' ? '' : `/k8s/clusters/${ clusterId }`;
 
-  let newUrl = `${ clusterPrefix }${ url.path }`;
+  let newUrl = `${ getClusterPrefix(monitoringVersion, clusterId) }${ url.path }`;
 
   if (url.query.viewPanel) {
     newUrl = addParam(newUrl, 'viewPanel', url.query.viewPanel);
@@ -20,14 +31,13 @@ export function computeDashboardUrl(embedUrl, clusterId, params) {
   return newUrl;
 }
 
-export async function dashboardExists(store, clusterId, embedUrl, storeName = 'cluster') {
+export async function dashboardExists(monitoringVersion, store, clusterId, embedUrl, storeName = 'cluster') {
   if ( !haveV2Monitoring(store.getters) ) {
     return false;
   }
 
   const url = parseUrl(embedUrl);
-  const clusterPrefix = clusterId === 'local' ? '' : `/k8s/clusters/${ clusterId }`;
-  const prefix = `${ clusterPrefix }/api/v1/namespaces/cattle-monitoring-system/services/http:rancher-monitoring-grafana:80/proxy/`;
+  const prefix = `${ getClusterPrefix(monitoringVersion, clusterId) }/api/v1/namespaces/cattle-monitoring-system/services/http:rancher-monitoring-grafana:80/proxy/`;
   const delimiter = 'http:rancher-monitoring-grafana:80/proxy/';
   const path = url.path.split(delimiter)[1];
   const uid = path.split('/')[1];
@@ -43,41 +53,50 @@ export async function dashboardExists(store, clusterId, embedUrl, storeName = 'c
 }
 
 export async function allDashboardsExist(store, clusterId, embeddedUrls, storeName = 'cluster') {
-  const existPromises = embeddedUrls.map(url => dashboardExists(store, clusterId, url, storeName));
+  let res;
+
+  try {
+    res = await store.dispatch(`${ storeName }/find`, { type: CATALOG.APP, id: 'cattle-monitoring-system/rancher-monitoring' });
+  } catch (err) {
+    return false;
+  }
+
+  const monitoringVersion = res?.currentVersion;
+
+  const existPromises = embeddedUrls.map(url => dashboardExists(monitoringVersion, store, clusterId, url, storeName));
 
   return (await Promise.all(existPromises)).every(exists => exists);
 }
 
-export function queryGrafana(dispatch, clusterId, query, range, step) {
-  const clusterPrefix = clusterId === 'local' ? '' : `/k8s/clusters/${ clusterId }`;
-  const url = `${ clusterPrefix }/api/v1/namespaces/cattle-monitoring-system/services/http:rancher-monitoring-grafana:80/proxy/api/datasources/proxy/1/api/v1/query_range?query=${ query }&start=${ range.start }&end=${ range.end }&step=${ step }`;
+export function queryGrafana(monitoringVersion, dispatch, clusterId, query, range, step) {
+  const url = `${ getClusterPrefix(monitoringVersion, clusterId) }/api/v1/namespaces/cattle-monitoring-system/services/http:rancher-monitoring-grafana:80/proxy/api/datasources/proxy/1/api/v1/query_range?query=${ query }&start=${ range.start }&end=${ range.end }&step=${ step }`;
 
   return dispatch('cluster/request', { url, redirectUnauthorized: false });
 }
 
-export async function hasLeader(dispatch, clusterId) {
+export async function hasLeader(monitoringVersion, dispatch, clusterId) {
   const end = Date.now() / 1000;
   const start = end - (5 * 60);
 
-  const response = await queryGrafana(dispatch, clusterId, 'max(etcd_server_has_leader)', { start, end }, 30);
+  const response = await queryGrafana(monitoringVersion, dispatch, clusterId, 'max(etcd_server_has_leader)', { start, end }, 30);
 
   return response.data.result[0]?.values?.[0]?.[1] === '1';
 }
 
-export async function leaderChanges(dispatch, clusterId) {
+export async function leaderChanges(monitoringVersion, dispatch, clusterId) {
   const end = Date.now() / 1000;
   const start = end - (60 * 60);
 
-  const response = await queryGrafana(dispatch, clusterId, 'max(etcd_server_leader_changes_seen_total)', { start, end }, 30);
+  const response = await queryGrafana(monitoringVersion, dispatch, clusterId, 'max(etcd_server_leader_changes_seen_total)', { start, end }, 30);
 
   return response.data.result[0]?.values?.[0]?.[1] || 0;
 }
 
-export async function failedProposals(dispatch, clusterId) {
+export async function failedProposals(monitoringVersion, dispatch, clusterId) {
   const end = Date.now() / 1000;
   const start = end - (60 * 60);
 
-  const response = await queryGrafana(dispatch, clusterId, 'sum(etcd_server_proposals_failed_total)', { start, end }, 30);
+  const response = await queryGrafana(monitoringVersion, dispatch, clusterId, 'sum(etcd_server_proposals_failed_total)', { start, end }, 30);
 
   return response.data.result[0]?.values?.[0]?.[1] || 0;
 }

package/utils/monitoring.js

@@ -26,9 +26,10 @@ export function haveV2Monitoring(getters) {
   if (haveV1Monitoring(getters)) {
     return false;
   }
+  const inStore = getters['getStoreNameByProductId'];
 
   // Just check for the pod monitors CRD
-  const schemas = getters[`cluster/all`](SCHEMA);
+  const schemas = getters[`${ inStore }/all`](SCHEMA);
   const exists = findBy(schemas, 'id', normalizeType(MONITORING.PODMONITOR));
 
   return !!exists;