@rancher/shell 0.5.3 → 2.0.0

package/store/__tests__/catalog.test.ts

@@ -0,0 +1,224 @@
+import { CATALOG } from '@shell/config/types';
+import { state, getters, actions, mutations } from '../catalog';
+import Vuex from 'vuex';
+import { createLocalVue } from '@vue/test-utils';
+
+const clusterRepo = { _key: 'testClusterRepo' };
+const repoChartName = 'abc';
+const repoChart = {
+  name:     repoChartName,
+  type:     'namespaced',
+  version:  1,
+  metadata: { name: repoChartName }
+};
+const repoCharts = [repoChart];
+const repo = {
+  metadata:   { name: 'testRepo' },
+  _key:       'testRepo',
+  links:      { index: 'fetchindex' },
+  canLoad:    true,
+  followLink: () => ({ entries: { [repoChartName]: repoCharts } })
+};
+
+const catalogStoreName = 'catalog';
+const clusterStore = 'cluster';
+
+const expectedChartKey = `namespace/${ repo._key }/${ repoChartName }`;
+const initialVersionInfo = { junk: true };
+const initialRawChartName = 'cde';
+const initialRawChart = {
+  id:       `namespace/${ repo._key }/${ initialRawChartName }`,
+  repoKey:  repo._key,
+  type:     'namespaced',
+  name:     initialRawChartName,
+  version:  1,
+  metadata: { name: initialRawChartName }
+};
+const initialRawCharts = { [initialRawChart.id]: initialRawChart };
+const initialLoadedInfo = { [repo._key]: true };
+
+describe('catalog', () => {
+  describe('load', () => {
+    const constructStore = () => {
+      const catalogStore = {
+        state: state(),
+        getters,
+        mutations,
+        actions,
+      };
+
+      const localVue = createLocalVue();
+
+      localVue.use(Vuex);
+
+      return {
+        modules: {
+          i18n: {
+            namespaced: true,
+            getters:    { withFallback: (state: any) => () => '' }
+          },
+          [catalogStoreName]: {
+            namespaced: true,
+            state:      {
+              ...catalogStore.state,
+              // Set initial state
+              // - repos have been loaded
+              // - some charts exist
+              // - some chart version info has been fetched
+              loaded:       initialLoadedInfo,
+              charts:       initialRawCharts,
+              versionInfos: initialVersionInfo,
+            },
+            mutations: catalogStore.mutations,
+            actions:   catalogStore.actions,
+            getters:   catalogStore.getters
+          },
+          [clusterStore]: {
+            namespaced: true,
+            getters:    { schemaFor: (state: any) => (schema: string) => ({}) },
+            actions:    {
+              findAll: (ctx: any, ...args: any[]) => {
+                if (args[0].type === CATALOG.CLUSTER_REPO) {
+                  return Promise.resolve([clusterRepo]);
+                }
+                if (args[0].type === CATALOG.REPO) {
+                  return Promise.resolve([repo]);
+                }
+
+                return Promise.resolve([]);
+              },
+            }
+          }
+        },
+        state: {
+          $plugin:            { getDynamic: () => require(`@shell/models/chart`) },
+          [catalogStoreName]: { } as { [key: string]: any},
+        },
+        getters: {
+          currentCluster: () => ({ }),
+          currentProduct: () => ({ inStore: clusterStore }),
+        },
+        mutations: { },
+        actions:   { }
+      };
+    };
+
+    it('no force', async() => {
+      const localVue = createLocalVue();
+
+      localVue.use(Vuex);
+
+      const store = new Vuex.Store(constructStore());
+
+      // Validate initial state of store
+      expect(store.getters[`${ catalogStoreName }/rawCharts`]).toStrictEqual(initialRawCharts);
+      expect(store.getters[`${ catalogStoreName }/charts`]).toStrictEqual([]);
+
+      // Make the request
+      await store.dispatch(`${ catalogStoreName }/load`, {
+        force: false,
+        reset: false
+      });
+
+      // Basics should always be ok
+      expect(store.getters[`${ catalogStoreName }/inStore`]).toStrictEqual(clusterStore);
+      expect(store.getters[`${ catalogStoreName }/errors`]).toStrictEqual([]);
+      expect(store.getters[`${ catalogStoreName }/repos`]).toStrictEqual([clusterRepo, repo]);
+      expect(store.state[catalogStoreName].loaded).toStrictEqual(initialLoadedInfo);
+
+      // Store should still be in it's initial state (but charts populated)
+      expect(store.getters[`${ catalogStoreName }/rawCharts`]).toStrictEqual(initialRawCharts);
+      expect(store.getters[`${ catalogStoreName }/charts`]).toStrictEqual([initialRawChart]);
+
+      // We haven't reset the version info, so it should be unchanged
+      expect(store.state[catalogStoreName].versionInfos).toStrictEqual(initialVersionInfo);
+    });
+
+    it('force', async() => {
+      const localVue = createLocalVue();
+
+      localVue.use(Vuex);
+
+      const store = new Vuex.Store(constructStore());
+
+      // Validate initial state of store
+      let rawCharts = store.getters[`${ catalogStoreName }/rawCharts`];
+
+      expect(store.getters[`${ catalogStoreName }/rawCharts`]).toStrictEqual(initialRawCharts);
+      expect(rawCharts[initialRawChart.id]).toBeDefined();
+      expect(rawCharts[initialRawChart.id].id).toBe(initialRawChart.id);
+
+      expect(store.getters[`${ catalogStoreName }/charts`]).toStrictEqual([]);
+
+      // Make the request
+      await store.dispatch(`${ catalogStoreName }/load`, {
+        force: true, // Force such that we should get some values
+        reset: false
+      });
+
+      rawCharts = store.getters[`${ catalogStoreName }/rawCharts`];
+      const charts = store.getters[`${ catalogStoreName }/charts`];
+
+      // Basics should always be ok
+      expect(store.getters[`${ catalogStoreName }/inStore`]).toStrictEqual(clusterStore);
+      expect(store.getters[`${ catalogStoreName }/errors`]).toStrictEqual([]);
+      expect(store.getters[`${ catalogStoreName }/repos`]).toStrictEqual([clusterRepo, repo]);
+      expect(store.state[catalogStoreName].loaded).toStrictEqual(initialLoadedInfo);
+
+      // Store should have it's initial chart... and the new one
+      expect(rawCharts[initialRawChart.id]).toBeDefined();
+      expect(rawCharts[initialRawChart.id].id).toBe(initialRawChart.id);
+      expect(rawCharts[expectedChartKey]).toBeDefined();
+      expect(rawCharts[expectedChartKey].id).toBe(expectedChartKey);
+      expect(rawCharts[expectedChartKey].versions[0].version).toBe(repoChart.version);
+      expect(charts[0]).toBeDefined();
+      expect(charts[0].id).toBe(initialRawChart.id);
+      expect(charts[1]).toBeDefined();
+      expect(charts[1].id).toBe(expectedChartKey);
+
+      // Version info should be unchanged
+      expect(store.state[catalogStoreName].versionInfos).toStrictEqual(initialVersionInfo);
+    });
+
+    it('force + reset', async() => {
+      const localVue = createLocalVue();
+
+      localVue.use(Vuex);
+
+      const store = new Vuex.Store(constructStore());
+
+      // Validate initial state of store
+      expect(store.getters[`${ catalogStoreName }/rawCharts`]).toStrictEqual(initialRawCharts);
+      expect(store.getters[`${ catalogStoreName }/charts`]).toStrictEqual([]);
+
+      // Make the request
+      await store.dispatch(`${ catalogStoreName }/load`, {
+        force: true,
+        reset: true
+      });
+
+      const rawCharts = store.getters[`${ catalogStoreName }/rawCharts`];
+      const charts = store.getters[`${ catalogStoreName }/charts`];
+
+      // Basics should always be ok
+      expect(store.getters[`${ catalogStoreName }/inStore`]).toStrictEqual(clusterStore);
+      expect(store.getters[`${ catalogStoreName }/errors`]).toStrictEqual([]);
+      expect(store.getters[`${ catalogStoreName }/repos`]).toStrictEqual([clusterRepo, repo]);
+      expect(store.state[catalogStoreName].loaded).toStrictEqual(initialLoadedInfo);
+
+      // Store should NOT have it's initial chart... and should have the new one
+      expect(rawCharts[initialRawChart.id]).not.toBeDefined();
+      expect(rawCharts[expectedChartKey]).toBeDefined();
+      expect(rawCharts[expectedChartKey].id).toBe(expectedChartKey);
+      expect(rawCharts[expectedChartKey].versions[0].version).toBe(repoChart.version);
+
+      expect(charts).toHaveLength(1);
+      expect(charts[0]).toBeDefined();
+      expect(charts[0].id).toBe(expectedChartKey);
+      expect(charts[0].versions[0].version).toBe(repoChart.version);
+
+      // Version info should be changed (it's now empty given reset)
+      expect(store.state[catalogStoreName].versionInfos).toStrictEqual({ });
+    });
+  });
+});

