@spinnaker/cloudrun 0.1.6

package/src/help/cloudrun.help.ts

@@ -0,0 +1,99 @@
+import { HelpContentsRegistry } from '@spinnaker/core';
+
+const helpContents = [
+  {
+    key: 'cloudrun.serverGroup.stack',
+    value:
+      '(Optional) <b>Stack</b> is one of the core naming components of a cluster, used to create vertical stacks of dependent services for integration testing.',
+  },
+
+  {
+    key: 'cloudrun.serverGroup.file',
+    value: `<pre>
+    apiVersion: serving.knative.dev/v1
+    kind: Service
+    metadata:
+        name: spinappcloud1
+        namespace: '135005621049'
+        labels:
+            cloud.googleapis.com/location: us-central1
+    annotations:
+        run.googleapis.com/client-name: cloud-console
+        serving.knative.dev/creator: kiran@opsmx.io
+        serving.knative.dev/lastModifier: kiran@opsmx.io
+        client.knative.dev/user-image: us-docker.pkg.dev/cloudrun/container/hello
+        run.googleapis.com/ingress-status: all
+    spec:
+        template:
+        metagoogleapis.com/ingress: all
+        run.data:
+        name: spinappcloud1
+    annotations:
+        run.googleapis.com/client-name: cloud-console
+        autoscaling.knative.dev/minScale: '1'
+        autoscaling.knative.dev/maxScale: '3'
+    spec:
+        containerConcurrency: 80
+        timeoutSeconds: 200
+        serviceAccountName:spinnaker-cloudrun-account@my-orbit-project-71824.iam.gserviceaccount.com
+        containers:
+           - image:us-docker.pkg.dev/cloudrun/container/hello
+        ports:
+           - name: http1
+        containerPort: 8080
+        resources:
+        limits:
+        cpu: 1000m
+        memory: 256Mi  
+</pre>
+    `,
+  },
+
+  {
+    key: 'cloudrun.serverGroup.detail',
+    value:
+      ' (Optional) <b>Detail</b> is a string of free-form alphanumeric characters and hyphens to describe any other variables.',
+  },
+  {
+    key: 'cloudrun.serverGroup.configFiles',
+    value: `<p> The contents of a Cloud Run Service yaml </p>`,
+  },
+  {
+    key: 'cloudrun.loadBalancer.allocations',
+    value: 'An allocation is the percent of traffic directed to a server group.',
+  },
+  {
+    key: 'cloudrun.manifest.source',
+    value: `
+    <p>Where the manifest file content is read from.</p>
+    <p>
+      <b>text:</b> The manifest is supplied statically to the pipeline from the below text-box.
+    </p>
+    <p>
+      <b>artifact:</b> The manifest is read from an artifact supplied/created upstream. The expected artifact must be referenced here, and will be bound at runtime.
+    </p>`,
+  },
+  {
+    key: 'cloudrun.manifest.expectedArtifact',
+    value:
+      'The artifact that is to be applied to the Cloud Run account for this stage.  The artifact should represent a valid Cloud Run manifest.',
+  },
+  {
+    key: 'cloudrun.manifest.skipExpressionEvaluation',
+    value:
+      '<p>Skip SpEL expression evaluation of the manifest artifact in this stage. Can be paired with the "Evaluate SpEL expressions in overrides at bake time" option in the Bake Manifest stage when baking a third-party manifest artifact with expressions not meant for Spinnaker to evaluate as SpEL.</p>',
+  },
+  {
+    key: 'cloudrun.manifest.requiredArtifactsToBind',
+    value:
+      'These artifacts must be present in the context for this stage to successfully complete. Artifacts specified will be <a href="https://www.spinnaker.io/reference/artifacts/in-cloudrun-v2/#binding-artifacts-in-manifests" target="_blank">bound to the deployed manifest.</a>',
+  },
+  {
+    key: 'cloudrun.manifest.account',
+    value: `
+    <p>A Spinnaker account corresponds to a physical Cloud Run cluster. If you are unsure which account to use, talk to your Spinnaker admin.</p>
+    `,
+  },
+];
+
+helpContents.forEach((entry) => HelpContentsRegistry.register(entry.key, entry.value));

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './cloudrun.module';
+export * from './serverGroup';
+export * from './loadBalancer';

