@rancher/shell 3.0.5-rc.5 → 3.0.5-rc.7

package/components/formatter/WorkloadHealthScale.vue

@@ -182,7 +182,7 @@ export default {
     <div
       id="trigger"
       class="hs-popover__trigger"
-      aria-role="button"
+      role="button"
       tabindex="0"
       :class="{expanded}"
       :aria-roledescription="t('workload.scaleWorkloads')"

package/components/formatter/__tests__/LiveDate.test.ts

@@ -16,6 +16,15 @@ const defaultMock = {
 };
 
 describe('component: LiveDate', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+    jest.setSystemTime(new Date('2025-07-10T10:00:00.000Z'));
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
   it('should show a dash if no date is provided', () => {
     const wrapper = mount(LiveDate as unknown as ExtendedVue<Vue, {}, {}, {}, DefaultProps>, { global: { mocks: defaultMock } });
     const element = wrapper.find('span');
@@ -55,8 +64,7 @@ describe('component: LiveDate', () => {
     let element = wrapper.find('span');
 
     expect(element.text()).toContain('Just now');
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-    await wrapper.vm.liveUpdate(Date.now());
+    await wrapper.vm.liveUpdate(Date.now() + 1000);
 
     element = wrapper.find('span');
     expect(element.text()).toContain('1 %unit.sec%');

package/components/google/AccountAccess.vue

@@ -0,0 +1,209 @@
+<script lang="ts">
+import { defineComponent } from 'vue';
+import { _CREATE, _VIEW } from '@shell/config/query-params';
+import LabeledInput from '@components/Form/LabeledInput/LabeledInput.vue';
+import SelectCredential from '@shell/edit/provisioning.cattle.io.cluster/SelectCredential.vue';
+import AsyncButton from '@shell/components/AsyncButton.vue';
+import { mapGetters, Store } from 'vuex';
+import { getGKEZones } from '@shell/components/google/util/gcp';
+
+export default defineComponent({
+  name: 'GKEAccountAccess',
+
+  emits: ['update:isAuthenticated', 'error', 'update:project', 'cancel-credential', 'update:credential'],
+
+  components: {
+    LabeledInput,
+    SelectCredential,
+    AsyncButton
+  },
+
+  props: {
+    mode: {
+      type:    String,
+      default: _CREATE
+    },
+
+    credential: {
+      type:    String,
+      default: null
+    },
+
+    project: {
+      type:    String,
+      default: ''
+    },
+
+    isAuthenticated: {
+      type:    Boolean,
+      default: false
+    },
+  },
+
+  created() {
+    if (this.mode === _VIEW) {
+      this.$emit('update:isAuthenticated', true);
+    }
+  },
+
+  computed: {
+    ...mapGetters({ t: 'i18n/t' }),
+
+    CREATE(): string {
+      return _CREATE;
+    },
+
+    VIEW(): string {
+      return _VIEW;
+    },
+
+    isView():boolean {
+      return this.mode === _VIEW;
+    }
+
+  },
+
+  methods: {
+    async testProjectId(cb: (success: Boolean)=>{}) {
+      const store = this.$store as Store<any>;
+
+      try {
+        await getGKEZones(store, this.credential, this.project, {});
+
+        this.$emit('update:isAuthenticated', true);
+
+        // eslint-disable-next-line node/no-callback-literal
+        return cb(true);
+      } catch (e) {
+        this.$emit('error', e?.data || e);
+        this.$emit('update:isAuthenticated', false);
+
+        // eslint-disable-next-line node/no-callback-literal
+        return cb(false);
+      }
+    },
+
+    // gcp credentials include a project id - we can grab that and auto-fill to save users having to manually enter it
+    // this only applies to new credentials because of the way credential data is stored
+    parseNewCredential(e) {
+      const authJson = e?.googlecredentialConfig?.authEncodedJson;
+
+      if (authJson) {
+        try {
+          // eslint-disable-next-line camelcase
+          const { project_id:projectId } = JSON.parse(authJson);
+
+          if (projectId) {
+            this.$emit('update:project', projectId);
+          }
+        } catch (e) {
+
+        }
+      }
+    }
+  },
+});
+</script>
+
+<template>
+  <div
+    :class="{'showing-form': !credential}"
+    class="credential-project"
+  >
+    <div
+      v-show="!!credential"
+      class="project mb-10"
+    >
+      <LabeledInput
+        :disabled="isAuthenticated"
+        :value="project"
+        label-key="gke.project.label"
+        required
+        @update:value="(val) => $emit('update:project', val.trim())"
+      />
+    </div>
+    <div
+      :class="{'view': isView}"
+      class="select-credential-container"
+    >
+      <SelectCredential
+        :value="credential"
+        data-testid="crugke-select-credential"
+        :mode="(isView|| isAuthenticated) ? VIEW : CREATE"
+        provider="gcp"
+        :default-on-cancel="true"
+        :showing-form="!credential"
+        class="select-credential"
+        :cancel="()=>$emit('cancel-credential')"
+        @update:value="$emit('update:credential', $event)"
+        @credential-created="parseNewCredential"
+      />
+    </div>
+  </div>
+  <div
+    v-if="!isView && !isAuthenticated && !!credential"
+    class="row mt-10"
+  >
+    <div
+      v-show="!!credential"
+      class="auth-button-container mb-10"
+    >
+      <AsyncButton
+        :disabled="!credential || !project || isAuthenticated"
+        type="button"
+        class="btn"
+        mode="authenticate"
+        @click="testProjectId"
+      />
+    </div>
+  </div>
+</template>
+
+<style scoped lang="scss">
+  .credential-project {
+    display: flex;
+    min-width: 150px;
+    .project {
+      flex-basis: 49.25%;
+      flex-grow: 0;
+      margin: 0 1.75% 0 0;
+    }
+
+    &.showing-form {
+      flex-grow:1;
+      flex-direction: column;
+
+      &>.project {
+        margin: 0;
+      }
+
+      &>.select-credential-container{
+      display:flex;
+      flex-direction: column;
+      flex-grow: 1;
+      }
+    }
+
+    &>.select-credential-container{
+      flex-basis: 49.25%;
+
+      &.view{
+        margin: 0;
+      }
+
+      &>.select-credential{
+        flex-grow: 1;
+      }
+
+    }
+  }
+
+  .auth-button-container {
+    align-content: center;
+    width: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: flex-start;
+  }
+
+</style>

package/components/google/types/gcp.d.ts

@@ -0,0 +1,136 @@
+interface GKEVersionChannel {
+  channel: 'RAPID' | 'REGULAR' | 'STABLE',
+  defaultVersion: string,
+  validVersions: string[]
+}
+
+interface GKENetwork {
+  autoCreateSubnetworks: boolean,
+  creationTimestamp: string,
+  id: string,
+  kind: string,
+  mtu: number,
+  name: string,
+  networkFirewallPolicyEnforcementOrder: string,
+  routingConfig: {
+    routingMode: string
+  },
+  selfLink: string,
+  selfLinkWIthId: string,
+  subnetworks: string[]
+}
+
+interface GKEImage {
+    id: string,
+}
+
+export interface GKESubnetwork{
+  creationTimestamp?: string,
+  fingerprint?: string,
+  gatewayAddress?: string,
+  id?: string,
+  ipCidrRange: string,
+  kind?: string,
+  name?: string,
+  network: string,
+  privateIpGoogleAccess?: boolean,
+  purpose?: string,
+  region?: string,
+  secondaryIpRanges?: {
+    ipCidrRange: string,
+    rangeName: string,
+    status?: string,
+  }[],
+  selfLink?: string,
+  stackType?: string
+  subnetwork?: string
+}
+
+export interface GKEMachineType {
+  creationTimestamp?: string,
+  description?: string,
+  guestCpus?: number,
+  id?: string,
+  kind?: string,
+  maximumPersistentDisks?: number,
+  maximumPersistentDisksSizeGb?: string,
+  memoryMb?: number,
+  name: string,
+  selfLink?: string,
+  zone?: string
+}
+
+export interface GKEZone {
+  availableCpuPlatforms: string[]
+  creationTimestamp: string,
+  description: string,
+  id: string,
+  kind: string,
+  name: string,
+  region: string,
+  selfLink: string,
+  status: string
+  disabled?: boolean,
+  sortName?: string
+}
+
+export interface GKEServiceAccount {
+  displayName: string,
+  email: string,
+  etag: string,
+  name: string,
+  oauth2ClientId: string,
+  projectId: string,
+  uniqueId: string
+}
+
+export interface getGKEVersionsResponse {
+  channels: GKEVersionChannel[],
+  defaultClusterVersion: string,
+  defaultImageType: string,
+  validImageTypes: string[],
+  validMasterVersions: string[],
+  validNodeVersions: string[]
+}
+
+export interface getGKENetworksResponse {
+  id: string,
+  items: GKENetwork[],
+  kind: string,
+  selfLink: string
+}
+
+export interface getGKESubnetworksResponse {
+  id: string,
+  items: GKESubnetwork[],
+  kind: string,
+  selfLink: string
+}
+export interface getGKESharedSubnetworksResponse {
+  subnetworks: GKESubnetwork[]
+}
+
+export interface getGKEClustersResponse {
+  clusters: {
+    name: string,
+    releaseChannel?: {
+        channel?:string
+      },
+    status?: string
+  }[]
+}
+
+export interface getGKEMachineTypesResponse {
+  items: GKEMachineType[]
+}
+
+export interface getGKEZonesResponse {
+  items: GKEZone[]
+}
+
+export interface getGKEServiceAccountsResponse {
+  accounts: GKEServiceAccount[]
+}
+export interface getGKEImageFamiliesResponse {
+    images: GKEImage[]
+  }

package/components/google/types/index.d.ts

@@ -0,0 +1,101 @@
+import { GKEMachineType, GKENetwork, GKESubnetwork } from '@shell/components/google/types/gcp';
+
+export interface GKENodePool {
+  autoscaling: {
+    enabled?: boolean,
+    maxNodeCount?: number,
+    minNodeCount?: number
+  },
+  config: {
+    diskSizeGb?: number,
+    diskType?: string,
+    imageType?: string,
+    labels?: any,
+    localSsdCount?: number,
+    machineType?: string,
+    serviceAccount?: string | null,
+    oauthScopes?: string[],
+    preemptible?: boolean,
+    taints?: any,
+    tags?: any
+  },
+  initialNodeCount?: number,
+  management: {
+    autoRepair?: boolean,
+    autoUpgrade?: boolean
+  },
+  maxPodsConstraint?: number,
+  name: string,
+  version?: string,
+  _isNewOrUnprovisioned?: boolean
+  _id?: string
+  _minMaxValid?: boolean
+  _nameUnique?: boolean
+}
+
+export interface GKEConfig {
+  imported: boolean,
+  clusterAddons: {
+    horizontalPodAutoscaling: boolean,
+    httpLoadBalancing: boolean,
+    networkPolicyConfig: boolean
+  },
+  clusterIpv4Cidr: string,
+  clusterName: string,
+  description: string,
+  enableKubernetesAlpha: boolean,
+  googleCredentialSecret: string,
+  ipAllocationPolicy: {
+    clusterIpv4CidrBlock: string,
+    clusterSecondaryRangeName?: any,
+    createSubnetwork: boolean,
+    nodeIpv4CidrBlock?: any,
+    servicesIpv4CidrBlock: string,
+    servicesSecondaryRangeName?: any,
+    subnetworkName?: any,
+    useIpAliases: boolean,
+    clusterIpv4Cidr: string
+  },
+  kubernetesVersion: string,
+  labels: any,
+  locations: any[],
+  loggingService: string,
+  maintenanceWindow: string,
+  masterAuthorizedNetworks: { enabled: boolean, cidrBlocks?: string[] },
+  monitoringService: string,
+  network: string,
+  networkPolicyEnabled: boolean,
+  nodePools: GKENodePool[],
+  privateClusterConfig: {
+    enablePrivateEndpoint: boolean,
+    enablePrivateNodes: boolean,
+    masterIpv4CidrBlock?: any
+  },
+  projectID: string,
+  region: string,
+  subnetwork: string,
+  zone: string
+}
+
+export interface GKEMachineTypeOption extends GKEMachineType {
+  label: string,
+  kind?:string,
+  value?:string,
+  disabled?:boolean,
+}
+
+export interface GKENetworkOption extends Partial<GKENetwork>{
+  label: string,
+  kind?: string,
+  disabled?: boolean,
+}
+
+export interface GKESubnetworkOption extends Partial<GKESubnetwork>{
+  label: string,
+}
+
+export interface GKESecondaryRangeOption {
+  label: string,
+  rangeName: string,
+  ipCidrRange?: string
+}