@rancher/shell 0.3.20 → 0.3.22

package/rancher-components/components/Form/LabeledInput/LabeledInput.vue

@@ -206,6 +206,13 @@ export default (
       }
     },
 
+    /**
+     * Emit on input change
+     */
+    onChange(event: Event): void {
+      this.$emit('change', event);
+    },
+
     /**
      * Emit on input with delay. Note: Arrow function is avoided due context
      * binding.
@@ -299,6 +306,7 @@ export default (
         @input="onInput($event.target.value)"
         @focus="onFocus"
         @blur="onBlur"
+        @change="onChange"
       >
     </slot>
 

package/rancher-components/components/Form/Radio/RadioButton.test.ts

@@ -4,7 +4,7 @@ import { cleanHtmlDirective } from '@shell/plugins/clean-html-directive';
 
 describe('radioButton.vue', () => {
   it('renders label slot contents', () => {
-    const wrapper = shallowMount(RadioButton, { slots: { label: 'Test Label' } });
+    const wrapper = shallowMount(RadioButton, { slots: { label: 'Test Label' }, propsData: { val: {}, value: {} } });
 
     expect(wrapper.find('.radio-label').text()).toBe('Test Label');
   });
@@ -14,7 +14,9 @@ describe('radioButton.vue', () => {
       RadioButton,
       {
         directives: { cleanHtmlDirective },
-        propsData:  { label: 'Test Label' }
+        propsData:  {
+          label: 'Test Label', val: {}, value: {}
+        }
       });
 
     expect(wrapper.find('.radio-label').text()).toBe('Test Label');
@@ -23,7 +25,9 @@ describe('radioButton.vue', () => {
   it('renders slot contents when both slot and label prop are provided', () => {
     const wrapper = shallowMount(RadioButton, {
       slots:     { label: 'Test Label - Slot' },
-      propsData: { label: 'Test Label - Props' },
+      propsData: {
+        label: 'Test Label - Props', val: {}, value: {}
+      },
     });
 
     expect(wrapper.find('.radio-label').text()).toBe('Test Label - Slot');

package/scripts/extension/parse-tag-name

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+GITHUB_RELEASE_TAG=$1
+GITHUB_RUN_ID=$2
+GITHUB_WORKFLOW_TYPE=$3
+
+# Check packages for released tag name
+if [[ "${GITHUB_WORKFLOW_TYPE}" == "container" ]]; then
+  for d in pkg/*/ ; do
+    pkg=$(basename $d)
+
+    PKG_VERSION=$(jq -r .version pkg/${pkg}/package.json)
+    PKG_NAME="${pkg}-${PKG_VERSION}"
+
+    if [[ "${GITHUB_RELEASE_TAG}" == "${PKG_NAME}" ]]; then
+      gh run cancel ${GITHUB_RUN_ID}
+    else
+      continue
+    fi
+  done
+else
+  # Check base extension name for tag name
+  BASE_EXT=$(jq -r .name package.json)
+  EXT_VERSION=$(jq -r .version package.json)
+
+  if [[ "${GITHUB_RELEASE_TAG}" == "${BASE_EXT}-${EXT_VERSION}" ]]; then
+    echo -e "tag: ${GITHUB_RELEASE_TAG}"
+    gh run cancel ${GITHUB_RUN_ID}
+  fi
+fi

package/types/shell/index.d.ts

@@ -2003,6 +2003,7 @@ export namespace AUTH_TYPE {
     const _SSH: string;
     const _S3: string;
 }
+export const LOCAL_CLUSTER: "local";
 }
 
 // @shell/mixins/create-edit-view/impl
@@ -3029,6 +3030,7 @@ export function authProvidersInfo(store: any): Promise<{
 }>;
 export function checkSchemasForFindAllHash(types: any, store: any): any;
 export function checkPermissions(types: any, getters: any): any;
+export function canViewResource(store: any, resource: any): boolean;
 }
 
 // @shell/utils/aws
@@ -4060,6 +4062,7 @@ export default _default;
 
 declare module '@shell/utils/validators/cidr' {
 export function isValidCIDR(cidr: any): boolean;
+export function isValidIP(ip: any): boolean;
 export function isValidMac(value: any): boolean;
 }
 

package/utils/auth.js