package/src/instance/details/details.controller.ts

@@ -0,0 +1,84 @@
+import type { IController, IQService } from 'angular';
+import { module } from 'angular';
+import { flattenDeep } from 'lodash';
+
+import type { Application, ILoadBalancer } from '@spinnaker/core';
+import { InstanceReader, RecentHistoryService } from '@spinnaker/core';
+import type { ICloudrunInstance } from '../../common/domain';
+
+interface InstanceFromStateParams {
+  instanceId: string;
+}
+
+interface InstanceManager {
+  account: string;
+  region: string;
+  category: string; // e.g., serverGroup, loadBalancer.
+  name: string; // Parent resource name, not instance name.
+  instances: ICloudrunInstance[];
+}
+
+class CloudrunInstanceDetailsController implements IController {
+  public state = { loading: true };
+  public instance: ICloudrunInstance;
+  public instanceIdNotFound: string;
+  public upToolTip = "A Cloud Run instance is 'Up' if a load balancer is directing traffic to its server group.";
+  public outOfServiceToolTip = `
+    A Cloud Run instance is 'Out Of Service' if no load balancers are directing traffic to its server group.`;
+
+  public static $inject = ['$q', 'app', 'instance'];
+
+  constructor(private $q: IQService, private app: Application, instance: InstanceFromStateParams) {
+    this.app
+      .ready()
+      .then(() => this.retrieveInstance(instance))
+      .then((instanceDetails) => {
+        this.instance = instanceDetails;
+        this.state.loading = false;
+      })
+      .catch(() => {
+        this.instanceIdNotFound = instance.instanceId;
+        this.state.loading = false;
+      });
+  }
+
+  private retrieveInstance(instance: InstanceFromStateParams): PromiseLike<ICloudrunInstance> {
+    const instanceLocatorPredicate = (dataSource: InstanceManager) => {
+      return dataSource.instances.some((possibleMatch) => possibleMatch.id === instance.instanceId);
+    };
+
+    const dataSources: InstanceManager[] = flattenDeep([
+      this.app.getDataSource('serverGroups').data,
+      this.app.getDataSource('loadBalancers').data,
+      this.app.getDataSource('loadBalancers').data.map((loadBalancer: ILoadBalancer) => loadBalancer.serverGroups),
+    ]);
+
+    const instanceManager = dataSources.find(instanceLocatorPredicate);
+
+    if (instanceManager) {
+      const recentHistoryExtraData: { [key: string]: string } = {
+        region: instanceManager.region,
+        account: instanceManager.account,
+      };
+      if (instanceManager.category === 'serverGroup') {
+        recentHistoryExtraData.serverGroup = instanceManager.name;
+      }
+      RecentHistoryService.addExtraDataToLatest('instances', recentHistoryExtraData);
+
+      return InstanceReader.getInstanceDetails(
+        instanceManager.account,
+        instanceManager.region,
+        instance.instanceId,
+      ).then((instanceDetails: ICloudrunInstance) => {
+        instanceDetails.account = instanceManager.account;
+        instanceDetails.region = instanceManager.region;
+        return instanceDetails;
+      });
+    } else {
+      return this.$q.reject();
+    }
+  }
+}
+
+export const CLOUDRUN_INSTANCE_DETAILS_CTRL = 'spinnaker.cloudrun.instanceDetails.controller';
+module(CLOUDRUN_INSTANCE_DETAILS_CTRL, []).controller('cloudrunInstanceDetailsCtrl', CloudrunInstanceDetailsController);

package/src/instance/details/details.html

