@spinnaker/cloudrun 0.0.0-main-2

package/src/loadBalancer/configure/wizard/wizard.controller.ts

@@ -0,0 +1,157 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController } from 'angular';
+import { module } from 'angular';
+import type { IModalServiceInstance } from 'angular-ui-bootstrap';
+import { cloneDeep } from 'lodash';
+
+import type { Application } from '@spinnaker/core';
+import { LoadBalancerWriter, TaskMonitor } from '@spinnaker/core';
+
+import type { CloudrunLoadBalancerTransformer, ICloudrunTrafficSplitDescription } from '../../loadBalancerTransformer';
+import { CloudrunLoadBalancerUpsertDescription } from '../../loadBalancerTransformer';
+
+import './wizard.less';
+
+class CloudrunLoadBalancerWizardController implements IController {
+  public state = { loading: true };
+  public loadBalancer: CloudrunLoadBalancerUpsertDescription;
+  public heading: string;
+  public submitButtonLabel: string;
+  public taskMonitor: TaskMonitor;
+
+  public static $inject = [
+    '$scope',
+    '$state',
+    '$uibModalInstance',
+    'application',
+    'loadBalancer',
+    'isNew',
+    'forPipelineConfig',
+    'cloudrunLoadBalancerTransformer',
+    'wizardSubFormValidation',
+  ];
+  constructor(
+    public $scope: ng.IScope,
+    private $state: StateService,
+    private $uibModalInstance: IModalServiceInstance,
+    private application: Application,
+    loadBalancer: CloudrunLoadBalancerUpsertDescription,
+    public isNew: boolean,
+    private forPipelineConfig: boolean,
+    private cloudrunLoadBalancerTransformer: CloudrunLoadBalancerTransformer,
+    private wizardSubFormValidation: any,
+  ) {
+    this.submitButtonLabel = this.forPipelineConfig ? 'Done' : 'Update';
+
+    if (this.isNew) {
+      this.heading = 'Create New Load Balancer';
+    } else {
+      this.heading = `Edit ${[
+        loadBalancer.name,
+        loadBalancer.region,
+        loadBalancer.account || loadBalancer.credentials,
+      ].join(':')}`;
+      this.cloudrunLoadBalancerTransformer
+        .convertLoadBalancerForEditing(loadBalancer, application)
+        .then((convertedLoadBalancer) => {
+          this.loadBalancer = this.cloudrunLoadBalancerTransformer.convertLoadBalancerToUpsertDescription(
+            convertedLoadBalancer,
+          );
+          if (loadBalancer.split && !this.loadBalancer.splitDescription) {
+            this.loadBalancer.splitDescription = CloudrunLoadBalancerUpsertDescription.convertTrafficSplitToTrafficSplitDescription(
+              loadBalancer.split,
+            );
+          } else {
+            this.loadBalancer.splitDescription = loadBalancer.splitDescription;
+          }
+          this.loadBalancer.mapAllocationsToPercentages();
+          this.setTaskMonitor();
+          this.initializeFormValidation();
+          this.state.loading = false;
+        });
+    }
+  }
+
+  public submit(): any {
+    const description = cloneDeep(this.loadBalancer);
+    description.mapAllocationsToPercentages();
+    delete description.serverGroups;
+
+    if (this.forPipelineConfig) {
+      return this.$uibModalInstance.close(description);
+    } else {
+      return this.taskMonitor.submit(() => {
+        return LoadBalancerWriter.upsertLoadBalancer(description, this.application, 'Update');
+      });
+    }
+  }
+
+  public cancel(): void {
+    this.$uibModalInstance.dismiss();
+  }
+
+  public showSubmitButton(): boolean {
+    return this.wizardSubFormValidation.subFormsAreValid();
+  }
+
+  private setTaskMonitor(): void {
+    this.taskMonitor = new TaskMonitor({
+      application: this.application,
+      title: 'Updating your load balancer',
+      modalInstance: this.$uibModalInstance,
+      onTaskComplete: () => this.onTaskComplete(),
+    });
+  }
+
+  private initializeFormValidation(): void {
+    this.wizardSubFormValidation.config({ form: 'form', scope: this.$scope }).register({
+      page: 'basic-settings',
+      subForm: 'basicSettingsForm',
+      validators: [
+        {
+          watchString: 'ctrl.loadBalancer.splitDescription',
+          validator: (splitDescription: ICloudrunTrafficSplitDescription): boolean => {
+            return (
+              splitDescription.allocationDescriptions.reduce((sum, description) => sum + description.percent, 0) === 100
+            );
+          },
+          watchDeep: true,
+        },
+      ],
+    });
+  }
+
+  private onTaskComplete(): void {
+    this.application.getDataSource('loadBalancers').refresh();
+    this.application.getDataSource('loadBalancers').onNextRefresh(this.$scope, () => this.onApplicationRefresh());
+  }
+
+  private onApplicationRefresh(): void {
+    // If the user has already closed the modal, do not navigate to the new details view
+    if ((this.$scope as any).$$destroyed) {
+      // $$destroyed is not in the ng.IScope interface
+      return;
+    }
+
+    this.$uibModalInstance.dismiss();
+    const newStateParams = {
+      name: this.loadBalancer.name,
+      accountId: this.loadBalancer.credentials,
+      region: this.loadBalancer.region,
+      provider: 'cloudrun',
+    };
+
+    if (!this.$state.includes('**.loadBalancerDetails')) {
+      this.$state.go('.loadBalancerDetails', newStateParams);
+    } else {
+      this.$state.go('^.loadBalancerDetails', newStateParams);
+    }
+  }
+}
+
+export const CLOUDRUN_LOAD_BALANCER_WIZARD_CTRL = 'spinnaker.cloudrun.loadBalancer.wizard.controller';
+
+module(CLOUDRUN_LOAD_BALANCER_WIZARD_CTRL, []).controller(
+  'cloudrunLoadBalancerWizardCtrl',
+  CloudrunLoadBalancerWizardController,
+);

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

