@rancher/shell 0.1.0

package/models/k8s.cni.cncf.io.networkattachmentdefinition.js

@@ -0,0 +1,93 @@
+import Vue from 'vue';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { HCI } from '@shell/config/labels-annotations';
+
+export default class NetworkAttachmentDef extends SteveModel {
+  get _availableActions() {
+    let out = super._availableActions;
+    const toFilter = ['goToClone', 'cloneYaml', 'goToViewConfig', 'goToEditYaml', 'goToEdit'];
+
+    out = out.filter((action) => {
+      if (!toFilter.includes(action.action)) {
+        return action;
+      }
+    });
+
+    return out;
+  }
+
+  applyDefaults() {
+    const spec = this.spec || {
+      config: JSON.stringify({
+        cniVersion:  '0.3.1',
+        name:        '',
+        type:        'bridge',
+        bridge:      'harvester-br0',
+        promiscMode: true,
+        vlan:        '',
+        ipam:        {}
+      })
+    };
+
+    Vue.set(this, 'spec', spec);
+  }
+
+  get parseConfig() {
+    try {
+      return JSON.parse(this.spec.config) || {};
+    } catch (err) {
+      return {};
+    }
+  }
+
+  get isIpamStatic() {
+    return this.parseConfig.ipam?.type === 'static';
+  }
+
+  get vlanType() {
+    const type = this.parseConfig.type;
+
+    return type === 'bridge' ? 'L2VlanNetwork' : type;
+  }
+
+  get vlanId() {
+    return this.parseConfig.vlan;
+  }
+
+  get customValidationRules() {
+    const rules = [
+      {
+        nullable:       false,
+        path:           'metadata.name',
+        required:       true,
+        minLength:      1,
+        maxLength:      63,
+        translationKey: 'harvester.fields.name'
+      }
+    ];
+
+    return rules;
+  }
+
+  get connectivity() {
+    const annotations = this.metadata?.annotations || {};
+    const route = annotations[HCI.NETWORK_ROUTE];
+    let config = {};
+
+    try {
+      config = JSON.parse(route || '{}');
+    } catch {
+      return 'invalid';
+    }
+
+    const connectivity = config.connectivity;
+
+    if (connectivity === 'false') {
+      return 'inactive';
+    } else if (connectivity === 'true') {
+      return 'active';
+    } else {
+      return connectivity;
+    }
+  }
+}

package/models/logging.banzaicloud.io.clusterflow.js

@@ -0,0 +1,36 @@
+import { LOGGING } from '@shell/config/types';
+import uniq from 'lodash/uniq';
+import Flow from './logging.banzaicloud.io.flow';
+
+export default class LogClusterFlow extends Flow {
+  get allOutputs() {
+    return this.$rootGetters['cluster/all'](LOGGING.CLUSTER_OUTPUT) || [];
+  }
+
+  get outputs() {
+    if (!this.allOutputs) {
+      // Handle the case where the user doesn't have permission
+      // to see Outputs
+      return [];
+    }
+    const outputRefs = this?.spec?.globalOutputRefs || this?.spec?.outputRefs || [];
+
+    return this.allOutputs.filter(output => outputRefs.includes(output.name));
+  }
+
+  get outputProviders() {
+    const duplicatedProviders = this.outputs
+      .flatMap(output => output.providers);
+
+    return uniq(duplicatedProviders) || [];
+  }
+
+  get customValidationRules() {
+    return [
+      {
+        path:           'spec',
+        validators:     ['flowOutput'],
+      },
+    ];
+  }
+}

package/models/logging.banzaicloud.io.clusteroutput.js

@@ -0,0 +1,4 @@
+import LogOutput from '@shell/models/logging.banzaicloud.io.output';
+
+export default class LogClusterOutput extends LogOutput {
+}

package/models/logging.banzaicloud.io.flow.js

