@rancher/shell 0.1.0

package/utils/dynamic-importer.js

@@ -0,0 +1,120 @@
+// Note: This file exists and ESLint is disabled on it in .eslintignore because it currently chokes on import()s
+// So it can be disabled just on this file that does nothing else, instead of every file that uses
+// an import with a variable in the path.
+
+export function importCloudCredential(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "cloud-credential" */ `@shell/cloud-credential/${name}`);
+}
+
+export function importMachineConfig(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "machine-config" */ `@shell/machine-config/${name}`);
+}
+
+export function importLogin(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "login" */ `@shell/components/auth/login/${name}`);
+}
+
+export function importChart(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "chart" */ `@shell/chart/${name}`);
+}
+
+export function importList(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "list" */ `@shell/list/${name}`);
+}
+
+export function importDetail(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "detail" */ `@shell/detail/${name}`);
+}
+
+export function importEdit(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "edit" */ `@shell/edit/${name}`);
+}
+
+export function importDialog(name) {
+  if ( !name ) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "dialog" */ `@shell/components/dialog/${name}`);
+}
+
+export function importWindowComponent(name) {
+  if ( !name ) {
+    throw new Error('Name required');
+  }
+
+  return () => import(/* webpackChunkName: "components/nav" */ `@shell/components/nav/WindowManager/${name}`);
+}
+
+export function loadProduct(name) {
+  if (!name) {
+    throw new Error('Name required');
+  }
+
+  // Note: directly returns the import, not a function
+  return import(/* webpackChunkName: "product" */ `@shell/config/product/${name}`);
+}
+
+export function listProducts() {
+  const ctx = require.context('@shell/config/product', true, /.*/);
+  const products = ctx.keys().filter(path => !path.endsWith('.js')).map(path => path.substr(2));
+
+  return products;
+}
+
+export function loadTranslation(name) {
+  if ( !name ) {
+    throw new Error('Name required');
+  }
+
+  // Note: directly returns the import, not a function
+  return import(/* webpackChunkName: "[request]" */ `@shell/assets/translations/${name}.yaml`);
+}
+
+export function importCustomPromptRemove(name) {
+  return () => import(/* webpackChunkName: "custom-prompt-remove" */ `@shell/promptRemove/${ name }`);
+}
+
+export function resolveList(key) {
+  return require.resolve(`@shell/list/${ key }`);
+}
+
+export function resolveEdit(key) {
+  return require.resolve(`@shell/edit/${ key }`);
+}
+
+export function resolveDetail(key) {
+  return require.resolve(`@shell/detail/${ key }`);
+}
+
+export function resolveWindowComponent(key) {
+  return require.resolve(`@shell/components/nav/WindowManager/${ key }`);
+}

package/utils/ember-page.js

@@ -0,0 +1,30 @@
+
+export const EMBER_FRAME = 'ember-iframe';
+let inactiveRemoveTimer;
+
+// Remove the IFrame if the user has not used an embedded page after this time
+// since last visiting an embedded page
+const INACTIVITY_CHECK_TIMEOUT = 60000;
+
+export function findEmberPage() {
+  return document.getElementById(EMBER_FRAME);
+}
+
+export function clearEmberInactiveTimer() {
+  clearTimeout(inactiveRemoveTimer);
+}
+
+export function startEmberInactiveTimer() {
+  if (findEmberPage() !== null) {
+    inactiveRemoveTimer = setTimeout(removeEmberPage, INACTIVITY_CHECK_TIMEOUT);
+  }
+}
+
+export function removeEmberPage() {
+  const iframeEl = findEmberPage();
+
+  if (iframeEl !== null) {
+    iframeEl.remove();
+    clearEmberInactiveTimer();
+  }
+}

package/utils/error.js

