@spinnaker/google 2026.2.2 → 2026.3.0

package/src/loadBalancer/details/gceLoadBalancerDetails.spec.tsx

@@ -0,0 +1,65 @@
+import React from 'react';
+import { shallow } from 'enzyme';
+
+import { CloudProviderRegistry, ManagedMenuItem } from '@spinnaker/core';
+
+import { GceLoadBalancerChoiceModal } from '../configure/choice/GceLoadBalancerChoiceModal';
+import { GceLoadBalancerActions } from './gceLoadBalancerDetails';
+
+describe('GceLoadBalancerActions', () => {
+  const app = { name: 'fnord' } as any;
+  const loadBalancer = {
+    account: 'account-a',
+    instances: [],
+    loadBalancerType: 'INTERNAL_MANAGED',
+    name: 'fnord-main',
+    region: 'europe-west1',
+  } as any;
+
+  it('hides write actions when the Google provider is disabled', () => {
+    spyOn(CloudProviderRegistry, 'isDisabled').and.returnValue(true);
+
+    const wrapper = shallow(<GceLoadBalancerActions app={app} loadBalancer={loadBalancer} />);
+
+    expect(wrapper.isEmptyRender()).toBe(true);
+  });
+
+  it('opens the current load balancer in edit mode through managed-resource gating', () => {
+    spyOn(CloudProviderRegistry, 'isDisabled').and.returnValue(false);
+    const show = spyOn(GceLoadBalancerChoiceModal, 'show').and.returnValue(Promise.resolve() as any);
+
+    const wrapper = shallow(<GceLoadBalancerActions app={app} loadBalancer={loadBalancer} />);
+    const edit = wrapper.find(ManagedMenuItem).filterWhere((item) => item.prop('children') === 'Edit Load Balancer');
+
+    expect(edit.prop('application')).toBe(app);
+    expect(edit.prop('resource')).toBe(loadBalancer);
+    edit.prop('onClick')();
+    expect(show).toHaveBeenCalledOnceWith({
+      app,
+      application: app,
+      forPipelineConfig: false,
+      isNew: false,
+      loadBalancer,
+      mode: 'edit',
+    } as any);
+  });
+
+  it('keeps delete behind managed-resource gating and disables it while instances are attached', () => {
+    spyOn(CloudProviderRegistry, 'isDisabled').and.returnValue(false);
+
+    const editable = shallow(<GceLoadBalancerActions app={app} loadBalancer={loadBalancer} />);
+    const managedDelete = editable
+      .find(ManagedMenuItem)
+      .filterWhere((item) => item.prop('children') === 'Delete Load Balancer');
+    expect(managedDelete.prop('application')).toBe(app);
+    expect(managedDelete.prop('resource')).toBe(loadBalancer);
+
+    const attached = shallow(
+      <GceLoadBalancerActions app={app} loadBalancer={{ ...loadBalancer, instances: [{ name: 'instance-a' }] }} />,
+    );
+    expect(
+      attached.find(ManagedMenuItem).filterWhere((item) => item.prop('children') === 'Delete Load Balancer'),
+    ).toHaveSize(0);
+    expect(attached.find('li.disabled').text()).toContain('Delete Load Balancer');
+  });
+});

package/src/loadBalancer/details/gceLoadBalancerDetails.tsx