@@ -0,0 +1,68 @@
+<div class="details-panel">
+  <div class="header">
+    <instance-details-header
+      health-state="ctrl.instance.healthState"
+      instance-id="ctrl.instance ? ctrl.instance.name : ctrl.instanceIdNotFound"
+      loading="ctrl.state.loading"
+      standalone="false"
+    ></instance-details-header>
+    <div ng-if="!ctrl.state.loading">
+      <div class="actions">
+        <div class="dropdown" uib-dropdown dropdown-append-to-body>
+          <button type="button" class="btn btn-sm btn-primary dropdown-toggle" uib-dropdown-toggle>
+            Instance Actions <span class="caret"></span>
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+  <div class="content" ng-if="!ctrl.state.loading && ctrl.instance">
+    <collapsible-section heading="Instance Information" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt>Launched</dt>
+        <dd ng-if="ctrl.instance.launchTime">{{ctrl.instance.launchTime | timestamp}}</dd>
+        <dt>In</dt>
+        <dd><account-tag account="ctrl.instance.account" pad="right"></account-tag>{{}}</dd>
+        <dt ng-if="ctrl.instance.serverGroup">Server Group</dt>
+        <dd ng-if="ctrl.instance.serverGroup">
+          <a
+            ui-sref="^.serverGroup({region: ctrl.instance.region,
+                                     accountId: ctrl.instance.account,
+                                     serverGroup: ctrl.instance.serverGroup,
+                                     provider: 'cloudrun'})"
+            >{{ctrl.instance.serverGroup}}</a
+          >
+        </dd>
+        <dt>Region</dt>
+        <dd>{{ctrl.instance.region}}</dd>
+        <cloudrun-conditional-dt-dd
+          component="ctrl.instance"
+          key="vmZoneName"
+          label="Zone"
+        ></cloudrun-conditional-dt-dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Status" expanded="true">
+      <dl>
+        <dt>Load Balancer</dt>
+        <dd>
+          <span
+            class="pull-left"
+            uib-tooltip="{{ctrl.instance.healthState === 'Up' ? ctrl.upToolTip : ctrl.outOfServiceToolTip}}"
+            tooltip-placement="right"
+          >
+            <span class="glyphicon glyphicon-{{ctrl.instance.healthState}}-triangle"></span>
+            {{ctrl.instance.loadBalancers[0]}}
+          </span>
+        </dd>
+      </dl>
+    </collapsible-section>
+  </div>
+  <div class="content" ng-if="!ctrl.state.loading && !ctrl.instance">
+    <div class="content-section">
+      <div class="content-body text-center">
+        <h3>Instance not found.</h3>
+      </div>
+    </div>
+  </div>
+</div>

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './infrastructure.types';

package/src/interfaces/infrastructure.types.ts

@@ -0,0 +1,23 @@
+import type { IInstance, ILoadBalancer, IMoniker, IServerGroup } from '@spinnaker/core';
+
+export interface ICloudrunResource {
+  apiVersion: string;
+  createdTime?: number;
+  displayName: string;
+  kind: string;
+  namespace: string;
+}
+
+export interface ICloudrunInstance extends IInstance, ICloudrunResource {
+  humanReadableName: string;
+  moniker: IMoniker;
+  publicDnsName?: string;
+}
+
+export interface ICloudrunLoadBalancer extends ILoadBalancer, ICloudrunResource {}
+
+export interface ICloudrunServerGroup extends IServerGroup, ICloudrunResource {
+  disabled: boolean;
+}
+
+//export interface ICloudrunServerGroupManager extends IServerGroupManager, ICloudrunResource {}

package/src/loadBalancer/configure/wizard/allocationConfigurationRow.component.ts

