@spinnaker/appengine 0.0.0-2025.1-0

package/src/serverGroup/transformer.ts

@@ -0,0 +1,92 @@
+import { module } from 'angular';
+
+import type { IArtifact, IArtifactAccountPair, IServerGroup } from '@spinnaker/core';
+
+import type { IAppengineServerGroupCommand } from './configure/serverGroupCommandBuilder.service';
+import type { GitCredentialType, IAppengineGitTrigger, IAppengineJenkinsTrigger } from '../domain/index';
+
+export class AppengineDeployDescription {
+  public cloudProvider = 'appengine';
+  public provider = 'appengine';
+  public credentials: string;
+  public account: string;
+  public application: string;
+  public stack?: string;
+  public freeFormDetails?: string;
+  public repositoryUrl: string;
+  public branch: string;
+  public configFilepaths: string[];
+  public configFiles: string[];
+  public configArtifacts: IArtifactAccountPair[];
+  public applicationDirectoryRoot: string;
+  public promote?: boolean;
+  public stopPreviousVersion?: boolean;
+  public type: string;
+  public region: string;
+  public strategy?: string;
+  public strategyApplication?: string;
+  public strategyPipeline?: string;
+  public fromTrigger?: boolean;
+  public trigger?: IAppengineGitTrigger | IAppengineJenkinsTrigger;
+  public gitCredentialType: GitCredentialType;
+  public interestingHealthProviderNames: string[];
+  public expectedArtifactId: string;
+  public expectedArtifact: IArtifact;
+  public fromArtifact: boolean;
+  public sourceType: string;
+  public storageAccountName?: string;
+  public containerImageUrl?: string;
+  public suppressVersionString?: boolean;
+
+  constructor(command: IAppengineServerGroupCommand) {
+    this.credentials = command.credentials;
+    this.account = command.credentials;
+    this.application = command.application;
+    this.stack = command.stack;
+    this.freeFormDetails = command.freeFormDetails;
+    this.repositoryUrl = command.repositoryUrl;
+    this.branch = command.branch;
+    this.configFilepaths = command.configFilepaths;
+    this.promote = command.promote;
+    this.stopPreviousVersion = command.stopPreviousVersion;
+    this.type = command.type;
+    this.region = command.region;
+    this.strategy = command.strategy;
+    this.strategyApplication = command.strategyApplication;
+    this.strategyPipeline = command.strategyPipeline;
+    this.fromTrigger = command.fromTrigger;
+    this.trigger = command.trigger;
+    this.gitCredentialType = command.gitCredentialType;
+    this.configFiles = command.configFiles;
+    this.configArtifacts = command.configArtifacts.filter((a) => !!a.id || !!a.artifact);
+    this.applicationDirectoryRoot = command.applicationDirectoryRoot;
+    this.interestingHealthProviderNames = command.interestingHealthProviderNames || [];
+    this.expectedArtifactId = command.expectedArtifactId;
+    this.expectedArtifact = command.expectedArtifact;
+    this.fromArtifact = command.fromArtifact;
+    this.sourceType = command.sourceType;
+    this.storageAccountName = command.storageAccountName;
+    this.containerImageUrl = command.containerImageUrl;
+    this.suppressVersionString = command.suppressVersionString;
+  }
+}
+
+export class AppengineServerGroupTransformer {
+  public static $inject = ['$q'];
+  constructor(private $q: ng.IQService) {}
+
+  public normalizeServerGroup(serverGroup: IServerGroup): PromiseLike<IServerGroup> {
+    return this.$q.resolve(serverGroup);
+  }
+
+  public convertServerGroupCommandToDeployConfiguration(command: IAppengineServerGroupCommand) {
+    return new AppengineDeployDescription(command);
+  }
+}
+
+export const APPENGINE_SERVER_GROUP_TRANSFORMER = 'spinnaker.appengine.serverGroup.transformer.service';
+
+module(APPENGINE_SERVER_GROUP_TRANSFORMER, []).service(
+  'appengineServerGroupTransformer',
+  AppengineServerGroupTransformer,
+);

package/src/serverGroup/transformet.spec.ts

