@rancher/shell 3.0.2-rc.2 → 3.0.2-rc.4

package/types/components/resourceLabeledSelect.ts

@@ -0,0 +1,48 @@
+import { LabelSelectPaginationFunctionOptions } from '@shell/components/form/labeled-select-utils/labeled-select.utils';
+import { LabelSelectPaginateFn } from '@shell/types/components/labeledSelect';
+
+type PaginateTypeOverridesFn = (opts: LabelSelectPaginationFunctionOptions) => LabelSelectPaginationFunctionOptions;
+
+interface SharedSettings {
+  /**
+   * Provide specific LabelSelect options for this mode (paginated / not paginated)
+   */
+  labelSelectOptions?: { [key: string]: any },
+  /**
+   * Map, filter, tweak, etc the resources to show in the LabelSelect
+   */
+  updateResources?: (resources: any[]) => any[]
+}
+
+/**
+ * Settings to use when the LabelSelect is paginating
+ */
+export interface ResourceLabeledSelectPaginateSettings extends SharedSettings {
+  /**
+   * Override the convenience function which fetches a page of results
+   */
+  overrideRequest?: LabelSelectPaginateFn,
+  /**
+   * Override the default settings used in the convenience function to fetch a page of results
+   */
+  requestSettings?: PaginateTypeOverridesFn,
+}
+
+/**
+ * Settings to use when the LabelSelect is fetching all resources (not paginating)
+ */
+export type ResourceLabeledSelectSettings = SharedSettings
+
+/**
+ * Force a specific mode
+ */
+export enum RESOURCE_LABEL_SELECT_MODE {
+  /**
+   * Fetch all resources
+   */
+  ALL_RESOURCES = 'ALL', // eslint-disable-line no-unused-vars
+  /**
+   * Determine if all resources are fetched given system settings
+   */
+  DYNAMIC = 'DYNAMIC', // eslint-disable-line no-unused-vars
+}

package/types/resources/fleet.d.ts

@@ -24,10 +24,19 @@ export interface BundleNonReadyBundle {
   nonReadyStatus: BundleNonReadyResource[],
 }
 
+export interface Condition {
+  status: string,
+  type: string,
+}
+
 export interface BundleDeploymentStatus {
   resources?: BundleDeploymentResource[],
   modifiedStatus?: BundleModifiedResource[],
   nonReadyStatus?: BundleNonReadyResource[],
+  appliedDeploymentId?: string,
+  ready: boolean
+  nonModified: boolean
+  conditions: Condition[],
 }
 
 export interface BundleStatusSummary {
@@ -38,3 +47,11 @@ export interface BundleStatus {
   resourceKey?: BundleResourceKey[],
   summary?: BundleStatusSummary,
 }
+
+export interface BundleDeployment {
+  spec: {
+    deploymentId: string,
+    stagedDeploymentId: string,
+  }
+  status?: BundleDeploymentStatus
+}

package/types/shell/index.d.ts

@@ -125,6 +125,8 @@ export namespace FLEET {
     export let CLUSTER_DISPLAY_NAME: string;
     export let CLUSTER_NAME: string;
     export let BUNDLE_ID: string;
+    export let BUNDLE_NAME: string;
+    export let BUNDLE_NAMESPACE: string;
     let MANAGED_1: string;
     export { MANAGED_1 as MANAGED };
     let CLUSTER_NAMESPACE_1: string;
@@ -997,6 +999,9 @@ export namespace LAST_SEEN_TIME {
     export { sort_50 as sort };
     export let tooltip: string;
 }
+export namespace EVENT_LAST_SEEN_TIME {
+    let defaultSort: boolean;
+}
 export namespace LAST_HEARTBEAT_TIME {
     let name_58: string;
     export { name_58 as name };
@@ -2203,6 +2208,21 @@ export const DEPRECATED: "Deprecated";
 export const EXPERIMENTAL: "Experimental";
 }
 
+// @shell/config/version
+
+declare module '@shell/config/version' {
+export function isRancherPrime(): boolean;
+export function getVersionData(): {
+    Version: string;
+    RancherPrime: string;
+    GitCommit: string;
+};
+export function setVersionData(v: any): void;
+export function getKubeVersionData(): {};
+export function setKubeVersionData(v: any): void;
+export const CURRENT_RANCHER_VERSION: "2.10";
+}
+
 // @shell/mixins/create-edit-view/impl
 
 declare module '@shell/mixins/create-edit-view/impl' {
@@ -2402,8 +2422,11 @@ export default class ClusterRepo {
     spec: {
         url: string;
     };
+    get _isClusterRepoDisabled(): boolean;
     get _availableActions(): any;
     refresh(): Promise<void>;
+    disableClusterRepo(): Promise<void>;
+    enableClusterRepo(): Promise<void>;
     get isGit(): boolean;
     get isOciType(): any;
     get isRancherSource(): boolean;
@@ -2429,6 +2452,8 @@ export default class ClusterRepo {
         };
     })[];
     get stateObj(): any;
+    get stateDisplay(): any;
+    get stateBackground(): any;
     waitForOperation(operationId: any, timeout: any, interval?: number): any;
 }
 }
