@spinnaker/google 0.0.0-2025.1-0

package/src/cache/cacheConfigurer.service.js

@@ -0,0 +1,41 @@
+'use strict';
+
+import { module } from 'angular';
+import { GCE_ADDRESS_READER } from '../address/address.reader';
+
+import { GOOGLE_BACKENDSERVICE_BACKENDSERVICE_READER } from '../backendService/backendService.reader';
+import { GCE_HEALTH_CHECK_READER } from '../healthCheck/healthCheck.read.service';
+
+export const GOOGLE_CACHE_CACHECONFIGURER_SERVICE = 'spinnaker.gce.cache.initializer';
+export const name = GOOGLE_CACHE_CACHECONFIGURER_SERVICE; // for backwards compatibility
+module(GOOGLE_CACHE_CACHECONFIGURER_SERVICE, [
+  GOOGLE_BACKENDSERVICE_BACKENDSERVICE_READER,
+  GCE_ADDRESS_READER,
+  GCE_HEALTH_CHECK_READER,
+]).factory('gceCacheConfigurer', [
+  'gceAddressReader',
+  'gceBackendServiceReader',
+  'gceCertificateReader',
+  'gceHealthCheckReader',
+  function (gceAddressReader, gceBackendServiceReader, gceCertificateReader, gceHealthCheckReader) {
+    const config = Object.create(null);
+
+    config.addresses = {
+      initializers: [() => gceAddressReader.listAddresses()],
+    };
+
+    config.backendServices = {
+      initializers: [() => gceBackendServiceReader.listBackendServices()],
+    };
+
+    config.certificates = {
+      initializers: [() => gceCertificateReader.listCertificates()],
+    };
+
+    config.healthChecks = {
+      initializers: [() => gceHealthCheckReader.listHealthChecks()],
+    };
+
+    return config;
+  },
+]);

package/src/cache/cacheRefresh.component.html

@@ -0,0 +1,17 @@
+<div ng-if="!$ctrl.renderCompact">
+  <p>
+    <span ng-if="$ctrl.refreshing"><span class="fa fa-sync-alt fa-spin"></span></span>
+    {{::$ctrl.capitalizedKey}}
+    <span ng-if="!$ctrl.refreshing">last refreshed {{ $ctrl.getRefreshTime() | timestamp }}</span>
+    <span ng-if="$ctrl.refreshing"> refreshing...</span>
+  </p>
+  <p>
+    If you're not finding a {{::$ctrl.depluralizedKey}} that was recently added,
+    <a href ng-click="$ctrl.refresh()">click here</a> to refresh the list.
+  </p>
+</div>
+<div ng-if="$ctrl.renderCompact">
+  <a href uib-tooltip-template="$ctrl.tooltipTemplate">
+    <span class="fa fa-sync-alt" ng-click="$ctrl.refresh()" ng-class="{ 'fa-spin': $ctrl.refreshing }"></span>
+  </a>
+</div>

package/src/cache/cacheRefresh.component.ts

@@ -0,0 +1,53 @@
+import type { IComponentOptions, IController } from 'angular';
+import { module } from 'angular';
+
+import type { CacheInitializerService } from '@spinnaker/core';
+import { CACHE_INITIALIZER_SERVICE, InfrastructureCaches } from '@spinnaker/core';
+
+class GceCacheRefreshCtrl implements IController {
+  public capitalizedKey: string;
+  public depluralizedKey: string;
+  public renderCompact: boolean;
+  public refreshing = false;
+  public tooltipTemplate = require('./cacheRefreshTooltip.html');
+  private onRefresh: Function;
+  private cacheKey: string;
+  private cacheKeyAlias: string;
+
+  public static $inject = ['cacheInitializer'];
+  constructor(private cacheInitializer: CacheInitializerService) {}
+
+  public $onInit(): void {
+    const cacheKeyAlias = this.cacheKeyAlias || this.cacheKey;
+    this.capitalizedKey = cacheKeyAlias[0].toUpperCase() + cacheKeyAlias.substring(1);
+    this.depluralizedKey = cacheKeyAlias.substring(0, cacheKeyAlias.length - 1);
+  }
+
+  public getRefreshTime(): number {
+    return InfrastructureCaches.get(this.cacheKey).getStats().ageMax;
+  }
+
+  public refresh(): void {
+    this.refreshing = true;
+    this.cacheInitializer
+      .refreshCache(this.cacheKey)
+      .then(() => this.onRefresh())
+      .then(() => {
+        this.refreshing = false;
+      });
+  }
+}
+
+const gceCacheRefresh: IComponentOptions = {
+  bindings: {
+    onRefresh: '&',
+    cacheKey: '@',
+    cacheKeyAlias: '@',
+    renderCompact: '<',
+  },
+  controller: GceCacheRefreshCtrl,
+  templateUrl: require('./cacheRefresh.component.html'),
+};
+
+export const GCE_CACHE_REFRESH = 'spinnaker.gce.cacheRefresh.component';
+module(GCE_CACHE_REFRESH, [CACHE_INITIALIZER_SERVICE]).component('gceCacheRefresh', gceCacheRefresh);