@@ -144,3 +144,20 @@ export const checkPermissions = (types, getters) => {
 
   return allHash(hash);
 };
+
+export const canViewResource = (store, resource) => {
+  // Note - don't use the current products store... because products can override stores for resources with `typeStoreMap`
+  const inStore = store.getters['currentStore'](resource);
+  // There's a chance we're in an extension's product who's store could be anything, so confirm schemaFor exists
+  const schemaFor = store.getters[`${ inStore }/schemaFor`];
+
+  // In order to check a resource is valid we need these
+  if (!inStore || !schemaFor) {
+    return false;
+  }
+
+  // Resource is valid if a schema exists for it (standard resource, spoofed resource) or it's a virtual resource
+  const validResource = schemaFor(resource) || store.getters['type-map/isVirtual'](resource);
+
+  return !!validResource;
+};

package/utils/object.js

@@ -72,7 +72,6 @@ export function get(obj, path) {
       return '(JSON Path err)';
     }
   }
-
   if ( !path.includes('.') ) {
     return obj?.[path];
   }

package/utils/settings.ts

@@ -1,7 +1,6 @@
 import { MANAGEMENT } from '@shell/config/types';
 import { Store } from 'vuex';
-import { DEFAULT_PERF_SETTING, SETTING } from '@shell/config/settings';
-import { GC_PREFERENCES } from '@shell/utils/gc/gc-types';
+import { DEFAULT_PERF_SETTING, PerfSettings, SETTING } from '@shell/config/settings';
 
 export const fetchOrCreateSetting = async(store: Store<any>, id: string, val: string, save = true): Promise<any> => {
   let setting;
@@ -44,21 +43,7 @@ export const setSetting = async(store: Store<any>, id: string, val: string): Pro
   return setting;
 };
 