@@ -0,0 +1,80 @@
+import { isArray } from '@shell/utils/array';
+
+export class ClusterNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ClusterNotFoundError';
+  }
+}
+
+export class ApiError extends Error {
+  constructor(res) {
+    super(stringify(res));
+    this.status = res._status || 0;
+    this.statusText = res._statusText;
+    this.headers = res.headers;
+    this.url = res._url;
+  }
+
+  toString() {
+    return `[${ this.status } ${ this.statusText }]: ${ this.message }`;
+  }
+
+  toJSON() {
+    return {
+      type:       'error',
+      status:     this.status,
+      statusText: this.statusText,
+      message:    this.statusMessage,
+      url:        this.url,
+    };
+  }
+}
+
+export function stringify(err) {
+  let str;
+
+  if ( typeof err === 'string' ) {
+    str = err;
+  } else if ( err && typeof err === 'object' ) {
+    if ( err.message ) {
+      str = err.message;
+      if ( err.detail ) {
+        if ( str ) {
+          str += ` (${ err.detail })`;
+        } else {
+          str = err.detail;
+        }
+      }
+    } else if ( err.detail ) {
+      str = err.detail;
+    } else if ( err.url ) {
+      str = `from ${ err.url }`;
+    }
+  }
+
+  if (!str) {
+    // Good luck...
+    str = JSON.stringify(err);
+  }
+
+  return str;
+}
+
+export function exceptionToErrorsArray(err) {
+  if ( err?.response?.data ) {
+    const body = err.response.data;
+
+    if ( body && body.message ) {
+      return [body.message];
+    } else {
+      return [err];
+    }
+  } else if (err.status && err.message) {
+    return [err.message];
+  } else if ( isArray(err) ) {
+    return err;
+  } else {
+    return [err];
+  }
+}

package/utils/gatekeeper/util.js

@@ -0,0 +1,35 @@
+import { GATEKEEPER, SCHEMA } from '@shell/config/types';
+
+export async function findAllConstraints(store) {
+  const constraintTypes = await findAllConstraintTypes(store);
+  const nestedConstraints = constraintTypes.map(ct => store.dispatch('cluster/findAll', { type: ct, opt: { force: true } }));
+
+  return (await Promise.all(nestedConstraints)).flat();
+}
+
+export function findAllConstraintTypes(store) {
+  const schemas = store.getters['cluster/all'](SCHEMA);
+
+  return findConstraintTypes(schemas);
+}
+
+export function findAllTemplates(store) {
+  return store.dispatch('cluster/findAll', { type: GATEKEEPER.CONSTRAINT_TEMPLATE });
+}
+
+export function findTemplateType(schemas) {
+  // @TODO this will just be a regular single type now that the server filters to preferred version
+  // so you can just add templates.gatekeeper.sh.constrainttemplate as a constant in types.js
+  const template = schemas.find((schema) => {
+    return schema?.attributes?.group === 'templates.gatekeeper.sh' &&
+        schema?.attributes?.kind === 'ConstraintTemplate';
+  });
+
+  return template?.id;
+}
+
+function findConstraintTypes(schemas) {
+  return schemas
+    .filter(schema => schema?.attributes?.group === 'constraints.gatekeeper.sh')
+    .map(schema => schema.id);
+}

package/utils/grafana.js

