@rancher/shell 0.1.0

package/plugins/steve/actions.js

@@ -0,0 +1,373 @@
+import https from 'https';
+import { addParam, parse as parseUrl, stringify as unParseUrl } from '@shell/utils/url';
+import { handleSpoofedRequest } from '@shell/plugins/dashboard-store/actions';
+import { set } from '@shell/utils/object';
+import { deferred } from '@shell/utils/promise';
+import { streamJson, streamingSupported } from '@shell/utils/stream';
+import isObject from 'lodash/isObject';
+
+export default {
+  async request({ state, dispatch, rootGetters }, pOpt ) {
+    const opt = pOpt.opt || pOpt;
+
+    const spoofedRes = await handleSpoofedRequest(rootGetters, 'cluster', opt);
+
+    if (spoofedRes) {
+      return spoofedRes;
+    }
+
+    opt.url = opt.url.replace(/\/*$/g, '');
+
+    // FIXME: RC Standalone - Tech Debt move this to steve store get/set prependPath
+    // Cover cases where the steve store isn't actually going out to steve (epinio standalone)
+    const prependPath = this.$config.rancherEnv === 'epinio' ? `/pp/v1/epinio/rancher` : '';
+
+    if (prependPath) {
+      if (opt.url.startsWith('/')) {
+        opt.url = prependPath + opt.url;
+      } else {
+        const url = parseUrl(opt.url);
+
+        if (!url.path.startsWith(prependPath)) {
+          url.path = prependPath + url.path;
+          opt.url = unParseUrl(url);
+        }
+      }
+    }
+
+    opt.httpsAgent = new https.Agent({ rejectUnauthorized: false });
+
+    const method = (opt.method || 'get').toLowerCase();
+    const headers = (opt.headers || {});
+    const key = JSON.stringify(headers) + method + opt.url;
+    let waiting;
+
+    if ( (method === 'get') ) {
+      waiting = state.deferredRequests[key];
+
+      if ( waiting ) {
+        const later = deferred();
+
+        waiting.push(later);
+
+        // console.log('Deferred request for', key, waiting.length);
+
+        return later.promise;
+      } else {
+        // Set it to something so that future requests know to defer.
+        waiting = [];
+        state.deferredRequests[key] = waiting;
+      }
+    }
+
+    if ( opt.stream && state.allowStreaming && state.config.supportsStream && streamingSupported() ) {
+      // console.log('Using Streaming for', opt.url);
+
+      return streamJson(opt.url, opt, opt.onData).then(() => {
+        return { finishDeferred: finishDeferred.bind(null, key, 'resolve') };
+      }).catch((err) => {
+        return onError(err);
+      });
+    } else {
+      // console.log('NOT Using Streaming for', opt.url);
+    }
+
+    let paginatedResult;
+
+    while (true) {
+      try {
+        const out = await makeRequest(this, opt);
+
+        if (!opt.depaginate) {
+          return out;
+        }
+
+        if (!paginatedResult) {
+          // First result, so store it
+          paginatedResult = out;
+        } else {
+          // Subsequent request, so add to it
+          paginatedResult.data = paginatedResult.data.concat(out.data);
+        }
+
+        if (out?.pagination?.next) {
+          // More results to come, update options
+          opt.url = out.pagination.next;
+        } else {
+          // No more results, so clear out the pagination section (which will be stale from the first request)
+          delete paginatedResult.pagination?.first;
+          delete paginatedResult.pagination?.last;
+          delete paginatedResult.pagination?.next;
+          delete paginatedResult.pagination?.partial;
+
+          return paginatedResult;
+        }
+      } catch (err) {
+        return onError(err);
+      }
+    }
+
+    function makeRequest(that, opt) {
+      return that.$axios(opt).then((res) => {
+        let out;
+
+        if ( opt.responseType ) {
+          out = res;
+        } else {
+          out = responseObject(res);
+        }
+
+        finishDeferred(key, 'resolve', out);
+
+        return out;
+      });
+    }
+
+    function finishDeferred(key, action = 'resolve', res) {
+      const waiting = state.deferredRequests[key] || [];
+
+      // console.log('Resolving deferred for', key, waiting.length);
+
+      while ( waiting.length ) {
+        waiting.pop()[action](res);
+      }
+
+      delete state.deferredRequests[key];
+    }
+
+    function responseObject(res) {
+      let out = res.data;
+
+      const fromHeader = res.headers['x-api-cattle-auth'];
+
+      if ( fromHeader && fromHeader !== rootGetters['auth/fromHeader'] ) {
+        dispatch('auth/gotHeader', fromHeader, { root: true });
+      }
+
+      if ( res.status === 204 || out === null ) {
+        out = {};
+      }
+
+      if ( typeof out !== 'object' ) {
+        out = { data: out };
+      }
+
+      Object.defineProperties(out, {
+        _status:     { value: res.status },
+        _statusText: { value: res.statusText },
+        _headers:    { value: res.headers },
+        _req:        { value: res.request },
+        _url:        { value: opt.url },
+      });
+
+      return out;
+    }
+
+    function onError(err) {
+      let out = err;
+
+      if ( err?.response ) {
+        const res = err.response;
+
+        // Go to the logout page for 401s, unless redirectUnauthorized specifically disables (for the login page)
+        if ( opt.redirectUnauthorized !== false && process.client && res.status === 401 ) {
+          dispatch('auth/logout', opt.logoutOnError, { root: true });
+        }
+
+        if ( typeof res.data !== 'undefined' ) {
+          out = responseObject(res);
+        }
+      }
+
+      finishDeferred(key, 'reject', out);
+
+      return Promise.reject(out);
+    }
+  },
+
+  promptMove({ commit, state }, resources) {
+    commit('action-menu/togglePromptMove', resources, { root: true });
+  },
+
+  promptRestore({ commit, state }, resources ) {
+    commit('action-menu/togglePromptRestore', resources, { root: true });
+  },
+
+  assignTo({ commit, state }, resources = []) {
+    commit('action-menu/toggleAssignTo', resources, { root: true });
+  },
+
+  async resourceAction({ getters, dispatch }, {
+    resource, actionName, body, opt,
+  }) {
+    opt = opt || {};
+
+    if ( !opt.url ) {
+      opt.url = resource.actionLinkFor(actionName);
+      // opt.url = (resource.actions || resource.actionLinks)[actionName];
+    }
+
+    opt.method = 'post';
+    opt.data = body;
+
+    const res = await dispatch('request', { opt });
+
+    if ( opt.load !== false && res.type === 'collection' ) {
+      await dispatch('loadMulti', res.data);
+
+      return res.data.map(x => getters.byId(x.type, x.id) || x);
+    } else if ( opt.load !== false && res.type && res.id ) {
+      return dispatch('load', { data: res });
+    } else {
+      return res;
+    }
+  },
+
+  promptUpdate({ commit, state }, resources = []) {
+    commit('action-menu/togglePromptUpdate', resources, { root: true });
+  },
+
+  async collectionAction({ getters, dispatch }, {
+    type, actionName, body, opt
+  }) {
+    opt = opt || {};
+
+    if ( !opt.url ) {
+      // Cheating, but cheaper than loading the whole collection...
+      const schema = getters['schemaFor'](type);
+
+      opt.url = addParam(schema.links.collection, 'action', actionName);
+    }
+
+    opt.method = 'post';
+    opt.data = body;
+
+    const res = await dispatch('request', { opt });
+
+    if ( opt.load !== false && res.type === 'collection' ) {
+      await dispatch('loadMulti', res.data);
+
+      return res.data.map(x => getters.byId(x.type, x.id) || x);
+    } else if ( opt.load !== false && res.type && res.id ) {
+      return dispatch('load', { data: res });
+    } else {
+      return res;
+    }
+  },
+
+  cleanForNew(ctx, obj) {
+    const m = obj.metadata || {};
+
+    dropKeys(obj, newRootKeys);
+    dropKeys(m, newMetadataKeys);
+    dropCattleKeys(m.annotations);
+    dropCattleKeys(m.labels);
+
+    m.name = '';
+
+    if ( obj?.spec?.crd?.spec?.names?.kind ) {
+      obj.spec.crd.spec.names.kind = '';
+    }
+
+    return obj;
+  },
+
+  cleanForDiff(ctx, obj) {
+    const m = obj.metadata || {};
+
+    if ( !m.labels ) {
+      m.labels = {};
+    }
+
+    if ( !m.annotations ) {
+      m.annotations = {};
+    }
+
+    dropUnderscores(obj);
+    dropKeys(obj, diffRootKeys);
+    dropKeys(m, diffMetadataKeys);
+    dropCattleKeys(m.annotations);
+    dropCattleKeys(m.labels);
+
+    return obj;
+  },
+
+  cleanForDetail(ctx, resource) {
+    // Ensure labels & annotations exists, since lots of things need them
+    if ( !resource.metadata ) {
+      set(resource, 'metadata', {});
+    }
+
+    if ( !resource.metadata.annotations ) {
+      set(resource, 'metadata.annotations', {});
+    }
+
+    if ( !resource.metadata.labels ) {
+      set(resource, 'metadata.labels', {});
+    }
+
+    return resource;
+  },
+};
+
+const diffRootKeys = [
+  'actions', 'links', 'status', '__rehydrate', '__clone'
+];
+
+const diffMetadataKeys = [
+  'ownerReferences',
+  'selfLink',
+  'creationTimestamp',
+  'deletionTimestamp',
+  'state',
+  'fields',
+  'relationships',
+  'generation',
+  'managedFields',
+  'resourceVersion',
+];
+
+const newRootKeys = [
+  'actions', 'links', 'status', 'id'
+];
+
+const newMetadataKeys = [
+  ...diffMetadataKeys,
+  'uid',
+];
+
+function dropUnderscores(obj) {
+  for ( const k in obj ) {
+    if ( k.startsWith('__') ) {
+      delete obj[k];
+    } else {
+      const v = obj[k];
+
+      if ( isObject(v) ) {
+        dropUnderscores(v);
+      }
+    }
+  }
+}
+
+function dropKeys(obj, keys) {
+  if ( !obj ) {
+    return;
+  }
+
+  for ( const k of keys ) {
+    delete obj[k];
+  }
+}
+
+function dropCattleKeys(obj) {
+  if ( !obj ) {
+    return;
+  }
+
+  Object.keys(obj).forEach((key) => {
+    if ( !!key.match(/(^|field\.)cattle\.io(\/.*|$)/) ) {
+      delete obj[key];
+    }
+  });
+}

package/plugins/steve/getters.js

@@ -0,0 +1,105 @@
+import { isArray } from '@shell/utils/array';
+import { BY_TYPE } from '@shell/plugins/dashboard-store/classify';
+import { lookup } from '@shell/plugins/dashboard-store/model-loader';
+
+import SteveModel from './steve-class';
+import HybridModel, { cleanHybridResources } from './hybrid-class';
+import NormanModel from './norman-class';
+
+export const STEVE_MODEL_TYPES = {
+  NORMAN:  'norman',
+  STEVE:   'steve',
+  BY_TYPE: 'byType'
+};
+
+export default {
+  urlOptions: () => (url, opt) => {
+    opt = opt || {};
+
+    // Filter
+    if ( opt.filter ) {
+      const keys = Object.keys(opt.filter);
+
+      keys.forEach((key) => {
+        let vals = opt.filter[key];
+
+        if ( !isArray(vals) ) {
+          vals = [vals];
+        }
+
+        vals.forEach((val) => {
+          url += `${ (url.includes('?') ? '&' : '?') + encodeURIComponent(key) }=${ encodeURIComponent(val) }`;
+        });
+      });
+    }
+    // End: Filter
+
+    // Limit
+    const limit = opt.limit;
+
+    if ( limit ) {
+      url += `${ url.includes('?') ? '&' : '?' }limit=${ limit }`;
+    }
+    // End: Limit
+
+    // Sort
+    const sortBy = opt.sortBy;
+
+    if ( sortBy ) {
+      url += `${ url.includes('?') ? '&' : '?' }sort=${ encodeURIComponent(sortBy) }`;
+    }
+
+    const orderBy = opt.sortOrder;
+
+    if ( orderBy ) {
+      url += `${ url.includes('?') ? '&' : '?' }order=${ encodeURIComponent(orderBy) }`;
+    }
+    // End: Sort
+
+    return url;
+  },
+
+  defaultModel: state => (obj) => {
+    const which = state.config.modelBaseClass || STEVE_MODEL_TYPES.BY_TYPE.STEVE;
+
+    if ( which === STEVE_MODEL_TYPES.BY_TYPE ) {
+      if ( obj?.type?.startsWith('management.cattle.io.') || obj?.type?.startsWith('project.cattle.io.')) {
+        return HybridModel;
+      } else {
+        return SteveModel;
+      }
+    } else if ( which === STEVE_MODEL_TYPES.NORMAN ) {
+      return NormanModel;
+    } else {
+      return SteveModel;
+    }
+  },
+
+  classify: (state, getters, rootState) => (obj) => {
+    const customModel = lookup(state.config.namespace, obj?.type, obj?.metadata?.name, rootState);
+
+    if (customModel) {
+      return customModel;
+    }
+
+    const which = state.config.modelBaseClass || BY_TYPE;
+
+    if ( which === BY_TYPE ) {
+      if ( obj?.type?.startsWith('management.cattle.io.') || obj?.type?.startsWith('project.cattle.io.')) {
+        return HybridModel;
+      } else {
+        return SteveModel;
+      }
+    } else if ( which === STEVE_MODEL_TYPES.NORMAN ) {
+      return NormanModel;
+    } else {
+      return SteveModel;
+    }
+  },
+
+  cleanResource: () => (existing, data) => {
+    const typeSuperClass = Object.getPrototypeOf(Object.getPrototypeOf(existing))?.constructor;
+
+    return typeSuperClass === HybridModel ? cleanHybridResources(data) : data;
+  }
+};

package/plugins/steve/hybrid-class.js

@@ -0,0 +1,103 @@
+import { ANNOTATIONS_TO_IGNORE_REGEX, LABELS_TO_IGNORE_REGEX } from '@shell/config/labels-annotations';
+import omitBy from 'lodash/omitBy';
+import pickBy from 'lodash/pickBy';
+import Vue from 'vue';
+import { matchesSomeRegex } from '@shell/utils/string';
+import Resource from '@shell/plugins/dashboard-store/resource-class';
+
+// these are defined elsewhere in Steve models and will cause the error  "Cannot set property <whatever> of [object Object] which has only a getter" if defined at top-level
+export function cleanHybridResources(data) {
+  const potentialNormanHoldovers = ['state', 'name', 'description', 'labels', 'annotations'];
+
+  potentialNormanHoldovers.forEach(key => delete data[key]);
+
+  return data;
+}
+
+export default class HybridModel extends Resource {
+  constructor(data, ctx, rehydrateNamespace = null, setClone = false) {
+    const cleanedData = cleanHybridResources(data);
+
+    super(cleanedData, ctx, rehydrateNamespace, setClone);
+  }
+
+  get labels() {
+    const all = this.metadata?.labels || {};
+
+    return omitBy(all, (value, key) => {
+      return matchesSomeRegex(key, LABELS_TO_IGNORE_REGEX);
+    });
+  }
+
+  setLabels(val) {
+    if ( !this.metadata ) {
+      this.metadata = {};
+    }
+
+    const all = this.metadata.labels || {};
+    const wasIgnored = pickBy(all, (value, key) => {
+      return matchesSomeRegex(key, LABELS_TO_IGNORE_REGEX);
+    });
+
+    Vue.set(this.metadata, 'labels', { ...wasIgnored, ...val });
+  }
+
+  setLabel(key, val) {
+    if ( val ) {
+      if ( !this.metadata ) {
+        this.metadata = {};
+      }
+
+      if ( !this.metadata.labels ) {
+        this.metadata.labels = {};
+      }
+
+      Vue.set(this.metadata.labels, key, val);
+    } else if ( this.metadata?.labels ) {
+      Vue.set(this.metadata.labels, key, undefined);
+      delete this.metadata.labels[key];
+    }
+  }
+
+  get annotations() {
+    const all = this.metadata?.annotations || {};
+
+    return omitBy(all, (value, key) => {
+      return matchesSomeRegex(key, ANNOTATIONS_TO_IGNORE_REGEX);
+    });
+  }
+
+  setAnnotations(val) {
+    if ( !this.metadata ) {
+      this.metadata = {};
+    }
+
+    const all = this.metadata.annotations || {};
+    const wasIgnored = pickBy(all, (value, key) => {
+      return matchesSomeRegex(key, ANNOTATIONS_TO_IGNORE_REGEX);
+    });
+
+    Vue.set(this.metadata, 'annotations', { ...wasIgnored, ...val });
+  }
+
+  setAnnotation(key, val) {
+    if ( val ) {
+      if ( !this.metadata ) {
+        this.metadata = {};
+      }
+
+      if ( !this.metadata.annotations ) {
+        this.metadata.annotations = {};
+      }
+
+      Vue.set(this.metadata.annotations, key, val);
+    } else if ( this.metadata?.annotations ) {
+      Vue.set(this.metadata.annotations, key, undefined);
+      delete this.metadata.annotations[key];
+    }
+  }
+
+  get state() {
+    return this.stateObj?.name || 'unknown';
+  }
+}

package/plugins/steve/index.js

@@ -0,0 +1,70 @@
+import coreStore, { coreStoreModule, coreStoreState } from '@shell/plugins/dashboard-store/index';
+
+import {
+  mutations as subscribeMutations,
+  actions as subscribeActions,
+  getters as subscribeGetters
+} from './subscribe';
+
+import getters, { STEVE_MODEL_TYPES } from './getters';
+import mutations from './mutations';
+import actions from './actions';
+
+function SteveFactory(namespace, baseUrl) {
+  return {
+    ...coreStoreModule,
+
+    state() {
+      return {
+        ...coreStoreState(namespace, baseUrl),
+        socket:           null,
+        queue:            [], // For change event coalescing
+        wantSocket:       false,
+        debugSocket:      false,
+        allowStreaming:   true,
+        pendingFrames:    [],
+        deferredRequests: {},
+        started:          [],
+        inError:          {},
+      };
+    },
+
+    getters: {
+      ...coreStoreModule.getters,
+      ...getters,
+      ...subscribeGetters
+    },
+
+    mutations: {
+      ...coreStoreModule.mutations,
+      ...mutations,
+      ...subscribeMutations,
+    },
+
+    actions: {
+      ...coreStoreModule.actions,
+      ...actions,
+      ...subscribeActions
+    },
+  };
+}
+
+export default (config) => {
+  config.namespace = config.namespace || '';
+
+  config.baseUrl = config.baseUrl || `/${ config.namespace }`;
+
+  switch (config.namespace) {
+  case 'management':
+    config.modelBaseClass = STEVE_MODEL_TYPES.BY_TYPE;
+    break;
+  case 'rancher':
+    config.modelBaseClass = STEVE_MODEL_TYPES.NORMAN;
+    break;
+  }
+
+  return coreStore(
+    SteveFactory(config),
+    config,
+  );
+};

package/plugins/steve/mutations.js

@@ -0,0 +1,27 @@
+import { forgetType, resetStore, loadAll } from '@shell/plugins/dashboard-store/mutations';
+import { keyForSubscribe } from '@shell/plugins/steve/subscribe';
+import { perfLoadAll } from '@shell/plugins/steve/performanceTesting';
+
+export default {
+  loadAll(state, { type, data, ctx }) {
+    // Performance testing in dev and when env var is set
+    if (process.env.dev && process.env.perfTest) {
+      data = perfLoadAll(type, data);
+    }
+
+    return loadAll(state, {
+      type, data, ctx
+    });
+  },
+
+  forgetType(state, type) {
+    if ( forgetType(state, type) ) {
+      delete state.inError[keyForSubscribe({ type })];
+    }
+  },
+
+  reset(state) {
+    resetStore(state, this.commit);
+    this.commit(`${ state.config.namespace }/resetSubscriptions`);
+  }
+};