package/src/cache/cacheRefreshTooltip.html

@@ -0,0 +1,3 @@
+<p ng-if="$ctrl.refreshing">{{$ctrl.capitalizedKey}} data is <strong>refreshing</strong></p>
+<p ng-if="!$ctrl.refreshing">(click <span class="fa fa-sync-alt"></span> to refresh)</p>
+<p>Last refresh: {{$ctrl.getRefreshTime() | timestamp }}</p>

package/src/certificate/certificate.reader.ts

@@ -0,0 +1,31 @@
+import { module } from 'angular';
+
+import type { ISearchResults } from '@spinnaker/core';
+import { InfrastructureCaches, SearchService } from '@spinnaker/core';
+
+export interface IGceCertificate {
+  account: string;
+  name: string;
+  provider: string;
+  type: string;
+}
+
+export class GceCertificateReader {
+  public listCertificates(): PromiseLike<IGceCertificate[]> {
+    return SearchService.search<IGceCertificate>(
+      { q: '', type: 'sslCertificates', allowShortQuery: 'true' },
+      InfrastructureCaches.get('certificates'),
+    )
+      .then((searchResults: ISearchResults<IGceCertificate>) => {
+        if (searchResults && searchResults.results) {
+          return searchResults.results.filter((certificate) => certificate.provider === 'gce');
+        } else {
+          return [];
+        }
+      })
+      .catch(() => []);
+  }
+}
+
+export const GCE_CERTIFICATE_READER = 'spinnaker.gce.certificateReader.service';
+module(GCE_CERTIFICATE_READER, []).service('gceCertificateReader', GceCertificateReader);

package/src/common/footer.directive.html

@@ -0,0 +1,7 @@
+<div class="modal-footer">
+  <user-verification account="vm.account" verification="vm.verification"></user-verification>
+  <button type="submit" ng-click="vm.action()" style="display: none"></button>
+  <!-- Allows form submission via enter keypress-->
+  <button class="btn btn-default" ng-click="vm.cancel()">Cancel</button>
+  <button type="submit" class="btn btn-primary" ng-click="vm.action()" ng-disabled="!vm.isValid()">Submit</button>
+</div>

package/src/common/footer.directive.js

@@ -0,0 +1,22 @@
+'use strict';
+
+import * as angular from 'angular';
+
+export const GOOGLE_COMMON_FOOTER_DIRECTIVE = 'spinnaker.google.footer.directive';
+export const name = GOOGLE_COMMON_FOOTER_DIRECTIVE; // for backwards compatibility
+angular.module(GOOGLE_COMMON_FOOTER_DIRECTIVE, []).directive('gceFooter', function () {
+  return {
+    restrict: 'E',
+    templateUrl: require('./footer.directive.html'),
+    scope: {},
+    bindToController: {
+      action: '&',
+      isValid: '&',
+      cancel: '&',
+      account: '=?',
+      verification: '=?',
+    },
+    controllerAs: 'vm',
+    controller: angular.noop,
+  };
+});

package/src/common/xpnNaming.gce.service.js