@@ -0,0 +1,110 @@
+import { LOGGING } from '@shell/config/types';
+import { set } from '@shell/utils/object';
+import uniq from 'lodash/uniq';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export function matchRuleIsPopulated(rule) {
+  if ( !rule ) {
+    return false;
+  }
+
+  if ( rule.labels && Object.keys(rule.labels).length ) {
+    return true;
+  }
+
+  if ( rule.hosts?.length ) {
+    return true;
+  }
+
+  if ( rule.container_names?.length ) {
+    return true;
+  }
+
+  return false;
+}
+
+export default class LogFlow extends SteveModel {
+  applyDefaults() {
+    set(this, 'spec', this.spec || {});
+    set(this.spec, 'match', this.spec.match || []);
+    set(this.spec, 'filters', this.spec.filters || []);
+    set(this.spec, 'localOutputRefs', this.spec.localOutputRefs || []);
+    set(this.spec, 'globalOutputRefs', this.spec.globalOutputRefs || []);
+  }
+
+  get canCustomEdit() {
+    if ( !this.spec?.match?.length ) {
+      return true;
+    }
+
+    let out = true;
+
+    for ( const match of this.spec.match ) {
+      if ( matchRuleIsPopulated(match.select) && matchRuleIsPopulated(match.exclude) ) {
+        out = false;
+        break;
+      }
+    }
+
+    return out;
+  }
+
+  get allOutputs() {
+    return this.$rootGetters['cluster/all'](LOGGING.OUTPUT) || [];
+  }
+
+  get allClusterOutputs() {
+    return this.$rootGetters['cluster/all'](LOGGING.CLUSTER_OUTPUT) || [];
+  }
+
+  get outputs() {
+    const localOutputRefs = this.spec?.localOutputRefs || [];
+
+    return this.allOutputs.filter(output => localOutputRefs.includes(output.name));
+  }
+
+  get outputsSortable() {
+    const displays = this.outputs.map(o => o.nameDisplay);
+
+    displays.sort();
+
+    return displays.join('');
+  }
+
+  get clusterOutputs() {
+    const globalOutputRefs = this.spec?.globalOutputRefs || [];
+
+    if (this.allClusterOutputs) {
+      return this.allClusterOutputs.filter(output => globalOutputRefs.includes(output.name));
+    } else {
+      // Handle the case where the user doesn't have permission
+      // to see ClusterOutputs
+      return [];
+    }
+  }
+
+  get clusterOutputsSortable() {
+    const displays = this.clusterOutputs.map(o => o.nameDisplay);
+
+    displays.sort();
+
+    return displays.join('');
+  }
+
+  get providersDisplay() {
+    const combinedOutputs = [...this.outputs, ...this.clusterOutputs];
+    const duplicatedProviders = combinedOutputs
+      .flatMap(output => output.providersDisplay);
+
+    return uniq(duplicatedProviders) || [];
+  }
+
+  get customValidationRules() {
+    return [
+      {
+        path:           'spec',
+        validators:     ['flowOutput:verifyLocal'],
+      },
+    ];
+  }
+}

package/models/logging.banzaicloud.io.output.js

