@rancher/shell 0.3.8 → 0.3.10

package/plugins/codemirror.js

@@ -167,3 +167,161 @@ CodeMirror.registerHelper('fold', 'yamlcomments', (cm, start) => {
     };
   }
 });
+
+/**
+ * It display a dot for each space character in the text;
+ * used in combination with 'as-text-area' css properties in CodeMirror.vue to display line break markdowns
+ */
+CodeMirror.defineOption('showMarkdownLineBreaks', false, (codeMirror) => {
+  codeMirror.addOverlay({
+    name:  'show-markdown-line-breaks',
+    token: (stream) => {
+      if (stream.string[stream.pos].match(/\s/)) {
+        stream.next();
+
+        return stream.pos % 2 === 0 ? 'markdown-single-trailing-space-even' : 'markdown-single-trailing-space-odd';
+      }
+
+      stream.next();
+
+      return null;
+    }
+  });
+});
+
+/**
+ * It enables the text color selection in CodeMirror.vue
+ * references:
+ *   demo:   https://codemirror.net/5/demo/markselection.html#
+ *   add-on: https://codemirror.net/5/doc/manual.html#addon_mark-selection
+ *   source: https://codemirror.net/5/addon/selection/mark-selection.js
+ */
+CodeMirror.defineOption('styleSelectedText', false, (cm, val, old) => {
+  const prev = old && old !== CodeMirror.Init;
+
+  if (val && !prev) {
+    cm.state.markedSelection = [];
+    cm.state.markedSelectionStyle = typeof val === 'string' ? val : 'CodeMirror-selectedtext';
+    reset(cm);
+    cm.on('cursorActivity', onCursorActivity);
+    cm.on('change', onChange);
+  } else if (!val && prev) {
+    cm.off('cursorActivity', onCursorActivity);
+    cm.off('change', onChange);
+    clear(cm);
+    cm.state.markedSelection = cm.state.markedSelectionStyle = null;
+  }
+});
+
+function onCursorActivity(cm) {
+  if (cm.state.markedSelection) {
+    cm.operation(() => {
+      update(cm);
+    });
+  }
+}
+
+function onChange(cm) {
+  if (cm.state.markedSelection && cm.state.markedSelection.length) {
+    cm.operation(() => {
+      clear(cm);
+    });
+  }
+}
+
+const CHUNK_SIZE = 8;
+const Pos = CodeMirror.Pos;
+const cmp = CodeMirror.cmpPos;
+
+function coverRange(cm, from, to, addAt) {
+  if (cmp(from, to) === 0) {
+    return;
+  }
+  const array = cm.state.markedSelection;
+  const cls = cm.state.markedSelectionStyle;
+
+  for (let line = from.line;;) {
+    const start = line === from.line ? from : Pos(line, 0);
+    const endLine = line + CHUNK_SIZE; const atEnd = endLine >= to.line;
+    const end = atEnd ? to : Pos(endLine, 0);
+    const mark = cm.markText(start, end, { className: cls });
+
+    if (addAt === null || addAt === undefined) {
+      array.push(mark);
+    } else {
+      array.splice(addAt++, 0, mark);
+    }
+    if (atEnd) {
+      break;
+    }
+    line = endLine;
+  }
+}
+
+function clear(cm) {
+  const array = cm.state.markedSelection;
+
+  for (let i = 0; i < array.length; ++i) {
+    array[i].clear();
+  }
+  array.length = 0;
+}
+
+function reset(cm) {
+  clear(cm);
+  const ranges = cm.listSelections();
+
+  for (let i = 0; i < ranges.length; i++) {
+    coverRange(cm, ranges[i].from(), ranges[i].to());
+  }
+}
+
+function update(cm) {
+  if (!cm.somethingSelected()) {
+    return clear(cm);
+  }
+  if (cm.listSelections().length > 1) {
+    return reset(cm);
+  }
+
+  const from = cm.getCursor('start'); const to = cm.getCursor('end');
+
+  const array = cm.state.markedSelection;
+
+  if (!array.length) {
+    return coverRange(cm, from, to);
+  }
+
+  let coverStart = array[0].find(); let coverEnd = array[array.length - 1].find();
+
+  if (!coverStart || !coverEnd || to.line - from.line <= CHUNK_SIZE ||
+      cmp(from, coverEnd.to) >= 0 || cmp(to, coverStart.from) <= 0) {
+    return reset(cm);
+  }
+
+  while (cmp(from, coverStart.from) > 0) {
+    array.shift().clear();
+    coverStart = array[0].find();
+  }
+  if (cmp(from, coverStart.from) < 0) {
+    if (coverStart.to.line - from.line < CHUNK_SIZE) {
+      array.shift().clear();
+      coverRange(cm, from, coverStart.to, 0);
+    } else {
+      coverRange(cm, from, coverStart.from, 0);
+    }
+  }
+
+  while (cmp(to, coverEnd.to) < 0) {
+    array.pop().clear();
+    coverEnd = array[array.length - 1].find();
+  }
+  if (cmp(to, coverEnd.to) > 0) {
+    if (to.line - coverEnd.from.line < CHUNK_SIZE) {
+      array.pop().clear();
+      coverRange(cm, coverEnd.from, to);
+    } else {
+      coverRange(cm, coverEnd.to, to);
+    }
+  }
+}