@@ -0,0 +1,39 @@
+<form name="form">
+  <div ng-if="ctrl.state.loading && !ctrl.isNew" style="height: 200px" class="horizontal center middle">
+    <loading-spinner size="'small'"></loading-spinner>
+  </div>
+  <v2-modal-wizard
+    heading="{{::ctrl.heading}}"
+    task-monitor="ctrl.taskMonitor"
+    dismiss="$dismiss()"
+    ng-if="!ctrl.state.loading || ctrl.isNew"
+  >
+    <div ng-if="!ctrl.isNew">
+      <v2-wizard-page key="basic-settings" label="Basic Settings" mark-complete-on-view="false">
+        <cloudrun-load-balancer-basic-settings
+          load-balancer="ctrl.loadBalancer"
+          application="ctrl.application"
+          for-pipeline-config="ctrl.forPipelineConfig"
+        ></cloudrun-load-balancer-basic-settings>
+      </v2-wizard-page>
+    </div>
+  </v2-modal-wizard>
+  <cloudrun-load-balancer-message
+    ng-if="ctrl.isNew"
+    column-offset="1"
+    columns="10"
+    show-create-message="true"
+  ></cloudrun-load-balancer-message>
+  <div class="modal-footer">
+    <button class="btn btn-default" ng-click="ctrl.cancel()">Cancel</button>
+    <submit-button
+      ng-if="!ctrl.isNew && ctrl.showSubmitButton()"
+      label="ctrl.submitButtonLabel"
+      is-disabled="cloudrunLoadBalancerForm.$invalid || ctrl.taskMonitor.submitting || ctrl.state.loading"
+      submitting="ctrl.taskMonitor.submitting"
+      on-click="ctrl.submit()"
+      is-new="ctrl.isNew"
+    >
+    </submit-button>
+  </div>
+</form>

package/src/loadBalancer/configure/wizard/wizard.less

@@ -0,0 +1,9 @@
+cloudrun-load-balancer-basic-settings {
+  a.btn.btn-link {
+    padding: 0;
+  }
+
+  .form-group {
+    margin-top: 0.4rem;
+  }
+}

package/src/loadBalancer/details/details.controller.ts