@@ -0,0 +1,456 @@
+import React, { useCallback, useEffect, useState } from 'react';
+
+import {
+  AccountService,
+  AccountTag,
+  CloudProviderRegistry,
+  CollapsibleSection,
+  ConfirmationModalService,
+  InfrastructureCaches,
+  LoadBalancerWriter,
+  ManagedMenuItem,
+  TaskExecutor,
+  useDataSource,
+  useDeckRuntimeServices,
+} from '@spinnaker/core';
+
+import { GceLoadBalancerChoiceModal } from '../configure/choice/GceLoadBalancerChoiceModal';
+import { GceHttpLoadBalancerUtils } from '../httpLoadBalancerUtils.service';
+
+interface IUseDetailsProps {
+  app: any;
+  autoClose: () => void;
+  loadBalancerParams: any;
+}
+
+interface ILoadGceLoadBalancerDetailsProps extends IUseDetailsProps {
+  accountService?: typeof AccountService;
+  loadBalancers?: any[];
+  loadBalancerReader: any;
+}
+
+const gceHttpLoadBalancerUtils = new GceHttpLoadBalancerUtils();
+
+function isSameVpc(candidate: any, params: any): boolean {
+  return (candidate.vpcId || candidate.vpcid || null) === (params.vpcId || null);
+}
+
+function findLoadBalancerInList(loadBalancers: any[], params: any): any {
+  return (loadBalancers || []).find((candidate: any) => {
+    return (
+      candidate.name === params.name &&
+      candidate.account === params.accountId &&
+      (candidate.region === params.region || candidate.region === 'global') &&
+      isSameVpc(candidate, params)
+    );
+  });
+}
+
+function uniqBy<T>(items: T[], getKey: (item: T) => string): T[] {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    const key = getKey(item);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+function getProtocol(loadBalancer: any): string {
+  const port = loadBalancer?.listenerDescriptions?.[0]?.listener?.loadBalancerPort;
+  return port === '443' ? 'https:' : 'http:';
+}
+
+function getBackendServices(loadBalancer: any): any[] {
+  let backendServices = [loadBalancer.defaultService].filter(Boolean);
+
+  if ((loadBalancer.hostRules || []).length) {
+    (loadBalancer.hostRules || []).forEach((hostRule: any) => {
+      if (hostRule.pathMatcher?.defaultService) {
+        backendServices.push(hostRule.pathMatcher.defaultService);
+      }
+      backendServices = backendServices.concat(
+        (hostRule.pathMatcher?.pathRules || []).map((pathRule: any) => pathRule.backendService).filter(Boolean),
+      );
+    });
+  }
+
+  return uniqBy(backendServices, (backendService: any) => backendService.name || backendService.selfLink || '');
+}
+
+function getResourceTypes(loadBalancerType: string): string[] {
+  switch (loadBalancerType) {
+    case 'INTERNAL':
+      return ['gce_forwarding_rule', 'gce_backend_service'];
+    case 'NETWORK':
+      return ['gce_forwarding_rule', 'gce_target_pool', 'gce_health_check'];
+    case 'SSL':
+    case 'TCP':
+      return ['gce_forwarding_rule', 'gce_backend_service'];
+    case 'INTERNAL_MANAGED':
+      return ['http_load_balancer', 'gce_target_http_proxy', 'gce_url_map', 'gce_backend_service'];
+    default:
+      return ['http_load_balancer', 'gce_target_http_proxy', 'gce_url_map', 'gce_backend_service'];
+  }
+}
+
+function buildLogsLink(project: string, loadBalancer: any): string {
+  return `https://console.developers.google.com/project/${project}/logs?advancedFilter=resource.type=(${getResourceTypes(
+    loadBalancer.loadBalancerType,
+  ).join(' OR ')})%0A"${loadBalancer.name}"`;
+}
+
+async function loadDetails(loadBalancer: any, loadBalancerParams: any, loadBalancerReader: any): Promise<any[]> {
+  const provider =
+    loadBalancer.provider || loadBalancer.cloudProvider || loadBalancer.type || loadBalancerParams.provider;
+  const region = loadBalancer.region || loadBalancerParams.region;
+  if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer)) {
+    const detailSets = await Promise.all(
+      (loadBalancer.listeners || []).map((listener: any) =>
+        loadBalancerReader.getLoadBalancerDetails(
+          provider,
+          loadBalancerParams.accountId,
+          region,
+          listener.name || listener,
+        ),
+      ),
+    );
+    const loadBalancers = ([] as any[]).concat(...detailSets);
+    const representativeLoadBalancer = loadBalancers[0];
+
+    if (!representativeLoadBalancer) {
+      return [];
+    }
+
+    representativeLoadBalancer.dns = uniqBy(
+      loadBalancers
+        .map((detail: any) => ({ dnsname: detail.dnsname, protocol: getProtocol(detail) }))
+        .filter((detail: any) => detail.dnsname),
+      (detail: any) => detail.dnsname,
+    );
+    representativeLoadBalancer.listenerDescriptions = ([] as any[]).concat(
+      ...loadBalancers.map((detail: any) => detail.listenerDescriptions || []),
+    );
+    return [representativeLoadBalancer];
+  }
+
+  const details = await loadBalancerReader.getLoadBalancerDetails(
+    provider,
+    loadBalancerParams.accountId,
+    region,
+    loadBalancer.name,
+  );
+  if (details[0]) {
+    details[0].dns = { dnsname: details[0].dnsname, protocol: getProtocol(details[0]) };
+  }
+  return details;
+}
+
+export async function loadGceLoadBalancerDetails({
+  accountService = AccountService,
+  app,
+  autoClose,
+  loadBalancers,
+  loadBalancerParams,
+  loadBalancerReader,
+}: ILoadGceLoadBalancerDetailsProps): Promise<any | undefined> {
+  const loadBalancer = findLoadBalancerInList(loadBalancers || app?.loadBalancers?.data || [], loadBalancerParams);
+
+  if (!loadBalancer) {
+    autoClose();
+    return undefined;
+  }
+
+  const details = await loadDetails(loadBalancer, loadBalancerParams, loadBalancerReader);
+  const filtered = details.filter((detail: any) => (detail.vpcid || null) === (loadBalancerParams.vpcId || null));
+  if (filtered.length) {
+    loadBalancer.elb = filtered[0];
+    loadBalancer.account = loadBalancerParams.accountId;
+
+    if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer)) {
+      loadBalancer.elb.backendServices = getBackendServices(loadBalancer);
+      loadBalancer.elb.healthChecks = uniqBy(
+        loadBalancer.elb.backendServices.map((backendService: any) => backendService.healthCheck).filter(Boolean),
+        (healthCheck: any) => healthCheck.name || healthCheck.selfLink || '',
+      );
+    }
+  }
+
+  const accountDetails: any = await accountService.getAccountDetails(loadBalancerParams.accountId);
+  if (accountDetails?.project) {
+    loadBalancer.project = accountDetails.project;
+    loadBalancer.logsLink = buildLogsLink(accountDetails.project, loadBalancer);
+  }
+
+  return loadBalancer;
+}
+
+export function useGceLoadBalancerDetails({ app, autoClose, loadBalancerParams }: IUseDetailsProps): any {
+  const { loadBalancerReader } = useDeckRuntimeServices();
+  const dataSource = app.getDataSource('loadBalancers');
+  const { data: loadBalancers, loaded, refresh, error } = useDataSource<any[]>(dataSource);
+  const [data, setData] = useState<any>();
+  const [loadingDetails, setLoadingDetails] = useState(false);
+  const [detailsError, setDetailsError] = useState<string | null>(null);
+
+  const refetch = useCallback(async () => {
+    if (!loaded || error) {
+      return;
+    }
+
+    setLoadingDetails(true);
+    setDetailsError(null);
+    try {
+      setData(
+        await loadGceLoadBalancerDetails({
+          app,
+          autoClose,
+          loadBalancers,
+          loadBalancerParams,
+          loadBalancerReader,
+        }),
+      );
+    } catch (e) {
+      setDetailsError(e?.message || String(e));
+    } finally {
+      setLoadingDetails(false);
+    }
+  }, [app, autoClose, error, loadBalancerReader, loadBalancers, loadBalancerParams, loaded]);
+
+  useEffect(() => {
+    refetch();
+  }, [refetch]);
+
+  return {
+    data,
+    error: error || detailsError,
+    loading: !loaded || loadingDetails,
+    refetch: async () => {
+      refresh();
+    },
+  };
+}
+
+function deleteGceHttpLoadBalancer(loadBalancer: any, app: any, params: any = {}): Promise<any> {
+  const region = loadBalancer.region || 'global';
+  const job = {
+    cloudProvider: loadBalancer.provider || 'gce',
+    credentials: loadBalancer.account,
+    loadBalancerName: loadBalancer.listeners?.[0]?.name || loadBalancer.name,
+    loadBalancerType: loadBalancer.loadBalancerType,
+    region,
+    regions: [region],
+    type: 'deleteLoadBalancer',
+    ...params,
+  };
+
+  InfrastructureCaches.clearCache('backendServices');
+  InfrastructureCaches.clearCache('healthChecks');
+
+  return TaskExecutor.executeTask({
+    application: app,
+    description: `Delete load balancer: ${loadBalancer.urlMapName || loadBalancer.name} in ${
+      loadBalancer.account
+    }:global`,
+    job: [job],
+  });
+}
+
+function deleteGceLoadBalancer(loadBalancer: any, app: any, params: any = {}): Promise<any> {
+  if (gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer)) {
+    return deleteGceHttpLoadBalancer(loadBalancer, app, params);
+  }
+
+  const region = loadBalancer.region || 'global';
+  return LoadBalancerWriter.deleteLoadBalancer(
+    {
+      accountName: loadBalancer.account,
+      cloudProvider: 'gce',
+      credentials: loadBalancer.account,
+      deleteHealthChecks: false,
+      loadBalancerName: loadBalancer.name,
+      loadBalancerType: loadBalancer.loadBalancerType || 'NETWORK',
+      region,
+      regions: [region],
+      vpcId: loadBalancer.vpcId,
+      ...params,
+    },
+    app,
+  );
+}
+
+function GceLoadBalancerDeleteOptions({
+  deleteParams,
+  loadBalancer,
+}: {
+  deleteParams: { deleteHealthChecks: boolean };
+  loadBalancer: any;
+}): JSX.Element {
+  const hasHealthChecks = gceHttpLoadBalancerUtils.isHttpLoadBalancer(loadBalancer) || !!loadBalancer.healthCheck;
+  if (!hasHealthChecks) {
+    return null;
+  }
+
+  return (
+    <label className="checkbox-inline">
+      <input
+        type="checkbox"
+        onChange={(event) => {
+          deleteParams.deleteHealthChecks = event.currentTarget.checked;
+        }}
+      />
+      Delete associated health checks
+    </label>
+  );
+}
+
+export function GceLoadBalancerActions({ app, loadBalancer }: { app: any; loadBalancer: any }): JSX.Element {
+  if (CloudProviderRegistry.isDisabled('gce')) {
+    return null;
+  }
+
+  const hasInstances = (loadBalancer.instances || []).length > 0;
+  const editLoadBalancer = () => {
+    GceLoadBalancerChoiceModal.show({
+      app,
+      application: app,
+      forPipelineConfig: false,
+      isNew: false,
+      loadBalancer,
+      mode: 'edit',
+    } as any);
+  };
+  const deleteLoadBalancer = () => {
+    const deleteParams = { deleteHealthChecks: false };
+    ConfirmationModalService.confirm({
+      account: loadBalancer.account,
+      bodyContent: <GceLoadBalancerDeleteOptions deleteParams={deleteParams} loadBalancer={loadBalancer} />,
+      buttonText: `Delete ${loadBalancer.name}`,
+      header: `Really delete ${loadBalancer.name}?`,
+      submitMethod: (params: any = {}) =>
+        deleteGceLoadBalancer(loadBalancer, app, { deleteHealthChecks: deleteParams.deleteHealthChecks, ...params }),
+      taskMonitorConfig: { application: app, title: `Deleting ${loadBalancer.name}` },
+    });
+  };
+
+  return (
+    <div className="dropdown" id="gce-load-balancer-actions-dropdown">
+      <button className="btn btn-sm btn-primary dropdown-toggle" data-toggle="dropdown" type="button">
+        Load Balancer Actions
+      </button>
+      <ul className="dropdown-menu">
+        <ManagedMenuItem application={app} resource={loadBalancer} onClick={editLoadBalancer}>
+          Edit Load Balancer
+        </ManagedMenuItem>
+        {!hasInstances && (
+          <ManagedMenuItem application={app} resource={loadBalancer} onClick={deleteLoadBalancer}>
+            Delete Load Balancer
+          </ManagedMenuItem>
+        )}
+        {hasInstances && (
+          <li className="disabled" title="You must detach all instances before deleting this load balancer.">
+            <a>Delete Load Balancer</a>
+          </li>
+        )}
+      </ul>
+    </div>
+  );
+}
+
+export function GceLoadBalancerInformationSection({ loadBalancer }: { app: any; loadBalancer: any }): JSX.Element {
+  return (
+    <CollapsibleSection heading="Load Balancer Information" defaultExpanded={true}>
+      <dl className="dl-horizontal dl-narrow">
+        <dt>Account</dt>
+        <dd>
+          <AccountTag account={loadBalancer.account} />
+        </dd>
+        <dt>Region</dt>
+        <dd>{loadBalancer.region || 'global'}</dd>
+        <dt>Type</dt>
+        <dd>{loadBalancer.loadBalancerType || loadBalancer.providerType || '-'}</dd>
+        {loadBalancer.project && (
+          <>
+            <dt>Project</dt>
+            <dd>{loadBalancer.project}</dd>
+          </>
+        )}
+        {loadBalancer.elb?.dns && (
+          <>
+            <dt>DNS</dt>
+            <dd>
+              {Array.isArray(loadBalancer.elb.dns)
+                ? loadBalancer.elb.dns.map((dns: any) => `${dns.protocol}//${dns.dnsname}`).join(', ')
+                : `${loadBalancer.elb.dns.protocol}//${loadBalancer.elb.dns.dnsname}`}
+            </dd>
+          </>
+        )}
+      </dl>
+    </CollapsibleSection>
+  );
+}
+
+export function GceLoadBalancerListenersSection({ loadBalancer }: { app: any; loadBalancer: any }): JSX.Element {
+  return (
+    <CollapsibleSection heading="Listeners" defaultExpanded={true}>
+      {(loadBalancer.listeners || []).length ? (
+        <ul>
+          {loadBalancer.listeners.map((listener: any, index: number) => (
+            <li key={index}>{[listener.protocol, listener.port || listener.portRange].filter(Boolean).join(':')}</li>
+          ))}
+        </ul>
+      ) : (
+        <span>No listeners configured</span>
+      )}
+    </CollapsibleSection>
+  );
+}
+
+export function GceLoadBalancerBackendServicesSection({ loadBalancer }: { app: any; loadBalancer: any }): JSX.Element {
+  const backendServices = loadBalancer.elb?.backendServices || [];
+  const healthChecks = loadBalancer.elb?.healthChecks || [];
+
+  if (!backendServices.length && !healthChecks.length) {
+    return null;
+  }
+
+  return (
+    <CollapsibleSection heading="Backend Services" defaultExpanded={true}>
+      {backendServices.length > 0 && (
+        <dl className="dl-horizontal dl-narrow">
+          <dt>Services</dt>
+          <dd>{backendServices.map((backendService: any) => backendService.name).join(', ')}</dd>
+        </dl>
+      )}
+      {healthChecks.length > 0 && (
+        <dl className="dl-horizontal dl-narrow">
+          <dt>Health Checks</dt>
+          <dd>{healthChecks.map((healthCheck: any) => healthCheck.name).join(', ')}</dd>
+        </dl>
+      )}
+    </CollapsibleSection>
+  );
+}
+
+export function GceLoadBalancerLogsSection({ loadBalancer }: { app: any; loadBalancer: any }): JSX.Element {
+  return (
+    <CollapsibleSection heading="Logs" defaultExpanded={false}>
+      {loadBalancer.logsLink ? (
+        <a href={loadBalancer.logsLink} target="_blank" rel="noopener noreferrer">
+          View Google Cloud logs
+        </a>
+      ) : (
+        <span>No log link available</span>
+      )}
+    </CollapsibleSection>
+  );
+}
+
+export const gceLoadBalancerDetailsSections = [
+  GceLoadBalancerInformationSection,
+  GceLoadBalancerListenersSection,
+  GceLoadBalancerBackendServicesSection,
+  GceLoadBalancerLogsSection,
+];

