@rancher/shell 0.1.3 → 0.1.4

package/store/prefs.js

@@ -15,6 +15,7 @@ export const create = function(name, def, opt = {}) {
   const asCookie = opt.asCookie === true;
   const asUserPreference = opt.asUserPreference !== false;
   const options = opt.options;
+  const inheritFrom = opt.inheritFrom;
 
   definitions[name] = {
     def,
@@ -22,6 +23,7 @@ export const create = function(name, def, opt = {}) {
     parseJSON,
     asCookie,
     asUserPreference,
+    inheritFrom, // if value is not defined on server, we can default it to another pref
     mangleRead:  opt.mangleRead, // Alter the value read from the API (to match old Rancher expectations)
     mangleWrite: opt.mangleWrite, // Alter the value written back to the API (ditto)
   };
@@ -72,6 +74,7 @@ export const HIDE_REPOS = create('hide-repos', [], { parseJSON });
 export const HIDE_DESC = create('hide-desc', [], { parseJSON });
 export const HIDE_SENSITIVE = create('hide-sensitive', true, { options: [true, false], parseJSON });
 export const SHOW_PRE_RELEASE = create('show-pre-release', false, { options: [false, true], parseJSON });
+export const SHOW_CHART_MODE = create('chartMode', 'featured', { parseJSON });
 
 export const DATE_FORMAT = create('date-format', 'ddd, MMM D YYYY', {
   options: [
@@ -91,12 +94,18 @@ export const TIME_FORMAT = create('time-format', 'h:mm:ss a', {
 });
 
 export const TIME_ZONE = create('time-zone', 'local');
+// DEV will be deprecated on v2.7.0, but is needed so that we can grab the value for the new settings that derived from it
+// such as: VIEW_IN_API, ALL_NAMESPACES, THEME_SHORTCUT
 export const DEV = create('dev', false, { parseJSON });
+export const VIEW_IN_API = create('view-in-api', false, { parseJSON, inheritFrom: DEV });
+export const ALL_NAMESPACES = create('all-namespaces', false, { parseJSON, inheritFrom: DEV });
+export const THEME_SHORTCUT = create('theme-shortcut', false, { parseJSON, inheritFrom: DEV });
 export const LAST_VISITED = create('last-visited', 'home', { parseJSON });
 export const SEEN_WHATS_NEW = create('seen-whatsnew', '', { parseJSON });
 export const READ_WHATS_NEW = create('read-whatsnew', '', { parseJSON });
 export const AFTER_LOGIN_ROUTE = create('after-login-route', 'home', { parseJSON } );
 export const HIDE_HOME_PAGE_CARDS = create('home-page-cards', {}, { parseJSON } );
+export const PLUGIN_DEVELOPER = create('plugin-developer', false, { parseJSON, inheritFrom: DEV }); // Is the user a plugin developer?
 
 export const _RKE1 = 'rke1';
 export const _RKE2 = 'rke2';
@@ -105,6 +114,9 @@ export const PROVISIONER = create('provisioner', _RKE1, { options: [_RKE1, _RKE2
 // Promo for Cluster Tools feature on Cluster Dashboard page
 export const CLUSTER_TOOLS_TIP = create('hide-cluster-tools-tip', false, { parseJSON });
 
+// Promo for Pod Security Policies (PSPs) being deprecated on kube version 1.25 on Cluster Dashboard page
+export const PSP_DEPRECATION_BANNER = create('hide-psp-deprecation-banner', false, { parseJSON });
+
 // Maximum number of clusters to show in the slide-in menu
 export const MENU_MAX_CLUSTERS = create('menu-max-clusters', 4, { options: [2, 3, 4, 5, 6, 7, 8, 9, 10], parseJSON });
 
@@ -431,6 +443,10 @@ export const actions = {
       const definition = definitions[key];
       let value = clone(server.data[key]);
 
+      if (value === undefined && definition.inheritFrom) {
+        value = clone(server.data[definition.inheritFrom]);
+      }
+
       if ( value === undefined || key === ignoreKey) {
         continue;
       }

package/store/type-map.js

@@ -122,7 +122,7 @@
 // )
 import { AGE, NAME, NAMESPACE as NAMESPACE_COL, STATE } from '@shell/config/table-headers';
 import { COUNT, SCHEMA, MANAGEMENT, NAMESPACE } from '@shell/config/types';
-import { DEV, EXPANDED_GROUPS, FAVORITE_TYPES } from '@shell/store/prefs';
+import { VIEW_IN_API, EXPANDED_GROUPS, FAVORITE_TYPES } from '@shell/store/prefs';
 import {
   addObject, findBy, insertAt, isArray, removeObject, filterBy
 } from '@shell/utils/array';
@@ -131,7 +131,7 @@ import {
   ensureRegex, escapeHtml, escapeRegex, ucFirst, pluralize
 } from '@shell/utils/string';
 import {
-  importList, importDetail, importEdit, listProducts, loadProduct, importCustomPromptRemove, resolveList, resolveEdit, resolveWindowComponent, importWindowComponent, resolveDetail, importDialog
+  importChart, importList, importDetail, importEdit, listProducts, loadProduct, importCustomPromptRemove, resolveList, resolveEdit, resolveWindowComponent, importWindowComponent, resolveChart, resolveDetail, importDialog
 } from '@shell/utils/dynamic-importer';
 
 import { NAME as EXPLORER } from '@shell/config/product/explorer';
@@ -168,6 +168,7 @@ export const IF_HAVE = {
   NOT_V1_ISTIO:             'not-v1-istio',
   MULTI_CLUSTER:            'multi-cluster',
   NEUVECTOR_NAMESPACE:      'neuvector-namespace',
+  ADMIN:                    'admin-user',
 };
 
 export function DSL(store, product, module = 'type-map') {
@@ -360,6 +361,7 @@ export const state = function() {
       groupLabel:       {},
       ignore:           {},
       list:             {},
+      chart:            {},
       detail:           {},
       edit:             {},
       componentFor:     {},
@@ -802,7 +804,7 @@ export const getters = {
       const module = findBy(state.products, 'name', product).inStore;
       const schemas = rootGetters[`${ module }/all`](SCHEMA);
       const counts = rootGetters[`${ module }/all`](COUNT)?.[0]?.counts || {};
-      const isDev = rootGetters['prefs/get'](DEV);
+      const isDev = rootGetters['prefs/get'](VIEW_IN_API);
       const isBasic = mode === BASIC;
 
       const out = {};
@@ -1055,6 +1057,14 @@ export const getters = {
     };
   },
 
+  hasCustomChart(state, getters, rootState) {
+    return (rawType) => {
+      const key = getters.componentFor(rawType);
+
+      return hasCustom(state, rootState, 'chart', key, key => resolveChart(key));
+    };
+  },
+
   hasCustomDetail(state, getters, rootState) {
     return (rawType, subType) => {
       const key = getters.componentFor(rawType, subType);
@@ -1123,6 +1133,12 @@ export const getters = {
     };
   },
 
+  importChart(state, getters, rootState) {
+    return (rawType) => {
+      return loadExtension(rootState, 'chart', getters.componentFor(rawType), importChart);
+    };
+  },
+
   importDetail(state, getters, rootState) {
     return (rawType, subType) => {
       return loadExtension(rootState, 'detail', getters.componentFor(rawType, subType), importDetail);
@@ -1215,7 +1231,7 @@ export const getters = {
   activeProducts(state, getters, rootState, rootGetters) {
     const knownTypes = {};
     const knownGroups = {};
-    const isDev = rootGetters['prefs/get'](DEV);
+    const isDev = rootGetters['prefs/get'](VIEW_IN_API);
 
     if ( state.schemaGeneration < 0 ) {
       // This does nothing, but makes activeProducts depend on schemaGeneration
@@ -1544,7 +1560,7 @@ export const mutations = {
     let obj = { ...options, match };
 
     if ( idx >= 0 ) {
-      obj = Object.assign(obj, state.typeOptions[idx]);
+      obj = Object.assign(state.typeOptions[idx], obj);
       state.typeOptions.splice(idx, 1, obj);
     } else {
       const obj = Object.assign({}, options, { match });
@@ -1732,11 +1748,22 @@ function ifHave(getters, option) {
   case IF_HAVE.NEUVECTOR_NAMESPACE: {
     return getters[`cluster/all`](NAMESPACE).find(n => n.metadata.name === NEU_VECTOR_NAMESPACE);
   }
+  case IF_HAVE.ADMIN: {
+    return isAdminUser(getters);
+  }
   default:
     return false;
   }
 }
 
+// Could list a larger set of resources that typically only an admin user would have
+export function isAdminUser(getters) {
+  const canEditSettings = (getters['management/schemaFor'](MANAGEMENT.SETTING)?.resourceMethods || []).includes('PUT');
+  const canEditFeatureFlags = (getters['management/schemaFor'](MANAGEMENT.FEATURE)?.resourceMethods || []).includes('PUT');
+
+  return canEditSettings && canEditFeatureFlags;
+}
+
 // Is V1 Istio installed?
 function isV1Istio(getters) {
   const cluster = getters['currentCluster'];

package/store/uiplugins.ts

@@ -3,20 +3,22 @@
 
 // import { addObject, removeObject } from '@shell/utils/array';
 
-import { allHash } from '@shell/utils/promise';
 import { Plugin } from '@shell/core/plugin';
 
 interface UIPluginState {
   plugins: Plugin[],
-  catalog: any[],
-  catalogs: string[],
+  errors: any,
+}
+
+interface LoadError {
+  name: string,
+  error: boolean,
 }
 
 export const state = function(): UIPluginState {
   return {
     plugins:    [],
-    catalog:    [],
-    catalogs:   [''],
+    errors:     {},
   };
 };
 
@@ -25,16 +27,16 @@ export const getters = {
     return state.plugins;
   },
 
-  catalog: (state: any) => {
-    return state.catalog;
-  },
-
-  catalogs: (state: any) => {
-    return state.catalogs;
+  errors: (state: any) => {
+    return state.errors;
   },
 };
 
 export const mutations = {
+  setError(state: UIPluginState, error: LoadError) {
+    state.errors[error.name] = error.error;
+  },
+
   addPlugin(state: UIPluginState, plugin: Plugin) {
     // TODO: Duplicates?
     state.plugins.push(plugin);
@@ -47,59 +49,11 @@ export const mutations = {
       state.plugins.splice(index, 1);
     }
   },
-
-  setCatalog(state: UIPluginState, catalog: any) {
-    state.catalog = catalog;
-  },
-
-  addCatalog(state: UIPluginState, catalog: string) {
-    state.catalogs.push(catalog);
-  }
 };
 
 export const actions = {
-  addCatalog( { commit, dispatch }: any, url: string ) {
-    commit('addCatalog', url);
-  },
-
-  // This is just for PoC - we wouldn't get the catalog from Verdaccio
-  // This fetches the catalog each time
-  async loadCatalogs( { getters, commit, dispatch }: any) {
-    const packages: any[] = [];
-    const catalogHash = {} as any;
-    const catalogs = getters['catalogs'];
-
-    catalogs.forEach((url: string) => {
-      const base = url;
-
-      if (!url) {
-        url = '/verdaccio/data/packages';
-      } else {
-        url = `/uiplugins-catalog/?${ url }`;
-      }
-
-      try {
-        catalogHash[base] = dispatch('rancher/request', { url }, { root: true });
-      } catch (err) {
-        // Ignore errors... or all plugins fail
-        console.warn('Unable to fetch catalog: ', url, err); // eslint-disable-line no-console
-      }
-    });
-
-    const res = await allHash(catalogHash);
-
-    Object.keys(res as any).forEach((r: string) => {
-      const v: any = (res as any)[r];
-
-      v.forEach((p: any) => {
-        p.location = r;
-        packages.push(p);
-      });
-    });
-
-    const uiPackages = packages.filter((pkg: any) => pkg.rancher);
-
-    commit('setCatalog', uiPackages);
+  setError( { commit }: any, error: LoadError ) {
+    commit('setError', error);
   },
 
   addPlugin({ commit }: any, plugin: Plugin) {

package/utils/__tests__/object.test.ts

@@ -38,18 +38,6 @@ describe('fx: get', () => {
     expect(result).toBeUndefined();
     expect(() => result).not.toThrow();
   });
-
-  it.each([
-    'key2.nonsense',
-    'non.sense',
-  ])('should catch error and return undefined', (path) => {
-    const obj = { key1: 'value', key2: { bat: 42, 'with.dots': 43 } };
-
-    const result = get(obj, path);
-
-    expect(result).toBeUndefined();
-    expect(() => result).not.toThrow();
-  });
 });
 
 describe('fx: getter', () => {
@@ -95,18 +83,6 @@ describe('fx: getter', () => {
       expect(result).toBeUndefined();
       expect(() => result).not.toThrow();
     });
-
-    it.each([
-      'key2.nonsense',
-      'non.sense',
-    ])('should catch error and return undefined', (path) => {
-      const obj = { key1: 'value', key2: { bat: 42, 'with.dots': 43 } };
-
-      const result = getter(path)(obj);
-
-      expect(result).toBeUndefined();
-      expect(() => result).not.toThrow();
-    });
   });
 });
 

package/utils/__tests__/selector.test.ts

@@ -171,7 +171,7 @@ describe('fx: parse', () => {
       ['!some.prefix/key-bar_baz '],
       ['! some.prefix/key-bar_baz '],
       [' !  some.prefix/key-bar_baz '],
-    ])('should parse expression %p to selector %p', (expression) => {
+    ])('should parse expression %p to selector %p using prefixes', (expression) => {
       const expected = {
         key:      'some.prefix/key-bar_baz',
         operator: 'DoesNotExist',

package/utils/dynamic-importer.js

@@ -107,6 +107,10 @@ export function resolveList(key) {
   return require.resolve(`@shell/list/${ key }`);
 }
 
+export function resolveChart(key) {
+  return require.resolve(`@shell/chart/${ key }`);
+}
+
 export function resolveEdit(key) {
   return require.resolve(`@shell/edit/${ key }`);
 }

package/utils/grafana.js

@@ -1,5 +1,5 @@
+import { haveV2Monitoring } from '@shell/utils/monitoring';
 import { parse as parseUrl, addParam } from '@shell/utils/url';
-import { MONITORING } from '@shell/config/types';
 
 export function computeDashboardUrl(embedUrl, clusterId, params) {
   const url = parseUrl(embedUrl);
@@ -21,7 +21,7 @@ export function computeDashboardUrl(embedUrl, clusterId, params) {
 }
 
 export async function dashboardExists(store, clusterId, embedUrl, storeName = 'cluster') {
-  if (!isMonitoringInstalled(store.getters, storeName)) {
+  if ( !haveV2Monitoring(store.getters) ) {
     return false;
   }
 
@@ -81,7 +81,3 @@ export async function failedProposals(dispatch, clusterId) {
 
   return response.data.result[0]?.values?.[0]?.[1] || 0;
 }
-
-function isMonitoringInstalled(getters, storeName = 'cluster') {
-  return !!getters[`${ storeName }/schemaFor`](MONITORING.SERVICEMONITOR);
-}

package/utils/socket.js

@@ -31,6 +31,8 @@ export default class Socket extends EventTarget {
   hasBeenOpen = false;
   hasReconnected = false;
   protocol = null;
+  maxTries = null;
+  tries = 0;
 
   // "Private"
   socket = null;
@@ -38,17 +40,19 @@ export default class Socket extends EventTarget {
   framesReceived = 0;
   frameTimer;
   reconnectTimer;
-  tries = 0;
   disconnectCbs = [];
   disconnectedAt = 0;
   closingId = 0;
 
-  constructor(url, autoReconnect = true, frameTimeout = null, protocol = null) {
+  constructor(url, autoReconnect = true, frameTimeout = null, protocol = null, maxTries = null) {
     super();
 
     this.setUrl(url);
     this.autoReconnect = autoReconnect;
     this.protocol = protocol;
+    // maxTries = null === never stop trying to reconnect
+    // allow maxTries to be defined on individual sockets bc not all will clearly warn the user that we've stopped trying
+    this.maxTries = maxTries;
 
     if ( frameTimeout !== null ) {
       this.frameTimeout = frameTimeout;
@@ -57,10 +61,10 @@ export default class Socket extends EventTarget {
 
   setUrl(url) {
     if ( !url.match(/wss?:\/\//) ) {
-      url = window.location.origin.replace(/^http/, 'ws') + url;
+      url = self.location.origin.replace(/^http/, 'ws') + url;
     }
 
-    if ( window.location.protocol === 'https:' && url.startsWith(INSECURE) ) {
+    if ( self.location.protocol === 'https:' && url.startsWith(INSECURE) ) {
       url = SECURE + url.substr(INSECURE.length);
     }
 
@@ -74,6 +78,10 @@ export default class Socket extends EventTarget {
       return;
     }
 
+    if (this.state !== STATE_RECONNECTING) {
+      this.state = STATE_CONNECTING;
+    }
+
     Object.assign(this.metadata, metadata);
 
     const id = sockId++;
@@ -83,6 +91,8 @@ export default class Socket extends EventTarget {
 
     let socket;
 
+    this.tries++;
+
     if ( this.protocol ) {
       socket = new WebSocket(url, this.protocol);
     } else {
@@ -209,11 +219,11 @@ export default class Socket extends EventTarget {
     this._log('opened');
     const now = (new Date()).getTime();
 
-    const at = this.disconnectedAt;
-    let after = 0;
+    const atTime = this.disconnectedAt;
+    let afterMilliseconds = 0;
 
-    if ( at ) {
-      after = now - at;
+    if ( atTime ) {
+      afterMilliseconds = now - atTime;
     }
 
     if ( this.hasBeenOpen ) {
@@ -225,7 +235,8 @@ export default class Socket extends EventTarget {
     this.framesReceived = 0;
     this.disconnectedAt = 0;
 
-    this.dispatchEvent(new CustomEvent(EVENT_CONNECTED, { detail: { tries: this.tries, after } }));
+    this.dispatchEvent(new CustomEvent(EVENT_CONNECTED, { detail: { tries: this.tries, afterMilliseconds } }));
+    this.tries = 0;
     this._resetWatchdog();
     clearTimeout(this.reconnectTimer);
   }
@@ -291,18 +302,26 @@ export default class Socket extends EventTarget {
       this.dispatchEvent(e);
       warningShown = true;
     } else if ( this.autoReconnect ) {
-      if (this.tries === 0) {
-        const e = new CustomEvent(EVENT_DISCONNECT_ERROR);
+      this.state = STATE_RECONNECTING;
+
+      if (this.maxTries && this.tries > 1 && this.tries <= this.maxTries) {
+        // dispatch an event which will trigger a growl from steve-plugin sockets warning users that we've lost connection and are attemping to reconnect
+        const e = new CustomEvent(EVENT_CONNECT_ERROR);
 
         this.dispatchEvent(e);
       }
-      this.state = STATE_RECONNECTING;
-      this.tries++;
-      const delay = Math.max(1000, Math.min(1000 * this.tries, 30000));
 
-      this.reconnectTimer = setTimeout(() => {
-        this.connect();
-      }, delay);
+      if (this.maxTries && this.tries > this.maxTries) {
+        this.state = STATE_DISCONNECTED;
+        // dispatch an event which will trigger a growl from steve-plugin sockets warning users that we've given up trying to reconnect
+        this.dispatchEvent(new CustomEvent(EVENT_DISCONNECT_ERROR));
+      } else {
+        const delay = Math.max(1000, Math.min(1000 * this.tries, 30000));
+
+        this.reconnectTimer = setTimeout(() => {
+          this.connect();
+        }, delay);
+      }
     } else {
       this.state = STATE_DISCONNECTED;
     }
@@ -315,10 +334,12 @@ export default class Socket extends EventTarget {
   }
 
   _log(...args) {
-    args.unshift('Socket');
+    const message = JSON.parse(JSON.stringify([...args]));
+
+    message.unshift('Socket');
 
-    args.push(`(state=${ this.state }, id=${ this.socket ? this.socket.sockId : 0 })`);
+    message.push(`(state=${ this.state }, id=${ this.socket ? this.socket.sockId : 0 })`);
 
-    console.log(args.join(' ')); // eslint-disable-line no-console
+    console.log(message.join(' ')); // eslint-disable-line no-console
   }
 }

package/utils/string.js

@@ -70,13 +70,7 @@ export function random32(count) {
   const out = [];
   let i;
 
-  if ( process.server ) {
-    const crypto = require('crypto');
-
-    for ( i = 0 ; i < count ; i++ ) {
-      out[i] = crypto.randomBytes(4).readUInt32BE(0, true);
-    }
-  } else if (window.crypto && window.crypto.getRandomValues) {
+  if (window.crypto && window.crypto.getRandomValues) {
     const tmp = new Uint32Array(count);
 
     window.crypto.getRandomValues(tmp);

package/utils/validators/formRules/__tests__/index.test.ts

@@ -906,6 +906,114 @@ describe('formRules', () => {
     expect(formRuleResult).toStrictEqual(expectedResult);
   });
 
+  // this rule is pretty much identical to the standard hostname, but also allows for wildcards
+  it('"wildcardHostname" : returns undefined when value is valid hostname', () => {
+    const testValue = 'www.url.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+
+    expect(formRuleResult).toBeUndefined();
+  });
+
+  it('"wildcardHostname" : returns expected message when value starts with a dot', () => {
+    const testValue = '.hostname';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startDot', key: 'testDisplayKey' });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when value starts is too long for a hostname', () => {
+    const testValue = 'There.are.many.variations.of.passages.of.Lorem.Ipsum.available.but.the.majority.have.suffered.alteration.in.some.form.by.injected.humour.or.randomised.words.which.dont.look.even.slightly.believable.If.you.are.going.to.use.a.passage.of.Lorem.Ipsum.you.need';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({
+      message: 'validation.dns.hostname.tooLong', key: 'testDisplayKey', max: 253
+    });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when value contains invalid characters', () => {
+    const testValue = 'www.host*name.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({
+      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
+    });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when value contains a space character', () => {
+    const testValue = 'www.host name.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({
+      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: 'Space'
+    });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when hostname label starts with a dash', () => {
+    const testValue = 'www.-hostname.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.startHyphen', key: 'testDisplayKey' });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when hostname label ends with a dash', () => {
+    const testValue = 'www.hostname-.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({ message: 'validation.dns.hostname.endHyphen', key: 'testDisplayKey' });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when hostname label contains a double-dash at the third character position', () => {
+    const testValue = 'www.ho--stname.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({ message: 'validation.dns.doubleHyphen', key: 'testDisplayKey' });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when hostname label is too long', () => {
+    const testValue = 'www.0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({
+      message: 'validation.dns.hostname.tooLongLabel', key: 'testDisplayKey', max: 63
+    });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when wildcard character is not the first part', () => {
+    const testValue = 'www.*.hostname.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+    const expectedResult = JSON.stringify({
+      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
+    });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns expected message when wildcard character is at the beginning but not its own part', () => {
+    const testValue = '*hostname.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+
+    const expectedResult = JSON.stringify({
+      message: 'validation.chars', key: 'testDisplayKey', count: 1, chars: '"*"'
+    });
+
+    expect(formRuleResult).toStrictEqual(expectedResult);
+  });
+
+  it('"wildcardHostname" : returns valid when wildcard character is the first part', () => {
+    const testValue = '*.hostname.com';
+    const formRuleResult = formRules.wildcardHostname(testValue);
+
+    expect(formRuleResult).toBeUndefined();
+  });
+
   it('"absolutePath" : return expected message when path doesn\'t begin with a "/"', () => {
     const formRuleResult = formRules.absolutePath('absolute_path');
     const expectedResult = JSON.stringify({ message: 'validation.path', key: 'testDisplayKey' });

package/utils/validators/formRules/index.ts

@@ -204,6 +204,13 @@ export default function(t: (key: string, options?: any) => string, opt: {display
     }
   };
 
+  const wildcardHostname: Validator = (val: string) => {
+    // allow wildcard in first part of hostname
+    val = val ? val.replace(/^\*\./, '') : val;
+
+    return hostname(val);
+  };
+
   const externalName: Validator = (val: string) => {
     if (isEmpty(val)) {
       return t('validation.service.externalName.none');
@@ -442,6 +449,7 @@ export default function(t: (key: string, options?: any) => string, opt: {display
     hostname,
     testRule,
     subDomain,
-    absolutePath
+    absolutePath,
+    wildcardHostname,
   };
 }