@@ -0,0 +1,35 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+export const GOOGLE_COMMON_XPNNAMING_GCE_SERVICE = 'spinnaker.gce.common.xpnNaming.service';
+export const name = GOOGLE_COMMON_XPNNAMING_GCE_SERVICE; // for backwards compatibility
+module(GOOGLE_COMMON_XPNNAMING_GCE_SERVICE, []).factory('gceXpnNamingService', function () {
+  const deriveProjectId = (resourceWithSelfLink) => {
+    const pathSegments = resourceWithSelfLink.selfLink.split('/');
+    return pathSegments[pathSegments.indexOf('projects') + 1];
+  };
+
+  const decorateXpnResourceIfNecessary = (projectId, xpnResource) => {
+    if (!xpnResource) {
+      return null;
+    }
+
+    // A network selfLink looks like: https://compute.googleapis.com/compute/beta/projects/test-host-project/global/networks/default
+    // A subnet selfLink looks like: https://compute.googleapis.com/compute/beta/projects/my-test-service-project/regions/us-west1/subnetworks/default
+    const xpnResourcePathSegments = xpnResource.split('/');
+    const xpnResourceProjectId = xpnResourcePathSegments[xpnResourcePathSegments.indexOf('projects') + 1];
+    const xpnResourceName = _.last(xpnResourcePathSegments);
+    if (xpnResourceProjectId !== projectId) {
+      return xpnResourceProjectId + '/' + xpnResourceName;
+    } else {
+      return xpnResourceName;
+    }
+  };
+
+  return {
+    deriveProjectId,
+    decorateXpnResourceIfNecessary,
+  };
+});

package/src/domain/autoHealingPolicy.ts

@@ -0,0 +1,14 @@
+import type { IGceHealthCheckKind } from './healthCheck';
+
+export interface IGceAutoHealingPolicy {
+  healthCheck?: string; // received from server as health check URL, but posted as health check name
+  healthCheckKind?: IGceHealthCheckKind; // used by Clouddriver to disambiguate health checks
+  healthCheckUrl?: string; // used by Deck as unique ID
+  initialDelaySec?: number;
+  maxUnavailable?: IMaxUnavailable;
+}
+
+export interface IMaxUnavailable {
+  fixed?: number;
+  percent?: number;
+}

package/src/domain/backendService.ts

@@ -0,0 +1,15 @@
+import type { IGceHealthCheck } from './healthCheck';
+
+export interface IGceBackendService {
+  name: string;
+  backends: any[];
+  healthCheck: IGceHealthCheck;
+  sessionAffinity: string;
+  portName: string;
+  connectionDrainingTimeoutsSec: number;
+}
+
+export interface INamedPort {
+  name: string;
+  port: number;
+}

package/src/domain/disk.ts

@@ -0,0 +1,10 @@
+export interface IGceDisk {
+  boot: boolean;
+  deviceName: string;
+  index: number;
+  initializeParams: {
+    diskSizeGb: number;
+    diskType: string;
+    sourceImage: string;
+  };
+}

package/src/domain/healthCheck.ts

@@ -0,0 +1,19 @@
+export interface IGceHealthCheck {
+  account: string;
+  name: string;
+  requestPath: string;
+  port: number;
+  healthCheckType: string;
+  checkIntervalSec: number;
+  timeoutSec: number;
+  unhealthyThreshold: number;
+  healthyThreshold: number;
+  kind: IGceHealthCheckKind;
+  selfLink: string;
+}
+
+export enum IGceHealthCheckKind {
+  healthCheck = 'healthCheck',
+  httpHealthCheck = 'httpHealthCheck',
+  httpsHealthCheck = 'httpsHealthCheck',
+}

package/src/domain/index.ts

@@ -0,0 +1,8 @@
+export * from './autoHealingPolicy';
+export * from './backendService';
+export * from './healthCheck';
+export * from './loadBalancer';
+export * from './network';
+export * from './serverGroup';
+export * from './subnet';
+export * from './disk';

package/src/domain/loadBalancer.ts