package/src/loadBalancer/httpLoadBalancerUtils.service.ts

@@ -1,4 +1,3 @@
-import { module } from 'angular';
 import { uniq } from 'lodash';
 
 import type { IGceHttpLoadBalancer, IGceLoadBalancer } from '../domain/loadBalancer';
@@ -7,9 +6,10 @@ export class GceHttpLoadBalancerUtils {
   public static REGION = 'global';
 
   public isHttpLoadBalancer(lb: IGceLoadBalancer): lb is IGceHttpLoadBalancer {
+    const loadBalancer = lb as any;
     return (
-      (lb.provider === 'gce' || lb.type === 'gce') &&
-      (lb.loadBalancerType === 'HTTP' || lb.loadBalancerType === 'INTERNAL_MANAGED')
+      (loadBalancer.provider === 'gce' || loadBalancer.type === 'gce') &&
+      (loadBalancer.loadBalancerType === 'HTTP' || loadBalancer.loadBalancerType === 'INTERNAL_MANAGED')
     );
   }
 
@@ -37,6 +37,3 @@ export class GceHttpLoadBalancerUtils {
     return uniq(normalizedLoadBalancerNames);
   }
 }
-
-export const GCE_HTTP_LOAD_BALANCER_UTILS = 'spinnaker.gce.httpLoadBalancerUtils.service';
-module(GCE_HTTP_LOAD_BALANCER_UTILS, []).service('gceHttpLoadBalancerUtils', GceHttpLoadBalancerUtils);

