TypeScript core.PipelineConfigValidator类代码示例

          toTest.clusters.forEach((cluster: any) => {
            const clusterName: string = NameUtils.getClusterName(
              cluster.application,
              cluster.stack,
              cluster.freeFormDetails,
            );
            if (clusterName === stage.cluster && cluster.account === stage.credentials && cluster.region === region) {
              regionFound = true;
            }
          });
        } else if (
          toTest.type === 'cloneServerGroup' &&
          NameUtils.getClusterName(toTest.application, toTest.stack, toTest.freeFormDetails) === stage.cluster &&
          toTest.region === region
        ) {
          regionFound = true;
        }
      });
      if (!regionFound) {
        allRegionsFound = false;
      }
    });
    if (!allRegionsFound) {
      return validator.message;
    }
    return null;
  }
}

PipelineConfigValidator.registerValidator('cfTargetImpedance', new CfTargetImpedanceValidator());

};

const sourceStruct = (manifest: ICloudFoundryServiceManifestSource) => {
  return manifest.direct ? 'direct' : 'artifact';
};

PipelineConfigValidator.registerValidator(
  'requiredDeployServiceField',
  new class implements IStageOrTriggerValidator {
    public validate(
      _pipeline: IPipeline,
      stage: IStage | ITrigger,
      validationConfig: IServiceFieldValidatorConfig,
    ): string {
      const serviceInput: ICloudFoundryServiceManifestSource = get(stage, 'manifest');
      if (sourceType(serviceInput, get(stage, 'userProvided')) !== validationConfig.manifestSource) {
        return null;
      }
      const manifestSource: any = get(serviceInput, sourceStruct(serviceInput));
      const content: any = get(manifestSource, validationConfig.fieldName);
      const fieldLabel = validationConfig.fieldLabel || upperFirst(validationConfig.fieldName);
      return content ? null : `<strong>${fieldLabel}</strong> is a required field for the Deploy Service stage.`;
    }
  }(),
);

PipelineConfigValidator.registerValidator(
  'validDeployServiceParameterJson',
  new class implements IStageOrTriggerValidator {
    private validationMessage(validationConfig: IServiceFieldValidatorConfig): string {
      return (

};

const sourceStruct = (manifest: ICloudFoundryServiceManifestSource) => {
  return manifest && manifest.direct ? 'direct' : 'artifact';
};

PipelineConfigValidator.registerValidator(
  'requiredDeployServiceField',
  new class implements IStageOrTriggerValidator {
    public validate(
      _pipeline: IPipeline,
      stage: IStage | ITrigger,
      validationConfig: IServiceFieldValidatorConfig,
    ): string {
      const serviceInput: ICloudFoundryServiceManifestSource = get(stage, 'manifest');
      if (sourceType(serviceInput, get(stage, 'userProvided')) !== validationConfig.manifestSource) {
        return null;
      }
      const manifestSource: any = get(serviceInput, sourceStruct(serviceInput));
      const content: any = get(manifestSource, validationConfig.fieldName);
      const fieldLabel = validationConfig.fieldLabel || upperFirst(validationConfig.fieldName);
      return content ? null : `<strong>${fieldLabel}</strong> is a required field for the Deploy Service stage.`;
    }
  }(),
);

PipelineConfigValidator.registerValidator(
  'validDeployServiceParameterJsonOrYaml',
  new class implements IStageOrTriggerValidator {
    private isJson(value: string): boolean {
      try {

    if (hasMin) {
      if (hasMax) {
        message = `<strong>${fieldLabel}</strong> should be from ${min} to ${max} in ${pipeline.name}.`;
      } else {
        message = `<strong>${fieldLabel}</strong> should be at least ${min} in ${pipeline.name}.`;
      }
    } else if (hasMax) {
      message = `<strong>${fieldLabel}</strong> should be no more than ${max} in ${pipeline.name}.`;
    }
    return validationConfig.message || message;
  }

  protected printableFieldLabel(config: IInstanceFieldSizeValidationConfig): string {
    const fieldLabel: string = config.fieldLabel || config.fieldName;
    return upperFirst(fieldLabel);
  }

  protected fieldIsValid(stage: IStage | ITrigger, config: IInstanceFieldSizeValidationConfig): boolean {
    const fieldExists = has(stage, config.fieldName);
    const field: any = get(stage, config.fieldName);
    const hasMax: boolean = has(config, 'max');
    const hasMin: boolean = has(config, 'min');
    const max: number = get(config, 'max');
    const min: number = get(config, 'min');

    return fieldExists && ((!hasMax || (hasMax && field <= max)) && (!hasMin || (hasMin && field >= min)));
  }
}

PipelineConfigValidator.registerValidator('cfInstanceSizeField', new CfInstanceSizeFieldValidator());

  PipelineConfigValidator,
} from '@spinnaker/core';

export interface IStageWithManifestSelector extends IStage {
  manifestName: string;
  location: string;
}

export class ManifestSelectorValidator implements IStageOrTriggerValidator {
  public validate(
    _pipeline: IPipeline,
    stage: IStageWithManifestSelector,
    _validator: IValidatorConfig,
    _config: IStageOrTriggerTypeConfig,
  ): string {
    const [kind, name] = (stage.manifestName || '').split(' ');
    if (!name && !kind) {
      return `<strong>Name</strong> and <strong>Kind</strong> are required fields.`;
    }
    if (!name) {
      return `<strong>Name</strong> is a required field.`;
    }
    if (!kind) {
      return `<strong>Kind</strong> is a required field.`;
    }
    return null;
  }
}

PipelineConfigValidator.registerValidator('manifestSelector', new ManifestSelectorValidator());

import { get } from 'lodash';

import { IPipeline, IStage, IStageOrTriggerValidator, ITrigger, PipelineConfigValidator } from '@spinnaker/core';

export class CfRequiredRoutesFieldValidator implements IStageOrTriggerValidator {
  public validate(_pipeline: IPipeline, stage: IStage | ITrigger, validationConfig: any): string {
    const routes: string[] = get(stage, validationConfig.fieldName);
    const routeErrors = routes
      .map((route: string) => {
        const regex = /^([-\w]+)\.([-.\w]+)(:\d+)?([-/\w]+)?$/gm;
        route = route || '';
        if (regex.exec(route) === null) {
          return `"${route}" did not match the expected format "host.some.domain[:9999][/some/path]"`;
        }
        return null;
      })
      .filter(err => err != null);
    return (routeErrors && routeErrors.length && routeErrors[0]) || null;
  }
}

PipelineConfigValidator.registerValidator('cfRequiredRoutesField', new CfRequiredRoutesFieldValidator());