@@ -0,0 +1,49 @@
+import type { ILoadBalancer } from '@spinnaker/core';
+
+import type { IGceBackendService } from './backendService';
+
+export interface IGceLoadBalancer extends ILoadBalancer {
+  name: string;
+  account: string;
+  credentials: string;
+  detail: string;
+  loadBalancerName: string;
+  portRange?: string;
+  region: string;
+  stack: string;
+}
+
+export interface IGceHttpLoadBalancer extends IGceLoadBalancer {
+  certificate: string;
+  defaultService: IGceBackendService;
+  detail: string;
+  hostRules: IGceHostRule;
+  ipAddress: string;
+  listeners: IGceListener[];
+  loadBalancerType: 'HTTP';
+  provider: 'gce';
+  region: 'global';
+  stack: string;
+  urlMapName: string;
+  subnet?: string;
+}
+
+export interface IGceHostRule {
+  hostPatterns: string[];
+  pathMatcher: IGcePathMatcher;
+}
+
+export interface IGcePathMatcher {
+  pathRules: IGcePathRule[];
+}
+
+export interface IGcePathRule {
+  paths: string[];
+}
+
+export interface IGceListener {
+  certificate: string;
+  name: string;
+  port: string;
+  ipAddress: string;
+}

package/src/domain/network.ts

@@ -0,0 +1,10 @@
+export interface IGceNetwork {
+  account: string;
+  autoCreateSubnets: boolean;
+  cloudProvider: string;
+  id: string;
+  name: string;
+  region: string;
+  selfLink: string;
+  subnets: string[];
+}

package/src/domain/serverGroup.ts

@@ -0,0 +1,8 @@
+import type { IServerGroup } from '@spinnaker/core';
+
+import type { IGceAutoHealingPolicy } from './autoHealingPolicy';
+
+// TODO(dpeach): fill in the remaining GCE specific properties.
+export interface IGceServerGroup extends IServerGroup {
+  autoHealingPolicy?: IGceAutoHealingPolicy;
+}

package/src/domain/subnet.ts

@@ -0,0 +1,12 @@
+export interface IGceSubnet {
+  account: string;
+  cidrBlock: string;
+  gatewayAddress: string;
+  id: string;
+  name: string;
+  network: string;
+  purpose: string;
+  region: string;
+  selfLink: string;
+  type: string;
+}

package/src/gce.module.ts