package/plugins/dashboard-store/actions.js

@@ -317,13 +317,15 @@ export default {
 
     // ToDo: SM if we start a "bigger" watch (such as watch without a namespace vs a watch with a namespace), we should stop the stop the "smaller" watch so we don't have duplicate events coming back
     if ( opt.watch !== false ) {
-      dispatch('watch', {
+      const args = {
         type,
         revision:  out.revision,
         namespace: opt.watchNamespace || opt.namespaced, // it could be either apparently
         // ToDo: SM namespaced is sometimes a boolean and sometimes a string, I don't see it as especially broken but we should refactor that in the future
         force:     opt.forceWatch === true,
-      });
+      };
+
+      dispatch('watch', args);
     }
 
     const all = getters.all(type);

package/plugins/dashboard-store/getters.js

@@ -274,6 +274,12 @@ export default {
     return false;
   },
 
+  haveNamespace: (state, getters) => (type) => {
+    type = getters.normalizeType(type);
+
+    return state.types[type]?.haveNamespace || null;
+  },
+
   haveSelector: (state, getters) => (type, selector) => {
     type = getters.normalizeType(type);
     const entry = state.types[type];

package/plugins/dashboard-store/mutations.js

@@ -209,9 +209,9 @@ export function batchChanges(state, { ctx, batch }) {
     const removeAtIndexes = [];
 
     // looping through the batch, executing changes, deferring creates and removes since they change the array length
-    Object.keys(batch[normalizedType]).forEach((id) => {
+    Object.keys(combinedBatch[normalizedType]).forEach((id) => {
       const index = typeCacheIndexMap[id];
-      const resource = batch[normalizedType][id];
+      const resource = combinedBatch[normalizedType][id];
 
       // an empty resource passed into batch changes is how we'll signal which ones to delete
       if (Object.keys(resource).length === 0 && index !== undefined) {

package/plugins/plugin.js

@@ -40,7 +40,12 @@ export default async function(context) {
         });
       }
     } catch (e) {
-      console.error('Could not load UI Plugin list', e); // eslint-disable-line no-console
+      if (e?.code === 404) {
+        // Not found, so extensions operator probably not installed
+        console.log('Could not load UI Extensions list (Extensions Operator may not be installed)'); // eslint-disable-line no-console
+      } else {
+        console.error('Could not load UI Extensions list', e); // eslint-disable-line no-console
+      }
     }
 
     // Load all of the plugins

package/plugins/steve/actions.js

@@ -11,7 +11,7 @@ import jsyaml from 'js-yaml';
 
 export default {
 
-  // Need to override this, so that thhe 'this' context is correct (this class not the base class)
+  // Need to override this, so that the 'this' context is correct (this class not the base class)
   async loadSchemas(ctx, watch = true) {
     return await loadSchemas(ctx, watch);
   },

package/plugins/steve/getters.js

@@ -8,6 +8,7 @@ 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';
+import pAndNFiltering from '@shell/utils/projectAndNamespaceFiltering.utils';
 
 export const STEVE_MODEL_TYPES = {
   NORMAN:  'norman',
@@ -42,6 +43,15 @@ export default {
         });
       });
     }
+
+    // `opt.namespaced` is either
+    // - a string representing a single namespace - add restriction to the url
+    // - an array of namespaces or projects - add restriction as a param
+    const namespaceProjectFilter = pAndNFiltering.checkAndCreateParam(opt);
+
+    if (namespaceProjectFilter) {
+      url += `${ (url.includes('?') ? '&' : '?') + namespaceProjectFilter }`;
+    }
     // End: Filter
 
     // Limit
@@ -72,12 +82,13 @@ export default {
   urlFor: (state, getters) => (type, id, opt) => {
     let url = urlFor(state, getters)(type, id, opt);
 
-    if (opt.namespaced) {
+    // `namespaced` is either
+    // - a string representing a single namespace - add restriction to the url
+    // - an array of namespaces or projects - add restriction as a param
+    if (opt.namespaced && !pAndNFiltering.isApplicable(opt)) {
       const parts = url.split('/');
 
       url = `${ parts.join('/') }/${ opt.namespaced }`;
-
-      return url;
     }
 
     return url;

package/plugins/steve/resourceWatcher.js

@@ -5,10 +5,9 @@
 import Socket, {
   NO_WATCH,
   NO_SCHEMA,
-  EVENT_MESSAGE,
   EVENT_CONNECTED,
+  REVISION_TOO_OLD
 } from '@shell/utils/socket';
-import { addParam } from '@shell/utils/url';
 
 export const WATCH_STATUSES = {
   /**
@@ -64,7 +63,7 @@ export const watchKeyFromMessage = (msg) => {
 };
 
 const {
-  WATCH_PENDING, WATCH_REQUESTED, WATCHING, STOPPED, REMOVE_PENDING, REQUESTED_REMOVE
+  WATCH_PENDING, WATCH_REQUESTED, WATCHING, REMOVE_PENDING, REQUESTED_REMOVE
 } = WATCH_STATUSES;
 
 export default class ResourceWatcher extends Socket {
@@ -110,12 +109,13 @@ export default class ResourceWatcher extends Socket {
     return !!this.watches?.[watchKey];
   }
 
-  async watch(watchKey, providedResourceVersion, providedResourceVersionTime, providedKeyParts = {}, providedSkipResourceVersion) {
+  watch(watchKey, providedResourceVersion, providedResourceVersionTime, providedKeyParts = {}, providedSkipResourceVersion) {
     const {
       resourceType: providedResourceType,
       id: providedId,
       namespace: providedNamespace,
-      selector: providedSelector
+      selector: providedSelector,
+      force: providedForce,
     } = providedKeyParts;
 
     this.trace('watch:', 'requested', watchKey);
@@ -126,8 +126,10 @@ export default class ResourceWatcher extends Socket {
       return;
     }
 
-    if (this.watches?.[watchKey]?.error) {
-      this.trace('watch:', 'in error, aborting', watchKey);
+    if (!providedForce && this.watches?.[watchKey]?.error) {
+      if (this.watches?.[watchKey]?.error.reason !== REVISION_TOO_OLD) {
+        this.trace('watch:', 'in error, aborting', watchKey);
+      }
 
       return;
     }
@@ -136,7 +138,7 @@ export default class ResourceWatcher extends Socket {
     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 skipResourceVersion = this.watches?.[watchKey]?.skipResourceVersion || providedSkipResourceVersion;
 
     const watchObject = {
       resourceType,
@@ -145,47 +147,8 @@ export default class ResourceWatcher extends Socket {
       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 resourceVersionTime = providedResourceVersionTime || this.watches?.[watchKey]?.resourceVersionTime;
+    const resourceVersion = providedResourceVersion || this.watches?.[watchKey]?.resourceVersion;
 
     const success = this.send(JSON.stringify({
       ...watchObject,
@@ -240,16 +203,21 @@ export default class ResourceWatcher extends Socket {
 
     if (eventName === 'resource.start' && this.watches?.[watchKey]?.status === WATCH_REQUESTED) {
       this.watches[watchKey].status = WATCHING;
+      delete this.watches[watchKey].error;
     } 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 }));
-      }
+      // Find some way to resolve the correct resourceVersion from within the resourceWatcher until then:
+      // reset the watch in the resourceWatcher, we'll handle recovery up the chain. For now
+      // dispatch the event to the host process which should have a handler for resource.stop
+
+      // if (this.watches?.[watchKey]?.status === REQUESTED_REMOVE) {
+      this.watches[watchKey] = { error: this.watches[watchKey]?.error };
+      // } 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();
 
@@ -262,14 +230,20 @@ export default class ResourceWatcher extends Socket {
 
         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);
+        this.watches[watchKey].error = { type: resourceType, reason: REVISION_TOO_OLD };
+        // Needs to match sub resyncWatch params
+        this.dispatchEvent(new CustomEvent('resync', {
+          detail: {
+            data: {
+              resourceType, id, namespace, selector
+            }
+          }
+        }));
       }
+      this.trace('_onmessage:', 'new error', this.watches[watchKey].error);
     }
 
     super._onmessage(event);