@@ -0,0 +1,70 @@
+import type { IComponentOptions, IController } from 'angular';
+import { module } from 'angular';
+import { uniq } from 'lodash';
+
+import type { ICloudrunAllocationDescription } from '../../loadBalancerTransformer';
+
+class CloudrunAllocationConfigurationRowCtrl implements IController {
+  public allocationDescription: ICloudrunAllocationDescription;
+  public serverGroupOptions: string[];
+
+  public getServerGroupOptions(): string[] {
+    if (this.allocationDescription.revisionName) {
+      return uniq(this.serverGroupOptions.concat(this.allocationDescription.revisionName));
+    } else {
+      return this.serverGroupOptions;
+    }
+  }
+}
+
+const cloudrunAllocationConfigurationRowComponent: IComponentOptions = {
+  bindings: {
+    allocationDescription: '<',
+    removeAllocation: '&',
+    serverGroupOptions: '<',
+    onAllocationChange: '&',
+  },
+  template: `
+    <div class="form-group">
+      <div class="row">
+        <div class="col-md-7">
+          <ui-select ng-model="$ctrl.allocationDescription.revisionName"
+                     on-select="$ctrl.onAllocationChange()"
+                     class="form-control input-sm">
+            <ui-select-match placeholder="Select...">
+              {{$select.selected}}
+            </ui-select-match>
+            <ui-select-choices repeat="serverGroup as serverGroup in $ctrl.getServerGroupOptions() | filter: $select.search">
+              <div ng-bind-html="serverGroup | highlight: $select.search"></div>
+            </ui-select-choices>
+          </ui-select>
+        </div>
+        <div class="col-md-3">
+          <div class="input-group input-group-sm">
+            <input type="number"
+                   ng-model="$ctrl.allocationDescription.percent"
+                   required
+                   class="form-control input-sm"
+                   min="0"
+                   ng-change="$ctrl.onAllocationChange()"
+                   max="100"/>
+            <span class="input-group-addon">%</span>
+          </div>
+        </div>
+        <div class="col-md-2">
+          <a class="btn btn-link sm-label" ng-click="$ctrl.removeAllocation()">
+            <span class="glyphicon glyphicon-trash"></span>
+          </a>
+        </div>
+      </div>
+    </div>
+  `,
+  controller: CloudrunAllocationConfigurationRowCtrl,
+};
+
+export const CLOUDRUN_ALLOCATION_CONFIGURATION_ROW = 'spinnaker.cloudrun.allocationConfigurationRow.component';
+
+module(CLOUDRUN_ALLOCATION_CONFIGURATION_ROW, []).component(
+  'cloudrunAllocationConfigurationRow',
+  cloudrunAllocationConfigurationRowComponent,
+);

package/src/loadBalancer/configure/wizard/basicSettings.component.html

@@ -0,0 +1,44 @@
+<ng-form name="basicSettingsForm">
+  <div class="row">
+    <div class="form-group">
+      <div class="col-md-3 sm-label-right">
+        Allocations
+        <help-field key="cloudrun.loadBalancer.allocations"></help-field>
+      </div>
+      <div class="col-md-9">
+        <div ng-if="!$ctrl.forPipelineConfig">
+          <cloudrun-allocation-configuration-row
+            ng-repeat="description in $ctrl.loadBalancer.splitDescription.allocationDescriptions"
+            allocation-description="description"
+            server-group-options="$ctrl.serverGroupOptions"
+            on-allocation-change="$ctrl.updateServerGroupOptions()"
+            remove-allocation="$ctrl.removeAllocation($index)"
+          >
+          </cloudrun-allocation-configuration-row>
+        </div>
+        <div ng-if="$ctrl.forPipelineConfig">
+          <cloudrun-stage-allocation-configuration-row
+            ng-repeat="description in $ctrl.loadBalancer.splitDescription.allocationDescriptions"
+            allocation-description="description"
+            application="$ctrl.application"
+            region="{{ $ctrl.loadBalancer.region }}"
+            account="{{ $ctrl.loadBalancer.account || $ctrl.loadBalancer.credentials }}"
+            name="{{ $ctrl.loadBalancer.name }}"
+            server-group-options="$ctrl.serverGroupOptions"
+            on-allocation-change="$ctrl.updateServerGroupOptions()"
+            remove-allocation="$ctrl.removeAllocation($index)"
+          >
+          </cloudrun-stage-allocation-configuration-row>
+        </div>
+        <button class="add-new col-md-11" ng-if="$ctrl.showAddButton()" ng-click="$ctrl.addAllocation()">
+          <span class="glyphicon glyphicon-plus-sign"></span> Add allocation
+        </button>
+      </div>
+    </div>
+    <div class="form-group" ng-if="$ctrl.allocationIsInvalid()">
+      <div class="col-md-12 text-center">
+        <p class="alert alert-warning">Allocations must sum to 100%.</p>
+      </div>
+    </div>
+  </div>
+</ng-form>

package/src/loadBalancer/configure/wizard/basicSettings.component.ts