@@ -0,0 +1,155 @@
+import { module } from 'angular';
+
+import { CloudProviderRegistry, DeploymentStrategyRegistry } from '@spinnaker/core';
+
+import { GCE_PREDICTIVE_AUTOSCALING } from './autoscalingPolicy/components/metricSettings/GcePredictiveAutoscaling';
+import { GOOGLE_CACHE_CACHECONFIGURER_SERVICE } from './cache/cacheConfigurer.service';
+import { GOOGLE_COMMON_XPNNAMING_GCE_SERVICE } from './common/xpnNaming.gce.service';
+import './help/gce.help';
+import { GceImageReader } from './image';
+import { GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCE_FILTER } from './instance/custom/customInstance.filter';
+import { GOOGLE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER } from './instance/details/instance.details.controller';
+import { GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE } from './instance/gceInstanceType.service';
+import { GOOGLE_INSTANCE_GCEMULTIINSTANCETASK_TRANSFORMER } from './instance/gceMultiInstanceTask.transformer';
+import { IAP_INTERCEPTOR } from './interceptors/iap.interceptor';
+import { GCE_LOAD_BALANCER_CHOICE_MODAL } from './loadBalancer/configure/choice/gceLoadBalancerChoice.modal';
+import { GOOGLE_LOADBALANCER_CONFIGURE_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER } from './loadBalancer/configure/http/createHttpLoadBalancer.controller';
+import { GCE_INTERNAL_LOAD_BALANCER_CTRL } from './loadBalancer/configure/internal/gceCreateInternalLoadBalancer.controller';
+import { GOOGLE_LOADBALANCER_CONFIGURE_INTERNAL_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER } from './loadBalancer/configure/internalhttp/createInternalHttpLoadBalancer.controller';
+import { GOOGLE_LOADBALANCER_CONFIGURE_NETWORK_CREATELOADBALANCER_CONTROLLER } from './loadBalancer/configure/network/createLoadBalancer.controller';
+import { GCE_SSL_LOAD_BALANCER_CTRL } from './loadBalancer/configure/ssl/gceCreateSslLoadBalancer.controller';
+import { GCE_TCP_LOAD_BALANCER_CTRL } from './loadBalancer/configure/tcp/gceCreateTcpLoadBalancer.controller';
+import { GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER } from './loadBalancer/details/loadBalancerDetail.controller';
+import { LOAD_BALANCER_SET_TRANSFORMER } from './loadBalancer/loadBalancer.setTransformer';
+import { GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER } from './loadBalancer/loadBalancer.transformer';
+import logo from './logo/gce.logo.png';
+import { GOOGLE_PIPELINE_STAGES_BAKE_GCEBAKESTAGE } from './pipeline/stages/bake/gceBakeStage';
+import { GOOGLE_PIPELINE_STAGES_CLONESERVERGROUP_GCECLONESERVERGROUPSTAGE } from './pipeline/stages/cloneServerGroup/gceCloneServerGroupStage';
+import { GOOGLE_PIPELINE_STAGES_DESTROYASG_GCEDESTROYASGSTAGE } from './pipeline/stages/destroyAsg/gceDestroyAsgStage';
+import { GOOGLE_PIPELINE_STAGES_DISABLEASG_GCEDISABLEASGSTAGE } from './pipeline/stages/disableAsg/gceDisableAsgStage';
+import { GOOGLE_PIPELINE_STAGES_DISABLECLUSTER_GCEDISABLECLUSTERSTAGE } from './pipeline/stages/disableCluster/gceDisableClusterStage';
+import { GOOGLE_PIPELINE_STAGES_ENABLEASG_GCEENABLEASGSTAGE } from './pipeline/stages/enableAsg/gceEnableAsgStage';
+import { GOOGLE_PIPELINE_STAGES_FINDAMI_GCEFINDAMISTAGE } from './pipeline/stages/findAmi/gceFindAmiStage';
+import { GOOGLE_PIPELINE_STAGES_FINDIMAGEFROMTAGS_GCEFINDIMAGEFROMTAGSSTAGE } from './pipeline/stages/findImageFromTags/gceFindImageFromTagsStage';
+import { GOOGLE_PIPELINE_STAGES_RESIZEASG_GCERESIZEASGSTAGE } from './pipeline/stages/resizeAsg/gceResizeAsgStage';
+import { GOOGLE_PIPELINE_STAGES_SCALEDOWNCLUSTER_GCESCALEDOWNCLUSTERSTAGE } from './pipeline/stages/scaleDownCluster/gceScaleDownClusterStage';
+import { GOOGLE_PIPELINE_STAGES_SHRINKCLUSTER_GCESHRINKCLUSTERSTAGE } from './pipeline/stages/shrinkCluster/gceShrinkClusterStage';
+import { GOOGLE_PIPELINE_STAGES_TAGIMAGE_GCETAGIMAGESTAGE } from './pipeline/stages/tagImage/gceTagImageStage';
+import { GOOGLE_SECURITYGROUP_CONFIGURE_CREATESECURITYGROUP_CONTROLLER } from './securityGroup/configure/createSecurityGroup.controller';
+import { GOOGLE_SECURITYGROUP_CONFIGURE_EDITSECURITYGROUP_CONTROLLER } from './securityGroup/configure/editSecurityGroup.controller';
+import { GOOGLE_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER } from './securityGroup/details/securityGroupDetail.controller';
+import { GOOGLE_SECURITYGROUP_SECURITYGROUP_READER } from './securityGroup/securityGroup.reader';
+import { GOOGLE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER } from './securityGroup/securityGroup.transformer';
+import { GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_GCE_MODULE } from './serverGroup/configure/serverGroup.configure.gce.module';
+import { GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE } from './serverGroup/configure/serverGroupCommandBuilder.service';
+import { GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_GCE_CONTROLLER } from './serverGroup/configure/wizard/cloneServerGroup.gce.controller';
+import { GCE_SERVER_GROUP_DISK_DESCRIPTIONS } from './serverGroup/details/ServerGroupDiskDescriptions';
+import { GCE_SCALE_IN_CONTROLS } from './serverGroup/details/autoscalingPolicy/modal/GceScaleInControls';
+import { GOOGLE_SERVERGROUP_DETAILS_SERVERGROUP_DETAILS_GCE_MODULE } from './serverGroup/details/serverGroup.details.gce.module';
+import { GOOGLE_SERVERGROUP_SERVERGROUP_TRANSFORMER } from './serverGroup/serverGroup.transformer';
+import { GOOGLE_SUBNET_SUBNET_RENDERER } from './subnet/subnet.renderer';
+import { GOOGLE_VALIDATION_APPLICATIONNAME_VALIDATOR } from './validation/applicationName.validator';
+
+import './logo/gce.logo.less';
+
+export const GOOGLE_MODULE = 'spinnaker.gce';
+module(GOOGLE_MODULE, [
+  LOAD_BALANCER_SET_TRANSFORMER,
+  GCE_INTERNAL_LOAD_BALANCER_CTRL,
+  GCE_LOAD_BALANCER_CHOICE_MODAL,
+  GCE_SSL_LOAD_BALANCER_CTRL,
+  GCE_TCP_LOAD_BALANCER_CTRL,
+  IAP_INTERCEPTOR,
+  GCE_SERVER_GROUP_DISK_DESCRIPTIONS,
+  GCE_SCALE_IN_CONTROLS,
+  GCE_PREDICTIVE_AUTOSCALING,
+  GOOGLE_SERVERGROUP_DETAILS_SERVERGROUP_DETAILS_GCE_MODULE,
+  GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUPCOMMANDBUILDER_SERVICE,
+  GOOGLE_SERVERGROUP_CONFIGURE_WIZARD_CLONESERVERGROUP_GCE_CONTROLLER,
+  GOOGLE_SERVERGROUP_CONFIGURE_SERVERGROUP_CONFIGURE_GCE_MODULE,
+  GOOGLE_SERVERGROUP_SERVERGROUP_TRANSFORMER,
+  GOOGLE_PIPELINE_STAGES_BAKE_GCEBAKESTAGE,
+  GOOGLE_PIPELINE_STAGES_CLONESERVERGROUP_GCECLONESERVERGROUPSTAGE,
+  GOOGLE_PIPELINE_STAGES_DESTROYASG_GCEDESTROYASGSTAGE,
+  GOOGLE_PIPELINE_STAGES_DISABLEASG_GCEDISABLEASGSTAGE,
+  GOOGLE_PIPELINE_STAGES_DISABLECLUSTER_GCEDISABLECLUSTERSTAGE,
+  GOOGLE_PIPELINE_STAGES_ENABLEASG_GCEENABLEASGSTAGE,
+  GOOGLE_PIPELINE_STAGES_FINDAMI_GCEFINDAMISTAGE,
+  GOOGLE_PIPELINE_STAGES_FINDIMAGEFROMTAGS_GCEFINDIMAGEFROMTAGSSTAGE,
+  GOOGLE_PIPELINE_STAGES_RESIZEASG_GCERESIZEASGSTAGE,
+  GOOGLE_PIPELINE_STAGES_SCALEDOWNCLUSTER_GCESCALEDOWNCLUSTERSTAGE,
+  GOOGLE_PIPELINE_STAGES_SHRINKCLUSTER_GCESHRINKCLUSTERSTAGE,
+  GOOGLE_PIPELINE_STAGES_TAGIMAGE_GCETAGIMAGESTAGE,
+  GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE,
+  GOOGLE_INSTANCE_GCEMULTIINSTANCETASK_TRANSFORMER,
+  GOOGLE_INSTANCE_CUSTOM_CUSTOMINSTANCE_FILTER,
+  GOOGLE_LOADBALANCER_LOADBALANCER_TRANSFORMER,
+  GOOGLE_LOADBALANCER_DETAILS_LOADBALANCERDETAIL_CONTROLLER,
+  GOOGLE_LOADBALANCER_CONFIGURE_NETWORK_CREATELOADBALANCER_CONTROLLER,
+  GOOGLE_LOADBALANCER_CONFIGURE_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER,
+  GOOGLE_LOADBALANCER_CONFIGURE_INTERNAL_HTTP_CREATEHTTPLOADBALANCER_CONTROLLER,
+  GOOGLE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER,
+  GOOGLE_SECURITYGROUP_DETAILS_SECURITYGROUPDETAIL_CONTROLLER,
+  GOOGLE_SECURITYGROUP_CONFIGURE_CREATESECURITYGROUP_CONTROLLER,
+  GOOGLE_SECURITYGROUP_CONFIGURE_EDITSECURITYGROUP_CONTROLLER,
+  GOOGLE_SECURITYGROUP_SECURITYGROUP_TRANSFORMER,
+  GOOGLE_SECURITYGROUP_SECURITYGROUP_READER,
+  GOOGLE_SUBNET_SUBNET_RENDERER,
+  GOOGLE_VALIDATION_APPLICATIONNAME_VALIDATOR,
+  GOOGLE_CACHE_CACHECONFIGURER_SERVICE,
+  GOOGLE_COMMON_XPNNAMING_GCE_SERVICE,
+]).config(() => {
+  CloudProviderRegistry.registerProvider('gce', {
+    name: 'Google',
+    logo: {
+      path: logo,
+    },
+    cache: {
+      configurer: 'gceCacheConfigurer',
+    },
+    image: {
+      reader: GceImageReader,
+    },
+    serverGroup: {
+      transformer: 'gceServerGroupTransformer',
+      detailsTemplateUrl: require('./serverGroup/details/serverGroupDetails.html'),
+      detailsController: 'gceServerGroupDetailsCtrl',
+      cloneServerGroupTemplateUrl: require('./serverGroup/configure/wizard/serverGroupWizard.html'),
+      cloneServerGroupController: 'gceCloneServerGroupCtrl',
+      commandBuilder: 'gceServerGroupCommandBuilder',
+      configurationService: 'gceServerGroupConfigurationService',
+    },
+    instance: {
+      instanceTypeService: 'gceInstanceTypeService',
+      detailsTemplateUrl: require('./instance/details/instanceDetails.html'),
+      detailsController: 'gceInstanceDetailsCtrl',
+      multiInstanceTaskTransformer: 'gceMultiInstanceTaskTransformer',
+      customInstanceBuilderTemplateUrl: require('./serverGroup/configure/wizard/customInstance/customInstanceBuilder.html'),
+    },
+    loadBalancer: {
+      transformer: 'gceLoadBalancerTransformer',
+      setTransformer: 'gceLoadBalancerSetTransformer',
+      detailsTemplateUrl: require('./loadBalancer/details/loadBalancerDetails.html'),
+      detailsController: 'gceLoadBalancerDetailsCtrl',
+      createLoadBalancerTemplateUrl: require('./loadBalancer/configure/choice/gceLoadBalancerChoice.modal.html'),
+      createLoadBalancerController: 'gceLoadBalancerChoiceCtrl',
+    },
+    securityGroup: {
+      transformer: 'gceSecurityGroupTransformer',
+      reader: 'gceSecurityGroupReader',
+      detailsTemplateUrl: require('./securityGroup/details/securityGroupDetail.html'),
+      detailsController: 'gceSecurityGroupDetailsCtrl',
+      createSecurityGroupTemplateUrl: require('./securityGroup/configure/createSecurityGroup.html'),
+      createSecurityGroupController: 'gceCreateSecurityGroupCtrl',
+    },
+    subnet: {
+      renderer: 'gceSubnetRenderer',
+    },
+    snapshotsEnabled: true,
+    applicationProviderFields: {
+      templateUrl: require('./applicationProviderFields/gceFields.html'),
+    },
+  });
+});
+
+DeploymentStrategyRegistry.registerProvider('gce', ['custom', 'redblack']);