@@ -0,0 +1,140 @@
+import type { StateService } from '@uirouter/angularjs';
+import type { IController, IScope } from 'angular';
+import { module } from 'angular';
+import type { IModalService } from 'angular-ui-bootstrap';
+import { cloneDeep } from 'lodash';
+
+import type { Application, ILoadBalancer, ILoadBalancerDeleteCommand } from '@spinnaker/core';
+import { ConfirmationModalService, LoadBalancerWriter } from '@spinnaker/core';
+import type { ICloudrunLoadBalancer } from '../../common/domain/index';
+
+interface ILoadBalancerFromStateParams {
+  accountId: string;
+  region: string;
+  name: string;
+}
+
+class CloudrunLoadBalancerDetailsController implements IController {
+  public state = { loading: true };
+  private loadBalancerFromParams: ILoadBalancerFromStateParams;
+  public loadBalancer: ICloudrunLoadBalancer;
+
+  public static $inject = ['$uibModal', '$state', '$scope', 'loadBalancer', 'app'];
+  constructor(
+    private $uibModal: IModalService,
+    private $state: StateService,
+    private $scope: IScope,
+    loadBalancer: ILoadBalancerFromStateParams,
+    private app: Application,
+  ) {
+    this.loadBalancerFromParams = loadBalancer;
+    this.app
+      .getDataSource('loadBalancers')
+      .ready()
+      .then(() => this.extractLoadBalancer());
+  }
+
+  // edit loadbalancer to change traffic
+
+  public editLoadBalancer(): void {
+    this.$uibModal.open({
+      templateUrl: require('../configure/wizard/wizard.html'),
+      controller: 'cloudrunLoadBalancerWizardCtrl as ctrl',
+      size: 'lg',
+      resolve: {
+        application: () => this.app,
+        loadBalancer: () => cloneDeep(this.loadBalancer),
+        isNew: () => false,
+        forPipelineConfig: () => false,
+      },
+    });
+  }
+
+  private extractLoadBalancer(): void {
+    this.loadBalancer = this.app.getDataSource('loadBalancers').data.find((test: ILoadBalancer) => {
+      return test.name === this.loadBalancerFromParams.name && test.account === this.loadBalancerFromParams.accountId;
+    }) as ICloudrunLoadBalancer;
+
+    if (this.loadBalancer) {
+      this.state.loading = false;
+      this.app.getDataSource('loadBalancers').onRefresh(this.$scope, () => this.extractLoadBalancer());
+    } else {
+      this.autoClose();
+    }
+  }
+
+  public deleteLoadBalancer(): void {
+    const taskMonitor = {
+      application: this.app,
+      title: 'Deleting ' + this.loadBalancer.name,
+    };
+
+    const submitMethod = () => {
+      const loadBalancer: ILoadBalancerDeleteCommand = {
+        cloudProvider: this.loadBalancer.cloudProvider,
+        loadBalancerName: this.loadBalancer.name,
+        credentials: this.loadBalancer.account,
+      };
+      return LoadBalancerWriter.deleteLoadBalancer(loadBalancer, this.app);
+    };
+
+    ConfirmationModalService.confirm({
+      header: 'Really delete ' + this.loadBalancer.name + '?',
+      buttonText: 'Delete ' + this.loadBalancer.name,
+      body: this.getConfirmationModalBodyHtml(),
+      account: this.loadBalancer.account,
+      taskMonitorConfig: taskMonitor,
+      submitMethod,
+    });
+  }
+
+  public canDeleteLoadBalancer(): boolean {
+    return this.loadBalancer.name !== 'default';
+  }
+
+  private getConfirmationModalBodyHtml(): string {
+    const serverGroupNames = this.loadBalancer.serverGroups.map((serverGroup) => serverGroup.name);
+    const hasAny = serverGroupNames ? serverGroupNames.length > 0 : false;
+    const hasMoreThanOne = serverGroupNames ? serverGroupNames.length > 1 : false;
+
+    // HTML accepted by the confirmationModalService is static (i.e., not managed by angular).
+    if (hasAny) {
+      if (hasMoreThanOne) {
+        const listOfServerGroupNames = serverGroupNames.map((name) => `<li>${name}</li>`).join('');
+        return `<div class="alert alert-warning">
+            <p>
+              Deleting <b>${this.loadBalancer.name}</b> will destroy the following server groups:
+              <ul>
+                ${listOfServerGroupNames}
+              </ul>
+            </p>
+          </div>
+        `;
+      } else {
+        return `<div class="alert alert-warning">
+            <p>
+              Deleting <b>${this.loadBalancer.name}</b> will destroy <b>${serverGroupNames[0]}</b>.
+            </p>
+          </div>
+        `;
+      }
+    } else {
+      return null;
+    }
+  }
+
+  private autoClose(): void {
+    if (this.$scope.$$destroyed) {
+      return;
+    } else {
+      this.$state.params.allowModalToStayOpen = true;
+      this.$state.go('^', null, { location: 'replace' });
+    }
+  }
+}
+
+export const CLOUDRUN_LOAD_BALANCER_DETAILS_CTRL = 'spinnaker.cloudrun.loadBalancerDetails.controller';
+module(CLOUDRUN_LOAD_BALANCER_DETAILS_CTRL, []).controller(
+  'cloudrunLoadBalancerDetailsCtrl',
+  CloudrunLoadBalancerDetailsController,
+);

