@rancher/shell 0.1.2 → 0.1.3

package/models/harvesterhci.io.management.cluster.js

@@ -1,11 +1,10 @@
 import Vue from 'vue';
 import ProvCluster from '@shell/models/provisioning.cattle.io.cluster';
-import { DEFAULT_WORKSPACE } from '@shell/config/types';
-export default class HciCluster extends ProvCluster {
-  get availableActions() {
-    return this._availableActions;
-  }
+import { DEFAULT_WORKSPACE, HCI, MANAGEMENT } from '@shell/config/types';
+import { HARVESTER_NAME, HARVESTER_NAME as VIRTUAL } from '@shell/config/product/harvester-manager';
+import { SETTING } from '@shell/config/settings';
 
+export default class HciCluster extends ProvCluster {
   get stateObj() {
     return this._stateObj;
   }
@@ -30,4 +29,194 @@ export default class HciCluster extends ProvCluster {
   get canEdit() {
     return false;
   }
+
+  cachedHarvesterClusterVersion = '';
+
+  _uiInfo = undefined;
+
+  /**
+   * Fetch and cache the response for /ui-info
+   *
+   * Storing this in a cache means any changes to `ui-info` require a dashboard refresh... but it cuts out a http request every time we
+   * go to a cluster
+   *
+   * @param {string} clusterId
+   */
+  async _getUiInfo(clusterId) {
+    if (!this._uiInfo) {
+      try {
+        const infoUrl = `/k8s/clusters/${ clusterId }/v1/harvester/ui-info`;
+
+        this._uiInfo = await this.$dispatch('request', { url: infoUrl });
+      } catch (e) {
+        console.info(`Failed to fetch harvester ui-info from ${ this.nameDisplay }, this may be an older cluster that cannot provide one`); // eslint-disable-line no-console
+      }
+    }
+
+    return this._uiInfo;
+  }
+
+  /**
+   * Determine the harvester plugin's package name and url for legacy clusters that don't provide the package (i.e. it's coming from
+   * outside the cluster)
+   */
+  _legacyClusterPkgDetails() {
+    let uiOfflinePreferred = this.$rootGetters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_OFFLINE_PREFERRED)?.value;
+    // options: ['dynamic', 'true', 'false']
+
+    if (uiOfflinePreferred === 'dynamic') {
+      // We shouldn't need to worry about the version of the dashboard when embedded in harvester (aka in isSingleProduct)
+      const version = this.$rootGetters['management/byId'](MANAGEMENT.SETTING, 'server-version')?.value;
+
+      if (version.endsWith('-head')) {
+        uiOfflinePreferred = 'false';
+      } else {
+        uiOfflinePreferred = 'true';
+      }
+    }
+
+    // This is the version that's embedded in the dashboard
+    const pkgName = `${ HARVESTER_NAME }-1.0.3`;
+
+    if (uiOfflinePreferred === 'true') {
+      // Embedded (aka give me the version of the embedded plugin that was in the last release)
+      const embeddedPath = `dashboard/${ pkgName }/${ pkgName }.umd.min.js`;
+
+      return {
+        pkgUrl: process.env.dev ? `${ process.env.api }/${ embeddedPath }` : embeddedPath,
+        pkgName
+      };
+    }
+
+    if (uiOfflinePreferred === 'false') {
+      // Remote (aka give me the latest version of the embedded plugin that might not have been released yet)
+      const uiDashboardHarvesterRemotePlugin = this.$rootGetters['management/byId'](MANAGEMENT.SETTING, SETTING.UI_DASHBOARD_HARVESTER_LEGACY_PLUGIN)?.value;
+      const parts = uiDashboardHarvesterRemotePlugin?.replace('.umd.min.js', '').split('/');
+      const pkgNameFromUrl = parts?.length > 1 ? parts[parts.length - 1] : null;
+
+      if (!pkgNameFromUrl) {
+        throw new Error(`Unable to determine harvester plugin name from '${ uiDashboardHarvesterRemotePlugin }'`);
+      }
+
+      return {
+        pkgUrl:  uiDashboardHarvesterRemotePlugin,
+        pkgName: pkgNameFromUrl
+      };
+    }
+
+    throw new Error(`Unsupported value for ${ SETTING.UI_OFFLINE_PREFERRED }: 'uiOfflinePreferred'`);
+  }
+
+  /**
+   * Determine the harvester plugin's package name and url for clusters that provide the plugin
+   */
+  _supportedClusterPkgDetails(uiInfo, clusterId) {
+    const pkgName = `${ HARVESTER_NAME }-${ uiInfo['ui-plugin-bundled-version'] }`;
+    const fileName = `${ pkgName }.umd.min.js`;
+    let pkgUrl;
+
+    if (uiInfo['ui-source'] === 'bundled' ) { // offline bundled
+      pkgUrl = `k8s/clusters/${ clusterId }/v1/harvester/plugin-assets/${ fileName }`;
+    } else if (uiInfo['ui-source'] === 'external') {
+      if (uiInfo['ui-plugin-index']) {
+        pkgUrl = uiInfo['ui-plugin-index'];
+      } else {
+        throw new Error('Harvester cluster requested the plugin at `ui-plugin-index` is used, however did not provide a value for it');
+      }
+    }
+
+    return {
+      pkgUrl,
+      pkgName
+    };
+  }
+
+  _overridePkgDetails() {
+    // Support loading the pkg from a locally, or other, address
+    // This helps testing of the harvester plugin when packaged up, instead of directly imported
+    const harvesterPkgUrl = process.env.harvesterPkgUrl;
+
+    if (!harvesterPkgUrl) {
+      return;
+    }
+    const parts = harvesterPkgUrl.replace('.umd.min.js', '').split('/');
+    const pkgNameFromUrl = parts.length > 1 ? parts[parts.length - 1] : null;
+
+    if (pkgNameFromUrl) {
+      return {
+        pkgUrl:  harvesterPkgUrl,
+        pkgName: pkgNameFromUrl
+      };
+    }
+  }
+
+  async _pkgDetails() {
+    const overridePkgDetails = this._overridePkgDetails();
+
+    if (overridePkgDetails) {
+      return overridePkgDetails;
+    }
+
+    const clusterId = this.mgmt.id;
+    const uiInfo = await this._getUiInfo(clusterId);
+
+    return uiInfo ? this._supportedClusterPkgDetails(uiInfo, clusterId) : this._legacyClusterPkgDetails();
+  }
+
+  async loadClusterPlugin() {
+    // Skip loading if it's built in
+    const plugins = this.$rootState.$plugin.getPlugins();
+    const loadedPkgs = Object.keys(plugins);
+
+    if (loadedPkgs.find(pkg => pkg === HARVESTER_NAME)) {
+      console.info('Harvester plugin built is built in, skipping load from external sources'); // eslint-disable-line no-console
+
+      return;
+    }
+
+    // Determine the plugin name and the url it can be fetched from
+    const { pkgUrl, pkgName } = await this._pkgDetails();
+
+    console.info('Harvester plugin details: ', pkgName, pkgUrl); // eslint-disable-line no-console
+
+    // Skip loading if we've previously loaded the correct one
+    if (!!plugins[pkgName]) {
+      console.info('Harvester plugin already loaded, no need to load', pkgName); // eslint-disable-line no-console
+
+      return;
+    }
+
+    console.info('Attempting to load Harvester plugin', pkgName); // eslint-disable-line no-console
+
+    const res = await this.$rootState.$plugin.loadAsync(pkgName, pkgUrl);
+
+    console.info('Loaded Harvester plugin', pkgName); // eslint-disable-line no-console
+
+    return res;
+  }
+
+  goToCluster() {
+    this.loadClusterPlugin()
+      .then(() => {
+        this.currentRouter().push({
+          name:   `${ VIRTUAL }-c-cluster-resource`,
+          params: {
+            cluster:  this.status.clusterName,
+            product:  VIRTUAL,
+            resource: HCI.DASHBOARD // Go directly to dashboard to avoid blip of components on screen
+          }
+        });
+      })
+      .catch((err) => {
+        const message = typeof error === 'object' ? JSON.stringify(err) : err;
+
+        console.error('Failed to load harvester package: ', message); // eslint-disable-line no-console
+
+        this.$dispatch('growl/error', {
+          title:   this.t('harvesterManager.plugins.loadError'),
+          message,
+          timeout: 5000
+        }, { root: true });
+      });
+  }
 }

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

@@ -9,7 +9,7 @@ import jsyaml from 'js-yaml';
 import { eachLimit } from '@shell/utils/promise';
 import { addParams } from '@shell/utils/url';
 import { isEmpty } from '@shell/utils/object';
-import { NAME as HARVESTER } from '@shell/config/product/harvester';
+import { HARVESTER_NAME as HARVESTER } from '@shell/config/product/harvester-manager';
 import { isHarvesterCluster } from '@shell/utils/cluster';
 import HybridModel from '@shell/plugins/steve/hybrid-class';
 import { LINUX, WINDOWS } from '@shell/store/catalog';

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

@@ -2,6 +2,7 @@ import { CREATOR_ID } from '@shell/config/labels-annotations';
 import { _CREATE } from '@shell/config/query-params';
 import { MANAGEMENT, NORMAN } from '@shell/config/types';
 import HybridModel from '@shell/plugins/steve/hybrid-class';
+import { HARVESTER_NAME } from '@shell/config/product/harvester-manager';
 
 export default class CRTB extends HybridModel {
   detailPageHeaderActionOverride(realMode) {
@@ -65,6 +66,9 @@ export default class CRTB extends HybridModel {
     return this.cluster ? this.cluster.nameDisplay : this.clusterName;
   }
 
+  /**
+   * This is used in a table formatter on the management.cattle.io.user detail view which exists outside harvester so no override on this route as there is with listLocation
+   */
   get clusterDetailLocation() {
     if (this.cluster) {
       return this.cluster.detailLocation;
@@ -82,6 +86,11 @@ export default class CRTB extends HybridModel {
   }
 
   get listLocation() {
+    // Harvester uses these resource directly... but has different routes
+    if (this.$rootGetters['currentProduct'].inStore === HARVESTER_NAME) {
+      return { name: `${ HARVESTER_NAME }-c-cluster-members` };
+    }
+
     return { name: 'c-cluster-product-members' };
   }
 

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

@@ -2,6 +2,7 @@ import { DEFAULT_PROJECT, SYSTEM_PROJECT } from '@shell/config/labels-annotation
 import { MANAGEMENT, NAMESPACE, NORMAN } from '@shell/config/types';
 import HybridModel from '@shell/plugins/steve/hybrid-class';
 import isEmpty from 'lodash/isEmpty';
+import { HARVESTER_NAME as HARVESTER } from '@shell/config/product/harvester-manager';
 
 function clearUnusedResourceQuotas(spec, types) {
   types.forEach((type) => {
@@ -61,10 +62,30 @@ export default class Project extends HybridModel {
     });
   }
 
+  get doneOverride() {
+    return this.listLocation;
+  }
+
   get listLocation() {
+    // Harvester uses these resource directly... but has different routes. listLocation covers routes leading back to route
+    if (this.$rootGetters['currentProduct'].inStore === HARVESTER) {
+      return { name: `${ HARVESTER }-c-cluster-projectsnamespaces` };
+    }
+
     return { name: 'c-cluster-product-projectsnamespaces' };
   }
 
+  get _detailLocation() {
+    // Harvester uses these resource directly... but has different routes. detailLocation covers routes leading to resource (like edit)
+    const _detailLocation = super._detailLocation;
+
+    if (this.$rootGetters['currentProduct'].inStore === HARVESTER) {
+      _detailLocation.name = `${ HARVESTER }-${ _detailLocation.name }`.replace('-product', '');
+    }
+
+    return _detailLocation;
+  }
+
   get parentLocationOverride() {
     return this.listLocation;
   }
@@ -81,9 +102,9 @@ export default class Project extends HybridModel {
     try {
       await newValue.doAction('setpodsecuritypolicytemplate', { podSecurityPolicyTemplateId: this.spec.podSecurityPolicyTemplateId || null });
     } catch (err) {
-      if (err.status === 409) {
+      if ( err.status === 409 || err.status === 403 ) {
         // The backend updates each new project soon after it is created,
-        // so there is a chance of a resource conflict error. If that happens,
+        // so there is a chance of a resource conflict or forbidden error. If that happens,
         // retry the action.
         await newValue.doAction('setpodsecuritypolicytemplate', { podSecurityPolicyTemplateId: this.spec.podSecurityPolicyTemplateId || null });
       } else {

package/models/namespace.js

@@ -9,6 +9,7 @@ import { escapeHtml } from '@shell/utils/string';
 import { insertAt, isArray } from '@shell/utils/array';
 import SteveModel from '@shell/plugins/steve/steve-class';
 import Vue from 'vue';
+import { HARVESTER_NAME as HARVESTER } from '@shell/config/product/harvester-manager';
 
 const OBSCURE_NAMESPACE_PREFIX = [
   'c-', // cluster namespace
@@ -172,11 +173,26 @@ export default class Namespace extends SteveModel {
   }
 
   get listLocation() {
-    if (this.$rootGetters['isSingleProduct']) {
-      return { name: 'c-cluster-product-resource' };
+    const listLocation = { name: this.$rootGetters['isRancher'] ? 'c-cluster-product-projectsnamespaces' : 'c-cluster-product-resource' };
+
+    // Harvester uses these resource directly... but has different routes. listLocation covers routes leading back to route
+    if (this.$rootGetters['currentProduct'].inStore === HARVESTER) {
+      listLocation.name = `${ HARVESTER }-${ listLocation.name }`.replace('-product', '');
+      listLocation.params = { resource: 'namespace' };
+    }
+
+    return listLocation;
+  }
+
+  get _detailLocation() {
+    const _detailLocation = super._detailLocation;
+
+    // Harvester uses these resource directly... but has different routes. detailLocation covers routes leading to resource (like edit)
+    if (this.$rootGetters['currentProduct'].inStore === HARVESTER) {
+      _detailLocation.name = `${ HARVESTER }-${ _detailLocation.name }`.replace('-product', '');
     }
 
-    return { name: this.$rootGetters['isRancher'] ? 'c-cluster-product-projectsnamespaces' : 'c-cluster-product-namespaces' };
+    return _detailLocation;
   }
 
   get parentLocationOverride() {

package/models/pod.js

@@ -1,8 +1,8 @@
 import { insertAt } from '@shell/utils/array';
 import { colorForState, stateDisplay } from '@shell/plugins/dashboard-store/resource-class';
 import { NODE, WORKLOAD_TYPES } from '@shell/config/types';
-import SteveModel from '@shell/plugins/steve/steve-class';
 import { escapeHtml, shortenedImage } from '@shell/utils/string';
+import WorkloadService from '@shell/models/workload.service';
 
 export const WORKLOAD_PRIORITY = {
   [WORKLOAD_TYPES.DEPLOYMENT]:             1,
@@ -14,7 +14,7 @@ export const WORKLOAD_PRIORITY = {
   [WORKLOAD_TYPES.REPLICATION_CONTROLLER]: 7,
 };
 
-export default class Pod extends SteveModel {
+export default class Pod extends WorkloadService {
   get _availableActions() {
     const out = super._availableActions;
 
@@ -180,4 +180,21 @@ export default class Pod extends SteveModel {
 
     return 0;
   }
+
+  save() {
+    const { metadata, spec } = this.spec.template;
+
+    this.spec = {
+      ...this.spec,
+      metadata: {
+        ...this.metadata,
+        ...metadata
+      },
+      ...spec
+    };
+
+    delete this.spec.template;
+
+    return this._save(...arguments);
+  }
 }

package/models/provisioning.cattle.io.cluster.js

@@ -269,6 +269,10 @@ export default class ProvCluster extends SteveModel {
     return !!this.mgmt?.isReady;
   }
 
+  get eksNodeGroups() {
+    return this.mgmt?.spec?.eksConfig?.nodeGroups;
+  }
+
   waitForProvisioner(timeout, interval) {
     return this.waitForTestFn(() => {
       return !!this.provisioner;

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);