package/src/gce.settings.ts

@@ -0,0 +1,23 @@
+import { defaults } from 'lodash';
+
+import type { IInstanceStorage, IProviderSettings } from '@spinnaker/core';
+import { SETTINGS } from '@spinnaker/core';
+
+export interface IGCEProviderSettings extends IProviderSettings {
+  defaults: {
+    account?: string;
+    region?: string;
+    zone?: string;
+    instanceTypeStorage?: IInstanceStorage;
+  };
+  feature: {
+    predictiveAutoscaling?: boolean;
+    statefulMigsEnabled?: boolean;
+  };
+}
+
+export const GCEProviderSettings: IGCEProviderSettings = defaults(SETTINGS.providers.gce || {}, {
+  defaults: {},
+  feature: {},
+  resetToOriginal: SETTINGS.resetProvider('gce'),
+});

package/src/gceNetworkSelectField.directive.js

@@ -0,0 +1,22 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const GOOGLE_GCENETWORKSELECTFIELD_DIRECTIVE = 'spinnaker.google.networkSelectField.directive';
+export const name = GOOGLE_GCENETWORKSELECTFIELD_DIRECTIVE; // for backwards compatibility
+module(GOOGLE_GCENETWORKSELECTFIELD_DIRECTIVE, []).directive('gceNetworkSelectField', function () {
+  return {
+    restrict: 'E',
+    templateUrl: require('./networkSelectField.directive.html'),
+    scope: {
+      networks: '=',
+      component: '=',
+      field: '@',
+      account: '=',
+      helpKey: '@',
+      onChange: '&',
+      labelColumns: '@',
+      fieldColumns: '@',
+    },
+  };
+});

