@rancher/shell 0.1.3 → 0.1.21

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,
   };
 }

package/config/footer.js

@@ -1,19 +0,0 @@
-import { DOCS_BASE } from '@shell/config/private-label';
-
-export function options(issues, hideRancher) {
-  if (!issues) {
-    if (hideRancher) {
-      return { };
-    }
-    issues = 'https://github.com/rancher/dashboard/issues/new';
-  } else if (hideRancher) {
-    return { 'footer.issue': issues };
-  }
-
-  return {
-    'footer.docs':    DOCS_BASE,
-    'footer.forums': 'https://forums.rancher.com/',
-    'footer.slack':  'https://slack.rancher.io',
-    'footer.issue':  issues,
-  };
-}

package/creators/pkg/nuxt.config.js

@@ -1,6 +0,0 @@
-import config from '@rancher/shell/nuxt.config';
-
-export default config(__dirname, {
-  excludes:   [],
-  autoImport: []
-});