@@ -0,0 +1,161 @@
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export const PROVIDERS = [
+  {
+    name:     'awsElasticsearch',
+    labelKey: 'logging.outputProviders.awsElasticsearch',
+    default:  { endpoint: {} },
+  },
+  {
+    name:     'azurestorage',
+    labelKey: 'logging.outputProviders.azurestorage',
+    default:  { },
+  },
+  {
+    name:     'cloudwatch',
+    labelKey: 'logging.outputProviders.cloudwatch',
+    default:  { },
+  },
+  {
+    name:     'datadog',
+    labelKey: 'logging.outputProviders.datadog',
+    default:  { },
+  },
+  {
+    name:     'elasticsearch',
+    labelKey: 'logging.outputProviders.elasticsearch',
+    default:  {},
+  },
+  {
+    name:     'file',
+    labelKey: 'logging.outputProviders.file',
+    default:  { },
+  },
+  {
+    name:     'forward',
+    labelKey: 'logging.outputProviders.forward',
+    default:  { servers: [{}] },
+  },
+  {
+    name:     'gelf',
+    labelKey: 'logging.outputProviders.gelf',
+    default:  { },
+  },
+  {
+    name:     'gcs',
+    labelKey: 'logging.outputProviders.gcs',
+    default:  { },
+  },
+  {
+    name:     'kafka',
+    labelKey: 'logging.outputProviders.kafka',
+    default:  { format: { type: 'json' } },
+  },
+  {
+    name:     'kinesisStream',
+    labelKey: 'logging.outputProviders.kinesisStream',
+    default:  { },
+  },
+  {
+    name:     'logdna',
+    labelKey: 'logging.outputProviders.logdna',
+    default:  { },
+  },
+  {
+    name:     'logz',
+    labelKey: 'logging.outputProviders.logz',
+    default:  { endpoint: {} },
+  },
+  {
+    name:     'loki',
+    labelKey: 'logging.outputProviders.loki',
+    default:  { configure_kubernetes_labels: true },
+  },
+  {
+    name:     'newrelic',
+    labelKey: 'logging.outputProviders.newrelic',
+    default:  { },
+  },
+  {
+    name:     'splunkHec',
+    labelKey: 'logging.outputProviders.splunkHec',
+    default:  {},
+  },
+  {
+    name:     'sumologic',
+    labelKey: 'logging.outputProviders.sumologic',
+    default:  { },
+  },
+  {
+    name:     'syslog',
+    labelKey: 'logging.outputProviders.syslog',
+    default:  { },
+  },
+  {
+
+    name:     's3',
+    labelKey: 'logging.outputProviders.s3',
+    default:  { },
+  },
+];
+
+export default class LogOutput extends SteveModel {
+  get canCustomEdit() {
+    return this.allProvidersSupported;
+  }
+
+  get providers() {
+    const spec = this.spec || {};
+
+    return Object.keys(spec)
+      .filter(provider => provider !== 'loggingRef');
+  }
+
+  get providersDisplay() {
+    return this.providers.map((p) => {
+      const translation = this.t(`logging.outputProviders.${ p }`);
+
+      return translation || this.t('logging.outputProviders.unknown');
+    });
+  }
+
+  isSupportedProvider(provider) {
+    return !!PROVIDERS.find(p => p.name === provider);
+  }
+
+  get allProvidersSupported() {
+    return this.providers.every(this.isSupportedProvider);
+  }
+
+  get providersSortable() {
+    const copy = [...this.providersDisplay];
+
+    copy.sort();
+
+    return copy.join('');
+  }
+
+  get text() {
+    return this.nameDisplay;
+  }
+
+  get url() {
+    return {
+      name:   'c-cluster-product-resource-namespace-id',
+      params:   {
+        resource:  this.type,
+        id:        this.name,
+        namespace: this.namespace
+      }
+    };
+  }
+
+  get customValidationRules() {
+    return [
+      {
+        path:           'spec.logdna',
+        validators:     ['logdna'],
+      }
+    ];
+  }
+}

package/models/management.cattle.io.authconfig.js

@@ -0,0 +1,69 @@
+import { insertAt } from '@shell/utils/array';
+import SteveModel from '@shell/plugins/steve/steve-class';
+
+export const configType = {
+  activedirectory: 'ldap',
+  azuread:         'oauth',
+  openldap:        'ldap',
+  freeipa:         'ldap',
+  ping:            'saml',
+  adfs:            'saml',
+  keycloak:        'saml',
+  okta:            'saml',
+  shibboleth:      'saml',
+  googleoauth:     'oauth',
+  local:           '',
+  github:          'oauth',
+  keycloakoidc:    'oidc'
+};
+
+const imageOverrides = { keycloakoidc: 'keycloak' };
+
+export default class AuthConfig extends SteveModel {
+  get _availableActions() {
+    const out = super._availableActions;
+
+    insertAt(out, 0, {
+      action:     'disable',
+      label:      'Disable',
+      icon:       'icon icon-spinner',
+      enabled:    this.enabled === true,
+    });
+
+    insertAt(out, 1, { divider: true });
+
+    return out;
+  }
+
+  get nameDisplay() {
+    return this.$rootGetters['i18n/withFallback'](`model.authConfig.name."${ this.id }"`, null, this.provider);
+  }
+
+  get provider() {
+    return this.$rootGetters['i18n/withFallback'](`model.authConfig.provider."${ this.id }"`, null, this.id);
+  }
+
+  get configType() {
+    return configType[this.id];
+  }
+
+  get sideLabel() {
+    return this.$rootGetters['i18n/withFallback'](`model.authConfig.description."${ this.configType }"`, null, this.configType);
+  }
+
+  get icon() {
+    try {
+      return require(`~shell/assets/images/vendor/${ imageOverrides[this.id] || this.id }.svg`);
+    } catch (e) {
+      return '';
+    }
+  }
+
+  get state() {
+    if ( this.enabled ) {
+      return 'active';
+    }
+
+    return 'inactive';
+  }
+}