@rancher/shell 0.1.2 → 0.1.3

package/models/workload.service.js

@@ -0,0 +1,314 @@
+
+import { findBy } from '@shell/utils/array';
+import { TARGET_WORKLOADS, UI_MANAGED, HCI as HCI_LABELS_ANNOTATIONS } from '@shell/config/labels-annotations';
+import { WORKLOAD_TYPES, SERVICE } from '@shell/config/types';
+import { clone, get } from '@shell/utils/object';
+import SteveModel from '@shell/plugins/steve/steve-class';
+import { shortenedImage } from '@shell/utils/string';
+
+export default class WorkloadService extends SteveModel {
+  async getPortsWithServiceType() {
+    const ports = [];
+
+    this.containers.forEach(container => ports.push(...(container.ports || [])));
+    (this.initContainers || []).forEach(container => ports.push(...(container.ports || [])));
+
+    // Only get services owned if we can access the service resource
+    const canAccessServices = this.$getters['schemaFor'](SERVICE);
+    const services = canAccessServices ? await this.getServicesOwned() : [];
+    const clusterIPServicePorts = [];
+    const loadBalancerServicePorts = [];
+    const nodePortServicePorts = [];
+
+    if (services.length) {
+      services.forEach((svc) => {
+        switch (svc.spec.type) {
+        case 'ClusterIP':
+          clusterIPServicePorts.push(...(svc?.spec?.ports || []));
+          break;
+        case 'LoadBalancer':
+          loadBalancerServicePorts.push(...(svc?.spec?.ports || []));
+          break;
+        case 'NodePort':
+          nodePortServicePorts.push(...(svc?.spec?.ports || []));
+          break;
+        default:
+          break;
+        }
+      });
+    }
+    ports.forEach((port) => {
+      const name = port.name ? port.name : `${ port.containerPort }${ port.protocol.toLowerCase() }${ port.hostPort || port._listeningPort || '' }`;
+
+      port.name = name;
+
+      if (port._serviceType && port._serviceType !== '') {
+        return;
+      }
+
+      if (loadBalancerServicePorts.length) {
+        const portSpec = findBy(loadBalancerServicePorts, 'name', name);
+
+        if (portSpec) {
+          port._listeningPort = portSpec.port;
+
+          port._serviceType = 'LoadBalancer';
+
+          return;
+        }
+      } if (nodePortServicePorts.length) {
+        const portSpec = findBy(nodePortServicePorts, 'name', name);
+
+        if (portSpec) {
+          port._listeningPort = portSpec.nodePort;
+
+          port._serviceType = 'NodePort';
+
+          return;
+        }
+      } if (clusterIPServicePorts.length) {
+        if (findBy(clusterIPServicePorts, 'name', name)) {
+          port._serviceType = 'ClusterIP';
+        }
+      }
+    });
+
+    return ports;
+  }
+
+  async getServicesOwned(force = false) {
+    const normanTypes = {
+      [WORKLOAD_TYPES.REPLICA_SET]:  'replicaSet',
+      [WORKLOAD_TYPES.DEPLOYMENT]:   'deployment',
+      [WORKLOAD_TYPES.STATEFUL_SET]: 'statefulSet',
+      [WORKLOAD_TYPES.DAEMON_SET]:   'daemonSet',
+    };
+    const selectorKey = Object.keys(this.workloadSelector)[0];
+
+    const normanSelectorValue =
+      `${ normanTypes[this._type ? this._type : this.type] }-${
+        this.metadata.namespace
+      }-${ this.metadata.name }`;
+
+    const steveSelectorValue = this.workloadSelector[selectorKey];
+    const allSvc = await this.$dispatch('cluster/findAll', { type: SERVICE, opt: { force } }, { root: true });
+
+    return (allSvc || []).filter(svc => (svc.spec?.selector || {})[selectorKey] === steveSelectorValue || (svc.spec?.selector || {})[selectorKey] === normanSelectorValue );
+  }
+
+  get imageNames() {
+    let containers;
+    const images = [];
+
+    if (this.type === WORKLOAD_TYPES.CRON_JOB) {
+      containers = get(this, 'spec.jobTemplate.spec.template.spec.containers');
+    } else {
+      containers = get(this, 'spec.template.spec.containers');
+    }
+    if (containers) {
+      containers.forEach((container) => {
+        if (!images.includes(container.image)) {
+          images.push(container.image);
+        }
+      });
+    }
+
+    return images.map(shortenedImage);
+  }
+
+  get containers() {
+    if (this.type === WORKLOAD_TYPES.CRON_JOB) {
+      // cronjob pod template is nested slightly different than other types
+      const { spec: { jobTemplate: { spec: { template: { spec: { containers } } } } } } = this;
+
+      return containers;
+    }
+    const { spec:{ template:{ spec:{ containers } } } } = this;
+
+    return containers;
+  }
+
+  get initContainers() {
+    if (this.type === WORKLOAD_TYPES.CRON_JOB) {
+      // cronjob pod template is nested slightly different than other types
+      const { spec: { jobTemplate: { spec: { template: { spec: { initContainers } } } } } } = this;
+
+      return initContainers;
+    }
+    const { spec:{ template:{ spec:{ initContainers } } } } = this;
+
+    return initContainers;
+  }
+
+  get workloadSelector() {
+    return {
+      'workload.user.cattle.io/workloadselector': `${ this._type ? this._type : this.type }-${
+        this.metadata.namespace
+      }-${ this.metadata.name }`
+    };
+  }
+
+  // create clusterip, nodeport, loadbalancer services from container port spec
+  async servicesFromContainerPorts(mode, ports) {
+    const ownerRef = {
+      apiVersion: this.apiVersion,
+      controller: true,
+      kind:       this.kind,
+      name:       this.metadata.name,
+      uid:        this.metadata.uid
+    };
+
+    const annotations = { [TARGET_WORKLOADS]: JSON.stringify([`${ this.metadata.namespace }/${ this.metadata.name }`]), [UI_MANAGED]: 'true' };
+
+    let clusterIP = {
+      type: SERVICE,
+      spec: {
+        ports:    [],
+        selector: this.workloadSelector,
+        type:     'ClusterIP'
+      },
+      metadata: {
+        name:            this.metadata.name,
+        namespace:       this.metadata.namespace,
+        annotations,
+        ownerReferences: [ownerRef]
+      },
+    };
+
+    let nodePort = {
+      type: SERVICE,
+      spec: {
+        ports:    [],
+        selector: this.workloadSelector,
+        type:     'NodePort'
+      },
+      metadata: {
+        name:            `${ this.metadata.name }-nodeport`,
+        namespace:       this.metadata.namespace,
+        annotations,
+        ownerReferences: [ownerRef]
+      },
+    };
+
+    let loadBalancer = {
+      type: SERVICE,
+      spec: {
+        ports:                 [],
+        selector:              this.workloadSelector,
+        type:                  'LoadBalancer',
+        externalTrafficPolicy: 'Cluster'
+      },
+      metadata: {
+        name:            `${ this.metadata.name }-loadbalancer`,
+        namespace:       this.metadata.namespace,
+        annotations,
+        ownerReferences: [ownerRef]
+      },
+    };
+
+    const existing = await this.getServicesOwned(this.isFromNorman);
+
+    if (existing && existing.length) {
+      existing.forEach((service) => {
+        switch (service.spec.type) {
+        case 'ClusterIP':
+          clusterIP = service;
+          clusterIP.spec.ports = [];
+          break;
+        case 'NodePort':
+          nodePort = service;
+          nodePort.spec.ports = [];
+          break;
+        case 'LoadBalancer':
+          loadBalancer = service;
+          loadBalancer.spec.ports = [];
+          break;
+        default:
+          break;
+        }
+      });
+    }
+    ports.forEach((port) => {
+      const portSpec = {
+        name: port.name, protocol: port.protocol, port: port.containerPort, targetPort: port.containerPort
+      };
+
+      if (port._serviceType !== '') {
+        clusterIP.spec.ports.push(portSpec);
+        switch (port._serviceType) {
+        case 'NodePort': {
+          const npPort = clone(portSpec);
+
+          if (port._listeningPort) {
+            npPort.nodePort = port._listeningPort;
+          }
+          nodePort.spec.ports.push(npPort);
+          break; }
+        case 'LoadBalancer': {
+          const lbPort = clone(portSpec);
+
+          if (port._listeningPort) {
+            lbPort.port = port._listeningPort;
+          }
+          loadBalancer.spec.ports.push(lbPort);
+          break; }
+        default:
+          break;
+        }
+      }
+    });
+
+    const toSave = [];
+    const toRemove = [];
+    let clusterIPProxy;
+
+    if (clusterIP.spec.ports.length > 0) {
+      if (clusterIP.id) {
+        clusterIPProxy = clusterIP;
+      } else {
+        clusterIPProxy = await this.$dispatch(`cluster/create`, clusterIP, { root: true });
+      }
+      toSave.push(clusterIPProxy);
+    } else if (clusterIP.id) {
+      toRemove.push(clusterIP);
+    }
+
+    if (nodePort.spec.ports.length > 0) {
+      let nodePortProxy;
+
+      // if id is defined it's a preexisting service
+      if (nodePort.id) {
+        nodePortProxy = nodePort;
+      } else {
+        nodePortProxy = await this.$dispatch(`cluster/create`, nodePort, { root: true });
+      }
+      toSave.push(nodePortProxy);
+      // if id defined but no ports, the service already exists but should be removed (user has removed all container ports mapping to it)
+    } else if (nodePort.id) {
+      toRemove.push(nodePort);
+    }
+
+    if (loadBalancer.spec.ports.length > 0) {
+      let loadBalancerProxy;
+
+      if (loadBalancer.id) {
+        loadBalancerProxy = loadBalancer;
+      } else {
+        loadBalancer = clone(loadBalancer);
+
+        const portsWithIpam = ports.filter(p => p._ipam) || [];
+
+        if (portsWithIpam.length > 0) {
+          loadBalancer.metadata.annotations[HCI_LABELS_ANNOTATIONS.CLOUD_PROVIDER_IPAM] = portsWithIpam[0]._ipam;
+        }
+
+        loadBalancerProxy = await this.$dispatch(`cluster/create`, loadBalancer, { root: true });
+      }
+      toSave.push(loadBalancerProxy);
+    } else if (loadBalancer.id) {
+      toRemove.push(loadBalancer);
+    }
+
+    return { toSave, toRemove };
+  }
+}