@@ -0,0 +1,40 @@
+import { AppengineServerGroupTransformer } from './transformer';
+
+describe('command transforms', () => {
+  it('converts the command into an AppengineDeployDescription object', () => {
+    const transformer = new AppengineServerGroupTransformer(null);
+    const command: any = {
+      expectedArtifact: {
+        id: '1234',
+        type: 'docker/image',
+        name: 'gcr.io/hale-entry-305216/test',
+        version: 'test',
+        reference: 'gcr.io/hale-entry-305216/test:test',
+        artifactAccount: 'docker-registry',
+        customKind: true,
+      },
+      credentials: 'credentials',
+      region: 'us-central',
+      selectedProvider: 'appengine',
+      applicationDirectoryRoot: '',
+      viewState: {
+        mode: '',
+        submitButtonLabel: '',
+        disableStrategySelection: true,
+      },
+      expectedArtifactId: '',
+      interestingHealthProviderNames: [],
+      backingData: '',
+      fromArtifact: false,
+      sourceType: '',
+      configArtifacts: [],
+      application: 'dockerImageApp',
+    };
+
+    const transformed = transformer.convertServerGroupCommandToDeployConfiguration(command);
+    expect(transformed.cloudProvider).toBe('appengine');
+    expect(transformed.provider).toBe('appengine');
+    expect(transformed.application).toBe('dockerImageApp');
+    expect(transformed.expectedArtifact.name).toBe('gcr.io/hale-entry-305216/test');
+  });
+});

package/src/serverGroup/writer/serverGroup.write.service.ts

@@ -0,0 +1,57 @@
+import { module } from 'angular';
+
+import type { Application, IJob, ITask, ITaskCommand } from '@spinnaker/core';
+import { TaskExecutor } from '@spinnaker/core';
+import type { IAppengineServerGroup } from '../../domain/index';
+
+interface IAppengineServerGroupWriteJob extends IJob {
+  serverGroupName: string;
+  region: string;
+  credentials: string;
+  cloudProvider: string;
+}
+
+export class AppengineServerGroupWriter {
+  public startServerGroup(serverGroup: IAppengineServerGroup, application: Application): PromiseLike<ITask> {
+    const job = this.buildJob(serverGroup, application, 'startAppEngineServerGroup');
+
+    const command: ITaskCommand = {
+      job: [job],
+      application,
+      description: `Start Server Group: ${serverGroup.name}`,
+    };
+
+    return TaskExecutor.executeTask(command);
+  }
+
+  public stopServerGroup(serverGroup: IAppengineServerGroup, application: Application): PromiseLike<ITask> {
+    const job = this.buildJob(serverGroup, application, 'stopAppEngineServerGroup');
+
+    const command: ITaskCommand = {
+      job: [job],
+      application,
+      description: `Stop Server Group: ${serverGroup.name}`,
+    };
+
+    return TaskExecutor.executeTask(command);
+  }
+
+  private buildJob(
+    serverGroup: IAppengineServerGroup,
+    application: Application,
+    type: string,
+  ): IAppengineServerGroupWriteJob {
+    return {
+      type,
+      region: serverGroup.region,
+      serverGroupName: serverGroup.name,
+      credentials: serverGroup.account,
+      cloudProvider: 'appengine',
+      application: application.name,
+    };
+  }
+}
+
+export const APPENGINE_SERVER_GROUP_WRITER = 'spinnaker.appengine.serverGroup.write.service';
+
+module(APPENGINE_SERVER_GROUP_WRITER, []).service('appengineServerGroupWriter', AppengineServerGroupWriter);

package/src/validation/ApplicationNameValidator.ts

@@ -0,0 +1,40 @@
+import type { IApplicationNameValidator, IValidationResult } from '@spinnaker/core';
+import { ApplicationNameValidator } from '@spinnaker/core';
+
+// See https://cloud.google.com/appengine/docs/admin-api/reference/rest/v1/apps.services.versions#Version
+class AppengineApplicationNameValidator implements IApplicationNameValidator {
+  public validate(name = ''): IValidationResult {
+    const warnings: string[] = [];
+    const errors: string[] = [];
+    if (name.length) {
+      this.validateSpecialCharacters(name, errors);
+      this.validateLength(name, warnings, errors);
+    }
+    return { warnings, errors };
+  }
+
+  private validateSpecialCharacters(name: string, errors: string[]): void {
+    const pattern = /^[a-z0-9]*$/g;
+    if (!pattern.test(name)) {
+      errors.push('Only numbers and lowercase letters are allowed.');
+    }
+  }
+
+  private validateLength(name: string, warnings: string[], errors: string[]): void {
+    if (name.length > 58) {
+      errors.push('The maximum length for an App Engine application name is 63 characters.');
+      return;
+    }
+    if (name.length > 48) {
+      if (name.length >= 56) {
+        warnings.push('You will not be able to include a stack or detail field for clusters.');
+      } else {
+        const remaining = 56 - name.length;
+        warnings.push(`If you plan to include a stack or detail field for clusters, you will only have
+                       ${remaining} character${remaining > 1 ? 's' : ''} to do so.`);
+      }
+    }
+  }
+}
+
+ApplicationNameValidator.registerValidator('appengine', new AppengineApplicationNameValidator());