@spinnaker/google 0.0.0-2025.1-0

package/src/instance/details/instanceDetails.html

@@ -0,0 +1,248 @@
+<div class="details-panel">
+  <div class="header">
+    <instance-details-header
+      health-state="instance.healthState"
+      instance-id="instance ? instance.instanceId : instanceIdNotFound"
+      loading="state.loading"
+      standalone="state.standalone"
+    ></instance-details-header>
+    <div ng-if="!state.loading">
+      <div class="actions" ng-class="{ insights: instance.insightActions.length > 0 }" ng-if="instance.placement">
+        <div class="dropdown" uib-dropdown dropdown-append-to-body>
+          <button
+            type="button"
+            class="btn btn-sm btn-primary dropdown-toggle"
+            ng-disabled="disabled"
+            uib-dropdown-toggle
+          >
+            Instance Actions <span class="caret"></span>
+          </button>
+          <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+            <li>
+              <a href ng-click="ctrl.enableInstanceInDiscovery()" ng-if="ctrl.canRegisterWithDiscovery()"
+                >Enable in Discovery</a
+              >
+            </li>
+            <li>
+              <a href ng-click="ctrl.disableInstanceInDiscovery()" ng-if="ctrl.hasHealthState('Discovery', 'Up')"
+                >Disable in Discovery</a
+              >
+            </li>
+            <li>
+              <a href ng-click="ctrl.registerInstanceWithLoadBalancer()" ng-if="ctrl.canRegisterWithLoadBalancer()"
+                >Register with Load Balancer</a
+              >
+            </li>
+            <li>
+              <a href ng-click="ctrl.deregisterInstanceFromLoadBalancer()" ng-if="ctrl.canDeregisterFromLoadBalancer()"
+                >Deregister from Load Balancer</a
+              >
+            </li>
+            <li role="presentation" class="divider" ng-if="ctrl.showInstanceActionsDivider()"></li>
+            <li><a href ng-click="ctrl.rebootInstance()">Reboot</a></li>
+            <li><a href ng-click="ctrl.terminateInstance()">Terminate</a></li>
+            <li>
+              <a href ng-click="ctrl.terminateInstanceAndShrinkServerGroup()" ng-if="instance.serverGroup"
+                >Terminate and Shrink Server Group</a
+              >
+            </li>
+          </ul>
+        </div>
+        <div class="dropdown" ng-if="instance.insightActions.length > 0" uib-dropdown dropdown-append-to-body>
+          <button type="button" class="btn btn-sm btn-default dropdown-toggle" uib-dropdown-toggle>
+            Insight <span class="caret"></span>
+          </button>
+          <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+            <li ng-repeat="action in instance.insightActions">
+              <a target="_blank" href="{{action.url}}">{{action.label}}</a>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  </div>
+  <div class="content" ng-if="!state.loading && instance">
+    <collapsible-section heading="Instance Information" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt>Launched</dt>
+        <dd ng-if="instance.launchTime">{{instance.launchTime | timestamp}}</dd>
+        <dd ng-if="!instance.launchTime">(Unknown)</dd>
+        <dt>In</dt>
+        <dd>
+          <account-tag account="instance.account" pad="right"></account-tag>
+          {{instance.placement.availabilityZone || '(Unknown)'}}
+        </dd>
+        <dt>Type</dt>
+        <dd>{{instance.instanceType || '(Unknown)' | customInstanceFilter}}</dd>
+        <dt>CPU Platform</dt>
+        <dd>{{instance.cpuPlatform}}</dd>
+        <dt ng-if="instance.serverGroup">Server Group</dt>
+        <dd ng-if="instance.serverGroup">
+          <a
+            ui-sref="^.serverGroup({region: instance.region,
+              accountId: instance.account,
+              serverGroup: instance.serverGroup,
+              provider: instance.provider})"
+            >{{instance.serverGroup}}</a
+          >
+        </dd>
+        <dt>Network</dt>
+        <dd>{{instance.network || '(Unknown)'}}</dd>
+        <dt ng-if="instance.subnet">Subnet</dt>
+        <dd ng-if="instance.subnet">{{instance.subnet}}</dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Status" expanded="true">
+      <p ng-if="instance.healthState !== 'Starting' && !healthMetrics.length">
+        No health metrics found for this instance
+      </p>
+      <p ng-if="instance.healthState === 'Starting' && !healthMetrics.length">
+        <span class="glyphicon glyphicon-Starting-triangle"></span> <strong>Starting</strong>
+      </p>
+
+      <dl class="horizontal-when-filters-collapsed">
+        <dt ng-repeat-start="metric in healthMetrics | orderBy: 'type'">{{metric.type | robotToHuman}}</dt>
+        <dd ng-repeat-end>
+          <div ng-if="metric.type !== 'LoadBalancer'">
+            <span
+              uib-tooltip="{{metric.state.toLowerCase() === 'down' ? metric.description : ''}}"
+              tooltip-placement="left"
+            >
+              <span class="glyphicon glyphicon-{{metric.state}}-triangle"></span>
+              {{metric.state | robotToHuman}}
+            </span>
+            <span class="pad-left small">
+              <a ng-if="metric.healthCheckUrl" target="_blank" href="{{metric.healthCheckUrl}}">Health Check</a>
+              <span ng-if="metric.healthCheckUrl && metric.statusPageUrl"> | </span>
+              <a ng-if="metric.statusPageUrl" target="_blank" href="{{metric.statusPageUrl}}">Status</a>
+            </span>
+          </div>
+          <div
+            ng-if="metric.type === 'LoadBalancer' && metric.loadBalancers.length"
+            ng-repeat="loadBalancer in metric.loadBalancers"
+          >
+            <instance-load-balancer-health load-balancer="loadBalancer"></instance-load-balancer-health>
+          </div>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="DNS">
+      <dl class="horizontal-when-filters-collapsed">
+        <dt ng-if="instance.internalDnsName">Internal DNS Name</dt>
+        <dd ng-if="instance.internalDnsName">
+          <a href="http://{{instance.internalDnsName}}" target="_blank">{{instance.internalDnsName}}</a>
+          <copy-to-clipboard
+            class="copy-to-clipboard copy-to-clipboard-sm"
+            text="instance.internalDnsName"
+            tool-tip="'Copy to clipboard'"
+          >
+          </copy-to-clipboard>
+        </dd>
+        <dt ng-if="instance.internalIpAddress">Internal IP Address</dt>
+        <dd ng-if="instance.internalIpAddress">
+          <a href="http://{{instance.internalIpAddress}}" target="_blank">{{instance.internalIpAddress}}</a>
+          <copy-to-clipboard
+            class="copy-to-clipboard copy-to-clipboard-sm"
+            text="instance.internalIpAddress"
+            tool-tip="'Copy to clipboard'"
+          >
+          </copy-to-clipboard>
+        </dd>
+        <dt ng-if="instance.externalIpAddress">External IP Address</dt>
+        <dd ng-if="instance.externalIpAddress">
+          <a href="http://{{instance.externalIpAddress}}" target="_blank">{{instance.externalIpAddress}}</a>
+          <copy-to-clipboard
+            class="copy-to-clipboard copy-to-clipboard-sm"
+            text="instance.externalIpAddress"
+            tool-tip="'Copy to clipboard'"
+          >
+          </copy-to-clipboard>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="{{firewallsLabel}}">
+      <ul>
+        <li ng-repeat="securityGroup in instance.securityGroups | orderBy:'groupName'">
+          <a
+            ui-sref="^.firewallDetails({name:securityGroup.groupName, accountId: instance.account, region: 'global', provider: instance.provider})"
+          >
+            {{securityGroup.groupName}}
+          </a>
+        </li>
+      </ul>
+    </collapsible-section>
+    <collapsible-section heading="Custom Metadata">
+      <div ng-if="!instance.metadata.items.length">No custom metadata associated with this instance</div>
+      <dl ng-if="instance.metadata.items.length">
+        <dt ng-repeat-start="metadata in instance.metadata.items">
+          {{metadata.key}}
+          <help-field key="gce.instance.customMetadata.{{metadata.key}}"></help-field>
+        </dt>
+        <dd ng-repeat-end>{{metadata.value.length > 90 ? metadata.value.substring(0, 90) + "..." : metadata.value}}</dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Tags">
+      <div ng-if="!instance.tags.items.length">No tags associated with this instance</div>
+      <dl ng-if="instance.tags.items.length">
+        <dd ng-repeat="tag in instance.tags.items">
+          {{tag}}
+          <help-field content="{{instance.tags.helpMap[tag]}}"></help-field>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Labels">
+      <div ng-if="!instance.labels">No labels associated with this instance</div>
+      <dl ng-if="instance.labels">
+        <dt ng-repeat-start="(key, value) in instance.labels">
+          {{key}}
+          <help-field key="gce.instance.labels.{{key}}"></help-field>
+        </dt>
+        <dd ng-repeat-end>{{value}}</dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="SSH" ng-if="!instance.notFound">
+      <dl>
+        <dt ng-if="instance.sshLink">SSH into this instance</dt>
+        <dd ng-if="instance.sshLink">
+          <a href="{{instance.sshLink}}" target="_blank">SSH</a>
+          <copy-to-clipboard
+            class="copy-to-clipboard copy-to-clipboard-sm"
+            text="instance.sshLink"
+            tool-tip="'Copy to clipboard'"
+          >
+          </copy-to-clipboard>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Logs">
+      <ul>
+        <li ng-if="instance.logsLink">
+          <a href="{{instance.logsLink}}" target="_blank">Cloud Console Logs</a>
+          <copy-to-clipboard
+            class="copy-to-clipboard copy-to-clipboard-sm"
+            text="instance.logsLink"
+            tool-tip="'Copy to clipboard'"
+          >
+          </copy-to-clipboard>
+        </li>
+        <li>
+          <console-output-link instance="instance"></console-output-link>
+        </li>
+      </ul>
+    </collapsible-section>
+    <instance-links
+      address="baseIpAddress"
+      application="application"
+      instance="instance"
+      moniker="moniker"
+      environment="environment"
+    ></instance-links>
+  </div>
+  <div class="content" ng-if="!state.loading && !instance">
+    <div class="content-section">
+      <div class="content-body text-center">
+        <h3>Instance not found.</h3>
+      </div>
+    </div>
+  </div>
+</div>