package/nuxt.config.js

@@ -141,16 +141,16 @@ export default function(dir, _appConfig) {
       // Package file must have rancher field to be a plugin
       if (includePkg(name) && f.rancher) {
         reqs += `$plugin.initPlugin('${ name }', require(\'~/pkg/${ name }\')); `;
-      }
 
-      // // Serve the code for the UI package in case its used for dynamic loading (but not if the same package was provided in node_modules)
-      // if (!nmPackages[name]) {
-      //   const pkgPackageFile = require(path.join(dir, 'pkg', name, 'package.json'));
-      //   const pkgRef = `${ name }-${ pkgPackageFile.version }`;
+        // // Serve the code for the UI package in case its used for dynamic loading (but not if the same package was provided in node_modules)
+        // if (!nmPackages[name]) {
+        //   const pkgPackageFile = require(path.join(dir, 'pkg', name, 'package.json'));
+        //   const pkgRef = `${ name }-${ pkgPackageFile.version }`;
 
-      //   serverMiddleware.push({ path: `/pkg/${ pkgRef }`, handler: serveStatic(`${ dir }/dist-pkg/${ pkgRef }`) });
-      // }
-      autoImportTypes[`@rancher/auto-import/${ name }`] = generateDynamicTypeImport(`@pkg/${ name }`, path.join(dir, `pkg/${ name }`));
+        //   serverMiddleware.push({ path: `/pkg/${ pkgRef }`, handler: serveStatic(`${ dir }/dist-pkg/${ pkgRef }`) });
+        // }
+        autoImportTypes[`@rancher/auto-import/${ name }`] = generateDynamicTypeImport(`@pkg/${ name }`, path.join(dir, `pkg/${ name }`));
+      }
     });
   }
 