package/src/loadBalancer/details/details.html

@@ -0,0 +1,89 @@
+<div class="details-panel">
+  <div ng-if="ctrl.state.loading" class="header">
+    <div class="close-button">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <div class="horizontal center middle">
+      <loading-spinner size="'small'"></loading-spinner>
+    </div>
+  </div>
+
+  <div ng-if="!ctrl.state.loading" class="header">
+    <div class="close-button">
+      <a class="btn btn-link" ui-sref="^">
+        <span class="glyphicon glyphicon-remove"></span>
+      </a>
+    </div>
+    <div class="header-text horizontal middle">
+      <i class="fa icon-sitemap"></i>
+      <h3 class="horizontal middle space-between flex-1" select-on-dbl-click>{{ctrl.loadBalancer.name}}</h3>
+    </div>
+    <div>
+      <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>
+            Load Balancer Actions <span class="caret"></span>
+          </button>
+          <ul class="dropdown-menu" uib-dropdown-menu role="menu">
+            <li><a href ng-click="ctrl.editLoadBalancer()">Edit Load Balancer</a></li>
+            <li ng-if="ctrl.canDeleteLoadBalancer()">
+              <a href ng-click="ctrl.deleteLoadBalancer()">Delete Load Balancer</a>
+            </li>
+            <li
+              ng-if="!ctrl.canDeleteLoadBalancer()"
+              uib-tooltip="You cannot delete a default service."
+              class="disabled"
+            >
+              <a href>Delete Load Balancer</a>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div ng-if="!ctrl.state.loading" class="content">
+    <collapsible-section heading="Load Balancer Details" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <dt>In</dt>
+        <dd><account-tag account="ctrl.loadBalancer.account" pad="right"></account-tag></dd>
+        <dt>Region</dt>
+        <dd>{{ctrl.loadBalancer.region}}</dd>
+        <dt ng-if="ctrl.loadBalancer.serverGroups.length">Server Groups</dt>
+        <dd ng-if="ctrl.loadBalancer.serverGroups.length">
+          <ul>
+            <li ng-repeat="serverGroup in ctrl.loadBalancer.serverGroups | orderBy: ['isDisabled', '-name']">
+              <a
+                ui-sref="^.serverGroup({region: serverGroup.region,
+                                         accountId: serverGroup.account,
+                                         serverGroup: serverGroup.name,
+                                         provider: 'cloudrun'})"
+              >
+                {{serverGroup.name}}
+              </a>
+            </li>
+          </ul>
+        </dd>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="Status" expanded="true">
+      <health-counts class="pull-left" container="ctrl.loadBalancer.instanceCounts"></health-counts>
+    </collapsible-section>
+    <collapsible-section heading="Traffic Split" expanded="true">
+      <dl class="dl-horizontal dl-narrow">
+        <ul>
+          <li ng-repeat="trafficTarget in ctrl.loadBalancer.split.trafficTargets">
+            {{trafficTarget.revisionName}}:<span class="pull-right">{{trafficTarget.percent}}</span>
+          </li>
+        </ul>
+      </dl>
+    </collapsible-section>
+    <collapsible-section heading="DNS" expanded="true">
+      <dl class="dl-narrow">
+        <cloudrun-component-url-details component="ctrl.loadBalancer"></cloudrun-component-url-details>
+      </dl>
+    </collapsible-section>
+  </div>
+</div>

package/src/loadBalancer/index.ts

@@ -0,0 +1,3 @@
+export * from './loadBalancerTransformer';
+export * from './details/details.controller';
+export * from './configure/wizard/wizard.controller';