@@ -2816,6 +2841,7 @@ export default class Resource {
     get $dispatch(): any;
     get $state(): any;
     get $rootState(): any;
+    get $plugin(): any;
     get customValidationRules(): any[];
     get _key(): any;
     get schema(): any;
@@ -3117,6 +3143,10 @@ export default class SteveModel extends HybridModel {
     set description(value: any);
     get description(): any;
     _description: any;
+    /**
+     * Get all model extensions for this model
+     */
+    get modelExtensions(): any;
     cleanForSave(data: any, forNew: any): any;
 }
 import HybridModel from './hybrid-class';
@@ -3153,6 +3183,31 @@ export namespace actions {
 }
 }
 
+// @shell/store/plugins
+
+declare module '@shell/store/plugins' {
+export function simplify(key: any): any;
+export function configureCredential(name: any, opt: any): void;
+export function mapDriver(name: any, to: any): void;
+export const rke1Supports: string[];
+export const likelyFields: any[];
+export const iffyFields: any[];
+export const fullFields: any[];
+export const prefixFields: any[];
+export const suffixFields: any[];
+export function state(): {};
+export namespace getters {
+    function credentialOptions(): (name: any) => any;
+    function credentialDriverFor(): (name: any) => any;
+    function credentialFieldForDriver(): (name: any) => any;
+    function clusterDrivers(): any[];
+    function schemaForDriver(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
+    function fieldNamesForDriver(state: any, getters: any): (name: any) => Promise<string[]>;
+    function fieldsForDriver(state: any, getters: any): (name: any) => Promise<{}>;
+    function cloudProviderForDriver(): (name: any) => any;
+}
+}
+
 // @shell/store/prefs
 
 declare module '@shell/store/prefs' {
@@ -3440,6 +3495,8 @@ export function filterHiddenLocalCluster(mgmtClusters: any, store: any): any;
  */
 export function abbreviateClusterName(input: string): string;
 export function labelForAddon(store: any, name: any, configuration?: boolean): any;
+export function filterOutDeprecatedPatchVersions(allVersions: any, currentVersion: any): any;
+export function getAllOptionsAfterCurrentVersion(store: any, versions: any, currentVersion: any, defaultVersion: any): any;
 }
 
 // @shell/utils/color
@@ -4502,6 +4559,10 @@ export function containerImages(spec: any, getters: any, errors: any): void;
 
 declare module '@shell/utils/validators/cron-schedule' {
 export function cronSchedule(schedule: string, getters: any, errors: any): void;
+export namespace cronScheduleRule {
+    function validation(text: any): string;
+    let message: string;
+}
 }
 
 // @shell/utils/validators/flow-output

package/utils/auth.js

@@ -116,7 +116,11 @@ export const checkSchemasForFindAllHash = (types, store) => {
     const validSchema = value.schemaValidator ? value.schemaValidator(schema) : !!schema;
 
     if (validSchema) {
-      hash[key] = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type, opt: value.opt } );
+      const res = store.dispatch(`${ value.inStoreType }/findAll`, { type: value.type, opt: value.opt } );
+
+      if (!value.skipWait) {
+        hash[key] = res;
+      }
     }
   }
 