@@ -0,0 +1,87 @@
+import { parse as parseUrl, addParam } from '@shell/utils/url';
+import { MONITORING } from '@shell/config/types';
+
+export function computeDashboardUrl(embedUrl, clusterId, params) {
+  const url = parseUrl(embedUrl);
+  const clusterPrefix = clusterId === 'local' ? '' : `/k8s/clusters/${ clusterId }`;
+
+  let newUrl = `${ clusterPrefix }${ url.path }`;
+
+  if (url.query.viewPanel) {
+    newUrl = addParam(newUrl, 'viewPanel', url.query.viewPanel);
+  }
+  newUrl = addParam(newUrl, 'orgId', url.query.orgId);
+  newUrl = addParam(newUrl, 'kiosk', null);
+
+  Object.entries(params).forEach((entry) => {
+    newUrl = addParam(newUrl, entry[0], entry[1]);
+  });
+
+  return newUrl;
+}
+
+export async function dashboardExists(store, clusterId, embedUrl, storeName = 'cluster') {
+  if (!isMonitoringInstalled(store.getters, storeName)) {
+    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 delimiter = 'http:rancher-monitoring-grafana:80/proxy/';
+  const path = url.path.split(delimiter)[1];
+  const uid = path.split('/')[1];
+  const newUrl = `${ prefix }api/dashboards/uid/${ uid }`;
+
+  try {
+    await store.dispatch(`${ storeName }/request`, { url: newUrl, redirectUnauthorized: false });
+
+    return true;
+  } catch (ex) {
+    return false;
+  }
+}
+
+export async function allDashboardsExist(store, clusterId, embeddedUrls, storeName = 'cluster') {
+  const existPromises = embeddedUrls.map(url => dashboardExists(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 }`;
+
+  return dispatch('cluster/request', { url, redirectUnauthorized: false });
+}
+
+export async function hasLeader(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);
+
+  return response.data.result[0]?.values?.[0]?.[1] === '1';
+}
+
+export async function leaderChanges(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);
+
+  return response.data.result[0]?.values?.[0]?.[1] || 0;
+}
+
+export async function failedProposals(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);
+
+  return response.data.result[0]?.values?.[0]?.[1] || 0;
+}
+
+function isMonitoringInstalled(getters, storeName = 'cluster') {
+  return !!getters[`${ storeName }/schemaFor`](MONITORING.SERVICEMONITOR);
+}

package/utils/group.js

@@ -0,0 +1,70 @@
+import { get } from '@shell/utils/object';
+import { filterBy } from '@shell/utils/array';
+import { sortBy } from '@shell/utils/sort';
+
+const NOT_GROUPED = 'none';
+
+// groupAndFilterBy(services, 'default')
+export function groupAndFilterOptions(ary, filter, {
+  defaultFilterKey = 'metadata.namespace',
+
+  groupBy = 'metadata.namespace',
+  groupPrefix = 'Namespace: ',
+
+  itemLabelKey = 'nameDisplay',
+  itemValueKey = 'id',
+  itemSortKey = 'nameSort',
+} = {}) {
+  let matching;
+
+  if ( filter && typeof filter === 'object' ) {
+    matching = filterBy((ary || []), filter);
+  } else if ( filter ) {
+    // If you want to filter on a value that's false-y (false, null, undefined) use the object version of filter
+    matching = filterBy((ary || []), defaultFilterKey, filter);
+  } else {
+    matching = ary;
+  }
+
+  const groups = {};
+
+  for ( const match of matching ) {
+    const name = groupBy ? get(match, groupBy) : NOT_GROUPED;
+    let entry = groups[name];
+
+    if ( !entry ) {
+      entry = {
+        group: `${ groupPrefix }${ name }`,
+        items: {},
+      };
+
+      groups[name] = entry;
+    }
+
+    const value = get(match, itemValueKey);
+
+    if ( !entry.items[value] ) {
+      entry.items[value] = {
+        obj:   match,
+        label: get(match, itemLabelKey),
+        value
+      };
+    }
+  }
+
+  const out = Object.keys(groups).map((name) => {
+    const entry = groups[name];
+
+    entry.items = sortBy(Object.values(entry.items), `obj.${ itemSortKey }`);
+
+    return entry;
+  });
+
+  if ( groupBy ) {
+    return sortBy(out, 'group');
+  } else if ( out.length ) {
+    return out[0].items;
+  } else {
+    return [];
+  }
+}

package/utils/install-redirect.js

@@ -0,0 +1,55 @@
+import { REPO_TYPE, REPO, CHART, VERSION } from '@shell/config/query-params';
+
+export default function(product, chartName, defaultResourceOrRoute, install = true) {
+  return async function middleware({ redirect, store } ) {
+    const cluster = store.getters['currentCluster']?.id || 'local';
+
+    if ( store.getters['type-map/isProductActive'](product) ) {
+      // If the product is installed and there's a default resource, redirect there
+
+      if ( defaultResourceOrRoute ) {
+        if ( typeof defaultResourceOrRoute === 'object' ) {
+          return redirect(defaultResourceOrRoute);
+        }
+
+        return redirect({
+          name:   'c-cluster-product-resource',
+          params: {
+            cluster,
+            product,
+            resource: defaultResourceOrRoute
+          },
+        });
+      }
+
+      // Otherwise just let the middleware pass through
+    } else if (install) {
+      // The product is not installed, redirect to the details chart
+
+      await store.dispatch('catalog/load');
+
+      const chart = store.getters['catalog/chart']({ chartName });
+
+      if ( chart ) {
+        return redirect({
+          name:   'c-cluster-apps-charts-chart',
+          params: { cluster },
+          query:  {
+            [REPO_TYPE]: chart.repoType,
+            [REPO]:      chart.repoName,
+            [CHART]:     chart.chartName,
+            [VERSION]:   chart.versions[0].version
+          },
+        });
+      } else {
+        // The chart's not available
+        store.dispatch('loadingError', `Chart not found for ${ product }`);
+      }
+    } else {
+      return redirect({
+        name:   'c-cluster-explorer',
+        params: { cluster },
+      });
+    }
+  };
+}

package/utils/monitoring.js

@@ -0,0 +1,73 @@
+// Helpers for determining if V2 or v1 Monitoring are installed
+
+import { SCHEMA, MONITORING, WORKLOAD_TYPES } from '@shell/config/types';
+import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
+import { findBy } from '@shell/utils/array';
+import { isEmpty } from '@shell/utils/object';
+
+// Can be used inside a components' computed property
+export function monitoringStatus() {
+  return {
+    monitoringStatus() {
+      const status = {
+        v1: haveV1Monitoring(this.$store.getters),
+        v2: haveV2Monitoring(this.$store.getters),
+      };
+
+      status.installed = status.v1 || status.v2;
+
+      return status;
+    }
+  };
+}
+
+export function haveV2Monitoring(getters) {
+  // Can't have V2 and V1 monitoring installed, so if V1 is installed we know v2 is not
+  if (haveV1Monitoring(getters)) {
+    return false;
+  }
+
+  // Just check for the pod monitors CRD
+  const schemas = getters[`cluster/all`](SCHEMA);
+  const exists = findBy(schemas, 'id', normalizeType(MONITORING.PODMONITOR));
+
+  return !!exists;
+}
+
+// For v1 Monitoring, the cluster object indicates presence via status.monitoringStatus
+export function haveV1Monitoring(getters) {
+  const cluster = getters['currentCluster'];
+
+  return !!cluster?.status?.monitoringStatus;
+}
+
+const CATTLE_MONITORING_NAMESPACE = 'cattle-monitoring-system';
+
+export async function haveV1MonitoringWorkloads(store) {
+  const workloadsByType = await Promise.all(
+    Object.values(WORKLOAD_TYPES).map(type => store.dispatch('cluster/findAll', { type })
+    )
+  );
+  const workloads = workloadsByType.flat();
+
+  for (let i = 0; i < workloads.length; i++) {
+    const workload = workloads[i];
+
+    if (!isEmpty(workload?.spec?.template?.spec?.containers) &&
+        workload.spec.template.spec.containers.find(c => c.image?.includes('quay.io/coreos/prometheus-operator') ||
+          c.image?.includes('rancher/coreos-prometheus-operator')) &&
+        workload?.metadata?.namespace !== CATTLE_MONITORING_NAMESPACE) {
+      return Promise.resolve(true);
+    }
+
+    return Promise.resolve(false);
+  }
+}
+
+// Other ways we check for monitoring:
+
+// (1) Using counts (requires RBAC permissions)
+// return !!this.clusterCounts?.[0]?.counts?.[CATALOG.APP]?.namespaces?.['cattle-monitoring-system'];
+
+// (2) Retrieving all workloads and looking for containers with a given image
+// See chart/monitoring/index.vue

package/utils/namespace-filter.js

@@ -0,0 +1,31 @@
+export const NAMESPACE_FILTER_SPECIAL = 'special';
+
+export const NAMESPACE_FILTER_ALL = 'all';
+export const NAMESPACE_FILTER_ALL_SYSTEM = 'all://system';
+export const NAMESPACE_FILTER_ALL_USER = 'all://user';
+export const NAMESPACE_FILTER_ALL_ORPHANS = 'all://orphans';
+export const NAMESPACE_FILTER_NAMESPACED_PREFIX = 'namespaced://';
+export const NAMESPACE_FILTER_NAMESPACED_YES = 'namespaced://true';
+export const NAMESPACE_FILTER_NAMESPACED_NO = 'namespaced://false';
+
+const SEPARATOR = '__%%__';
+
+export const createNamespaceFilterKey = (clusterId, product) => {
+  if (!product?.customNamespaceFilter) {
+    return clusterId;
+  }
+
+  return createNamespaceFilterKeyWithId(clusterId, product.name);
+};
+export const createNamespaceFilterKeyWithId = (clusterId, productId) => {
+  return `${ clusterId }${ SEPARATOR }${ productId }`;
+};
+
+export const splitNamespaceFilterKey = (key) => {
+  const [clusterId, productId] = key.split(SEPARATOR);
+
+  return {
+    clusterId,
+    productId
+  };
+};