@rancher/shell 0.2.5 → 0.3.1

package/plugins/steve/getters.js

@@ -6,6 +6,8 @@ import { NAMESPACE, SCHEMA, COUNT, UI } from '@shell/config/types';
 import SteveModel from './steve-class';
 import HybridModel, { cleanHybridResources } from './hybrid-class';
 import NormanModel from './norman-class';
+import { urlFor } from '@shell/plugins/dashboard-store/getters';
+import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
 
 export const STEVE_MODEL_TYPES = {
   NORMAN:  'norman',
@@ -67,6 +69,20 @@ export default {
     return url;
   },
 
+  urlFor: (state, getters) => (type, id, opt) => {
+    let url = urlFor(state, getters)(type, id, opt);
+
+    if (opt.namespaced) {
+      const parts = url.split('/');
+
+      url = `${ parts.join('/') }/${ opt.namespaced }`;
+
+      return url;
+    }
+
+    return url;
+  },
+
   defaultModel: state => (obj) => {
     const which = state.config.modelBaseClass || STEVE_MODEL_TYPES.BY_TYPE.STEVE;
 
@@ -106,6 +122,21 @@ export default {
   },
 
   cleanResource: () => (existing, data) => {
+    /**
+   * Resource counts are contained within a single 'count' resource with a 'counts' field that is a map of resource types
+   * When counts are updated through the websocket, only the resources that changed are sent so we can't load the new 'count' resource into the store as we would another resource
+   */
+    if (data?.type === COUNT && existing) {
+      data.counts = { ...existing.counts, ...data.counts };
+
+      return data;
+    }
+
+    // If the existing model has a cleanResource method, use it
+    if (existing?.cleanResource && typeof existing.cleanResource === 'function') {
+      return existing.cleanResource(data);
+    }
+
     const typeSuperClass = Object.getPrototypeOf(Object.getPrototypeOf(existing))?.constructor;
 
     return typeSuperClass === HybridModel ? cleanHybridResources(data) : data;
@@ -120,6 +151,18 @@ export default {
 
   gcIgnoreTypes: () => {
     return GC_IGNORE_TYPES;
-  }
+  },
+
+  currentGeneration: state => (type) => {
+    type = normalizeType(type);
+
+    const cache = state.types[type];
+
+    if ( !cache ) {
+      return null;
+    }
+
+    return cache.generation;
+  },
 
 };

package/plugins/steve/mutations.js

@@ -1,15 +1,18 @@
-import { addObject, removeObject } from '@shell/utils/array';
+import { addObject } from '@shell/utils/array';
 import { NAMESPACE, POD, SCHEMA } from '@shell/config/types';
 import {
   forgetType,
   resetStore,
   loadAll,
   load,
-  remove
+  remove,
+  batchChanges,
+  replace
 } from '@shell/plugins/dashboard-store/mutations';
-import { keyForSubscribe } from '@shell/plugins/steve/subscribe';
+import { keyForSubscribe } from '@shell/plugins/steve/resourceWatcher';
 import { perfLoadAll } from '@shell/plugins/steve/performanceTesting';
 import Vue from 'vue';
+import { classify } from '@shell/plugins/dashboard-store/classify';
 
 function registerNamespace(state, namespace) {
   let cache = state.podsByNamespace[namespace];
@@ -26,12 +29,99 @@ function registerNamespace(state, namespace) {
   return cache;
 }
 
+/**
+ * update the podsByNamespace cache with new or changed pods
+ */
+function updatePodsByNamespaceCache(state, ctx, pods, loadAll) {
+  if (loadAll) {
+    // Clear the entire cache - this is a fresh load
+    Object.keys(state.podsByNamespace).forEach((ns) => {
+      delete state.podsByNamespace[ns];
+    });
+  }
+
+  // Go through all of the pods and populate cache by namespace
+  pods.forEach((entry) => {
+    const classyResource = state.types[POD].map.get(entry.id) || classify(ctx, entry);
+
+    const cache = registerNamespace(state, classyResource.namespace); // Raw entry.namespace doesn't exist, so use classy
+    const existing = cache.map.get(entry.id);
+
+    if (existing) {
+      // CANNOT BE THE SAME REFERENCE
+      replace(existing, entry);
+    } else {
+      addObject(cache.list, classyResource);
+      cache.map.set(entry.id, classyResource);
+    }
+  });
+}
+
+/**
+ * clean the podsByNamespace cache of removed pods
+ */
+function cleanPodsByNamespaceCache(state, resource) {
+  if (resource && resource.type === POD) {
+    const cache = state.podsByNamespace[resource.namespace];
+
+    // Extra defensive check that the cache exists for the namespace being removed
+    if (cache) {
+      const inList = cache.list.findIndex(p => p.id === resource.id);
+
+      if ( inList >= 0 ) {
+        cache.list.splice(inList, 1);
+      }
+      cache.map.delete(resource.id);
+    }
+  } else if (resource && resource.type === NAMESPACE) {
+    // Namespace deleted
+    delete state.podsByNamespace[resource.id];
+  }
+}
+
 export default {
+  batchChanges(state, { ctx, batch }) {
+    batchChanges(state, { ctx, batch });
+
+    if (batch[POD]) {
+      const newAndChangedPods = Object.entries(batch[POD]).reduce((pods, [id, pod]) => {
+        if (pod.id) {
+          // resource.create and resource.change
+          pods.push(pod);// must NOT be same reference from store
+        } else {
+          // resource.remove (note - we've already lost the resource in the store, so pass through mocked one)
+          cleanPodsByNamespaceCache(state, {
+            id,
+            type:      POD,
+            namespace: id.substring(0, id.indexOf('/'))
+          });
+        }
+
+        return pods;
+      }, []);
+
+      updatePodsByNamespaceCache(state, ctx, newAndChangedPods, false);
+    }
+
+    if (batch[NAMESPACE]) {
+      Object.entries(batch[NAMESPACE]).forEach(([id, namespace]) => {
+        if (!namespace.id) {
+          // resource.remove (note - we've already lost the resource in the store, so pass through mocked one)
+          cleanPodsByNamespaceCache(state, {
+            id,
+            type: NAMESPACE,
+          });
+        }
+      });
+    }
+  },
+
   loadAll(state, {
     type,
     data,
     ctx,
-    skipHaveAll
+    skipHaveAll,
+    namespace
   }) {
     // Performance testing in dev and when env var is set
     if (process.env.dev && !!process.env.perfTest) {
@@ -39,23 +129,12 @@ export default {
     }
 
     const proxies = loadAll(state, {
-      type, data, ctx, skipHaveAll
+      type, data, ctx, skipHaveAll, namespace
     });
 
     // If we loaded a set of pods, then update the podsByNamespace cache
     if (type === POD) {
-      // Clear the entire cache - this is a fresh load
-      Object.keys(state.podsByNamespace).forEach((ns) => {
-        delete state.podsByNamespace[ns];
-      });
-
-      // Go through all of the pods and populate cache by namespace
-      proxies.forEach((entry) => {
-        const cache = registerNamespace(state, entry.namespace);
-
-        addObject(cache.list, entry);
-        cache.map.set(entry.id, entry);
-      });
+      updatePodsByNamespaceCache(state, ctx, proxies, true);
     }
 
     // Notify the web worker of the initial load of schemas
@@ -83,13 +162,6 @@ export default {
     state.podsByNamespace = {};
   },
 
-  clearFromQueue(state, type) {
-    // Remove anything in the queue that is a resource update for the given type
-    state.queue = state.queue.filter((item) => {
-      return item.body?.type !== type;
-    });
-  },
-
   loadMulti(state, { data, ctx }) {
     for (const entry of data) {
       const resource = load(state, { data: entry, ctx });
@@ -106,17 +178,6 @@ export default {
   remove(state, obj) {
     remove(state, obj, this.getters);
 
-    if (obj && obj.type === POD) {
-      const cache = state.podsByNamespace[obj.namespace];
-
-      // Extra defensive check that the cache exists for the namespace being removed
-      if (cache) {
-        removeObject(cache.list, obj);
-        cache.map.delete(obj.id);
-      }
-    } else if (obj && obj.type === NAMESPACE) {
-      // Namespace deleted
-      delete state.podsByNamespace[obj.namespace];
-    }
+    cleanPodsByNamespaceCache(state, obj);
   }
 };

package/plugins/steve/resourceWatcher.js

@@ -0,0 +1,277 @@
+/**
+ * Imports in a worker cannot include exports from the file invoking the worker or from files importing the invoking file.
+ */
+
+import Socket, {
+  NO_WATCH,
+  NO_SCHEMA,
+  EVENT_MESSAGE,
+  EVENT_CONNECTED,
+} from '@shell/utils/socket';
+import { addParam } from '@shell/utils/url';
+
+export const WATCH_STATUSES = {
+  /**
+   * watch has been asked for this resource but not request has not successfully been sent
+   */
+  WATCH_PENDING:    'pending',
+  /**
+   * requested but not confirmed by the socket yet
+   */
+  WATCH_REQUESTED:  'requested',
+  /**
+   * confirmed as active by the socket
+   */
+  WATCHING:         'watching',
+  /**
+   * temporarily stopped via message from the socket, a watch should immediately be triggered but the maintenance cycle will pick it up if that doesn't happen.
+   */
+  STOPPED:          'stopped',
+  /**
+   * stop has been asked for this resource, but request has not successfully been sent
+   */
+  REMOVE_PENDING:   'removed_pending',
+  /**
+   * stop request has been sent to the socket or it's been stopped by the socket itself and is now awaiting a resource.stop message
+   */
+  REMOVE_REQUESTED: 'removed_requested'
+};
+
+export const keyForSubscribe = ({
+  resourceType, type, namespace, id, selector
+} = {}) => {
+  return [(resourceType || type), namespace, id, selector] // each watch param in an array
+    .filter(param => !!param) // filter out all the empty ones // the filter makes these keys neater
+    .join('/'); // join into a string so we can use it as an object key
+};
+
+export const watchKeyFromMessage = (msg) => {
+  const {
+    resourceType,
+    namespace,
+    id,
+    selector
+  } = msg;
+
+  const watchObject = {
+    resourceType,
+    id,
+    namespace,
+    selector
+  };
+
+  return keyForSubscribe(watchObject);
+};
+
+const {
+  WATCH_PENDING, WATCH_REQUESTED, WATCHING, STOPPED, REMOVE_PENDING, REQUESTED_REMOVE
+} = WATCH_STATUSES;
+
+export default class ResourceWatcher extends Socket {
+  watches = {};
+  status = '';
+  debugWatcher = false;
+  csrf;
+
+  constructor(url, autoReconnect = true, frameTimeout = null, protocol = null, maxTries = null, csrf) {
+    super(url, autoReconnect, frameTimeout, protocol, maxTries, true);
+    this.baseUrl = self.location.origin + url.replace('subscribe', '');
+    this.csrf = csrf;
+
+    this.addEventListener(EVENT_CONNECTED, (e) => {
+      this.trace(EVENT_CONNECTED, ': processing previously requested or watched resources');
+
+      Object.values(this.watches).forEach((watch) => {
+        const { status, error } = watch;
+        const watchKey = keyForSubscribe(watch);
+
+        if ([WATCH_PENDING, WATCH_REQUESTED, WATCHING].includes(status) && !error) {
+          this.trace(EVENT_CONNECTED, ': re-watching previously required resource', watchKey, status);
+          this.watches[watchKey].status = WATCH_PENDING;
+          this.watch(watchKey);
+        } else if ([REMOVE_PENDING].includes(status)) {
+          this.trace(EVENT_CONNECTED, ': un-watching previously watched resource', watchKey, status);
+          this.watches[watchKey].status = REMOVE_PENDING;
+          this.unwatch(watchKey);
+        }
+      });
+    });
+  }
+
+  trace(...args) {
+    this.debugWatcher && console.info('Resource Watcher:', ...args); // eslint-disable-line no-console
+  }
+
+  setDebug(on) {
+    this.debugWatcher = !!on;
+  }
+
+  watchExists(watchKey) {
+    return !!this.watches?.[watchKey];
+  }
+
+  async watch(watchKey, providedResourceVersion, providedResourceVersionTime, providedKeyParts = {}, providedSkipResourceVersion) {
+    const {
+      resourceType: providedResourceType,
+      id: providedId,
+      namespace: providedNamespace,
+      selector: providedSelector
+    } = providedKeyParts;
+
+    this.trace('watch:', 'requested', watchKey);
+
+    if ([WATCH_REQUESTED, WATCHING].includes(this.watches?.[watchKey]?.status)) {
+      this.trace('watch:', 'already requested or watching, aborting', watchKey);
+
+      return;
+    }
+
+    if (this.watches?.[watchKey]?.error) {
+      this.trace('watch:', 'in error, aborting', watchKey);
+
+      return;
+    }
+
+    const resourceType = providedResourceType || this.watches?.[watchKey]?.resourceType;
+    const id = providedId || this.watches?.[watchKey]?.id;
+    const namespace = providedNamespace || this.watches?.[watchKey]?.namespace;
+    const selector = providedSelector || this.watches?.[watchKey]?.selector;
+    let skipResourceVersion = this.watches?.[watchKey]?.skipResourceVersion || providedSkipResourceVersion;
+
+    const watchObject = {
+      resourceType,
+      id,
+      namespace,
+      selector
+    };
+
+    let resourceVersionTime = providedResourceVersionTime || this.watches?.[watchKey]?.resourceVersionTime;
+    let resourceVersion = providedResourceVersion || this.watches?.[watchKey]?.resourceVersion;
+
+    if (!skipResourceVersion && (!resourceVersion || Date.now() - resourceVersionTime > 300000)) { // 300000ms is 5minutes
+      this.trace('watch:', 'revision update required', watchKey);
+
+      const resourceUrl = this.baseUrl + resourceType;
+      const limitedResourceUrl = addParam(resourceUrl, 'limit', 1);
+      const opt = {
+        method:  'get',
+        headers: { accept: 'application/json' },
+      };
+
+      if (this.csrf) {
+        opt.headers['x-api-csrf'] = this.csrf;
+      }
+
+      await fetch(limitedResourceUrl, opt)
+        .then((res) => {
+          this.watches[watchKey] = { ...watchObject };
+          if (!res.ok) {
+            this.watches[watchKey].error = res.json();
+            console.warn(`Resource error retrieving resourceVersion`, resourceType, ':', res.json()); // eslint-disable-line no-console
+          } else {
+            this.watches[watchKey].error = undefined;
+          }
+
+          return res.json();
+        })
+        .then((res) => {
+          if (res.revision) {
+            resourceVersionTime = Date.now();
+            resourceVersion = res.revision;
+          } else if (!this.watches[watchKey].error) {
+            // if there wasn't a revision in the response and there wasn't an error we wrote to the watch then the resource doesn't get a revision and we can skip it on subsequent rewatches
+            skipResourceVersion = true;
+          }
+        });
+      // When this fails we should re-fetch all resources (aka same as resyncWatch, or we actually call it). #7917
+      // This would match the old approach
+    }
+
+    const success = this.send(JSON.stringify({
+      ...watchObject,
+      resourceVersion: !skipResourceVersion ? resourceVersion : undefined
+    }));
+
+    this.watches[watchKey] = {
+      ...watchObject,
+      status: success ? WATCH_STATUSES.WATCH_REQUESTED : WATCH_STATUSES.WATCH_PENDING,
+      resourceVersion,
+      resourceVersionTime,
+      skipResourceVersion
+    };
+  }
+
+  unwatch(watchKey) {
+    const watch = this.watches?.[watchKey] || {};
+    const {
+      resourceType, id, namespace, selector
+    } = watch;
+    const watchObject = {
+      resourceType,
+      id,
+      namespace,
+      selector
+    };
+
+    if (resourceType && this.watches[watchKey].status !== REQUESTED_REMOVE) {
+      const success = this.send(JSON.stringify({
+        ...watchObject,
+        stop: true
+      }));
+
+      this.watches[watchKey].status = success ? REQUESTED_REMOVE : REMOVE_PENDING;
+    }
+  }
+
+  /**
+   * Handles message from Backend to UI
+   */
+  _onmessage(event) {
+    const {
+      name: eventName, resourceType, data: { type }, id, namespace, selector, data
+    } = JSON.parse(event.data);
+    const watchKey = keyForSubscribe({
+      resourceType,
+      type,
+      id,
+      namespace,
+      selector
+    });
+
+    if (eventName === 'resource.start' && this.watches?.[watchKey]?.status === WATCH_REQUESTED) {
+      this.watches[watchKey].status = WATCHING;
+    } else if (eventName === 'resource.stop' && this.watches?.[watchKey]) {
+      if (this.watches?.[watchKey]?.status === REQUESTED_REMOVE) {
+        delete this.watches[watchKey];
+      } else {
+        this.watches[watchKey].status = STOPPED;
+        delete this.watches[watchKey].resourceVersion;
+        delete this.watches[watchKey].resourceVersionTime;
+        this.watch(watchKey);
+        this.dispatchEvent(new CustomEvent(EVENT_MESSAGE, { detail: event }));
+      }
+    } else if (eventName === 'resource.error') {
+      const err = data?.error?.toLowerCase();
+
+      if ( this.watches[watchKey] && err.includes('watch not allowed') ) {
+        this.watches[watchKey].error = { type: resourceType, reason: NO_WATCH };
+      } else if ( this.watches[watchKey] && err.includes('failed to find schema') ) {
+        // This can happen when the cattle-cluster-agent goes down (redeploy deployment, kill pod, etc)
+        // The previous method was just to track the error and block any further attempts to watch (canWatch)
+        // This method means we can retry on the next findX (should be safe, unless there are other use cases...)
+
+        this.watches[watchKey].error = { type: resourceType, reason: NO_SCHEMA };
+      } else if ( err.includes('too old') ) {
+        // We don't actually know the gap between the requested revision and the oldest available revision.
+        // For this case we should re-fetch all resources (aka same as resyncWatch, or we actually call it). #7917
+        // This would match the old approach
+        delete this.watches[watchKey].resourceVersion;
+        delete this.watches[watchKey].resourceVersionTime;
+        delete this.watches[watchKey].skipResourceVersion;
+        this.watch(watchKey);
+      }
+    }
+
+    super._onmessage(event);
+  }
+}

package/plugins/steve/schema.utils.js

@@ -0,0 +1,25 @@
+import { normalizeType } from '@shell/plugins/dashboard-store/normalize';
+
+/**
+ * Inject special fields for indexing schemas
+ *
+ * Note
+ * This mutates input in a function, which is bad...
+ * but ensures the reference isn't broken, which is needed to maintain similar functionality as before
+ */
+export function addSchemaIndexFields(schema) {
+  schema._id = normalizeType(schema.id);
+  schema._group = normalizeType(schema.attributes?.group);
+}
+
+/**
+ * Remove special fields for indexing schemas
+ *
+ * Note
+ * This mutates input in a function, which is bad...
+ * but ensures the reference isn't broken, which is needed to maintain similar functionality as before
+ */
+export function removeSchemaIndexFields(schema) {
+  delete schema._id;
+  delete schema._group;
+}