package/src/loadBalancer/loadBalancerTransformer.ts

@@ -0,0 +1,168 @@
+import { module } from 'angular';
+import { camelCase, chain, cloneDeep, filter, get, has, reduce } from 'lodash';
+
+import type {
+  Application,
+  IInstance,
+  IInstanceCounts,
+  ILoadBalancer,
+  ILoadBalancerUpsertCommand,
+  IServerGroup,
+} from '@spinnaker/core';
+//import type { ICloudrunLoadBalancer, ICloudrunTrafficSplit, ShardBy } from '../common/domain/index';
+import type { ICloudrunLoadBalancer, ICloudrunTrafficSplit } from '../common/domain/index';
+
+export interface ICloudrunAllocationDescription {
+  revisionName?: string;
+  target?: string;
+  cluster?: string;
+  percent: number;
+}
+
+export interface ICloudrunTrafficSplitDescription {
+  allocationDescriptions: ICloudrunAllocationDescription[];
+}
+
+export class CloudrunLoadBalancerUpsertDescription implements ILoadBalancerUpsertCommand, ICloudrunLoadBalancer {
+  public credentials: string;
+  public account: string;
+  public loadBalancerName: string;
+  public name: string;
+  public splitDescription: ICloudrunTrafficSplitDescription;
+  public split?: ICloudrunTrafficSplit;
+  public migrateTraffic: boolean;
+  public region: string;
+  public cloudProvider: string;
+  public serverGroups?: any[];
+
+  public static convertTrafficSplitToTrafficSplitDescription(
+    split: ICloudrunTrafficSplit,
+  ): ICloudrunTrafficSplitDescription {
+    const allocationDescriptions = reduce(
+      split.trafficTargets,
+      (acc: any, trafficTarget: any) => {
+        const { revisionName, percent } = trafficTarget;
+        return acc.concat({ percent, revisionName });
+      },
+      [],
+    );
+    return { allocationDescriptions };
+  }
+
+  constructor(loadBalancer: ICloudrunLoadBalancer) {
+    this.credentials = loadBalancer.account || loadBalancer.credentials;
+    this.account = this.credentials;
+    this.cloudProvider = loadBalancer.cloudProvider;
+    this.loadBalancerName = loadBalancer.name;
+    this.name = loadBalancer.name;
+    this.region = loadBalancer.region;
+    this.migrateTraffic = loadBalancer.migrateTraffic || false;
+    this.serverGroups = loadBalancer.serverGroups;
+  }
+
+  public mapAllocationsToDecimals() {
+    this.splitDescription.allocationDescriptions.forEach((description) => {
+      description.percent = description.percent / 100;
+    });
+  }
+
+  public mapAllocationsToPercentages() {
+    this.splitDescription.allocationDescriptions.forEach((description) => {
+      // An allocation percent has at most one decimal place.
+      description.percent = Math.round(description.percent);
+    });
+  }
+}
+
+export class CloudrunLoadBalancerTransformer {
+  public static $inject = ['$q'];
+  constructor(private $q: ng.IQService) {}
+  public normalizeLoadBalancer(loadBalancer: ILoadBalancer): PromiseLike<ILoadBalancer> {
+    loadBalancer.provider = loadBalancer.type;
+    loadBalancer.instanceCounts = this.buildInstanceCounts(loadBalancer.serverGroups);
+    loadBalancer.instances = [];
+    loadBalancer.serverGroups.forEach((serverGroup) => {
+      serverGroup.account = loadBalancer.account;
+      serverGroup.region = loadBalancer.region;
+
+      if (serverGroup.detachedInstances) {
+        serverGroup.detachedInstances = (serverGroup.detachedInstances as any).map((id: string) => ({ id }));
+      }
+      serverGroup.instances = serverGroup.instances
+        .concat(serverGroup.detachedInstances || [])
+        .map((instance: any) => this.transformInstance(instance, loadBalancer));
+    });
+
+    const activeServerGroups = filter(loadBalancer.serverGroups, { isDisabled: false });
+    loadBalancer.instances = chain(activeServerGroups).map('instances').flatten().value() as IInstance[];
+    return this.$q.resolve(loadBalancer);
+  }
+
+  public convertLoadBalancerForEditing(
+    loadBalancer: ICloudrunLoadBalancer,
+    application: Application,
+  ): PromiseLike<ICloudrunLoadBalancer> {
+    return application
+      .getDataSource('loadBalancers')
+      .ready()
+      .then(() => {
+        const upToDateLoadBalancer = application
+          .getDataSource('loadBalancers')
+          .data.find((candidate: ILoadBalancer) => {
+            return (
+              candidate.name === loadBalancer.name &&
+              (candidate.account === loadBalancer.account || candidate.account === loadBalancer.credentials)
+            );
+          });
+
+        if (upToDateLoadBalancer) {
+          loadBalancer.serverGroups = cloneDeep(upToDateLoadBalancer.serverGroups);
+        }
+        return loadBalancer;
+      });
+  }
+
+  public convertLoadBalancerToUpsertDescription(
+    loadBalancer: ICloudrunLoadBalancer,
+  ): CloudrunLoadBalancerUpsertDescription {
+    return new CloudrunLoadBalancerUpsertDescription(loadBalancer);
+  }
+
+  private buildInstanceCounts(serverGroups: IServerGroup[]): IInstanceCounts {
+    const instanceCounts: IInstanceCounts = chain(serverGroups)
+      .map('instances')
+      .flatten()
+      .reduce(
+        (acc: IInstanceCounts, instance: any) => {
+          if (has(instance, 'health.state')) {
+            acc[camelCase(instance.health.state)]++;
+          }
+          return acc;
+        },
+        { up: 0, down: 0, outOfService: 0, succeeded: 0, failed: 0, starting: 0, unknown: 0 },
+      )
+      .value();
+
+    instanceCounts.outOfService += chain(serverGroups).map('detachedInstances').flatten().value().length;
+    return instanceCounts;
+  }
+
+  private transformInstance(instance: any, loadBalancer: ILoadBalancer) {
+    instance.provider = loadBalancer.type;
+    instance.account = loadBalancer.account;
+    instance.region = loadBalancer.region;
+    instance.loadBalancers = [loadBalancer.name];
+    const health = instance.health || {};
+    instance.healthState = get(instance, 'health.state') || 'OutOfService';
+    instance.health = [health];
+
+    return instance as IInstance;
+  }
+}
+
+export const CLOUDRUN_LOAD_BALANCER_TRANSFORMER = 'spinnaker.cloudrun.loadBalancer.transformer.service';
+
+module(CLOUDRUN_LOAD_BALANCER_TRANSFORMER, []).service(
+  'cloudrunLoadBalancerTransformer',
+  CloudrunLoadBalancerTransformer,
+);

