@spinnaker/azure 0.0.0-2025.1-0

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

@@ -0,0 +1,17 @@
+'use strict';
+
+describe('Service: InstanceType', function () {
+  beforeEach(function () {
+    window.module(require('./azureInstanceType.service').name);
+  });
+
+  beforeEach(
+    window.inject(function (_azureInstanceTypeService_) {
+      this.azureInstanceTypeService = _azureInstanceTypeService_;
+    }),
+  );
+
+  it('should instantiate the controller', function () {
+    expect(this.azureInstanceTypeService).toBeDefined();
+  });
+});

package/src/instance/details/instance.details.controller.js

@@ -0,0 +1,371 @@
+'use strict';
+
+import UIROUTER_ANGULARJS from '@uirouter/angularjs';
+import { module } from 'angular';
+import ANGULAR_UI_BOOTSTRAP from 'angular-ui-bootstrap';
+import _ from 'lodash';
+
+import {
+  CloudProviderRegistry,
+  ConfirmationModalService,
+  InstanceReader,
+  InstanceWriter,
+  RecentHistoryService,
+} from '@spinnaker/core';
+
+export const AZURE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER = 'spinnaker.azure.instance.detail.controller';
+export const name = AZURE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER; // for backwards compatibility
+module(AZURE_INSTANCE_DETAILS_INSTANCE_DETAILS_CONTROLLER, [UIROUTER_ANGULARJS, ANGULAR_UI_BOOTSTRAP]).controller(
+  'azureInstanceDetailsCtrl',
+  [
+    '$scope',
+    '$state',
+    '$uibModal',
+    'instance',
+    'app',
+    '$q',
+    function ($scope, $state, $uibModal, instance, app, $q) {
+      // needed for standalone instances
+      $scope.detailsTemplateUrl = CloudProviderRegistry.getValue('azure', 'instance.detailsTemplateUrl');
+
+      $scope.state = {
+        loading: true,
+        standalone: app.isStandalone,
+      };
+
+      function extractHealthMetrics(instance, latest) {
+        // do not backfill on standalone instances
+        if (app.isStandalone) {
+          instance.health = latest.health;
+        }
+
+        instance.health = instance.health || [];
+        const displayableMetrics = instance.health.filter(function (metric) {
+          return metric.type !== 'Azure' || metric.state !== 'Unknown';
+        });
+        // backfill details where applicable
+        if (latest.health) {
+          displayableMetrics.forEach(function (metric) {
+            const detailsMatch = latest.health.filter(function (latestHealth) {
+              return latestHealth.type === metric.type;
+            });
+            if (detailsMatch.length) {
+              _.defaults(metric, detailsMatch[0]);
+            }
+          });
+        }
+        $scope.healthMetrics = displayableMetrics;
+      }
+
+      function retrieveInstance() {
+        const extraData = {};
+        let instanceSummary, loadBalancers, account, region, vpcId;
+        if (!app.serverGroups) {
+          // standalone instance
+          instanceSummary = {};
+          loadBalancers = [];
+          account = instance.account;
+          region = instance.region;
+        } else {
+          app.serverGroups.data.some(function (serverGroup) {
+            return serverGroup.instances.some(function (possibleInstance) {
+              if (possibleInstance.id === instance.instanceId) {
+                instanceSummary = possibleInstance;
+                loadBalancers = serverGroup.loadBalancers;
+                account = serverGroup.account;
+                region = serverGroup.region;
+                vpcId = serverGroup.vpcId;
+                extraData.serverGroup = serverGroup.name;
+                extraData.vpcId = serverGroup.vpcId;
+                return true;
+              }
+            });
+          });
+          if (!instanceSummary) {
+            // perhaps it is in a server group that is part of another app
+            app.loadBalancers.data.some(function (loadBalancer) {
+              return loadBalancer.instances.some(function (possibleInstance) {
+                if (possibleInstance.id === instance.instanceId) {
+                  instanceSummary = possibleInstance;
+                  loadBalancers = [loadBalancer.name];
+                  account = loadBalancer.account;
+                  region = loadBalancer.region;
+                  vpcId = loadBalancer.vpcId;
+                  return true;
+                }
+              });
+            });
+            if (!instanceSummary) {
+              // perhaps it is in a disabled server group via a load balancer
+              app.loadBalancers.data.some(function (loadBalancer) {
+                return loadBalancer.serverGroups.some(function (serverGroup) {
+                  if (!serverGroup.isDisabled) {
+                    return false;
+                  }
+                  return serverGroup.instances.some(function (possibleInstance) {
+                    if (possibleInstance.id === instance.instanceId) {
+                      instanceSummary = possibleInstance;
+                      loadBalancers = [loadBalancer.name];
+                      account = loadBalancer.account;
+                      region = loadBalancer.region;
+                      vpcId = loadBalancer.vpcId;
+                      return true;
+                    }
+                  });
+                });
+              });
+            }
+          }
+        }
+
+        if (instanceSummary && account && region) {
+          extraData.account = account;
+          extraData.region = region;
+          RecentHistoryService.addExtraDataToLatest('instances', extraData);
+          return InstanceReader.getInstanceDetails(account, region, instance.instanceId).then(
+            function (details) {
+              $scope.state.loading = false;
+              extractHealthMetrics(instanceSummary, details);
+              $scope.instance = _.defaults(details, instanceSummary);
+              $scope.instance.account = account;
+              $scope.instance.region = region;
+              $scope.instance.vpcId = vpcId;
+              $scope.instance.loadBalancers = loadBalancers;
+              const discoveryMetric = _.find($scope.healthMetrics, function (metric) {
+                return metric.type === 'Discovery';
+              });
+              if (discoveryMetric && discoveryMetric.vipAddress) {
+                const vipList = discoveryMetric.vipAddress;
+                $scope.instance.vipAddress = vipList.includes(',') ? vipList.split(',') : [vipList];
+              }
+              $scope.baseIpAddress = details.publicDnsName || details.privateIpAddress;
+            },
+            function () {
+              // When an instance is first starting up, we may not have the details cached in oort yet, but we still
+              // want to let the user see what details we have
+              $scope.state.loading = false;
+              $state.go('^');
+            },
+          );
+        }
+
+        if (!instanceSummary) {
+          $scope.instanceIdNotFound = instance.instanceId;
+          $scope.state.loading = false;
+        }
+
+        return $q.when(null);
+      }
+
+      this.canDeregisterFromLoadBalancer = function () {
+        return $scope.instance.health.some(function (health) {
+          return health.type === 'LoadBalancer';
+        });
+      };
+
+      this.canRegisterWithLoadBalancer = function () {
+        const instance = $scope.instance;
+        if (!instance.loadBalancers || !instance.loadBalancers.length) {
+          return false;
+        }
+        const outOfService = instance.health.some(function (health) {
+          return health.type === 'LoadBalancer' && health.state === 'OutOfService';
+        });
+        const hasLoadBalancerHealth = instance.health.some(function (health) {
+          return health.type === 'LoadBalancer';
+        });
+        return outOfService || !hasLoadBalancerHealth;
+      };
+
+      this.canRegisterWithDiscovery = function () {
+        const instance = $scope.instance;
+        const discoveryHealth = instance.health.filter(function (health) {
+          return health.type === 'Discovery';
+        });
+        return discoveryHealth.length ? discoveryHealth[0].state === 'OutOfService' : false;
+      };
+
+      this.terminateInstance = function terminateInstance() {
+        const instance = $scope.instance;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Terminating ' + instance.instanceId,
+          onTaskComplete: function () {
+            if ($state.includes('**.instanceDetails', { instanceId: instance.instanceId })) {
+              $state.go('^');
+            }
+          },
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.terminateInstance(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really terminate ' + instance.instanceId + '?',
+          buttonText: 'Terminate ' + instance.instanceId,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.terminateInstanceAndShrinkServerGroup = function terminateInstanceAndShrinkServerGroup() {
+        const instance = $scope.instance;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Terminating ' + instance.instanceId + ' and shrinking server group',
+          onTaskComplete: function () {
+            if ($state.includes('**.instanceDetails', { instanceId: instance.instanceId })) {
+              $state.go('^');
+            }
+          },
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.terminateInstanceAndShrinkServerGroup(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really terminate ' + instance.instanceId + ' and shrink ' + instance.serverGroup + '?',
+          buttonText: 'Terminate ' + instance.instanceId + ' and shrink ' + instance.serverGroup,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.rebootInstance = function rebootInstance() {
+        const instance = $scope.instance;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Rebooting ' + instance.instanceId,
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.rebootInstance(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really reboot ' + instance.instanceId + '?',
+          buttonText: 'Reboot ' + instance.instanceId,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.registerInstanceWithLoadBalancer = function registerInstanceWithLoadBalancer() {
+        const instance = $scope.instance;
+        const loadBalancerNames = instance.loadBalancers.join(' and ');
+
+        const taskMonitor = {
+          application: app,
+          title: 'Registering ' + instance.instanceId + ' with ' + loadBalancerNames,
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.registerInstanceWithLoadBalancer(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really register ' + instance.instanceId + ' with ' + loadBalancerNames + '?',
+          buttonText: 'Register ' + instance.instanceId,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.deregisterInstanceFromLoadBalancer = function deregisterInstanceFromLoadBalancer() {
+        const instance = $scope.instance;
+        const loadBalancerNames = instance.loadBalancers.join(' and ');
+
+        const taskMonitor = {
+          application: app,
+          title: 'Deregistering ' + instance.instanceId + ' from ' + loadBalancerNames,
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.deregisterInstanceFromLoadBalancer(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really deregister ' + instance.instanceId + ' from ' + loadBalancerNames + '?',
+          buttonText: 'Deregister ' + instance.instanceId,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.enableInstanceInDiscovery = function enableInstanceInDiscovery() {
+        const instance = $scope.instance;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Enabling ' + instance.instanceId + ' in discovery',
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.enableInstanceInDiscovery(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really enable ' + instance.instanceId + ' in discovery?',
+          buttonText: 'Enable ' + instance.instanceId,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.disableInstanceInDiscovery = function disableInstanceInDiscovery() {
+        const instance = $scope.instance;
+
+        const taskMonitor = {
+          application: app,
+          title: 'Disabling ' + instance.instanceId + ' in discovery',
+        };
+
+        const submitMethod = function () {
+          return InstanceWriter.disableInstanceInDiscovery(instance, app);
+        };
+
+        ConfirmationModalService.confirm({
+          header: 'Really disable ' + instance.instanceId + ' in discovery?',
+          buttonText: 'Disable ' + instance.instanceId,
+          account: instance.account,
+          taskMonitorConfig: taskMonitor,
+          submitMethod: submitMethod,
+        });
+      };
+
+      this.hasHealthState = function hasHealthState(healthProviderType, state) {
+        const instance = $scope.instance;
+        return instance.health.some(function (health) {
+          return health.type === healthProviderType && health.state === state;
+        });
+      };
+
+      const initialize = app.isStandalone
+        ? retrieveInstance()
+        : $q.all([app.serverGroups.ready(), app.loadBalancers.ready()]).then(retrieveInstance);
+
+      initialize.then(() => {
+        // Two things to look out for here:
+        //  1. If the retrieveInstance call completes *after* the user has navigated away from the view, there
+        //     is no point in subscribing to the refresh
+        //  2. If this is a standalone instance, there is no application that will refresh
+        if (!$scope.$$destroyed && !app.isStandalone) {
+          app.serverGroups.onRefresh($scope, retrieveInstance);
+        }
+      });
+
+      $scope.account = instance.account;
+    },
+  ],
+);

package/src/instance/details/instance.details.controller.spec.js

@@ -0,0 +1,129 @@
+import { ApplicationModelBuilder, InstanceReader } from '@spinnaker/core';
+
+describe('Controller: azureInstanceDetailsCtrl', function () {
+  var controller;
+  var scope;
+  var $q;
+  var application;
+
+  beforeEach(window.module(require('./instance.details.controller').name));
+
+  beforeEach(
+    window.inject(function ($rootScope, $controller, _$q_) {
+      scope = $rootScope.$new();
+      $q = _$q_;
+
+      application = ApplicationModelBuilder.createApplicationForTests(
+        'app',
+        { key: 'loadBalancers', lazy: true, defaultData: [] },
+        { key: 'serverGroups', lazy: true, defaultData: [] },
+      );
+
+      this.createController = function (application, instance) {
+        controller = $controller('azureInstanceDetailsCtrl', {
+          $scope: scope,
+          instance: instance,
+          app: application,
+        });
+      };
+    }),
+  );
+
+  describe('health metrics', function () {
+    it('overrides new health with health from application, adding new fields', function () {
+      var details = {
+        health: [{ type: 'Discovery', status: 'Up', extra: 'details field', reason: 'mutated' }],
+      };
+      var params = {
+        instanceId: 'i-123',
+        region: 'us-west-1',
+        account: 'test',
+      };
+
+      spyOn(InstanceReader, 'getInstanceDetails').and.returnValue($q.when(details));
+
+      application.loadBalancers.loaded = true;
+
+      application.serverGroups.data = [
+        {
+          account: 'test',
+          region: 'us-west-1',
+          instances: [
+            {
+              id: 'i-123',
+              health: [{ type: 'Discovery', status: 'Down', reason: 'original reason' }],
+            },
+          ],
+        },
+      ];
+      application.serverGroups.loaded = true;
+
+      this.createController(application, params);
+      scope.$digest();
+
+      expect(scope.healthMetrics.length).toBe(1);
+      expect(scope.healthMetrics[0].reason).toBe('original reason');
+      expect(scope.healthMetrics[0].status).toBe('Down');
+      expect(scope.healthMetrics[0].extra).toBe('details field');
+    });
+  });
+
+  describe('canRegister methods', function () {
+    beforeEach(function () {
+      var details = {};
+      var params = {
+        instanceId: 'i-123',
+        region: 'us-west-1',
+        account: 'test',
+      };
+
+      spyOn(InstanceReader, 'getInstanceDetails').and.returnValue(
+        $q.when({
+          plain: function () {
+            return details;
+          },
+        }),
+      );
+
+      application.loadBalancers.loaded = true;
+      application.serverGroups.data = [
+        {
+          account: 'test',
+          region: 'us-west-1',
+          instances: [
+            {
+              id: 'i-123',
+              health: [{ type: 'Discovery', state: 'Up', reason: 'original reason' }],
+            },
+          ],
+        },
+      ];
+      application.serverGroups.loaded = true;
+
+      this.createController(application, params);
+      scope.$digest();
+    });
+
+    it('can register with discovery when discovery', function () {
+      expect(controller.canRegisterWithDiscovery()).toBe(false);
+      scope.instance.health[0].state = 'OutOfService';
+      expect(controller.canRegisterWithDiscovery()).toBe(true);
+      scope.instance.health[0].state = 'Down';
+      expect(controller.canRegisterWithDiscovery()).toBe(false);
+      scope.instance.health = [];
+      expect(controller.canRegisterWithDiscovery()).toBe(false);
+    });
+
+    it('can register with load balancer', function () {
+      expect(controller.canRegisterWithLoadBalancer()).toBe(false);
+      scope.instance.health[0].type = 'LoadBalancer';
+      scope.instance.health[0].state = 'OutOfService';
+      expect(controller.canRegisterWithLoadBalancer()).toBe(false);
+      // add a load balancer
+      scope.instance.loadBalancers = ['elb-1'];
+      expect(controller.canRegisterWithLoadBalancer()).toBe(true);
+      scope.instance.health[0].state = 'Up';
+      expect(controller.canRegisterWithLoadBalancer()).toBe(false);
+    });
+  });
+});

package/src/instance/details/instanceDetails.html

@@ -0,0 +1,43 @@
+<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>
+  <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" provider="instance.provider" pad="right"></account-tag>
+          {{instance.region || '(Unknown)'}}
+        </dd>
+        <dt>Type</dt>
+        <dd>{{instance.instanceType || '(Unknown)'}}</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>
+      </dl>
+    </collapsible-section>
+  </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/loadBalancer/configure/AzureLoadBalancerChoiceModal.tsx

@@ -0,0 +1,101 @@
+import React from 'react';
+import { Button, Modal } from 'react-bootstrap';
+
+import type { ILoadBalancerModalProps } from '@spinnaker/core';
+import { CloudProviderRegistry, ModalClose, ModalInjector, noop, ReactModal } from '@spinnaker/core';
+
+import type { IAzureLoadBalancer } from '../../utility';
+import { AzureLoadBalancerTypes } from '../../utility';
+
+export interface IAzureLoadBalancerChoiceModalState {
+  choices: IAzureLoadBalancer[];
+  selectedChoice: IAzureLoadBalancer;
+}
+
+export class AzureLoadBalancerChoiceModal extends React.Component<
+  ILoadBalancerModalProps,
+  IAzureLoadBalancerChoiceModalState
+> {
+  public static defaultProps: Partial<ILoadBalancerModalProps> = {
+    closeModal: noop,
+    dismissModal: noop,
+  };
+
+  public static show(props: ILoadBalancerModalProps): Promise<void> {
+    return ReactModal.show(AzureLoadBalancerChoiceModal, {
+      ...props,
+      className: 'create-pipeline-modal-overflow-visible',
+    });
+  }
+
+  constructor(props: ILoadBalancerModalProps) {
+    super(props);
+    this.state = {
+      choices: AzureLoadBalancerTypes,
+      selectedChoice: AzureLoadBalancerTypes[0],
+    };
+  }
+
+  public choiceSelected(choice: IAzureLoadBalancer): void {
+    this.setState({ selectedChoice: choice });
+  }
+
+  private choose = (): void => {
+    this.close();
+    const provider: any = CloudProviderRegistry.getValue('azure', 'loadBalancer');
+    ModalInjector.modalService
+      .open({
+        templateUrl: provider.createLoadBalancerTemplateUrl,
+        windowClass: 'modal-z-index',
+        controller: `${provider.createLoadBalancerController} as ctrl`,
+        size: 'lg',
+        resolve: {
+          application: () => this.props.app,
+          loadBalancer: (): any => null,
+          isNew: () => true,
+          forPipelineConfig: () => false,
+          loadBalancerType: () => this.state.selectedChoice,
+        },
+      })
+      .result.catch(() => {});
+  };
+
+  public close = (reason?: any): void => {
+    this.props.dismissModal(reason);
+  };
+
+  public render() {
+    const { choices, selectedChoice } = this.state;
+
+    return (
+      <>
+        <ModalClose dismiss={this.close} />
+        <Modal.Header>
+          <Modal.Title>Select Type of Load Balancer</Modal.Title>
+        </Modal.Header>
+        <Modal.Body>
+          <div className="modal-body">
+            <div className="card-choices">
+              {choices.map((choice) => (
+                <div
+                  key={choice.type}
+                  className={`card ${selectedChoice === choice ? 'active' : ''}`}
+                  onClick={() => this.choiceSelected(choice)}
+                >
+                  <h3 className="load-balancer-label">{choice.type}</h3>
+                  <div>{choice.description}</div>
+                </div>
+              ))}
+            </div>
+            <div className="load-balancer-description" />
+          </div>
+        </Modal.Body>
+        <Modal.Footer>
+          <Button onClick={this.choose}>
+            Configure Load Balancer <span className="glyphicon glyphicon-chevron-right" />
+          </Button>
+        </Modal.Footer>
+      </>
+    );
+  }
+}