package/utils/cluster.js

@@ -4,6 +4,8 @@ import { CAPI } from '@shell/config/labels-annotations';
 import { MANAGEMENT, VIRTUAL_HARVESTER_PROVIDER } from '@shell/config/types';
 import { SETTING } from '@shell/config/settings';
 import { PaginationFilterField, PaginationParamFilter } from '@shell/types/store/pagination.types';
+import { compare, sortable } from '@shell/utils/version';
+import { sortBy } from '@shell/utils/sort';
 
 /**
  * Combination of paginationFilterHiddenLocalCluster and paginationFilterOnlyKubernetesClusters
@@ -190,3 +192,107 @@ export function labelForAddon(store, name, configuration = true) {
 
   return store.getters['i18n/withFallback'](key, null, fallback);
 }
+
+function getMostRecentPatchVersions(sortedVersions) {
+  // Get the most recent patch version for each Kubernetes minor version.
+  const versionMap = {};
+
+  sortedVersions.forEach((version) => {
+    const majorMinor = `${ semver.major(version.value) }.${ semver.minor(version.value) }`;
+
+    if (!versionMap[majorMinor]) {
+      // Because we start with a sorted list of versions, we know the
+      // highest patch version is first in the list, so we only keep the
+      // first of each minor version in the list.
+      versionMap[majorMinor] = version.value;
+    }
+  });
+
+  return versionMap;
+}
+
+export function filterOutDeprecatedPatchVersions(allVersions, currentVersion) {
+  // Get the most recent patch version for each Kubernetes minor version.
+  const mostRecentPatchVersions = getMostRecentPatchVersions(allVersions);
+
+  const filteredVersions = allVersions.filter((version) => {
+    // Always show pre-releases
+    if (semver.prerelease(version.value)) {
+      return true;
+    }
+
+    const majorMinor = `${ semver.major(version.value) }.${ semver.minor(version.value) }`;
+
+    // Always show current version, else show if we haven't shown anything for this major.minor version yet
+    if (version.value === currentVersion || mostRecentPatchVersions[majorMinor] === version.value) {
+      return true;
+    }
+
+    return false;
+  });
+
+  return filteredVersions;
+}
+
+export function getAllOptionsAfterCurrentVersion(store, versions, currentVersion, defaultVersion) {
+  const out = (versions || []).filter((obj) => !!obj.serverArgs).map((obj) => {
+    let disabled = false;
+    let experimental = false;
+    let isCurrentVersion = false;
+    let label = obj.id;
+
+    if (currentVersion) {
+      disabled = compare(obj.id, currentVersion) < 0;
+      isCurrentVersion = compare(obj.id, currentVersion) === 0;
+    }
+
+    if (defaultVersion) {
+      experimental = compare(defaultVersion, obj.id) < 0;
+    }
+
+    if (isCurrentVersion) {
+      label = `${ label } ${ store.getters['i18n/t']('cluster.kubernetesVersion.current') }`;
+    }
+
+    if (experimental) {
+      label = `${ label } ${ store.getters['i18n/t']('cluster.kubernetesVersion.experimental') }`;
+    }
+
+    return {
+      label,
+      value:      obj.id,
+      sort:       sortable(obj.id),
+      serverArgs: obj.serverArgs,
+      agentArgs:  obj.agentArgs,
+      charts:     obj.charts,
+      disabled,
+    };
+  });
+
+  if (currentVersion && !out.find((obj) => obj.value === currentVersion)) {
+    out.push({
+      label: `${ currentVersion } ${ store.getters['i18n/t']('cluster.kubernetesVersion.current') }`,
+      value: currentVersion,
+      sort:  sortable(currentVersion),
+    });
+  }
+
+  const sorted = sortBy(out, 'sort:desc');
+
+  const mostRecentPatchVersions = getMostRecentPatchVersions(sorted);
+
+  const sortedWithDeprecatedLabel = sorted.map((optionData) => {
+    const majorMinor = `${ semver.major(optionData.value) }.${ semver.minor(optionData.value) }`;
+
+    if (mostRecentPatchVersions[majorMinor] === optionData.value) {
+      return optionData;
+    }
+
+    return {
+      ...optionData,
+      label: `${ optionData.label } ${ store.getters['i18n/t']('cluster.kubernetesVersion.deprecated') }`
+    };
+  });
+
+  return sortedWithDeprecatedLabel;
+}

package/utils/fleet.ts

@@ -1,11 +1,13 @@
 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_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { FLEET as FLEET_LABELS } from '@shell/config/labels-annotations';
 
 interface Resource extends BundleDeploymentResource {
   state: string,
@@ -28,6 +30,14 @@ function resourceKey(r: BundleResourceKey): string {
   return `${ r.kind }/${ r.namespace }/${ r.name }`;
 }
 
+function conditionIsTrue(conditions: Condition[] | undefined, type: string): boolean {
+  if (!conditions) {
+    return false;
+  }
+
+  return !!conditions.find((c) => c.type === type && c.status.toLowerCase() === 'true');
+}
+
 class Fleet {
   resourceId(r: BundleResourceKey): string {
     return r.namespace ? `${ r.namespace }/${ r.name }` : r.name;
@@ -147,11 +157,33 @@ class Fleet {
   }
 
   clusterIdFromBundleDeploymentLabels(labels?: Labels): string {
-    const clusterNamespace = labels?.[FLEET_ANNOTATIONS.CLUSTER_NAMESPACE];
-    const clusterName = labels?.[FLEET_ANNOTATIONS.CLUSTER];
+    const clusterNamespace = labels?.[FLEET_LABELS.CLUSTER_NAMESPACE];
+    const clusterName = labels?.[FLEET_LABELS.CLUSTER];
 
     return `${ clusterNamespace }/${ clusterName }`;
   }
+
+  bundleIdFromBundleDeploymentLabels(labels?: Labels): string {
+    const bundleNamespace = labels?.[FLEET_LABELS.BUNDLE_NAMESPACE];
+    const bundleName = labels?.[FLEET_LABELS.BUNDLE_NAME];
+
+    return `${ bundleNamespace }/${ bundleName }`;
+  }
+
+  bundleDeploymentState(bd: BundleDeployment): string {
+    // Ported from https://github.com/rancher/fleet/blob/534dbfdd6f74caf97bccd4cf977e42c5009b2432/internal/cmd/controller/summary/summary.go#L89
+    if (bd.status?.appliedDeploymentId !== bd.spec.deploymentId) {
+      return conditionIsTrue(bd.status?.conditions, 'Deployed') ? STATES_ENUM.WAIT_APPLIED : STATES_ENUM.ERR_APPLIED;
+    } else if (!bd.status?.ready) {
+      return STATES_ENUM.NOT_READY;
+    } else if (bd.spec.deploymentId !== bd.spec.stagedDeploymentId) {
+      return STATES_ENUM.OUT_OF_SYNC;
+    } else if (!bd.status?.nonModified) {
+      return STATES_ENUM.MODIFIED;
+    } else {
+      return STATES_ENUM.READY;
+    }
+  }
 }
 
 const instance = new Fleet();

package/utils/ingress.ts

@@ -0,0 +1,64 @@
+import { SECRET, SERVICE } from '@shell/config/types';
+import { SECRET_TYPES as TYPES } from '@shell/config/secret';
+import { VuexStore } from '@shell/types/store/vuex';
+
+/**
+ * Helper class for common functionality shared between the detail and edit ingress pages
+ *
+ * This could be an untyped mixin.. but this setups up us better for the future
+ */
+class IngressDetailEditHelper {
+  private $store: VuexStore;
+  private namespace: string;
+
+  constructor({
+    $store,
+    namespace,
+  }: {
+    $store: VuexStore
+    namespace: string,
+  }) {
+    this.$store = $store;
+    this.namespace = namespace;
+  }
+
+  /**
+   * Fetch services that will either be used to show
+   * - Create - the possible rule's target service
+   * - Edit - the selected and possible rule's target service
+   * - Detail - the selected rule's target service
+   */
+  async fetchServices(args?: { namespace: string}): Promise<any[]> {
+    return this.$store.dispatch('cluster/findAll', { type: SERVICE, opt: { namespaced: args?.namespace || this.namespace } });
+  }
+
+  /**
+   * Fetch secrets that will either be used to show
+   * - Create - the possible secrets to use as a certificates
+   * - Edit - the selected and possible secrets to use as a certificates
+   * - Detail - the selected secrets to use as certificates
+   */
+  async fetchSecrets(args?: { namespace: string}): Promise<any[]> {
+    return this.$store.dispatch('cluster/findAll', { type: SECRET, opt: { namespaced: args?.namespace || this.namespace } });
+  }
+
+  findAndMapCerts(secrets: any[]) {
+    return secrets
+      .filter((secret) => secret._type === TYPES.TLS)
+      .map((secret) => {
+        const { id } = secret;
+
+        return id.slice(id.indexOf('/') + 1);
+      });
+  }
+
+  findAndMapServiceTargets(services: any[]) {
+    return services.map((service) => ({
+      label: service.metadata.name,
+      value: service.metadata.name,
+      ports: service.spec.ports?.map((p: any) => p.port)
+    }));
+  }
+}
+
+export default IngressDetailEditHelper;