package/src/logo/cloudrun.icon.svg

@@ -0,0 +1,27 @@
+<svg width="24px" height="24px" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+    <defs>
+        <style>
+            .cls-1 {
+                fill: #aecbfa;
+            }
+
+            .cls-1,
+            .cls-2 {
+                fill-rule: evenodd;
+            }
+
+            .cls-2 {
+                fill: #4285f4;
+            }
+        </style>
+    </defs>
+    <title>Icon_24px_CloudRun_Color</title>
+    <g data-name="Product Icons">
+        <g>
+            <polygon class="cls-1" points="8.9 2.63 12.02 12 21.38 12 8.9 2.63" />
+            <polygon class="cls-2" points="21.38 12 12.02 12 8.9 21.38 21.38 12" />
+            <polygon class="cls-2" points="3.44 21.38 6.57 19.81 8.9 12 5.78 12 3.44 21.38" />
+            <polygon class="cls-1" points="3.44 2.63 5.78 12 8.9 12 6.57 4.19 3.44 2.63" />
+        </g>
+    </g>
+</svg>

package/src/logo/cloudrun.logo.less

@@ -0,0 +1,6 @@
+.cloud-provider-logo {
+  .icon-cloudrun {
+    mask-image: url(cloudrun.icon.svg);
+    background-color: #4285f4;
+  }
+}

package/src/manifest/ManifestSource.ts

@@ -0,0 +1,4 @@
+export enum ManifestSource {
+  TEXT = 'text',
+  ARTIFACT = 'artifact',
+}

package/src/manifest/index.ts

@@ -0,0 +1,2 @@
+export * from './manifest.service';
+export * from './manifestCommandBuilder.service';