@@ -265,7 +265,9 @@ export default function(dir, _appConfig) {
       dev,
       pl,
       perfTest,
-      rancherEnv
+      rancherEnv,
+      harvesterPkgUrl: process.env.HARVESTER_PKG_URL,
+      api
     },
 
     publicRuntimeConfig: { rancherEnv },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rancher/shell",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Rancher Dashboard Shell",
   "repository": "https://github.com/rancherlabs/dashboard",
   "license": "Apache-2.0",
@@ -84,8 +84,8 @@
     "eslint-import-resolver-node": "0.3.4",
     "eslint-module-utils": "2.6.1",
     "eslint-plugin-cypress": "^2.11.3",
-    "eslint-plugin-jest": "^23.6.0",    
     "eslint-plugin-import": "2.23.4",
+    "eslint-plugin-jest": "^23.6.0",
     "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-vue": "7.14.0",
     "event-target-shim": "^5.0.1",
@@ -158,4 +158,4 @@
       ".vue"
     ]
   }
-}
+}

package/pages/auth/login.vue

@@ -3,6 +3,7 @@ import { removeObject } from '@shell/utils/array';
 import { USERNAME } from '@shell/config/cookies';
 import { LabeledInput } from '@components/Form/LabeledInput';
 import AsyncButton from '@shell/components/AsyncButton';