package/store/auth.js

@@ -12,7 +12,8 @@ export const BASE_SCOPES = {
   github:       ['read:org'],
   googleoauth:  ['openid profile email'],
   azuread:      [],
-  keycloakoidc: ['openid profile email']
+  keycloakoidc: ['openid profile email'],
+  oidc:         ['openid profile email'],
 };
 
 const KEY = 'rc_nonce';
@@ -37,7 +38,7 @@ export const state = function() {
 };
 
 export const getters = {
-  fromHeader() {
+  fromHeader(state) {
     return state.fromHeader;
   },
 
@@ -344,9 +345,27 @@ export const actions = {
     }
   },
 
-  async logout({ dispatch, commit }) {
+  async logout({
+    dispatch, commit, getters, rootState
+  }, options = {}) {
+    // So, we only do this check if auth has been initialized.
+    //
+    // It's possible to be logged in and visit auth/logout directly instead
+    // of navigating from the app while being logged in. Unfortunately auth/logout
+    // doesn't use the authenticated middleware which means auth will never be
+    // initialized and this check will be invalid. This interferes with how we sometimes
+    // logout in our e2e tests.
+    //
+    // I'm going to leave this as is because we will be modifying and removing authenticated
+    // middleware soon and we should remove `force` at that time.
+    //
+    // TODO: remove `force` once authenticated middleware is removed/made sane.
+    if (!options?.force && !getters['loggedIn']) {
+      return;
+    }
+
     // Unload plugins - we will load again on login
-    await this.$plugin.logout();
+    await rootState.$plugin.logout();
 
     try {
       await dispatch('rancher/request', {

package/store/aws.js

@@ -4,7 +4,10 @@ import { FetchHttpHandler } from '@aws-sdk/fetch-http-handler';
 import { isArray, addObjects } from '@shell/utils/array';
 
 export const state = () => {
-  return {};
+  return {
+    instanceTypes: [],
+    clientInfo:    null
+  };
 };
 
 class Handler {
@@ -60,6 +63,21 @@ export const getters = {
 
   defaultInstanceType() {
     return 't3a.medium';
+  },
+
+  instanceTypes(state) {
+    return state.instanceTypes;
+  },
+
+  clientInfo(state) {
+    return state.clientInfo;
+  }
+};
+
+export const mutations = {
+  setInstanceTypes(state, { types, clientInfo }) {
+    state.instanceTypes = types;
+    state.clientInfo = clientInfo;
   }
 };
 
@@ -73,7 +91,11 @@ export const actions = {
   },
 
   kmsLib() {
-    return import(/* webpackChunkName: "aws-ec2" */ '@aws-sdk/client-kms');
+    return import(/* webpackChunkName: "aws-kms" */ '@aws-sdk/client-kms');
+  },
+
+  iamLib() {
+    return import(/* webpackChunkName: "aws-iam" */ '@aws-sdk/client-iam');
   },
 
   async ec2({ dispatch }, {
@@ -118,7 +140,29 @@ export const actions = {
     return client;
   },
 
-  async instanceInfo({ dispatch, rootGetters, state }, { client }) {
+  async iam({ dispatch }, {
+    region, cloudCredentialId, accessKey, secretKey
+  }) {
+    const lib = await dispatch('iamLib');
+
+    const client = new lib.IAM({
+      region,
+      credentialDefaultProvider: credentialDefaultProvider(accessKey, secretKey),
+      requestHandler:            new Handler(cloudCredentialId),
+    });
+
+    return client;
+  },
+
+  async describeInstanceTypes({
+    dispatch, rootGetters, state, commit
+  }, { client }) {
+    const cloudCredentialId = client?.config?.requestHandler?.cloudCredentialId;
+    const region = await client.config.region();
+
+    if (cloudCredentialId === rootGetters['aws/clientInfo']?.cloudCredentialId && region === rootGetters['aws/clientInfo']?.region) {
+      return rootGetters['aws/instanceTypes'];
+    }
     const data = await dispatch('depaginateList', { client, cmd: 'describeInstanceTypes' });
 
     const groups = (await import(/* webpackChunkName: "aws-data" */'@shell/assets/data/ec2-instance-groups.json')).default;
@@ -158,11 +202,12 @@ export const actions = {
 
       list.push({
         apiName,
-        currentGeneration: row.CurrentGeneration || false,
+        currentGeneration:     row.CurrentGeneration || false,
         groupLabel,
         instanceClass,
-        memoryBytes:       row.MemoryInfo.SizeInMiB * 1024 * 1024,
-        label:             rootGetters['i18n/t']('cluster.machineConfig.aws.sizeLabel', {
+        memoryBytes:           row.MemoryInfo.SizeInMiB * 1024 * 1024,
+        supportedUsageClasses: row.SupportedUsageClasses,
+        label:                 rootGetters['i18n/t']('cluster.machineConfig.aws.sizeLabel', {
           apiName,
           cpu:    row.VCpuInfo.DefaultVCpus,
           memory: row.MemoryInfo.SizeInMiB / 1024,
@@ -175,6 +220,8 @@ export const actions = {
 
     const out = sortBy(list, ['currentGeneration:desc', 'groupLabel', 'instanceClass', 'memoryBytes', 'apiName']);
 
+    commit('setInstanceTypes', { types: out, clientInfo: { region, cloudCredentialId } });
+
     return out;
   },
 

package/store/catalog.js

@@ -1,4 +1,4 @@
-import { CATALOG } from '@shell/config/types';
+import { CATALOG, EXPERIMENTAL, DEPRECATED } from '@shell/config/types';
 import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
 import { addParams } from '@shell/utils/url';
 import { allHash, allHashSettled } from '@shell/utils/promise';
@@ -102,7 +102,7 @@ export const getters = {
 
   chart(state, getters) {
     return ({
-      key, repoType, repoName, chartName, preferRepoType, preferRepoName, includeHidden
+      key, repoType, repoName, chartName, preferRepoType, preferRepoName, includeHidden, showDeprecated
     }) => {
       if ( key && !repoType && !repoName && !chartName) {
         const parsed = parseKey(key);
@@ -116,7 +116,7 @@ export const getters = {
         repoType,
         repoName,
         chartName,
-        deprecated: false,
+        deprecated: !!showDeprecated,
       });
 
       if ( includeHidden === false ) {
@@ -324,12 +324,21 @@ export const mutations = {
     }
   },
 
+  setVersions(state, versions) {
+    state.versionInfos = versions;
+  },
+
   cacheVersion(state, { key, info }) {
     state.versionInfos[key] = info;
   }
 };
 
 export const actions = {
+  /**
+   * force: Always refresh catalog's helm repo by re-fetching index.yaml
+   *
+   * reset: clear existing charts and version cache
+   */
   async load(ctx, { force, reset } = {}) {
     const {
       state, getters, rootGetters, commit, dispatch
@@ -397,6 +406,10 @@ export const actions = {
       errors,
       loaded,
     });
+
+    if (reset) {
+      commit('setVersions', {});
+    }
   },
 
   async refresh({ getters, commit, dispatch }) {
@@ -488,8 +501,10 @@ function addChart(ctx, map, chart, repo) {
     certified = CATALOG_ANNOTATIONS._OTHER;
   }
 
-  if ( chart.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL] ) {
-    sideLabel = 'Experimental';
+  if ( chart.deprecated ) {
+    sideLabel = DEPRECATED;
+  } else if ( chart.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL] ) {
+    sideLabel = EXPERIMENTAL;
   } else if (
     !repo.isRancherSource &&
     certifiedAnnotation &&
@@ -523,6 +538,7 @@ function addChart(ctx, map, chart, repo) {
       versions:            [],
       categories:          filterCategories(chart.keywords),
       deprecated:          !!chart.deprecated,
+      experimental:        !!chart.annotations?.[CATALOG_ANNOTATIONS.EXPERIMENTAL],
       hidden:              !!chart.annotations?.[CATALOG_ANNOTATIONS.HIDDEN],
       targetNamespace:     chart.annotations?.[CATALOG_ANNOTATIONS.NAMESPACE],
       targetName:          chart.annotations?.[CATALOG_ANNOTATIONS.RELEASE_NAME],

package/store/cru-resource.ts

@@ -0,0 +1,26 @@
+interface State {
+  createNamespace: boolean;
+}
+
+export const state = (): State => {
+  return { createNamespace: false };
+};
+
+export const mutations = {
+  SET_CREATE_NAMESPACE(state: State, shouldCreateNamespace: boolean): void {
+    state.createNamespace = shouldCreateNamespace;
+  }
+};
+
+export const actions = {
+  setCreateNamespace({ commit }: unknown, shouldCreateNamespace: boolean): void {
+    commit('SET_CREATE_NAMESPACE', shouldCreateNamespace);
+  }
+};
+
+export default {
+  namespaced: true,
+  state,
+  mutations,
+  actions,
+};

package/store/customisation.js

@@ -0,0 +1,35 @@
+const defaultState = {
+  previewCluster: {
+    ready:   true,
+    isLocal: false,
+    badge:   { }
+  }
+};
+
+export const state = function() {
+  return { previewCluster: defaultState.previewCluster };
+};
+
+export const getters = {
+  getPreviewCluster(state) {
+    return state.previewCluster;
+  },
+};
+
+export const mutations = {
+  setPreviewCluster(state, previewCluster) {
+    state.previewCluster = previewCluster;
+  },
+  setDefaultPreviewCluster(state) {
+    state.previewCluster = defaultState.previewCluster;
+  }
+};
+
+export const actions = {
+  setPreviewCluster({ commit }, previewCluster) {
+    commit('setPreviewCluster', previewCluster);
+  },
+  setDefaultPreviewCluster({ commit }) {
+    commit('setDefaultPreviewCluster');
+  }
+};

package/store/features.js

@@ -2,8 +2,8 @@ import { MANAGEMENT } from '@shell/config/types';
 
 const definitions = {};
 
-export const create = function(name, def) {
-  definitions[name] = { def };
+export const create = function(name, defaultValue) {
+  definitions[name] = { def: defaultValue };
 
   return name;
 };
@@ -33,6 +33,8 @@ export const FLEET = create('continuous-delivery', true);
 export const HARVESTER = create('harvester', true);
 export const HARVESTER_CONTAINER = create('harvester-baremetal-container-workload', false);
 export const FLEET_WORKSPACE_BACK = create('provisioningv2-fleet-workspace-back-population', false);
+export const STEVE_CACHE = create('ui-sql-cache', false);
+export const UIEXTENSION = create('uiextension', true);
 
 // Not currently used.. no point defining ones we don't use
 // export const EMBEDDED_CLUSTER_API = create('embedded-cluster-api', true);
@@ -61,9 +63,9 @@ export const getters = {
 };
 
 export const actions = {
-  loadServer({ rootGetters, dispatch }) {
+  async loadServer({ rootGetters, dispatch }) {
     if ( rootGetters['management/canList'](MANAGEMENT.FEATURE) ) {
-      return dispatch('management/findAll', { type: MANAGEMENT.FEATURE }, { root: true });
+      return await dispatch('management/findAll', { type: MANAGEMENT.FEATURE, opt: { watch: false } }, { root: true });
     }
   },
 };