-export const getPerformanceSetting = (rootGetters: Record<string, (arg0: string, arg1: string) => any>): {
-  inactivity: {
-      enabled: boolean;
-      threshold: number;
-  };
-  incrementalLoading: {
-      enabled: boolean;
-      threshold: number;
-  };
-  manualRefresh: {};
-  disableWebsocketNotification: boolean;
-  garbageCollection: GC_PREFERENCES;
-  forceNsFilterV2: any;
-  advancedWorker: {};
-} => {
+export const getPerformanceSetting = (rootGetters: Record<string, (arg0: string, arg1: string) => any>): PerfSettings => {
   const perfSettingResource = rootGetters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_PERFORMANCE);
   let perfSetting = {};
 

package/utils/validators/__tests__/cidr.test.ts

@@ -0,0 +1,33 @@
+import { isValidCIDR, isValidIP, isValidMac } from '@shell/utils/validators/cidr';
+
+describe('fx: isValidCIDR', () => {
+  it('should be valid', () => {
+    expect(isValidCIDR('10.42.0.0/8')).toBe(true);
+  });
+  it('should be invalid', () => {
+    expect(isValidCIDR('10.42.0.0')).toBe(false);
+    expect(isValidCIDR('10.42.0.0/500')).toBe(false);
+    expect(isValidCIDR('300.42.0.0/8')).toBe(false);
+  });
+});
+
+describe('fx: isValidIP', () => {
+  it('should be valid', () => {
+    expect(isValidIP('10.42.0.1')).toBe(true);
+  });
+  it('should be invalid', () => {
+    expect(isValidIP('10.42.0.0/8')).toBe(false);
+    expect(isValidIP('300.42.0.0')).toBe(false);
+  });
+});
+
+describe('fx: isValidMac', () => {
+  it('should be valid', () => {
+    expect(isValidMac('00-08-20-83-53-D1')).toBe(true);
+    expect(isValidMac('00-08-20-83-53-d1')).toBe(true);
+  });
+  it('should be invalid', () => {
+    expect(isValidMac('invalid')).toBe(false);
+    expect(isValidMac('00-08-20-83-53')).toBe(false);
+  });
+});

package/utils/validators/cidr.js

@@ -1,9 +1,14 @@
 const validCIDRregex = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(3[0-2]|2[0-9]|1[0-9]|[0-9])$/;
+const validIPRegex = /^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
 
 export function isValidCIDR(cidr) {
   return !!cidr.match(validCIDRregex);
 }
 
+export function isValidIP(ip) {
+  return !!ip.match(validIPRegex);
+}
+
 export function isValidMac(value) {
   return /^[A-Fa-f0-9]{2}(-[A-Fa-f0-9]{2}){5}$|^[A-Fa-f0-9]{2}(:[A-Fa-f0-9]{2}){5}$/.test(value);
 }

package/vue-config-helper.js

@@ -0,0 +1,135 @@
+const dev = (process.env.NODE_ENV !== 'production');
+const devPorts = dev || process.env.DEV_PORTS === 'true';
+const prime = process.env.PRIME;
+
+let api = process.env.API || 'http://localhost:8989';
+
+if ( !api.startsWith('http') ) {
+  api = `https://${ api }`;
+}
+
+// ===============================================================================================
+// Functions for the request proxying used in dev
+// ===============================================================================================
+
+function proxyMetaOpts(target) {
+  return {
+    target,
+    followRedirects: true,
+    secure:          !dev,
+    changeOrigin:    true,
+    onProxyReq,
+    onProxyReqWs,
+    onError,
+    onProxyRes,
+  };
+}
+
+function proxyOpts(target) {
+  return {
+    target,
+    secure:       !devPorts,
+    changeOrigin: true,
+    onProxyReq,
+    onProxyReqWs,
+    onError,
+    onProxyRes
+  };
+}
+
+// Intercept the /rancherversion API call wnad modify the 'RancherPrime' value
+// if configured to do so by the environment variable PRIME
+function proxyPrimeOpts(target) {
+  const opts = proxyOpts(target);
+
+  // Don't intercept if the PRIME environment variable is not set
+  if (!prime?.length) {
+    return opts;
+  }
+
+  opts.onProxyRes = (proxyRes, req, res) => {
+    const _end = res.end;
+    let body = '';
+
+    proxyRes.on( 'data', (data) => {
+      data = data.toString('utf-8');
+      body += data;
+    });
+
+    res.write = () => {};
+
+    res.end = () => {
+      let output = body;
+
+      try {
+        const out = JSON.parse(body);
+
+        out.RancherPrime = prime;
+        output = JSON.stringify(out);
+      } catch (err) {}
+
+      res.setHeader('content-length', output.length );
+      res.setHeader('content-type', 'application/json' );
+      res.setHeader('transfer-encoding', '');
+      res.setHeader('cache-control', 'no-cache');
+      res.writeHead(proxyRes.statusCode);
+      _end.apply(res, [output]);
+    };
+  };
+
+  return opts;
+}
+
+function onProxyRes(proxyRes, req, res) {
+  if (devPorts) {
+    proxyRes.headers['X-Frame-Options'] = 'ALLOWALL';
+  }
+}
+
+function proxyWsOpts(target) {
+  return {
+    ...proxyOpts(target),
+    ws:           true,
+    changeOrigin: true,
+  };
+}
+
+function onProxyReq(proxyReq, req) {
+  if (!(proxyReq._currentRequest && proxyReq._currentRequest._headerSent)) {
+    proxyReq.setHeader('x-api-host', req.headers['host']);
+    proxyReq.setHeader('x-forwarded-proto', 'https');
+  }
+}
+
+function onProxyReqWs(proxyReq, req, socket, options, head) {
+  req.headers.origin = options.target.href;
+  proxyReq.setHeader('origin', options.target.href);
+  proxyReq.setHeader('x-api-host', req.headers['host']);
+  proxyReq.setHeader('x-forwarded-proto', 'https');
+  // console.log(proxyReq.getHeaders());
+
+  socket.on('error', (err) => {
+    console.error('Proxy WS Error:', err); // eslint-disable-line no-console
+  });
+}
+
+function onError(err, req, res) {
+  res.statusCode = 598;
+  console.error('Proxy Error:', err); // eslint-disable-line no-console
+  res.write(JSON.stringify(err));
+}
+
+module.exports = {
+  dev,
+  devPorts,
+  prime,
+  api,
+  proxyMetaOpts,
+  proxyOpts,
+  proxyPrimeOpts,
+  onProxyRes,
+  proxyWsOpts,
+  onProxyReq,
+  onProxyReqWs,
+  onError
+};

package/vue.config.js

@@ -5,6 +5,7 @@ const webpack = require('webpack');
 const { generateDynamicTypeImport } = require('./pkg/auto-import');
 const CopyWebpackPlugin = require('copy-webpack-plugin');
 const serverMiddlewares = require('./server/server-middleware.js');
+const configHelper = require('./vue-config-helper.js');
 
 // Suppress info level logging messages from http-proxy-middleware
 // This hides all of the "[HPM Proxy created] ..." messages
@@ -20,24 +21,18 @@ console.info = oldInfoLogger; // eslint-disable-line no-console
 // const { STANDARD } = require('./config/private-label');
 const STANDARD = 1;
 
-const dev = (process.env.NODE_ENV !== 'production');
-const devPorts = dev || process.env.DEV_PORTS === 'true';
+const dev = configHelper.dev;
+const devPorts = configHelper.devPorts;
 
 // human readable version used on rancher dashboard about page
 const dashboardVersion = process.env.DASHBOARD_VERSION;
 
-const prime = process.env.PRIME;
-
 const pl = process.env.PL || STANDARD;
 const commit = process.env.COMMIT || 'head';
 const perfTest = (process.env.PERF_TEST === 'true'); // Enable performance testing when in dev
 const instrumentCode = (process.env.TEST_INSTRUMENT === 'true'); // Instrument code for code coverage in e2e tests
 
-let api = process.env.API || 'http://localhost:8989';
-
-if ( !api.startsWith('http') ) {
-  api = `https://${ api }`;
-}
+const api = configHelper.api;
 // ===============================================================================================
 // Nuxt configuration
 // ===============================================================================================
@@ -276,26 +271,26 @@ module.exports = function(dir, _appConfig) {
   console.log(`API: '${ api }'. Env: '${ rancherEnv }'`); // eslint-disable-line no-console
   const proxy = {
     ...appConfig.proxies,
-    '/k8s':            proxyWsOpts(api), // Straight to a remote cluster (/k8s/clusters/<id>/)
-    '/pp':             proxyWsOpts(api), // For (epinio) standalone API
-    '/api':            proxyWsOpts(api), // Management k8s API
-    '/apis':           proxyWsOpts(api), // Management k8s API
-    '/v1':             proxyWsOpts(api), // Management Steve API
-    '/v3':             proxyWsOpts(api), // Rancher API
-    '/v3-public':      proxyOpts(api), // Rancher Unauthed API
-    '/api-ui':         proxyOpts(api), // Browser API UI
-    '/meta':           proxyMetaOpts(api), // Browser API UI
-    '/v1-*':           proxyOpts(api), // SAML, KDM, etc
-    '/rancherversion': proxyPrimeOpts(api), // Rancher version endpoint
+    '/k8s':            configHelper.proxyWsOpts(api), // Straight to a remote cluster (/k8s/clusters/<id>/)
+    '/pp':             configHelper.proxyWsOpts(api), // For (epinio) standalone API
+    '/api':            configHelper.proxyWsOpts(api), // Management k8s API
+    '/apis':           configHelper.proxyWsOpts(api), // Management k8s API
+    '/v1':             configHelper.proxyWsOpts(api), // Management Steve API
+    '/v3':             configHelper.proxyWsOpts(api), // Rancher API
+    '/v3-public':      configHelper.proxyOpts(api), // Rancher Unauthed API
+    '/api-ui':         configHelper.proxyOpts(api), // Browser API UI
+    '/meta':           configHelper.proxyMetaOpts(api), // Browser API UI
+    '/v1-*':           configHelper.proxyOpts(api), // SAML, KDM, etc
+    '/rancherversion': configHelper.proxyPrimeOpts(api), // Rancher version endpoint
     // These are for Ember embedding
-    '/c/*/edit':       proxyOpts('https://127.0.0.1:8000'), // Can't proxy all of /c because that's used by Vue too
-    '/k/':             proxyOpts('https://127.0.0.1:8000'),
-    '/g/':             proxyOpts('https://127.0.0.1:8000'),
-    '/n/':             proxyOpts('https://127.0.0.1:8000'),
-    '/p/':             proxyOpts('https://127.0.0.1:8000'),
-    '/assets':         proxyOpts('https://127.0.0.1:8000'),
-    '/translations':   proxyOpts('https://127.0.0.1:8000'),
-    '/engines-dist':   proxyOpts('https://127.0.0.1:8000'),
+    '/c/*/edit':       configHelper.proxyOpts('https://127.0.0.1:8000'), // Can't proxy all of /c because that's used by Vue too
+    '/k/':             configHelper.proxyOpts('https://127.0.0.1:8000'),
+    '/g/':             configHelper.proxyOpts('https://127.0.0.1:8000'),
+    '/n/':             configHelper.proxyOpts('https://127.0.0.1:8000'),
+    '/p/':             configHelper.proxyOpts('https://127.0.0.1:8000'),
+    '/assets':         configHelper.proxyOpts('https://127.0.0.1:8000'),
+    '/translations':   configHelper.proxyOpts('https://127.0.0.1:8000'),
+    '/engines-dist':   configHelper.proxyOpts('https://127.0.0.1:8000'),
   };
 
   const config = {
@@ -570,114 +565,3 @@ module.exports = function(dir, _appConfig) {
 
   return config;
 };
-
-// ===============================================================================================
-// Functions for the request proxying used in dev
-// ===============================================================================================
-
-function proxyMetaOpts(target) {
-  return {
-    target,
-    followRedirects: true,
-    secure:          !dev,
-    changeOrigin:    true,
-    onProxyReq,
-    onProxyReqWs,
-    onError,
-    onProxyRes,
-  };
-}
-
-function proxyOpts(target) {
-  return {
-    target,
-    secure:       !devPorts,
-    changeOrigin: true,
-    onProxyReq,
-    onProxyReqWs,
-    onError,
-    onProxyRes
-  };
-}
-
-// Intercept the /rancherversion API call wnad modify the 'RancherPrime' value
-// if configured to do so by the environment variable PRIME
-function proxyPrimeOpts(target) {
-  const opts = proxyOpts(target);
-
-  // Don't intercept if the PRIME environment variable is not set
-  if (!prime?.length) {
-    return opts;
-  }
-
-  opts.onProxyRes = (proxyRes, req, res) => {
-    const _end = res.end;
-    let body = '';
-
-    proxyRes.on( 'data', (data) => {
-      data = data.toString('utf-8');
-      body += data;
-    });
-
-    res.write = () => {};
-
-    res.end = () => {
-      let output = body;
-
-      try {
-        const out = JSON.parse(body);
-
-        out.RancherPrime = prime;
-        output = JSON.stringify(out);
-      } catch (err) {}
-
-      res.setHeader('content-length', output.length );
-      res.setHeader('content-type', 'application/json' );
-      res.setHeader('transfer-encoding', '');
-      res.setHeader('cache-control', 'no-cache');
-      res.writeHead(proxyRes.statusCode);
-      _end.apply(res, [output]);
-    };
-  };
-
-  return opts;
-}
-
-function onProxyRes(proxyRes, req, res) {
-  if (devPorts) {
-    proxyRes.headers['X-Frame-Options'] = 'ALLOWALL';
-  }
-}
-
-function proxyWsOpts(target) {
-  return {
-    ...proxyOpts(target),
-    ws:           true,
-    changeOrigin: true,
-  };
-}
-
-function onProxyReq(proxyReq, req) {
-  if (!(proxyReq._currentRequest && proxyReq._currentRequest._headerSent)) {
-    proxyReq.setHeader('x-api-host', req.headers['host']);
-    proxyReq.setHeader('x-forwarded-proto', 'https');
-  }
-}
-
-function onProxyReqWs(proxyReq, req, socket, options, head) {
-  req.headers.origin = options.target.href;
-  proxyReq.setHeader('origin', options.target.href);
-  proxyReq.setHeader('x-api-host', req.headers['host']);
-  proxyReq.setHeader('x-forwarded-proto', 'https');
-  // console.log(proxyReq.getHeaders());
-
-  socket.on('error', (err) => {
-    console.error('Proxy WS Error:', err); // eslint-disable-line no-console
-  });
-}
-
-function onError(err, req, res) {
-  res.statusCode = 598;
-  console.error('Proxy Error:', err); // eslint-disable-line no-console
-  res.write(JSON.stringify(err));
-}