@@ -0,0 +1,86 @@
+import type { IController } from 'angular';
+import { module } from 'angular';
+import { difference } from 'lodash';
+
+import type { CloudrunLoadBalancerUpsertDescription } from '../../loadBalancerTransformer';
+
+class CloudrunLoadBalancerSettingsController implements IController {
+  public loadBalancer: CloudrunLoadBalancerUpsertDescription;
+  public serverGroupOptions: string[];
+  public forPipelineConfig: boolean;
+
+  public $onInit(): void {
+    this.updateServerGroupOptions();
+  }
+
+  public addAllocation(): void {
+    const remainingServerGroups = this.serverGroupsWithoutAllocation();
+    if (remainingServerGroups.length) {
+      this.loadBalancer.splitDescription.allocationDescriptions.push({
+        revisionName: remainingServerGroups[0],
+        percent: 0,
+      });
+      this.updateServerGroupOptions();
+    } else if (this.forPipelineConfig) {
+      this.loadBalancer.splitDescription.allocationDescriptions.push({
+        percent: 0,
+        revisionName: '',
+      });
+    }
+  }
+
+  public removeAllocation(index: number): void {
+    this.loadBalancer.splitDescription.allocationDescriptions.splice(index, 1);
+    this.updateServerGroupOptions();
+  }
+
+  public allocationIsInvalid(): boolean {
+    return (
+      this.loadBalancer.splitDescription.allocationDescriptions.reduce(
+        (sum, allocationDescription) => sum + allocationDescription.percent,
+        0,
+      ) !== 100
+    );
+  }
+
+  public updateServerGroupOptions(): void {
+    this.serverGroupOptions = this.serverGroupsWithoutAllocation();
+  }
+
+  public showAddButton(): boolean {
+    if (this.forPipelineConfig) {
+      return true;
+    } else {
+      return this.serverGroupsWithoutAllocation().length > 0;
+    }
+  }
+
+  public initializeAsTextInput(serverGroupName: string): boolean {
+    if (this.forPipelineConfig) {
+      return !this.loadBalancer.serverGroups.map((serverGroup) => serverGroup.name).includes(serverGroupName);
+    } else {
+      return false;
+    }
+  }
+
+  private serverGroupsWithoutAllocation(): string[] {
+    const serverGroupsWithAllocation = this.loadBalancer.splitDescription.allocationDescriptions.map(
+      (description) => description.revisionName,
+    );
+    const allServerGroups = this.loadBalancer.serverGroups.map((serverGroup) => serverGroup.name);
+    return difference(allServerGroups, serverGroupsWithAllocation);
+  }
+}
+
+const cloudrunLoadBalancerSettingsComponent: ng.IComponentOptions = {
+  bindings: { loadBalancer: '=', forPipelineConfig: '<', application: '<' },
+  controller: CloudrunLoadBalancerSettingsController,
+  templateUrl: require('./basicSettings.component.html'),
+};
+
+export const CLOUDRUN_LOAD_BALANCER_BASIC_SETTINGS = 'spinnaker.cloudrun.loadBalancerSettings.component';
+
+module(CLOUDRUN_LOAD_BALANCER_BASIC_SETTINGS, []).component(
+  'cloudrunLoadBalancerBasicSettings',
+  cloudrunLoadBalancerSettingsComponent,
+);

package/src/loadBalancer/configure/wizard/stageAllocationConfigurationRow.component.html