package/src/gceRegionSelectField.directive.js

@@ -0,0 +1,22 @@
+'use strict';
+
+import { module } from 'angular';
+
+export const GOOGLE_GCEREGIONSELECTFIELD_DIRECTIVE = 'spinnaker.google.regionSelectField.directive';
+export const name = GOOGLE_GCEREGIONSELECTFIELD_DIRECTIVE; // for backwards compatibility
+module(GOOGLE_GCEREGIONSELECTFIELD_DIRECTIVE, []).directive('gceRegionSelectField', function () {
+  return {
+    restrict: 'E',
+    templateUrl: require('./regionSelectField.directive.html'),
+    scope: {
+      regions: '=',
+      component: '=',
+      field: '@',
+      account: '=',
+      onChange: '&',
+      labelColumns: '@',
+      readOnly: '=',
+      fieldColumns: '@',
+    },
+  };
+});

package/src/healthCheck/healthCheck.read.service.ts

@@ -0,0 +1,55 @@
+import { module } from 'angular';
+import { uniqWith } from 'lodash';
+
+import type { ISearchResults } from '@spinnaker/core';
+import { InfrastructureCaches, SearchService } from '@spinnaker/core';
+import type { IGceHealthCheck } from '../domain';
+
+interface IHealthCheckSearchResults {
+  name: string;
+  account: string;
+  healthCheck: string; // JSON encoded string containing the real health check (it is missing the account).
+  region?: string;
+  kind: string;
+  provider: string;
+  type: string;
+}
+
+export class GceHealthCheckReader {
+  public listHealthChecks(type?: string): PromiseLike<IGceHealthCheck[]> {
+    if (type) {
+      return this.listHealthChecks().then((healthChecks) =>
+        healthChecks.filter((healthCheck) => healthCheck.healthCheckType === type),
+      );
+    } else {
+      return SearchService.search(
+        { q: '', type: 'healthChecks', allowShortQuery: 'true' },
+        InfrastructureCaches.get('healthChecks'),
+      )
+        .then((searchResults: ISearchResults<IHealthCheckSearchResults>) => {
+          if (searchResults && searchResults.results) {
+            const healthChecks = searchResults.results
+              .filter((result) => result.provider === 'gce')
+              .map((result) => {
+                const healthCheck = JSON.parse(result.healthCheck) as IGceHealthCheck;
+                healthCheck.account = result.account;
+                return healthCheck;
+              });
+            return uniqWith(healthChecks, (checkA: IGceHealthCheck, checkB: IGceHealthCheck) => {
+              return (
+                checkA.name === checkB.name &&
+                checkA.healthCheckType === checkB.healthCheckType &&
+                checkA.account === checkB.account
+              );
+            });
+          } else {
+            return [];
+          }
+        })
+        .catch(() => []);
+    }
+  }
+}
+
+export const GCE_HEALTH_CHECK_READER = 'spinnaker.gce.healthCheck.reader';
+module(GCE_HEALTH_CHECK_READER, []).service('gceHealthCheckReader', GceHealthCheckReader);