package/utils/uiplugins.ts

@@ -1,3 +1,4 @@
+import { matchesSomeRegex } from '@shell/utils/string';
 import { CATALOG as CATALOG_ANNOTATIONS } from '@shell/config/labels-annotations';
 import { CATALOG } from '@shell/config/types';
 import { UI_PLUGIN_BASE_URL, isSupportedChartVersion } from '@shell/config/uiplugins';
@@ -158,37 +159,56 @@ export async function installHelmChart(repo: any, chart: any, values: any = {},
 }
 
 /**
- * Get the Helm repository object
  *
  * @param store Vue store
- * @param url The url of the Helm repository
- * @param branch The branch of the Helm repository
+ * @param url Repository Url
  * @returns HelmRepository
  */
-export async function getHelmRepository(store: any, url: string, branch?: string): Promise<HelmRepository> {
+export async function getHelmRepositoryExact(store: any, url: string): Promise<HelmRepository> {
+  return await getHelmRepository(store, (repository: any) => {
+    const target = repository.spec?.gitRepo || repository.spec?.url;
+
+    return target === url;
+  });
+}
+
+/**
+ *
+ * @param store Vue store
+ * @param urlRegexes Regex to match a community repository
+ * @returns HelmRepository
+ */
+export async function getHelmRepositoryMatch(store: any, urlRegexes: string[]): Promise<HelmRepository> {
+  return await getHelmRepository(store, (repository: any) => {
+    const target = repository.spec?.gitBranch ? repository.spec?.gitRepo : repository.spec?.url;
+
+    return matchesSomeRegex(target, urlRegexes);
+  });
+}
+
+/**
+ *
+ * @param store Vue store
+ * @param matchFn Match function for repository's urls
+ * @returns HelmRepository
+ */
+async function getHelmRepository(store: any, matchFn: (repository: any) => boolean): Promise<HelmRepository> {
   if (store.getters['management/schemaFor'](CATALOG.CLUSTER_REPO)) {
     const repos = await store.dispatch('management/findAll', { type: CATALOG.CLUSTER_REPO, opt: { force: true, watch: false } });
 
-    return repos.find((r: any) => {
-      const target = branch ? r.spec?.gitRepo : r.spec?.url ;
-
-      return target === url;
-    });
+    return repos.find(matchFn);
   } else {
     throw new Error('No permissions');
   }
 }
 
 /**
- * Refresh the Helm repository
- * Ensures that we find the latest extension versions
  *
  * @param store Vue store
- * @param gitRepo Extension Repository url
- * @param gitBranch Extension Repository branch
+ * @param url Repository Url
  */
-export async function refreshHelmRepository(store: any, gitRepo: string, gitBranch: string): Promise<void> {
-  const repository = await getHelmRepository(store, gitRepo, gitBranch);
+export async function refreshHelmRepository(store: any, url: string): Promise<void> {
+  const repository = await getHelmRepositoryExact(store, url);
 
   const now = (new Date()).toISOString().replace(/\.\d+Z$/, 'Z');
 
@@ -202,40 +222,32 @@ export async function refreshHelmRepository(store: any, gitRepo: string, gitBran
 }
 
 /**
- * Ensure the required Helm Repository exits, if it does not, add it with the specified name
- *
- * Wait until the newly added repository has been downloaded
  *
  * @param store Vue store
- * @param url The url of the Helm repository
- * @param name The name of the cluster repository
- * @param branch The branch of the Helm repository
- * @returns HelmRepository object
+ * @param name Repository name
+ * @param url Repository Url
+ * @param branch Repository Branch
+ * @returns HelmRepository
  */
-export async function ensureHelmRepository(store: any, url: string, name: string, branch?: string): Promise<HelmRepository> {
-  let helmRepo = await getHelmRepository(store, url, branch);
-
-  // Add the Helm repository, if it is not there
-  if (!helmRepo) {
-    const data = {
-      type:     CATALOG.CLUSTER_REPO,
-      metadata: { name },
-      spec:     {} as any
-    };
-
-    if (branch) {
-      data.spec.gitBranch = branch;
-      data.spec.gitRepo = url;
-    } else {
-      data.spec.url = url;
-    }
-
-    // Create a model for the new repository and save it
-    const repo = await store.dispatch('management/create', data);
+export async function createHelmRepository(store: any, name: string, url: string, branch?: string): Promise<HelmRepository> {
+  const data = {
+    type:     CATALOG.CLUSTER_REPO,
+    metadata: { name },
+    spec:     {} as any
+  };
 
-    helmRepo = await repo.save();
+  if (branch) {
+    data.spec.gitBranch = branch;
+    data.spec.gitRepo = url;
+  } else {
+    data.spec.url = url;
   }
 
+  // Create a model for the new repository and save it
+  const repo = await store.dispatch('management/create', data);
+
+  const helmRepo = await repo.save();
+
   // Poll the repository until it says it has been downloaded
   let fetched = false;
   let tries = 0;
@@ -278,7 +290,7 @@ export async function ensureHelmRepository(store: any, url: string, name: string
  * Get the given Helm Chart from the specified Helm Repository
  *
  * @param store Vue store
- * @param repository Helm Repository
+ * @param repository Repository Url
  * @param chartName Helm Chart name
  * @returns Helm Chart
  */

package/utils/validators/cron-schedule.js

@@ -2,8 +2,13 @@ import cronstrue from 'cronstrue';
 
 export function cronSchedule(schedule = '', getters, errors) {
   try {
-    cronstrue.toString(schedule, { verbose: true });
+    cronScheduleRule.validation(schedule);
   } catch (e) {
-    errors.push(getters['i18n/t']('validation.invalidCron'));
+    errors.push(getters['i18n/t'](cronScheduleRule.message));
   }
 }
+
+export const cronScheduleRule = {
+  validation: (text) => cronstrue.toString(text, { verbose: true }),
+  message:    'validation.invalidCron'
+};