+import LocaleSelector from '@shell/components/LocaleSelector';
 import BrandImage from '@shell/components/BrandImage';
 import InfoBox from '@shell/components/InfoBox';
 import CopyCode from '@shell/components/CopyCode';
@@ -30,7 +31,7 @@ export default {
   name:       'Login',
   layout:     'unauthenticated',
   components: {
-    LabeledInput, AsyncButton, Checkbox, BrandImage, Banner, InfoBox, CopyCode, Password
+    LabeledInput, AsyncButton, Checkbox, BrandImage, Banner, InfoBox, CopyCode, Password, LocaleSelector
   },
 
   async asyncData({ route, redirect, store }) {
@@ -164,7 +165,7 @@ export default {
 
     kubectlCmd() {
       return "kubectl get secret --namespace cattle-system bootstrap-secret -o go-template='{{.data.bootstrapPassword|base64decode}}{{\"\\n\"}}'";
-    }
+    },
 
   },
 
@@ -393,6 +394,9 @@ export default {
               {{ nonLocalPrompt }}
             </a>
           </div>
+          <div class="locale-elector">
+            <LocaleSelector></LocaleSelector>
+          </div>
         </template>
       </div>
 
@@ -435,4 +439,9 @@ export default {
       }
     }
   }
+
+  .locale-elector {
+    position: absolute;
+    bottom: 30px;
+  }
 </style>

package/pages/auth/setup.vue

@@ -114,7 +114,7 @@ export default {
       setVendor(plSetting.value);
     }
 
-    const productName = plSetting.default === 'Harvester' ? 'Harvester' : 'Rancher';
+    const productName = plSetting.default;
 
     const principals = await store.dispatch('rancher/findAll', { type: NORMAN.PRINCIPAL, opt: { url: '/v3/principals' } });
     const me = findBy(principals, 'me', true);

package/pages/c/_cluster/_product/members/index.vue

@@ -1,96 +1,6 @@
 <script>