@@ -0,0 +1,45 @@
+<div class="form-group">
+  <div class="row">
+    <div class="col-md-7">
+      <cloudrun-stage-allocation-label allocation-description="$ctrl.allocationDescription">
+      </cloudrun-stage-allocation-label>
+    </div>
+    <div class="col-md-3">
+      <div class="input-group input-group-sm">
+        <input
+          type="number"
+          ng-model="$ctrl.allocationDescription.percent"
+          required
+          class="form-control input-sm"
+          min="0"
+          ng-change="$ctrl.onAllocationChange()"
+          max="100"
+        />
+        <span class="input-group-addon">%</span>
+      </div>
+    </div>
+    <div class="col-md-2">
+      <a class="btn btn-link sm-label" ng-click="$ctrl.removeAllocation()">
+        <span class="glyphicon glyphicon-trash"></span>
+      </a>
+    </div>
+  </div>
+</div>
+<div class="form-group">
+  <div class="well col-md-11" style="padding-top: 5px; padding-bottom: 10px">
+    <div class="row">
+      <div class="form-group">
+        <div>
+          <div class="col-md-3 sm-label-right">Cluster</div>
+          <div class="col-md-7" style="margin-bottom: 10px">
+            <input ng-model="$ctrl.allocationDescription.cluster" type="text" class="form-control input-sm" readonly />
+          </div>
+          <div class="col-md-3 sm-label-right">Target</div>
+          <div class="col-md-7">
+            <target-select model="$ctrl.allocationDescription" options="$ctrl.targets"></target-select>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>

package/src/loadBalancer/configure/wizard/stageAllocationConfigurationRow.component.ts

@@ -0,0 +1,84 @@
+import type { IComponentOptions, IController } from 'angular';
+import { module } from 'angular';
+import { uniq } from 'lodash';
+
+import { StageConstants } from '@spinnaker/core';
+
+import type { ICloudrunAllocationDescription } from '../../loadBalancerTransformer';
+
+class CloudrunStageAllocationLabelCtrl implements IController {
+  public inputViewValue: string;
+  private allocationDescription: ICloudrunAllocationDescription;
+
+  private static mapTargetCoordinateToLabel(targetCoordinate: string): string {
+    const target = StageConstants.TARGET_LIST.find((t) => t.val === targetCoordinate);
+    if (target) {
+      return target.label;
+    } else {
+      return null;
+    }
+  }
+
+  public $doCheck(): void {
+    this.setInputViewValue();
+  }
+
+  private setInputViewValue(): void {
+    if (this.allocationDescription.cluster && this.allocationDescription.target) {
+      const targetLabel = CloudrunStageAllocationLabelCtrl.mapTargetCoordinateToLabel(
+        this.allocationDescription.target,
+      );
+      this.inputViewValue = `${targetLabel} (${this.allocationDescription.cluster})`;
+    } else {
+      this.inputViewValue = null;
+    }
+  }
+}
+
+const cloudrunStageAllocationLabel: IComponentOptions = {
+  bindings: { allocationDescription: '<' },
+  controller: CloudrunStageAllocationLabelCtrl,
+  template: `<input ng-model="$ctrl.inputViewValue" type="text" class="form-control input-sm" readonly/>`,
+};
+
+class CloudrunStageAllocationConfigurationRowCtrl implements IController {
+  public allocationDescription: ICloudrunAllocationDescription;
+  public serverGroupOptions: string[];
+  public targets = StageConstants.TARGET_LIST;
+  public clusterList: string[];
+  public onAllocationChange: Function;
+  private name: string;
+
+  public $onInit() {
+    this.allocationDescription.cluster = this.name;
+  }
+
+  public getServerGroupOptions(): string[] {
+    if (this.allocationDescription.revisionName) {
+      return uniq(this.serverGroupOptions.concat(this.allocationDescription.revisionName));
+    } else {
+      return this.serverGroupOptions;
+    }
+  }
+}
+
+const cloudrunStageAllocationConfigurationRow: IComponentOptions = {
+  bindings: {
+    application: '<',
+    region: '@',
+    account: '@',
+    name: '@',
+    allocationDescription: '<',
+    removeAllocation: '&',
+    serverGroupOptions: '<',
+    onAllocationChange: '&',
+  },
+  controller: CloudrunStageAllocationConfigurationRowCtrl,
+  templateUrl: require('./stageAllocationConfigurationRow.component.html'),
+};
+
+export const CLOUDRUN_STAGE_ALLOCATION_CONFIGURATION_ROW =
+  'spinnaker.cloudrun.stageAllocationConfigurationRow.component';
+module(CLOUDRUN_STAGE_ALLOCATION_CONFIGURATION_ROW, [])
+  .component('cloudrunStageAllocationConfigurationRow', cloudrunStageAllocationConfigurationRow)
+  .component('cloudrunStageAllocationLabel', cloudrunStageAllocationLabel);