@rancher/shell 3.0.8 → 3.0.9-rc.2

package/utils/dynamic-content/new-release.ts

@@ -17,6 +17,7 @@ import { NotificationLevel } from '@shell/types/notifications';
 import { READ_NEW_RELEASE } from '@shell/store/prefs';
 import { Context, ReleaseInfo, VersionInfo } from './types';
 import { removeMatchingNotifications } from './util';
+import { getReleaseNotesURL } from '@shell/utils/version';
 
 export async function processReleaseVersion(context: Context, releaseInfo: ReleaseInfo[] | undefined, versionInfo: VersionInfo) {
   if (!releaseInfo || !versionInfo?.version || !Array.isArray(releaseInfo)) {
@@ -55,7 +56,8 @@ export async function processReleaseVersion(context: Context, releaseInfo: Relea
 
 async function addNewReleaseNotification(context: Context, version: string) {
   const prefix = 'new-release-';
-  const releaseNotesUrl = context.settings.releaseNotesUrl.replace('$version', version);
+  const releaseNotesUrl = getReleaseNotesURL(context.config.prime, version);
+
   const { dispatch, getters, logger } = context;
 
   // TODO: Get the preference
@@ -89,8 +91,8 @@ async function addNewReleaseNotification(context: Context, version: string) {
 async function addNewMultipleReleasesNotification(context: Context, version1: string, version2: string) {
   const prefix = 'new-release-';
   const key = `${ version1 }-${ version2 }`;
-  const releaseNotesUrl1 = context.settings.releaseNotesUrl.replace('$version', version1);
-  const releaseNotesUrl2 = context.settings.releaseNotesUrl.replace('$version', version2);
+  const releaseNotesUrl1 = getReleaseNotesURL(context.config.prime, version1);
+  const releaseNotesUrl2 = getReleaseNotesURL(context.config.prime, version2);
   const { dispatch, getters, logger } = context;
 
   // TODO: Get the preference

package/utils/dynamic-content/types.d.ts

@@ -34,7 +34,6 @@ export type Configuration = {
  * Settings configuration that can be supplied in the dynamic content package
  */
 export type SettingsInfo = {
-  releaseNotesUrl: string; // URL format to use when generating release note links for new releases
   suseExtensions: string[]; // Names of extra SUSE UI extensions on top of the list built-in
   debugVersion?: string;
 };

package/utils/error.js

@@ -1,4 +1,5 @@
 import { isArray } from '@shell/utils/array';
+const AWS_SDK_UNHANDLED_ERROR = 'Deserialization error:';
 
 export class ClusterNotFoundError extends Error {
   static NAME = 'ClusterNotFoundError'
@@ -129,3 +130,11 @@ export const normalizeError = (err) => {
     statusCode: (err.statusCode || err.status || (err.response && err.response.status) || 500)
   };
 };
+
+export const formatAWSError = (err) => {
+  if (err instanceof TypeError && err.message.includes(AWS_SDK_UNHANDLED_ERROR)) {
+    return err.$response.reason;
+  }
+
+  return err;
+};

package/utils/fleet.ts

@@ -64,11 +64,11 @@ class Application {
         clusterGroupSelector,
       } = target;
 
-      if (clusterGroup || clusterGroupSelector) {
+      if (clusterGroupSelector) {
         return 'advanced';
       }
 
-      if (clusterName) {
+      if (clusterName || clusterGroup) {
         mode = 'clusters';
       }
 

package/utils/inactivity.ts

@@ -1,8 +1,7 @@
 import { EXT } from '@shell/config/types';
-import { RancherKubeMetadata } from '@shell/types/kube/kube-api';
+import { SteveGetResponse } from '@shell/types/rancher/steve.api';
 
-interface UserActivityResponse {
-  metadata: RancherKubeMetadata,
+interface UserActivityResponse extends SteveGetResponse {
   status: {
     expiresAt: string
   }

package/utils/pagination-wrapper.ts

@@ -1,10 +1,13 @@
 import paginationUtils from '@shell/utils/pagination-utils';
 import { PaginationArgs, PaginationResourceContext } from '@shell/types/store/pagination.types';
 import { VuexStore } from '@shell/types/store/vuex';
-import { ActionFindPageArgs, ActionFindPageTransientResult } from '@shell/types/store/dashboard-store.types';
+import { ActionFindPageArgs, ActionFindPageTransientResponse } from '@shell/types/store/dashboard-store.types';
 import { STEVE_WATCH_EVENT_TYPES, STEVE_WATCH_MODE } from '@shell/types/store/subscribe.types';
 import { Reactive, reactive } from 'vue';
 import { STEVE_UNWATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_LISTENER_CALLBACK, STEVE_WATCH_EVENT_PARAMS, STEVE_WATCH_EVENT_PARAMS_COMMON } from '@shell/types/store/subscribe-events.types';
+import backOff from '@shell/utils/back-off';
+import { SteveRevision } from '@shell/plugins/steve/revision';
+import { STEVE_RESPONSE_CODE } from '@shell/types/rancher/steve.api';
 
 interface Args {
   $store: VuexStore,
@@ -30,8 +33,8 @@ interface Args {
   }
 }
 
-interface Result<T> extends Omit<ActionFindPageTransientResult<T>, 'data'> {
-  data: Reactive<T[]>
+interface Result<T> extends Omit<ActionFindPageTransientResponse<T>, 'data'> {
+  data: Reactive<T[]> | T[]
 }
 
 /**
@@ -50,9 +53,12 @@ class PaginationWrapper<T extends object> {
   private $store: VuexStore;
   private enabledFor: PaginationResourceContext;
   private onChange?: STEVE_WATCH_EVENT_LISTENER_CALLBACK;
-  private id: string;
+  public id: string;
+  private backOffId: string;
   private classify: boolean;
   private reactive: boolean;
+  private cachedRevision?: string;
+  private cachedResult?: Result<T>;
 
   public isEnabled: boolean;
   private steveWatchParams: STEVE_WATCH_EVENT_PARAMS_COMMON | undefined;
@@ -64,6 +70,7 @@ class PaginationWrapper<T extends object> {
 
     this.$store = $store;
     this.id = id;
+    this.backOffId = `${ this.id }`;
     this.enabledFor = enabledFor;
     this.onChange = onChange;
     this.classify = formatResponse?.classify || false;
@@ -72,31 +79,106 @@ class PaginationWrapper<T extends object> {
     this.isEnabled = paginationUtils.isEnabled({ rootGetters: $store.getters, $extension: this.$store.$extension }, enabledFor);
   }
 
-  async request({ pagination, forceWatch }: {
+  async request(requestArgs: {
     forceWatch?: boolean,
     pagination: PaginationArgs,
+    revision?: string,
   }): Promise<Result<T>> {
+    const { pagination, forceWatch, revision } = requestArgs;
+    const type = this.enabledFor.resource?.id;
+
     if (!this.isEnabled) {
-      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ this.enabledFor.resource?.id }' in context '${ this.enabledFor.resource?.context }' not supported`);
+      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ type }' in context '${ this.enabledFor.resource?.context }' not supported`);
     }
-    const opt: ActionFindPageArgs = {
-      watch:     false,
-      pagination,
-      transient: true,
-    };
 
-    // Fetch
-    const out: ActionFindPageTransientResult<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type: this.enabledFor.resource?.id });
+    const backOffId = this.backOffId;
+
+    const activeRevisionSt = backOff.getBackOff(backOffId)?.metadata.revision;
+    const cachedRevisionSt = this.cachedRevision;
+
+    const targetRevision = new SteveRevision(revision);
+    const activeRevision = new SteveRevision(activeRevisionSt);
+    const cachedRevision = new SteveRevision(cachedRevisionSt);
+    const currentRevision = new SteveRevision(activeRevisionSt || cachedRevisionSt);
+
+    // Three cases to support HA scenarios 2 + 3
+    // 1. current version is newer than target revision - abort/ignore (don't overwrite new with old)
+    // 2. current version in cache is older than target revision - reset previous (drop older requests with older revision, use new revision)
+    // 3. current version in cache is same as target revision - we're retrying
+
+    // There are two places we do this to cover the two cases we make http request following socket changes
+    // shell/utils/pagination-wrapper.ts - request
+    // shell/plugins/steve/subscribe.js - fetchPageResources
+
+    if (currentRevision.isNewerThan(targetRevision)) {
+      if (activeRevision.isNewerThan(targetRevision)) {
+        // eslint-disable-next-line no-console
+        console.info(`Ignoring event listener request to update '${ this.id }' with revision '${ targetRevision.revision }' (newer in-progress revision '${ activeRevision.revision }'). `);
+
+        // Case 1 - abort/ignore (don't overwrite new with old). Specifically we're fetching something with a higher revision, ignore the newer request with older revision
+        return Promise.reject(new Error('Ignoring current request in favour of other in-progress request with newer revision')); // This will abort the current batch of updates, meaning the other in-progress can update with the newer revision
+      }
+
+      if (cachedRevision.isNewerThan(targetRevision)) {
+        // eslint-disable-next-line no-console
+        console.info(`Ignoring event listener request to update '${ this.id }' with revision '${ targetRevision.revision }' (newer cached revision '${ cachedRevision.revision }'). `);
+
+        // Case 1 - abort/ignore (don't overwrite new with old). Specifically we're already fetched something with a higher revision, ignore the newer request with older revision and just return the cached version
+        if (this.cachedResult) {
+          return this.cachedResult;
+        }
+
+        return Promise.reject(new Error('Cache has higher revision than target revision... but no cached results?'));
+      }
+    }
+
+    if (targetRevision.isNewerThan(activeRevision)) {
+      // Case 2 - reset previous (drop older requests with older revision, use new revision)
+
+      // eslint-disable-next-line no-console
+      console.info(`Dropping event listener request to update '${ this.id }' with revision '${ currentRevision.revision }' (newer target revision '${ targetRevision.revision }'). `);
+
+      backOff.reset(backOffId);
+    }
+
+    // Keep making requests until we make one that succeeds, fails with unknown revision or we run out of retries
+    const out = await backOff.recurse<any, ActionFindPageTransientResponse<T>>({
+      id:              backOffId,
+      metadata:        { revision },
+      description:     `Fetching resources for ${ type } (wrapper). Initial request, or triggered by web socket`,
+      continueOnError: async(err) => {
+        // Have we made a request to a stale replica that does not know about the required revision? If so continue to try until we hit a ripe replica
+        return err?.status === 400 && err?.code === STEVE_RESPONSE_CODE.UNKNOWN_REVISION;
+      },
+      delayedFn: async() => {
+        const opt: ActionFindPageArgs = {
+          watch:     false,
+          pagination,
+          transient: true,
+          revision
+        };
+        const res: ActionFindPageTransientResponse<T> = await this.$store.dispatch(`${ this.enabledFor.store }/findPage`, { opt, type });
+
+        this.cachedRevision = res.pagination?.result.revision;
+
+        return res;
+      },
+    });
+
+    if (!out) {
+      // Skip
+      throw new Error(`Wrapper for type '${ this.enabledFor.store }/${ type }' in context '${ this.enabledFor.resource?.context }' failed to fetch resources`);
+    }
 
     // Watch
     const firstTime = !this.steveWatchParams;
 
-    if (this.onChange && (firstTime || forceWatch) ) { // && !this.steveWatchParams
+    if (this.onChange && (firstTime || forceWatch) ) {
       this.steveWatchParams = {
         event:  STEVE_WATCH_EVENT_TYPES.CHANGES,
         id:     this.id,
         params: {
-          type:  this.enabledFor.resource?.id as string,
+          type:  type as string,
           mode:  STEVE_WATCH_MODE.RESOURCE_CHANGES,
           force: forceWatch,
         },
@@ -112,13 +194,15 @@ class PaginationWrapper<T extends object> {
     }
 
     if (this.reactive) {
-      return {
+      this.cachedResult = {
         ...out,
         data: reactive(out.data)
       };
+    } else {
+      this.cachedResult = out;
     }
 
-    return out;
+    return this.cachedResult;
   }
 
   private async watch() {

package/utils/validators/formRules/index.ts

@@ -270,6 +270,8 @@ export default function(
 
   const containerImage: Validator = (val: any) => !val?.image ? t('workload.validation.containerImage', { name: val.name }) : undefined;
 
+  const localhostProfile: Validator = (val: any) => (val?.securityContext?.seccompProfile?.type === 'Localhost' && !val?.securityContext.seccompProfile?.localhostProfile && !val?.securityContext?.privileged) ? t('workload.validation.localhostProfile', { name: val.name }) : undefined;
+
   const containerImages: Validator = (val: any | [any]) => {
     const containers = val.jobTemplate ? val?.jobTemplate?.spec?.template?.spec?.containers : val?.template?.spec?.containers;
 
@@ -602,6 +604,7 @@ export default function(
     clusterName,
     containerImage,
     containerImages,
+    localhostProfile,
     cronSchedule,
     dnsLabel,
     dnsLabelIanaServiceName,

package/utils/version.js

@@ -141,3 +141,41 @@ export async function markReadReleaseNotes(store) {
     await store.dispatch('prefs/set', { key: READ_WHATS_NEW, value: getVersionInfo(store).fullVersion });
   }
 }
+
+const DEFAULT_RELEASE_NOTES_URLS = {
+  COMMUNITY: {
+    DEV:     'https://github.com/rancher/rancher/releases/latest',
+    RELEASE: 'https://github.com/rancher/rancher/releases/tag/v$VERSION',
+  },
+  PRIME: {
+    DEV:     'https://documentation.suse.com/cloudnative/rancher-manager/latest/en/release-notes.html',
+    RELEASE: 'https://documentation.suse.com/cloudnative/rancher-manager/v$MAJOR_MINOR/en/release-notes/v$VERSION.html',
+  }
+};
+
+/**
+ * Get the release notes URL for a given version
+ *
+ * @param {Get} version s
+ */
+export function getReleaseNotesURL(isPrime, version) {
+  // If version is not specified, return latest community release notes URL
+  if (!version) {
+    return DEFAULT_RELEASE_NOTES_URLS.COMMUNITY.DEV;
+  }
+
+  const vers = version.startsWith('v') ? version.slice(1) : version;
+  const vParts = vers.split('.');
+  let majorMinor = version;
+
+  if (vParts.length > 2) {
+    majorMinor = `${ vParts[0] }.${ vParts[1] }`;
+  }
+
+  const urls = isPrime ? DEFAULT_RELEASE_NOTES_URLS.PRIME : DEFAULT_RELEASE_NOTES_URLS.COMMUNITY;
+  const urlTemplate = isDevBuild(version) ? urls.DEV : urls.RELEASE;
+
+  return urlTemplate
+    .replace('$VERSION', vers)
+    .replace('$MAJOR_MINOR', majorMinor);
+}

package/components/auth/AzureWarning.vue

@@ -1,77 +0,0 @@
-<script>
-// This component will become redundant in 2023, see https://docs.microsoft.com/en-us/graph/migrate-azure-ad-graph-overview
-import { NORMAN, MANAGEMENT } from '@shell/config/types';
-import { get } from '@shell/utils/object';
-import { AZURE_MIGRATED } from '@shell/config/labels-annotations';
-import { BLANK_CLUSTER } from '@shell/store/store-types.js';
-
-export default {
-  async fetch() {
-    // Check for access to steve authConfigs because everyone can load the norman auth config schema
-    if (
-      this.$store.getters['isRancher'] &&
-      this.$store.getters['management/schemaFor'](MANAGEMENT.AUTH_CONFIG)
-    ) {
-      this.authConfig = await this.$store.dispatch('rancher/find', {
-        type: NORMAN.AUTH_CONFIG,
-        id:   'azuread',
-        opt:  { url: `/v3/${ NORMAN.AUTH_CONFIG }/azuread` }
-      });
-    }
-  },
-
-  data() {
-    return {
-      authConfig:      null,
-      authConfigRoute: {
-        name:   'c-cluster-auth-config-id',
-        params: {
-          cluster: this.$route.params.cluster || BLANK_CLUSTER,
-          id:      'azuread'
-        }
-      }
-    };
-  },
-
-  computed: {
-    showWarning() {
-      if (!this.authConfig) {
-        return false;
-      }
-
-      return (
-        get(this.authConfig, `annotations."${ AZURE_MIGRATED }"`) !== 'true' &&
-        this.authConfig.enabled
-      );
-    }
-  }
-};
-</script>
-
-<template>
-  <div
-    v-if="showWarning"
-    id="azure-warn"
-    class="banner"
-  >
-    <p>
-      {{ t('authConfig.azuread.updateEndpoint.banner.message') }}
-      <router-link :to="authConfigRoute">
-        {{ t('authConfig.azuread.updateEndpoint.banner.linkText') }}
-      </router-link>
-    </p>
-  </div>
-</template>
-
-<style lang="scss" scoped>
-#azure-warn {
-  background-color: var(--warning);
-  color: var(--warning-text);
-  line-height: 2em;
-  width: 100%;
-
-  > p {
-    text-align: center;
-  }
-}
-</style>