package/src/instance/gceInstanceType.service.js

@@ -0,0 +1,432 @@
+'use strict';
+
+import { module } from 'angular';
+import _ from 'lodash';
+
+import { AccountService, SETTINGS } from '@spinnaker/core';
+
+import { GCE_INSTANCE_TYPE_DISK_DEFAULTS } from './gceInstanceTypeDisks';
+
+export const GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE = 'spinnaker.gce.instanceType.service';
+export const name = GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE; // for backwards compatibility
+module(GOOGLE_INSTANCE_GCEINSTANCETYPE_SERVICE, []).factory('gceInstanceTypeService', [
+  '$q',
+  '$log',
+  function ($q, $log) {
+    const cachedResult = null;
+
+    const n1standard = {
+      type: 'n1-standard',
+      description:
+        'This family provides a balance of compute, memory, and network resources, and it is a good choice for general purpose applications.',
+      storageType: 'SSD',
+      storageHelpFieldKey: 'gce.instance.storage',
+      instanceTypes: [
+        {
+          name: 'n1-standard-1',
+          label: 'Small',
+          cpu: 1,
+          memory: 3.75,
+          costFactor: 1,
+        },
+        {
+          name: 'n1-standard-2',
+          label: 'Medium',
+          cpu: 2,
+          memory: 7.5,
+          costFactor: 2,
+        },
+        {
+          name: 'n1-standard-4',
+          label: 'Large',
+          cpu: 4,
+          memory: 15,
+          costFactor: 2,
+        },
+        {
+          name: 'n1-standard-8',
+          label: 'XLarge',
+          cpu: 8,
+          memory: 30,
+          costFactor: 3,
+        },
+        {
+          name: 'n1-standard-16',
+          label: '2XLarge',
+          cpu: 16,
+          memory: 60,
+          costFactor: 3,
+        },
+        {
+          name: 'n1-standard-32',
+          label: '4XLarge',
+          cpu: 32,
+          memory: 120,
+          costFactor: 4,
+        },
+        {
+          name: 'n1-standard-64',
+          label: '8XLarge',
+          cpu: 64,
+          memory: 240,
+          costFactor: 4,
+        },
+        {
+          name: 'n1-standard-96',
+          label: '12XLarge',
+          cpu: 96,
+          memory: 360,
+          costFactor: 4,
+        },
+      ],
+    };
+
+    const f1micro = {
+      type: 'f1-micro bursting',
+      description:
+        'This family of machine types is a good choice for small, non-resource intensive workloads that don’t use the full CPU often or consistently, but occasionally need to burst (e.g. web servers, developer environments and small databases).',
+      storageType: 'Std',
+      storageHelpFieldKey: 'gce.instance.storage',
+      instanceTypes: [
+        {
+          name: 'f1-micro',
+          label: 'Micro',
+          cpu: 1,
+          memory: 0.6,
+          costFactor: 1,
+        },
+        {
+          name: 'g1-small',
+          label: 'Small',
+          cpu: 1,
+          memory: 1.7,
+          costFactor: 1,
+        },
+        {
+          name: 'e2-micro',
+          label: 'E2 Micro',
+          cpu: 2,
+          memory: 1,
+          costFactor: 1,
+        },
+        {
+          name: 'e2-small',
+          label: 'E2 Small',
+          cpu: 2,
+          memory: 2,
+          costFactor: 2,
+        },
+        {
+          name: 'e2-medium',
+          label: 'E2 Medium',
+          cpu: 2,
+          memory: 4,
+          costFactor: 2,
+        },
+      ],
+    };
+
+    const n1highmem = {
+      type: 'n1-highmem',
+      description:
+        'High memory machine types are ideal for tasks that require more memory relative to virtual cores. High memory machine types have 6.50GB of RAM per virtual core.',
+      storageType: 'SSD',
+      storageHelpFieldKey: 'gce.instance.storage',
+      instanceTypes: [
+        {
+          name: 'n1-highmem-2',
+          label: 'Medium',
+          cpu: 2,
+          memory: 13,
+          costFactor: 2,
+        },
+        {
+          name: 'n1-highmem-4',
+          label: 'Large',
+          cpu: 4,
+          memory: 26,
+          costFactor: 2,
+        },
+        {
+          name: 'n1-highmem-8',
+          label: 'XLarge',
+          cpu: 8,
+          memory: 52,
+          costFactor: 3,
+        },
+        {
+          name: 'n1-highmem-16',
+          label: '2XLarge',
+          cpu: 16,
+          memory: 104,
+          costFactor: 3,
+        },
+        {
+          name: 'n1-highmem-32',
+          label: '4XLarge',
+          cpu: 32,
+          memory: 208,
+          costFactor: 4,
+        },
+        {
+          name: 'n1-highmem-64',
+          label: '8XLarge',
+          cpu: 64,
+          memory: 416,
+          costFactor: 4,
+        },
+        {
+          name: 'n1-highmem-96',
+          label: '12XLarge',
+          cpu: 96,
+          memory: 624,
+          costFactor: 4,
+        },
+      ],
+    };
+
+    const n1highcpu = {
+      type: 'n1-highcpu',
+      description:
+        'High CPU machine types are ideal for tasks that require more virtual cores relative to memory. High CPU machine types have one virtual core for every 0.90GB of RAM.',
+      storageType: 'SSD',
+      storageHelpFieldKey: 'gce.instance.storage',
+      instanceTypes: [
+        {
+          name: 'n1-highcpu-2',
+          label: 'Medium',
+          cpu: 2,
+          memory: 1.8,
+          costFactor: 1,
+        },
+        {
+          name: 'n1-highcpu-4',
+          label: 'Large',
+          cpu: 4,
+          memory: 3.6,
+          costFactor: 2,
+        },
+        {
+          name: 'n1-highcpu-8',
+          label: 'XLarge',
+          cpu: 8,
+          memory: 7.2,
+          costFactor: 2,
+        },
+        {
+          name: 'n1-highcpu-16',
+          label: '2XLarge',
+          cpu: 16,
+          memory: 14.4,
+          costFactor: 3,
+        },
+        {
+          name: 'n1-highcpu-32',
+          label: '4XLarge',
+          cpu: 32,
+          memory: 28.8,
+          costFactor: 4,
+        },
+        {
+          name: 'n1-highcpu-64',
+          label: '8XLarge',
+          cpu: 64,
+          memory: 57.6,
+          costFactor: 4,
+        },
+        {
+          name: 'n1-highcpu-96',
+          label: '12XLarge',
+          cpu: 96,
+          memory: 86.4,
+          costFactor: 4,
+        },
+      ],
+    };
+
+    const customMachine = {
+      type: 'buildCustom',
+      instanceTypes: [
+        {
+          name: 'n1buildCustom',
+          nameRegex: /custom-\d{1,2}-\d{4,6}/,
+          storage: {
+            localSSDSupported: true,
+          },
+        },
+        {
+          name: 'e2buildCustom',
+          nameRegex: /e2-custom-(\d{1,2})-(\d{3,6})/,
+          storage: {
+            localSSDSupported: false,
+          },
+        },
+        {
+          name: 'otherbuildCustom',
+          nameRegex: /(.*)-?custom-(\d{1,2})-(\d{3,6})/,
+          storage: {
+            localSSDSupported: true,
+          },
+        },
+      ],
+    };
+
+    const categories = [
+      {
+        type: 'general',
+        label: 'General Purpose',
+        families: [n1standard],
+        icon: 'hdd',
+      },
+      {
+        type: 'memory',
+        label: 'High Memory',
+        families: [n1highmem],
+        icon: 'hdd',
+      },
+      {
+        type: 'cpu',
+        label: 'High CPU',
+        families: [n1highcpu],
+        icon: 'hdd',
+      },
+      {
+        type: 'micro',
+        label: 'Micro Utility',
+        families: [f1micro],
+        icon: 'hdd',
+      },
+      {
+        type: 'custom',
+        label: 'Custom Type',
+        families: [],
+        icon: 'asterisk',
+      },
+      {
+        type: 'buildCustom',
+        label: 'Build Custom',
+        families: [customMachine],
+        icon: 'wrench',
+      },
+    ];
+
+    const getCategories = _.memoize(() => {
+      const initializedCategories = _.cloneDeep(categories);
+      return AccountService.getAllAccountDetailsForProvider('gce').then((accountDetails) => {
+        // All GCE accounts have the same instance type disk defaults, so we can pick the first one.
+        let instanceTypeDisks = _.get(accountDetails, '[0].instanceTypeDisks');
+        if (_.isEmpty(instanceTypeDisks)) {
+          instanceTypeDisks = GCE_INSTANCE_TYPE_DISK_DEFAULTS;
+        }
+        if (instanceTypeDisks) {
+          const families = _.flatten(initializedCategories.map((category) => category.families));
+          families.forEach((family) => {
+            family.instanceTypes.forEach((instanceType) => {
+              const diskDefaults = instanceTypeDisks.find(
+                (instanceTypeDisk) => instanceTypeDisk.instanceType === instanceType.name,
+              );
+              if (diskDefaults) {
+                const disks = diskDefaults.disks
+                  .map((disk) => {
+                    switch (disk.type) {
+                      case 'PD_SSD':
+                        return {
+                          type: 'pd-ssd',
+                          sizeGb: disk.sizeGb,
+                        };
+                      case 'PD_STANDARD':
+                        return {
+                          type: 'pd-standard',
+                          sizeGb: disk.sizeGb,
+                        };
+                      case 'LOCAL_SSD':
+                        return {
+                          type: 'local-ssd',
+                          sizeGb: 375,
+                        };
+                      default:
+                        $log.warn(`Disk type '${disk.type}' not supported.`);
+                        return null;
+                    }
+                  })
+                  .filter((disk) => !!disk);
+
+                let size = 0;
+                let count = 0;
+                if (diskDefaults.supportsLocalSSD) {
+                  count = disks.filter((disk) => disk.type === 'local-ssd').length;
+                  size = 375;
+                } else {
+                  // TODO(dpeach): This will render the disk defaults incorrectly for f1-micro and g1-small instance types
+                  // if the disk defaults set in Clouddriver have different sizes. Fixing it will require updating
+                  // the core instance type selector.
+                  // This logic will render the count of the largest disk.
+                  const persistentDisks = disks.filter((disk) => disk.type.startsWith('pd-'));
+                  if (persistentDisks.length) {
+                    size = persistentDisks.reduce((maxSizeGb, disk) => Math.max(maxSizeGb, disk.sizeGb), 0);
+                    count = persistentDisks.filter((disk) => disk.sizeGb === size).length;
+                  }
+                }
+
+                instanceType.storage = {
+                  localSSDSupported: diskDefaults.supportsLocalSSD,
+                  size: size,
+                  count: count,
+                  defaultSettings: { disks },
+                };
+              }
+            });
+          });
+        }
+        return initializedCategories;
+      });
+    });
+
+    function getAllTypesByRegion() {
+      if (cachedResult) {
+        return $q.when(cachedResult);
+      }
+
+      return getCategories().then((categories) => {
+        return _.chain(categories)
+          .map('families')
+          .flatten()
+          .map('instanceTypes')
+          .flatten()
+          .map('name')
+          .filter((name) => name !== 'n1buildCustom' && name !== 'e2buildCustom' && name !== 'otherbuildCustom')
+          .value();
+      });
+    }
+
+    function getAvailableTypesForLocations(locationToInstanceTypesMap, selectedLocations) {
+      if (!locationToInstanceTypesMap || !selectedLocations || selectedLocations.length === 0) {
+        console.error('Invalid input parameters');
+        return [];
+      }
+
+      const availableTypes = selectedLocations
+        .filter((location) => locationToInstanceTypesMap[location])
+        .flatMap((location) => locationToInstanceTypesMap[location].instanceTypes || []);
+
+      return availableTypes;
+    }
+
+    const getAvailableTypesForRegions = getAvailableTypesForLocations;
+
+    const resolveInstanceTypeDetails = (instanceType) => {
+      return {
+        name: instanceType,
+        storage: Object.assign({ isDefault: true }, SETTINGS.providers.gce.defaults.instanceTypeStorage),
+      };
+    };
+
+    return {
+      getCategories: getCategories,
+      getAvailableTypesForRegions: getAvailableTypesForRegions,
+      getAllTypesByRegion: getAllTypesByRegion,
+      getAvailableTypesForLocations: getAvailableTypesForLocations,
+      resolveInstanceTypeDetails: resolveInstanceTypeDetails,
+    };
+  },
+]);

package/src/instance/gceInstanceType.service.spec.js

@@ -0,0 +1,19 @@
+'use strict';
+
+describe('Service: gceInstanceTypeService', function () {
+  //NOTE: This is only testing the service dependencies. Please add more tests.
+
+  let gceInstanceTypeService;
+
+  beforeEach(window.module(require('./gceInstanceType.service').name));
+
+  beforeEach(
+    window.inject(function (_gceInstanceTypeService_) {
+      gceInstanceTypeService = _gceInstanceTypeService_;
+    }),
+  );
+
+  it('should instantiate the controller', function () {
+    expect(gceInstanceTypeService).toBeDefined();
+  });
+});