-import { MANAGEMENT, NORMAN, VIRTUAL_TYPES } from '@shell/config/types';
-import ResourceTable from '@shell/components/ResourceTable';
-import Loading from '@shell/components/Loading';
-import Masthead from '@shell/components/ResourceList/Masthead';
-import { AGE, ROLE, STATE, PRINCIPAL } from '@shell/config/table-headers';
-import { canViewClusterPermissionsEditor } from '@shell/components/form/Members/ClusterPermissionsEditor.vue';
-import Banner from '@components/Banner/Banner.vue';
-
-/**
- * Explorer members page.
- * Route: /c/local/explorer/members
- */
-export default {
-
-  name: 'ExplorerMembers',
-
-  components: {
-    Banner, Loading, Masthead, ResourceTable
-  },
-
-  async fetch() {
-    const clusterRoleTemplateBindingSchema = this.$store.getters[`rancher/schemaFor`](NORMAN.CLUSTER_ROLE_TEMPLATE_BINDING);
-
-    const hydration = [
-      clusterRoleTemplateBindingSchema ? this.$store.dispatch(`rancher/findAll`, { type: NORMAN.CLUSTER_ROLE_TEMPLATE_BINDING }, { root: true }) : [],
-      clusterRoleTemplateBindingSchema ? this.$store.dispatch(`management/findAll`, { type: MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING }) : [],
-      this.$store.dispatch('rancher/findAll', { type: NORMAN.PRINCIPAL }),
-      this.$store.dispatch(`management/findAll`, { type: MANAGEMENT.USER }),
-      this.$store.dispatch(`management/findAll`, { type: MANAGEMENT.ROLE_TEMPLATE }),
-    ];
-    const [clusterRoleTemplateBindings] = await Promise.all(hydration);
-    const steveBindings = await Promise.all(clusterRoleTemplateBindings.map(b => b.steve));
-
-    this.$set(this, 'clusterRoleTemplateBindings', steveBindings);
-  },
-
-  data() {
-    return {
-      schema:         this.$store.getters[`management/schemaFor`](MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING),
-      headers:        [
-        STATE,
-        PRINCIPAL,
-        ROLE,
-        AGE
-      ],
-      createLocation: {
-        name:   'c-cluster-product-resource-create',
-        params: {
-          product:  this.$store.getters['currentProduct'].name,
-          resource: MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING,
-        }
-      },
-      resource:                    MANAGEMENT.CLUSTER_ROLE_TEMPLATE_BINDING,
-      clusterRoleTemplateBindings: [],
-      VIRTUAL_TYPES
-    };
-  },
-
-  computed: {
-    filteredClusterRoleTemplateBindings() {
-      return this.clusterRoleTemplateBindings
-        .filter(b => b.clusterName === this.$store.getters['currentCluster'].id);
-    },
-    canManageMembers() {
-      return canViewClusterPermissionsEditor(this.$store);
-    },
-    isLocal() {
-      return this.$store.getters['currentCluster'].isLocal;
-    }
-  },
-};
+import ExplorerMembers from '@shell/components/ExplorerMembers';
+export default { components: { ExplorerMembers } };
 </script>
 
-<template>
-  <Loading v-if="$fetchState.pending" />
-  <div v-else>
-    <Masthead
-      :schema="schema"
-      :resource="resource"
-      :favorite-resource="VIRTUAL_TYPES.CLUSTER_MEMBERS"
-      :create-location="createLocation"
-      :create-button-label="t('members.createActionLabel')"
-    />
-    <Banner v-if="isLocal" color="error" :label="t('members.localClusterWarning')" />
-    <ResourceTable
-      :schema="schema"
-      :headers="headers"
-      :rows="filteredClusterRoleTemplateBindings"
-      :groupable="false"
-      :namespaced="false"
-      sub-search="subSearch"
-      :sub-fields="['nameDisplay']"
-    />
-  </div>
-</template>
+<template><ExplorerMembers v-bind="$attrs" /></template>