@rancher/shell 0.1.1 → 0.1.3

package/models/workload.js

@@ -1,16 +1,13 @@
 import { findBy, insertAt } from '@shell/utils/array';
-import {
-  TARGET_WORKLOADS, TIMESTAMP, UI_MANAGED, HCI as HCI_LABELS_ANNOTATIONS, CATTLE_PUBLIC_ENDPOINTS
-} from '@shell/config/labels-annotations';
+import { TIMESTAMP, CATTLE_PUBLIC_ENDPOINTS } from '@shell/config/labels-annotations';
 import { WORKLOAD_TYPES, SERVICE, POD } from '@shell/config/types';
-import { clone, get, set } from '@shell/utils/object';
+import { get, set } from '@shell/utils/object';
 import day from 'dayjs';
-import SteveModel from '@shell/plugins/steve/steve-class';
-import { shortenedImage } from '@shell/utils/string';
 import { convertSelectorObj, matching, matches } from '@shell/utils/selector';
 import { SEPARATOR } from '@shell/components/DetailTop';
+import WorkloadService from '@shell/models/workload.service';
 
-export default class Workload extends SteveModel {
+export default class Workload extends WorkloadService {
   // remove clone as yaml/edit as yaml until API supported
   get _availableActions() {
     let out = super._availableActions;
@@ -279,30 +276,6 @@ export default class Workload extends SteveModel {
     return out;
   }
 
-  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 endpoint() {
     return this?.metadata?.annotations[CATTLE_PUBLIC_ENDPOINTS];
   }
@@ -441,46 +414,6 @@ export default class Workload extends SteveModel {
     return out;
   }
 
-  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);
-  }
-
   redeploy() {
     const now = (new Date()).toISOString().replace(/\.\d+Z$/, 'Z');
 
@@ -496,14 +429,6 @@ export default class Workload extends SteveModel {
     this.save();
   }
 
-  get workloadSelector() {
-    return {
-      'workload.user.cattle.io/workloadselector': `${ this._type ? this._type : this.type }-${
-        this.metadata.namespace
-      }-${ this.metadata.name }`
-    };
-  }
-
   // match existing container ports with services created for this workload
   async getPortsWithServiceType() {
     const ports = [];
@@ -574,170 +499,6 @@ export default class Workload extends SteveModel {
     return ports;
   }
 
-  // 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 };
-  }
-
   get showAsWorkload() {
     const types = Object.values(WORKLOAD_TYPES);
 

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 },
@@ -305,8 +307,9 @@ export default function(dir, _appConfig) {
     },
 
     router: {
-      base:       routerBasePath,
-      middleware: ['i18n'],
+      base:          routerBasePath,
+      middleware:    ['i18n'],
+      prefetchLinks: false
     },
 
     alias: {
@@ -570,7 +573,6 @@ export default function(dir, _appConfig) {
       path.join(NUXT_SHELL, 'plugins/global-formatters'),
       path.join(NUXT_SHELL, 'plugins/trim-whitespace'),
       { src: path.join(NUXT_SHELL, 'plugins/extend-router') },
-      { src: path.join(NUXT_SHELL, 'plugins/lookup'), ssr: false },
       { src: path.join(NUXT_SHELL, 'plugins/console'), ssr: false },
       { src: path.join(NUXT_SHELL, 'plugins/int-number'), ssr: false },
       { src: path.join(NUXT_SHELL, 'plugins/nuxt-client-init'), ssr: false },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rancher/shell",
-  "version": "0.1.1",
+  "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"
     ]
   }
-}
+}