package/src/loadBalancer/loadBalancer.setTransformer.ts

@@ -1,12 +1,12 @@
-import { module } from 'angular';
 import { cloneDeep, groupBy, map, partition } from 'lodash';
 
 import type { IGceHttpLoadBalancer, IGceLoadBalancer } from '../domain/loadBalancer';
 
-import type { GceHttpLoadBalancerUtils } from './httpLoadBalancerUtils.service';
-import { GCE_HTTP_LOAD_BALANCER_UTILS } from './httpLoadBalancerUtils.service';
+import { GceHttpLoadBalancerUtils } from './httpLoadBalancerUtils.service';
 
 export class GceLoadBalancerSetTransformer {
+  private readonly gceHttpLoadBalancerUtils = new GceHttpLoadBalancerUtils();
+
   private static normalizeHttpLoadBalancerGroup(group: IGceHttpLoadBalancer[]): IGceHttpLoadBalancer {
     const normalized = cloneDeep(group[0]);
 
@@ -31,9 +31,6 @@ export class GceLoadBalancerSetTransformer {
     return portRange.split('-')[0];
   }
 
-  public static $inject = ['gceHttpLoadBalancerUtils'];
-  constructor(private gceHttpLoadBalancerUtils: GceHttpLoadBalancerUtils) {}
-
   public normalizeLoadBalancerSet = (loadBalancers: IGceLoadBalancer[]): IGceLoadBalancer[] => {
     const [httpLoadBalancers, otherLoadBalancers] = partition(loadBalancers, (lb) =>
       this.gceHttpLoadBalancerUtils.isHttpLoadBalancer(lb),
@@ -48,9 +45,3 @@ export class GceLoadBalancerSetTransformer {
     return (normalizedElSevenLoadBalancers as IGceLoadBalancer[]).concat(otherLoadBalancers);
   };
 }
-
-export const LOAD_BALANCER_SET_TRANSFORMER = 'spinnaker.gce.loadBalancer.setTransformer.service';
-module(LOAD_BALANCER_SET_TRANSFORMER, [GCE_HTTP_LOAD_BALANCER_UTILS]).service(
-  'gceLoadBalancerSetTransformer',
-  GceLoadBalancerSetTransformer,
-);

package/src/loadBalancer/loadBalancer.transformer.js

@@ -1,15 +1,11 @@
 'use strict';
 
-import { module } from 'angular';
 import _ from 'lodash';
 
 import { GCEProviderSettings } from '../gce.settings';
 
-export const GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER = 'spinnaker.gce.loadBalancer.transformer';
-export const name = GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER; // for backwards compatibility
-module(GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER, []).factory('gceLoadBalancerTransformer', [
-  '$q',
-  function ($q) {
+export class GceLoadBalancerTransformer {
+  constructor(promiseService) {
     function updateHealthCounts(container) {
       const instances = container.instances;
       const serverGroups = container.serverGroups || [container];
@@ -71,7 +67,7 @@ module(GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER, []).factory('gceLoadBalance
         loadBalancer.backendService.healthCheck.interval = loadBalancer.backendService.healthCheck.checkIntervalSec;
       }
       updateHealthCounts(loadBalancer);
-      return $q.when(loadBalancer);
+      return promiseService.resolve(loadBalancer);
     }
 
     function convertLoadBalancerForEditing(loadBalancer) {
@@ -164,5 +160,5 @@ module(GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER, []).factory('gceLoadBalance
       convertLoadBalancerForEditing: convertLoadBalancerForEditing,
       constructNewLoadBalancerTemplate: constructNewLoadBalancerTemplate,
     };
-  },
-]);
+  }
+}