@rancher/shell 1.2.0 → 2.0.0

package/edit/logging.banzaicloud.io.output/__tests__/logging.banzaicloud.io.output.test.ts

@@ -1,6 +1,109 @@
 import { mount } from '@vue/test-utils';
 import Banzai from '@shell/edit/logging.banzaicloud.io.output/index.vue';
 
+const outputSchema = {
+  id:    'logging.banzaicloud.io.output',
+  type:  'schema',
+  links: {
+    collection: 'https://localhost:8005/v1/logging.banzaicloud.io.outputs',
+    self:       'https://localhost:8005/v1/schemas/logging.banzaicloud.io.output'
+  },
+  pluralName:      'logging.banzaicloud.io.outputs',
+  resourceMethods: [
+    'GET',
+    'DELETE',
+    'PUT',
+    'PATCH'
+  ],
+  _resourceFields:        null,
+  requiresResourceFields: true,
+  collectionMethods:      [
+    'GET',
+    'POST'
+  ],
+  attributes: {
+    columns: [
+      {
+        name:  'Active',
+        field: '.status.active',
+        type:  'boolean'
+      },
+      {
+        name:  'Problems',
+        field: '.status.problemsCount',
+        type:  'integer'
+      }
+    ],
+    group:      'logging.banzaicloud.io',
+    kind:       'Output',
+    namespaced: true,
+    resource:   'outputs',
+    verbs:      [
+      'delete',
+      'deletecollection',
+      'get',
+      'list',
+      'patch',
+      'create',
+      'update',
+      'watch'
+    ],
+    version: 'v1beta1'
+  },
+  _id:                   'logging.banzaicloud.io.output',
+  _group:                'logging.banzaicloud.io',
+  store:                 'cluster',
+  _schemaDefinitionsIds: {
+    self:   'io.banzaicloud.logging.v1beta1.Output',
+    others: [
+      'io.banzaicloud.logging.v1beta1.Output.spec',
+      'io.banzaicloud.logging.v1beta1.Output.spec.awsElasticsearch.buffer'
+    ]
+  },
+  schemaDefinitions: {
+    'io.banzaicloud.logging.v1beta1.Output.spec.awsElasticsearch.buffer': {
+      resourceFields: {
+        chunk_full_threshold:           { type: 'string' },
+        chunk_limit_records:            { type: 'int' },
+        chunk_limit_size:               { type: 'string' },
+        compress:                       { type: 'string' },
+        delayed_commit_timeout:         { type: 'string' },
+        disable_chunk_backup:           { type: 'boolean' },
+        disabled:                       { type: 'boolean' },
+        flush_at_shutdown:              { type: 'boolean' },
+        flush_interval:                 { type: 'string' },
+        flush_mode:                     { type: 'string' },
+        flush_thread_burst_interval:    { type: 'string' },
+        flush_thread_count:             { type: 'int' },
+        flush_thread_interval:          { type: 'string' },
+        overflow_action:                { type: 'string' },
+        path:                           { type: 'string' },
+        queue_limit_length:             { type: 'int' },
+        queued_chunks_limit_size:       { type: 'int' },
+        retry_exponential_backoff_base: { type: 'string' },
+        retry_forever:                  { type: 'boolean' },
+        retry_max_interval:             { type: 'string' },
+        retry_max_times:                { type: 'int' },
+        retry_randomize:                { type: 'boolean' },
+        retry_secondary_threshold:      { type: 'string' },
+        retry_timeout:                  { type: 'string' },
+        retry_type:                     { type: 'string' },
+        retry_wait:                     { type: 'string' },
+        tags:                           { type: 'string' },
+        timekey:                        { type: 'string' },
+        timekey_use_utc:                { type: 'boolean' },
+        timekey_wait:                   { type: 'string' },
+        timekey_zone:                   { type: 'string' },
+        total_limit_size:               { type: 'string' },
+        type:                           { type: 'string' }
+      },
+      type:        'io.banzaicloud.logging.v1beta1.Output.spec.awsElasticsearch.buffer',
+      description: ''
+    }
+  },
+  fetchResourceFields: async() => jest.fn()
+};
+
 describe('view: logging.banzaicloud.io.output', () => {
   it.each([
     ['http://localhost:3100', []],
@@ -15,8 +118,10 @@ describe('view: logging.banzaicloud.io.output', () => {
         }
       },
       mocks: {
-        $store: {
-          getters: {
+        $fetchState: { pending: false },
+        $store:      {
+          dispatch: jest.fn(),
+          getters:  {
             currentStore:              () => 'current_store',
             'management/schemaFor':    jest.fn(),
             'current_store/all':       jest.fn(),
@@ -40,4 +145,129 @@ describe('view: logging.banzaicloud.io.output', () => {
 
     expect((wrapper.vm as any).errors).toStrictEqual(expectation);
   });
+
+  it('should load the default YAML data for output buffer config (from schema) in a CREATE scenario', async() => {
+    const wrapper = mount(Banzai, {
+      data:      () => ({ selectedProvider: 'awsElasticsearch' }),
+      propsData: {
+        value: {
+          save: jest.fn(),
+          spec: {}
+        }
+      },
+      mocks: {
+        $fetchState: { pending: false },
+        $store:      {
+          dispatch(arg: any) {
+            if (arg === 'cluster/find') {
+              return outputSchema;
+            }
+
+            return jest.fn();
+          },
+          getters: {
+            currentStore:              () => 'current_store',
+            'management/schemaFor':    jest.fn(),
+            'current_store/all':       jest.fn(),
+            'current_store/schemaFor': jest.fn(),
+            'cluster/all':             () => [outputSchema],
+            'cluster/byId':            () => outputSchema,
+            'type-map/isSpoofed':      jest.fn(),
+            'i18n/t':                  jest.fn().mockImplementation((key: string) => key),
+            namespaces:                () => ({}),
+          }
+        },
+        $route: {
+          name:  'whatever',
+          query: { AS: '' }
+        },
+        $router: { replace: jest.fn() },
+      }
+    });
+
+    // call async fetch - needed for test assertion
+    await Banzai.fetch.call(wrapper.vm);
+
+    const yaml = `#chunk_limit_records: int
+#chunk_limit_size: string
+#compress: string
+#delayed_commit_timeout: string
+#disable_chunk_backup: boolean
+#disabled: boolean
+#flush_at_shutdown: boolean
+#flush_interval: string
+#flush_mode: string
+#flush_thread_burst_interval: string
+#flush_thread_count: int
+#flush_thread_interval: string
+#overflow_action: string
+#path: string
+#queue_limit_length: int
+#queued_chunks_limit_size: int
+#retry_exponential_backoff_base: string
+#retry_forever: boolean
+#retry_max_interval: string
+#retry_max_times: int
+#retry_randomize: boolean
+#retry_secondary_threshold: string
+#retry_timeout: string
+#retry_type: string
+#retry_wait: string
+#tags: string
+#timekey: string
+#timekey_use_utc: boolean
+#timekey_wait: string
+#timekey_zone: string
+#total_limit_size: string
+#type: string`;
+
+    expect(wrapper.vm.initialBufferYaml).toStrictEqual(yaml);
+    expect(wrapper.vm.bufferYaml).toStrictEqual(yaml);
+  });
+
+  it('should load current output buffer config in an EDIT scenario', async() => {
+    const wrapper = mount(Banzai, {
+      data:      () => ({ selectedProvider: 'awsElasticsearch' }),
+      propsData: {
+        value: {
+          save: jest.fn(),
+          spec: { awsElasticsearch: { buffer: '#chunk_limit_records: int' } }
+        }
+      },
+      mocks: {
+        $fetchState: { pending: false },
+        $store:      {
+          dispatch(arg: any) {
+            if (arg === 'cluster/find') {
+              return outputSchema;
+            }
+
+            return jest.fn();
+          },
+          getters: {
+            currentStore:              () => 'current_store',
+            'management/schemaFor':    jest.fn(),
+            'current_store/all':       jest.fn(),
+            'current_store/schemaFor': jest.fn(),
+            'cluster/all':             jest.fn(),
+            'cluster/byId':            () => outputSchema,
+            'type-map/isSpoofed':      jest.fn(),
+            'i18n/t':                  jest.fn().mockImplementation((key: string) => key),
+            namespaces:                () => ({}),
+          }
+        },
+        $route: {
+          name:  'whatever',
+          query: { AS: '' }
+        },
+        $router: { replace: jest.fn() },
+      }
+    });
+
+    // call async fetch - needed for test assertion
+    await Banzai.fetch.call(wrapper.vm);
+
+    expect(wrapper.vm.initialBufferYaml).toContain('#chunk_limit_records: int');
+    expect(wrapper.vm.bufferYaml).toContain('#chunk_limit_records: int');
+  });
 });

package/edit/logging.banzaicloud.io.output/index.vue

@@ -1,6 +1,7 @@
 <script>
 import CreateEditView from '@shell/mixins/create-edit-view';
-import { SECRET, LOGGING, SCHEMA } from '@shell/config/types';
+import Loading from '@shell/components/Loading';
+import { LOGGING, SCHEMA } from '@shell/config/types';
 import Tabbed from '@shell/components/Tabbed';
 import Tab from '@shell/components/Tabbed/Tab';
 import CruResource from '@shell/components/CruResource';
@@ -19,18 +20,45 @@ import YamlEditor, { EDITOR_MODES } from '@shell/components/YamlEditor';
 
 export default {
   components: {
-    Banner, CruResource, Labels, LabeledSelect, NameNsDescription, Tab, Tabbed, YamlEditor
-  },
+    Banner, CruResource, Labels, LabeledSelect, NameNsDescription, Tab, Tabbed, YamlEditor, Loading
+  }, //
 
   mixins: [CreateEditView],
 
   async fetch() {
-    await this.$store.dispatch('cluster/findAll', { type: SECRET });
+    const schemas = this.$store.getters['cluster/all'](SCHEMA);
+    const resourceSchema = this.$store.getters['cluster/byId'](SCHEMA, LOGGING.OUTPUT);
+    const schemaDefinition = await resourceSchema.fetchResourceFields();
+
+    let bufferYaml = '';
+
+    if ( !isEmpty(this.value.spec[this.selectedProvider]?.buffer) ) {
+      bufferYaml = jsyaml.dump(this.value.spec[this.selectedProvider].buffer);
+    } else if (schemaDefinition) {
+      bufferYaml = createYaml(
+        schemas,
+        `io.banzaicloud.logging.v1beta1.Output.spec.${ this.selectedProvider }.buffer`,
+        {},
+        true,
+        1,
+        '',
+        LOGGING.OUTPUT
+      );
+
+      // createYaml doesn't support passing reference types (array, map) as the first type. As such
+      // I'm manipulating the output since I'm not sure it's something we want to actually support
+      // seeing as it's really createResourceYaml and this here is a gray area between spoofed types
+      // and just a field within a spec.
+      bufferYaml = bufferYaml.substring(bufferYaml.indexOf('\n') + 1).replace(/# {2}/g, '#');
+    }
+
+    if (bufferYaml.length) {
+      this.bufferYaml = bufferYaml;
+      this.initialBufferYaml = bufferYaml;
+    }
   },
 
   data() {
-    const schemas = this.$store.getters['cluster/all'](SCHEMA);
-
     if (this.isCreate) {
       this.value.metadata.namespace = 'default';
     }
@@ -44,8 +72,6 @@ export default {
     }));
 
     if (this.mode !== _VIEW) {
-      this.$set(this.value, 'spec', this.value.spec || {});
-
       providers.forEach((provider) => {
         this.$set(this.value.spec, provider.name, this.value.spec[provider.name] || clone(provider.default));
       });
@@ -58,28 +84,15 @@ export default {
       return !isEmpty(correctedSpecProvider) && !isEqual(correctedSpecProvider, provider.default);
     });
 
-    const selectedProvider = selectedProviders?.[0]?.value || providers[0].value;
-
-    let bufferYaml;
+    const hasMultipleProvidersSelected = selectedProviders?.length > 1;
 
-    if ( !isEmpty(this.value.spec[selectedProvider]?.buffer) ) {
-      bufferYaml = jsyaml.dump(this.value.spec[selectedProvider].buffer);
-    } else {
-      bufferYaml = createYaml(schemas, `logging.banzaicloud.io.v1beta1.output.spec.${ selectedProvider }.buffer`, []);
-      // createYaml doesn't support passing reference types (array, map) as the first type. As such
-      // I'm manipulating the output since I'm not sure it's something we want to actually support
-      // seeing as it's really createResourceYaml and this here is a gray area between spoofed types
-      // and just a field within a spec.
-      bufferYaml = bufferYaml.substring(bufferYaml.indexOf('\n') + 1).replace(/# {2}/g, '#');
-    }
+    const selectedProvider = selectedProviders?.[0]?.value || providers[0].value;
 
     return {
-      bufferYaml,
-      initialBufferYaml:            bufferYaml,
+      bufferYaml: '',
       providers,
       selectedProvider,
-      hasMultipleProvidersSelected: selectedProviders?.length > 1,
-      selectedProviders,
+      hasMultipleProvidersSelected,
       LOGGING
     };
   },
@@ -157,7 +170,11 @@ export default {
 </script>
 
 <template>
-  <div class="output">
+  <Loading v-if="$fetchState.pending" />
+  <div
+    v-else
+    class="output"
+  >
     <CruResource
       :done-route="doneRoute"
       :mode="cruMode"

package/edit/management.cattle.io.podsecurityadmissionconfigurationtemplate.vue

@@ -1,15 +1,15 @@
 <script lang="ts">
-import Vue, { PropType, VueConstructor } from 'vue';
+import { PropType, defineComponent } from 'vue';
 import CreateEditView from '@shell/mixins/create-edit-view';
 import CruResource from '@shell/components/CruResource.vue';
 import PodSecurityAdmission from '@shell/components/PodSecurityAdmission.vue';
 import Loading from '@shell/components/Loading.vue';
 import NameNsDescription from '@shell/components/form/NameNsDescription.vue';
-import { PSA, PSAConfig, PSADefaults, PSAExemptions } from '@shell/types/pod-security-admission';
+import { PSA, PSAConfig, PSADefaults, PSAExemptions } from '@shell/types/resources/pod-security-admission';
 import { PSADimensions } from '@shell/config/pod-security-admission';
 import { MANAGEMENT } from '@shell/config/types';
 
-export default (Vue as VueConstructor<Vue & InstanceType<typeof CreateEditView>>).extend({
+export default defineComponent({
   mixins:     [CreateEditView],
   components: {
     CruResource,

package/edit/management.cattle.io.project.vue

@@ -5,7 +5,6 @@ import CreateEditView from '@shell/mixins/create-edit-view';
 import FormValidation from '@shell/mixins/form-validation';
 import CruResource from '@shell/components/CruResource';
 import Labels from '@shell/components/form/Labels';
-import LabeledSelect from '@shell/components/form/LabeledSelect';
 import ResourceQuota from '@shell/components/form/ResourceQuota/Project';
 import { HARVESTER_TYPES, RANCHER_TYPES } from '@shell/components/form/ResourceQuota/shared';
 import Tab from '@shell/components/Tabbed/Tab';
@@ -21,26 +20,15 @@ import { Banner } from '@components/Banner';
 
 export default {
   components: {
-    ContainerResourceLimit, CruResource, Labels, LabeledSelect, NameNsDescription, ProjectMembershipEditor, ResourceQuota, Tabbed, Tab, Banner
+    ContainerResourceLimit, CruResource, Labels, NameNsDescription, ProjectMembershipEditor, ResourceQuota, Tabbed, Tab, Banner
   },
 
   mixins: [CreateEditView, FormValidation],
-  async fetch() {
-    if ( this.$store.getters['management/canList'](MANAGEMENT.POD_SECURITY_POLICY_TEMPLATE) ) {
-      this.allPSPs = await this.$store.dispatch('management/findAll', { type: MANAGEMENT.POD_SECURITY_POLICY_TEMPLATE });
-    }
-
-    // User can only change the PSP if the user has permissions to see the binding schema for PSP Templates
-    const pspBindingSchema = this.$store.getters['management/schemaFor'](MANAGEMENT.PSP_TEMPLATE_BINDING);
-
-    this.canEditPSPBindings = !!pspBindingSchema;
-  },
   data() {
     this.$set(this.value, 'spec', this.value.spec || {});
     this.$set(this.value.spec, 'podSecurityPolicyTemplateId', this.value.status?.podSecurityPolicyTemplateId || '');
 
     return {
-      allPSPs:                          [],
       projectRoleTemplateBindingSchema: this.$store.getters[`management/schemaFor`](MANAGEMENT.PROJECT_ROLE_TEMPLATE_BINDING),
       createLocation:                   {
         name:   'c-cluster-product-resource-create',
@@ -57,7 +45,6 @@ export default {
       HARVESTER_TYPES,
       RANCHER_TYPES,
       fvFormRuleSets:     [{ path: 'spec.displayName', rules: ['required'] }],
-      canEditPSPBindings: true,
     };
   },
   computed: {
@@ -91,31 +78,6 @@ export default {
       return (this.currentCluster?.spec?.kubernetesVersion || '').includes('k3s');
     },
 
-    pspOptions() {
-      if ( this.isK3s || !this.currentCluster.spec.defaultPodSecurityPolicyTemplateName ) {
-        return null;
-      }
-
-      const out = [{ label: this.t('project.psp.default'), value: '' }];
-
-      if ( this.allPSPs ) {
-        for ( const pspt of this.allPSPs ) {
-          out.push({
-            label: pspt.nameDisplay,
-            value: pspt.id,
-          });
-        }
-      }
-
-      const cur = this.value.status?.podSecurityPolicyTemplateId;
-
-      if ( cur && !out.find((x) => x.value === cur) ) {
-        out.unshift({ label: this.t('project.psp.current', { value: cur }), value: cur });
-      }
-
-      return out;
-    },
-
     isHarvester() {
       return this.$store.getters['currentProduct'].inStore === HARVESTER;
     },
@@ -141,8 +103,9 @@ export default {
   methods: {
     async save(saveCb) {
       try {
-        // clear up of the unused resourceQuotas will now be done on the model side
+        this.errors = [];
 
+        // clear up of the unused resourceQuotas will now be done on the model side
         if (this.mode === _CREATE) {
           const savedProject = await this.value.save();
 
@@ -223,19 +186,6 @@ export default {
       :normalize-name="false"
       :rules="{ name: fvGetAndReportPathRules('spec.displayName'), namespace: [], description: [] }"
     />
-    <div class="row mb-20">
-      <div class="col span-3">
-        <LabeledSelect
-          v-if="pspOptions"
-          v-model="value.spec.podSecurityPolicyTemplateId"
-          class="psp"
-          :mode="mode"
-          :options="pspOptions"
-          :disabled="!canEditPSPBindings"
-          :label="t('project.psp.label')"
-        />
-      </div>
-    </div>
     <Tabbed :side-tabs="true">
       <Tab
         v-if="canViewMembers"

package/edit/management.cattle.io.setting.vue

@@ -2,6 +2,7 @@
 import CruResource from '@shell/components/CruResource';
 import { LabeledInput } from '@components/Form/LabeledInput';
 import LabeledSelect from '@shell/components/form/LabeledSelect';
+import { Banner } from '@components/Banner';
 import CreateEditView from '@shell/mixins/create-edit-view';
 import { TextAreaAutoGrow } from '@components/Form/TextArea';
 import formRulesGenerator from '@shell/utils/validators/formRules/index';
@@ -11,6 +12,7 @@ import { RadioGroup } from '@components/Form/Radio';
 import FormValidation from '@shell/mixins/form-validation';
 import { setBrand } from '@shell/config/private-label';
 import { keyBy, mapValues } from 'lodash';
+import { isLocalhost, isServerUrl } from '@shell/utils/validators/setting';
 
 export default {
   components: {
@@ -18,7 +20,8 @@ export default {
     LabeledInput,
     LabeledSelect,
     RadioGroup,
-    TextAreaAutoGrow
+    TextAreaAutoGrow,
+    Banner
   },
 
   mixins: [CreateEditView, FormValidation],
@@ -40,6 +43,7 @@ export default {
   created() {
     this.value.value = this.value.value || this.value.default;
     this.enumOptions = this.setting?.kind === 'enum' ? this.setting.options.map((id) => ({
+      // i18n-uses advancedSettings.enum.*
       label: `advancedSettings.enum.${ this.value.id }.${ id }`,
       value: id,
     })) : [];
@@ -48,6 +52,12 @@ export default {
       path:  'value',
       rules: this.setting.ruleSet.map(({ name }) => name)
     }] : [];
+
+    // Don't allow the user to reset the server URL if there is no default
+    // helps to ensure that a value is always set
+    if (isServerUrl(this.value.id) && !this.value.default) {
+      this.canReset = false;
+    }
   },
 
   computed: {
@@ -63,6 +73,18 @@ export default {
 
           return factoryArg ? rule(factoryArg) : rule;
         }) : {};
+    },
+
+    showLocalhostWarning() {
+      return isServerUrl(this.value.id) && isLocalhost(this.value.value);
+    },
+
+    showWarningBanner() {
+      return this.setting?.warning;
+    },
+
+    validationPassed() {
+      return this.fvFormIsValid && this.fvGetPathErrors(['value']).length === 0;
     }
   },
 
@@ -98,6 +120,11 @@ export default {
       if (ev && ev.srcElement) {
         ev.srcElement.blur();
       }
+
+      if (isServerUrl(this.value.id) && !this.value.default) {
+        return;
+      }
+
       this.value.value = this.value.default;
     }
   }
@@ -113,11 +140,18 @@ export default {
     :resource="value"
     :subtypes="[]"
     :can-yaml="false"
-    :validation-passed="fvFormIsValid"
+    :validation-passed="validationPassed"
     @error="e=>errors = e"
     @finish="saveSettings"
     @cancel="done"
   >
+    <Banner
+      v-if="showWarningBanner"
+      color="warning"
+      :label="t(`advancedSettings.warnings.${ setting.warning }`)"
+      data-testid="advanced_settings_warning_banner"
+    />
+
     <h4>{{ description }}</h4>
 
     <h5
@@ -129,6 +163,7 @@ export default {
     <div class="edit-change mt-20">
       <h5 v-t="'advancedSettings.edit.changeSetting'" />
       <button
+        data-testid="advanced_settings_use_default"
         :disabled="!canReset"
         type="button"
         class="btn role-primary"
@@ -138,6 +173,21 @@ export default {
       </button>
     </div>
 
+    <Banner
+      v-if="showLocalhostWarning"
+      color="warning"
+      :label="t('validation.setting.serverUrl.localhost')"
+      data-testid="setting-serverurl-localhost-warning"
+    />
+
+    <Banner
+      v-for="(err, i) in fvGetPathErrors(['value'])"
+      :key="i"
+      color="error"
+      :label="err"
+      data-testid="setting-error-banner"
+    />
+
     <div class="mt-20">
       <div v-if="setting.kind === 'enum'">
         <LabeledSelect

package/edit/management.cattle.io.user.vue

@@ -8,6 +8,7 @@ import CruResource from '@shell/components/CruResource';
 import { exceptionToErrorsArray } from '@shell/utils/error';
 import { _CREATE, _EDIT } from '@shell/config/query-params';
 import Loading from '@shell/components/Loading';
+import { wait } from '@shell/utils/async';
 
 export default {
   components: {
@@ -159,7 +160,7 @@ export default {
         // - Fetching the norman user again sometimes shows the correct value, sometimes not
         // - Even if the fetched norman user shows the correct value, it doesn't show up in the steve user
         //   - Looks like we re-request the stale version via socket?
-        await new Promise((resolve) => setTimeout(resolve, 5000));
+        await wait(5000);
       }
 
       // Save user updates