// ValidateImageStreamMapping tests required fields for an ImageStreamMapping. func ValidateImageStreamMapping(mapping *api.ImageStreamMapping) fielderrors.ValidationErrorList { result := fielderrors.ValidationErrorList{} result = append(result, validation.ValidateObjectMeta(&mapping.ObjectMeta, true, oapi.MinimalNameRequirements).Prefix("metadata")...) hasRepository := len(mapping.DockerImageRepository) != 0 hasName := len(mapping.Name) != 0 switch { case hasRepository: if _, err := api.ParseDockerImageReference(mapping.DockerImageRepository); err != nil { result = append(result, fielderrors.NewFieldInvalid("dockerImageRepository", mapping.DockerImageRepository, err.Error())) } case hasName: default: result = append(result, fielderrors.NewFieldRequired("name")) result = append(result, fielderrors.NewFieldRequired("dockerImageRepository")) } if ok, msg := validation.ValidateNamespaceName(mapping.Namespace, false); !ok { result = append(result, fielderrors.NewFieldInvalid("namespace", mapping.Namespace, msg)) } if len(mapping.Tag) == 0 { result = append(result, fielderrors.NewFieldRequired("tag")) } if errs := ValidateImage(&mapping.Image).Prefix("image"); len(errs) != 0 { result = append(result, errs...) } return result }
func validateStrategy(strategy *buildapi.BuildStrategy) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} switch { case len(strategy.Type) == 0: allErrs = append(allErrs, fielderrors.NewFieldRequired("type")) case strategy.Type == buildapi.SourceBuildStrategyType: if strategy.SourceStrategy == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("stiStrategy")) } else { allErrs = append(allErrs, validateSourceStrategy(strategy.SourceStrategy).Prefix("stiStrategy")...) } case strategy.Type == buildapi.DockerBuildStrategyType: if strategy.DockerStrategy == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("dockerStrategy")) } else { allErrs = append(allErrs, validateDockerStrategy(strategy.DockerStrategy).Prefix("dockerStrategy")...) } case strategy.Type == buildapi.CustomBuildStrategyType: if strategy.CustomStrategy == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("customStrategy")) } else { allErrs = append(allErrs, validateCustomStrategy(strategy.CustomStrategy).Prefix("customStrategy")...) } default: allErrs = append(allErrs, fielderrors.NewFieldInvalid("type", strategy.Type, "type is not in the enumerated list")) } return allErrs }
func validateToImageReference(reference *kapi.ObjectReference) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} kind, name, namespace := reference.Kind, reference.Name, reference.Namespace switch kind { case "ImageStreamTag": if len(name) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("name")) } else if _, _, ok := imageapi.SplitImageStreamTag(name); !ok { allErrs = append(allErrs, fielderrors.NewFieldInvalid("name", name, "ImageStreamTag object references must be in the form <name>:<tag>")) } if len(namespace) != 0 && !util.IsDNS1123Subdomain(namespace) { allErrs = append(allErrs, fielderrors.NewFieldInvalid("namespace", namespace, "namespace must be a valid subdomain")) } case "DockerImage": if len(namespace) != 0 { allErrs = append(allErrs, fielderrors.NewFieldInvalid("namespace", namespace, "namespace is not valid when used with a 'DockerImage'")) } if _, err := imageapi.ParseDockerImageReference(name); err != nil { allErrs = append(allErrs, fielderrors.NewFieldInvalid("name", name, fmt.Sprintf("name is not a valid Docker pull specification: %v", err))) } case "": allErrs = append(allErrs, fielderrors.NewFieldRequired("kind")) default: allErrs = append(allErrs, fielderrors.NewFieldInvalid("kind", kind, "the target of build output must be an 'ImageStreamTag' or 'DockerImage'")) } return allErrs }
func validateTrigger(trigger *buildapi.BuildTriggerPolicy) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(trigger.Type) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("type")) return allErrs } // Validate each trigger type switch trigger.Type { case buildapi.GitHubWebHookBuildTriggerType: if trigger.GitHubWebHook == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("github")) } else { allErrs = append(allErrs, validateWebHook(trigger.GitHubWebHook).Prefix("github")...) } case buildapi.GenericWebHookBuildTriggerType: if trigger.GenericWebHook == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("generic")) } else { allErrs = append(allErrs, validateWebHook(trigger.GenericWebHook).Prefix("generic")...) } case buildapi.ImageChangeBuildTriggerType: if trigger.ImageChange == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("imageChange")) } default: allErrs = append(allErrs, fielderrors.NewFieldInvalid("type", trigger.Type, "invalid trigger type")) } return allErrs }
func validateStrategy(strategy *buildapi.BuildStrategy) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} switch { case len(strategy.Type) == 0: allErrs = append(allErrs, fielderrors.NewFieldRequired("type")) case strategy.Type == buildapi.SourceBuildStrategyType: if strategy.SourceStrategy == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("stiStrategy")) } else { allErrs = append(allErrs, validateSourceStrategy(strategy.SourceStrategy).Prefix("stiStrategy")...) } case strategy.Type == buildapi.DockerBuildStrategyType: // DockerStrategy is currently optional, initialize it to a default state if it's not set. if strategy.DockerStrategy == nil { strategy.DockerStrategy = &buildapi.DockerBuildStrategy{} } allErrs = append(allErrs, validateSecretRef(strategy.DockerStrategy.PullSecret).Prefix("pullSecret")...) case strategy.Type == buildapi.CustomBuildStrategyType: if strategy.CustomStrategy == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("customStrategy")) } else { allErrs = append(allErrs, validateCustomStrategy(strategy.CustomStrategy).Prefix("customStrategy")...) } default: allErrs = append(allErrs, fielderrors.NewFieldInvalid("type", strategy.Type, "type is not in the enumerated list")) } return allErrs }
func ValidateIdentity(identity *api.Identity) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} allErrs = append(allErrs, kvalidation.ValidateObjectMeta(&identity.ObjectMeta, false, ValidateIdentityName).Prefix("metadata")...) if len(identity.ProviderName) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("providerName")) } else if ok, msg := ValidateIdentityProviderName(identity.ProviderName); !ok { allErrs = append(allErrs, fielderrors.NewFieldInvalid("providerName", identity.ProviderName, msg)) } if len(identity.ProviderUserName) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("providerUserName")) } else if ok, msg := ValidateIdentityProviderName(identity.ProviderUserName); !ok { allErrs = append(allErrs, fielderrors.NewFieldInvalid("providerUserName", identity.ProviderUserName, msg)) } if len(identity.ProviderName) > 0 && len(identity.ProviderUserName) > 0 { expectedIdentityName := identity.ProviderName + ":" + identity.ProviderUserName if identity.Name != expectedIdentityName { allErrs = append(allErrs, fielderrors.NewFieldInvalid("user.name", identity.User.Name, fmt.Sprintf("must be %s", expectedIdentityName))) } } if ok, msg := ValidateUserName(identity.User.Name, false); !ok { allErrs = append(allErrs, fielderrors.NewFieldInvalid("user.name", identity.User.Name, msg)) } if len(identity.User.Name) == 0 && len(identity.User.UID) != 0 { allErrs = append(allErrs, fielderrors.NewFieldInvalid("user.uid", identity.User.UID, "may not be set if user.name is empty")) } if len(identity.User.Name) != 0 && len(identity.User.UID) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("user.uid")) } return allErrs }
func validateImageChangeParams(params *deployapi.DeploymentTriggerImageChangeParams) fielderrors.ValidationErrorList { errs := fielderrors.ValidationErrorList{} if len(params.From.Name) != 0 { if len(params.From.Kind) == 0 { params.From.Kind = "ImageStream" } kinds := util.NewStringSet("ImageRepository", "ImageStream", "ImageStreamTag") if !kinds.Has(params.From.Kind) { msg := fmt.Sprintf("kind must be one of: %s", strings.Join(kinds.List(), ", ")) errs = append(errs, fielderrors.NewFieldInvalid("from.kind", params.From.Kind, msg)) } if !util.IsDNS1123Subdomain(params.From.Name) { errs = append(errs, fielderrors.NewFieldInvalid("from.name", params.From.Name, "name must be a valid subdomain")) } if len(params.From.Namespace) != 0 && !util.IsDNS1123Subdomain(params.From.Namespace) { errs = append(errs, fielderrors.NewFieldInvalid("from.namespace", params.From.Namespace, "namespace must be a valid subdomain")) } if len(params.RepositoryName) != 0 { errs = append(errs, fielderrors.NewFieldInvalid("repositoryName", params.RepositoryName, "only one of 'from', 'repository' name may be specified")) } } else { if len(params.RepositoryName) == 0 { errs = append(errs, fielderrors.NewFieldRequired("from")) } } if len(params.ContainerNames) == 0 { errs = append(errs, fielderrors.NewFieldRequired("containerNames")) } return errs }
func validateDeploymentStrategy(strategy *deployapi.DeploymentStrategy) fielderrors.ValidationErrorList { errs := fielderrors.ValidationErrorList{} if len(strategy.Type) == 0 { errs = append(errs, fielderrors.NewFieldRequired("type")) } switch strategy.Type { case deployapi.DeploymentStrategyTypeRecreate: if strategy.RecreateParams != nil { errs = append(errs, validateRecreateParams(strategy.RecreateParams).Prefix("recreateParams")...) } case deployapi.DeploymentStrategyTypeRolling: if strategy.RollingParams == nil { errs = append(errs, fielderrors.NewFieldRequired("rollingParams")) } else { errs = append(errs, validateRollingParams(strategy.RollingParams).Prefix("rollingParams")...) } case deployapi.DeploymentStrategyTypeCustom: if strategy.CustomParams == nil { errs = append(errs, fielderrors.NewFieldRequired("customParams")) } else { errs = append(errs, validateCustomParams(strategy.CustomParams).Prefix("customParams")...) } } // TODO: validate resource requirements (prereq: https://github.com/GoogleCloudPlatform/kubernetes/pull/7059) return errs }
func ValidateResourceAccessReview(review *authorizationapi.ResourceAccessReview) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(review.Verb) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("verb")) } if len(review.Resource) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("resource")) } return allErrs }
func validateSource(input *buildapi.BuildSource) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if input.Type != buildapi.BuildSourceGit { allErrs = append(allErrs, fielderrors.NewFieldRequired("type")) } if input.Git == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("git")) } else { allErrs = append(allErrs, validateGitSource(input.Git).Prefix("git")...) } allErrs = append(allErrs, validateSecretRef(input.SourceSecret).Prefix("sourceSecret")...) return allErrs }
func ValidateOAuthConfig(config *api.OAuthConfig) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(config.MasterURL) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("masterURL")) } if _, urlErrs := ValidateURL(config.MasterPublicURL, "masterPublicURL"); len(urlErrs) > 0 { allErrs = append(allErrs, urlErrs...) } if len(config.AssetPublicURL) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("assetPublicURL")) } if config.SessionConfig != nil { allErrs = append(allErrs, ValidateSessionConfig(config.SessionConfig).Prefix("sessionConfig")...) } allErrs = append(allErrs, ValidateGrantConfig(config.GrantConfig).Prefix("grantConfig")...) providerNames := util.NewStringSet() redirectingIdentityProviders := []string{} for i, identityProvider := range config.IdentityProviders { if identityProvider.UseAsLogin { redirectingIdentityProviders = append(redirectingIdentityProviders, identityProvider.Name) if api.IsPasswordAuthenticator(identityProvider) { if config.SessionConfig == nil { allErrs = append(allErrs, fielderrors.NewFieldInvalid("sessionConfig", config, "sessionConfig is required if a password identity provider is used for browser based login")) } } } allErrs = append(allErrs, ValidateIdentityProvider(identityProvider).Prefix(fmt.Sprintf("identityProvider[%d]", i))...) if len(identityProvider.Name) > 0 { if providerNames.Has(identityProvider.Name) { allErrs = append(allErrs, fielderrors.NewFieldInvalid(fmt.Sprintf("identityProvider[%d].name", i), identityProvider.Name, "must have a unique name")) } providerNames.Insert(identityProvider.Name) } } if len(redirectingIdentityProviders) > 1 { allErrs = append(allErrs, fielderrors.NewFieldInvalid("identityProviders", config.IdentityProviders, fmt.Sprintf("only one identity provider can support login for a browser, found: %v", redirectingIdentityProviders))) } return allErrs }
func ValidateUserIdentityMapping(mapping *api.UserIdentityMapping) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} allErrs = append(allErrs, kvalidation.ValidateObjectMeta(&mapping.ObjectMeta, false, ValidateIdentityName).Prefix("metadata")...) if len(mapping.Identity.Name) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("identity.name")) } if mapping.Identity.Name != mapping.Name { allErrs = append(allErrs, fielderrors.NewFieldInvalid("identity.name", mapping.Identity.Name, "must match metadata.name")) } if len(mapping.User.Name) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("user.name")) } return allErrs }
func validateLifecycleHook(hook *deployapi.LifecycleHook) fielderrors.ValidationErrorList { errs := fielderrors.ValidationErrorList{} if len(hook.FailurePolicy) == 0 { errs = append(errs, fielderrors.NewFieldRequired("failurePolicy")) } if hook.ExecNewPod == nil { errs = append(errs, fielderrors.NewFieldRequired("execNewPod")) } else { errs = append(errs, validateExecNewPod(hook.ExecNewPod).Prefix("execNewPod")...) } return errs }
func ValidateOAuthIdentityProvider(clientID, clientSecret string, challenge bool) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(clientID) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("provider.clientID")) } if len(clientSecret) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("provider.clientSecret")) } if challenge { allErrs = append(allErrs, fielderrors.NewFieldInvalid("challenge", challenge, "oauth providers cannot be used for challenges")) } return allErrs }
func ValidateSessionConfig(config *api.SessionConfig) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} // Validate session secrets file, if specified if len(config.SessionSecretsFile) > 0 { fileErrs := ValidateFile(config.SessionSecretsFile, "sessionSecretsFile") if len(fileErrs) != 0 { // Missing file allErrs = append(allErrs, fileErrs...) } else { // Validate file contents secrets, err := latest.ReadSessionSecrets(config.SessionSecretsFile) if err != nil { allErrs = append(allErrs, fielderrors.NewFieldInvalid("sessionSecretsFile", config.SessionSecretsFile, fmt.Sprintf("error reading file: %v", err))) } else { for _, err := range ValidateSessionSecrets(secrets) { allErrs = append(allErrs, fielderrors.NewFieldInvalid("sessionSecretsFile", config.SessionSecretsFile, err.Error())) } } } } if len(config.SessionName) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("sessionName")) } return allErrs }
// ValidateRoute tests if required fields in the route are set. func ValidateRoute(route *routeapi.Route) fielderrors.ValidationErrorList { result := fielderrors.ValidationErrorList{} //ensure meta is set properly result = append(result, kval.ValidateObjectMeta(&route.ObjectMeta, true, oapi.GetNameValidationFunc(kval.ValidatePodName)).Prefix("metadata")...) //host is not required but if it is set ensure it meets DNS requirements if len(route.Host) > 0 { if !util.IsDNS1123Subdomain(route.Host) { result = append(result, fielderrors.NewFieldInvalid("host", route.Host, "host must conform to DNS 952 subdomain conventions")) } } if len(route.Path) > 0 && !strings.HasPrefix(route.Path, "/") { result = append(result, fielderrors.NewFieldInvalid("path", route.Path, "path must begin with /")) } if len(route.ServiceName) == 0 { result = append(result, fielderrors.NewFieldRequired("serviceName")) } if errs := validateTLS(route); len(errs) != 0 { result = append(result, errs.Prefix("tls")...) } return result }
func ValidatePolicyBinding(policyBinding *authorizationapi.PolicyBinding, isNamespaced bool) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} allErrs = append(allErrs, validation.ValidateObjectMeta(&policyBinding.ObjectMeta, isNamespaced, PolicyBindingNameValidator(policyBinding.PolicyRef.Namespace)).Prefix("metadata")...) if !isNamespaced { if len(policyBinding.PolicyRef.Namespace) > 0 { allErrs = append(allErrs, fielderrors.NewFieldInvalid("policyRef.namespace", policyBinding.PolicyRef.Namespace, "may not reference another namespace")) } } for roleBindingKey, roleBinding := range policyBinding.RoleBindings { if roleBinding == nil { allErrs = append(allErrs, fielderrors.NewFieldRequired("roleBindings."+roleBindingKey)) } if roleBinding.RoleRef.Namespace != policyBinding.PolicyRef.Namespace { allErrs = append(allErrs, fielderrors.NewFieldInvalid("roleBindings."+roleBindingKey+".roleRef.namespace", policyBinding.PolicyRef.Namespace, "must be "+policyBinding.PolicyRef.Namespace)) } if roleBindingKey != roleBinding.Name { allErrs = append(allErrs, fielderrors.NewFieldInvalid("roleBindings."+roleBindingKey+".metadata.name", roleBinding.Name, "must be "+roleBindingKey)) } allErrs = append(allErrs, ValidateRoleBinding(roleBinding, isNamespaced).Prefix("roleBindings."+roleBindingKey)...) } return allErrs }
func validateOutput(output *buildapi.BuildOutput) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} // TODO: make part of a generic ValidateObjectReference method upstream. if output.To != nil { kind, name, namespace := output.To.Kind, output.To.Name, output.To.Namespace if len(kind) == 0 { kind = "ImageStream" output.To.Kind = kind } if kind != "ImageStream" { allErrs = append(allErrs, fielderrors.NewFieldInvalid("to.kind", kind, "the target of build output must be 'ImageStream'")) } if len(name) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("to.name")) } else if !util.IsDNS1123Subdomain(name) { allErrs = append(allErrs, fielderrors.NewFieldInvalid("to.name", name, "name must be a valid subdomain")) } if len(namespace) != 0 && !util.IsDNS1123Subdomain(namespace) { allErrs = append(allErrs, fielderrors.NewFieldInvalid("to.namespace", namespace, "namespace must be a valid subdomain")) } } allErrs = append(allErrs, validateSecretRef(output.PushSecret).Prefix("pushSecret")...) if len(output.DockerImageReference) != 0 { if _, err := imageapi.ParseDockerImageReference(output.DockerImageReference); err != nil { allErrs = append(allErrs, fielderrors.NewFieldInvalid("dockerImageReference", output.DockerImageReference, err.Error())) } } return allErrs }
func ValidateNodeConfig(config *api.NodeConfig) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(config.NodeName) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("nodeName")) } allErrs = append(allErrs, ValidateServingInfo(config.ServingInfo).Prefix("servingInfo")...) allErrs = append(allErrs, ValidateKubeConfig(config.MasterKubeConfig, "masterKubeConfig")...) if len(config.DNSIP) > 0 { allErrs = append(allErrs, ValidateSpecifiedIP(config.DNSIP, "dnsIP")...) } allErrs = append(allErrs, ValidateImageConfig(config.ImageConfig).Prefix("imageConfig")...) if config.PodManifestConfig != nil { allErrs = append(allErrs, ValidatePodManifestConfig(config.PodManifestConfig).Prefix("podManifestConfig")...) } allErrs = append(allErrs, ValidateDockerConfig(config.DockerConfig).Prefix("dockerConfig")...) allErrs = append(allErrs, ValidateKubeletExtendedArguments(config.KubeletArguments).Prefix("kubeletArguments")...) return allErrs }
// GenerateParameterValues generates Value for each Parameter of the given // Template that has Generate field specified where Value is not already // supplied. // // Examples: // // from | value // ----------------------------- // "test[0-9]{1}x" | "test7x" // "[0-1]{8}" | "01001100" // "0x[A-F0-9]{4}" | "0xB3AF" // "[a-zA-Z0-9]{8}" | "hW4yQU5i" func (p *Processor) GenerateParameterValues(t *api.Template) error { for i := range t.Parameters { param := &t.Parameters[i] if len(param.Value) > 0 { continue } if param.Generate != "" { generator, ok := p.Generators[param.Generate] if !ok { return fmt.Errorf("template.parameters[%v]: Unable to find the '%v' generator", i, param.Generate) } if generator == nil { return fmt.Errorf("template.parameters[%v]: Invalid '%v' generator", i, param.Generate) } value, err := generator.GenerateValue(param.From) if err != nil { return err } param.Value, ok = value.(string) if !ok { return fmt.Errorf("template.parameters[%v]: Unable to convert the generated value '%#v' to string", i, value) } } if len(param.Value) == 0 && param.Required { err := fielderrors.NewFieldRequired(fmt.Sprintf("parameters[%d].value", i)) err.Detail = fmt.Sprintf("parameter %s is required and must be specified") return err } } return nil }
func validateWebHook(webHook *buildapi.WebHookTrigger) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(webHook.Secret) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("secret")) } return allErrs }
func validateTrigger(trigger *deployapi.DeploymentTriggerPolicy) fielderrors.ValidationErrorList { errs := fielderrors.ValidationErrorList{} if len(trigger.Type) == 0 { errs = append(errs, fielderrors.NewFieldRequired("type")) } if trigger.Type == deployapi.DeploymentTriggerOnImageChange { if trigger.ImageChangeParams == nil { errs = append(errs, fielderrors.NewFieldRequired("imageChangeParams")) } else { errs = append(errs, validateImageChangeParams(trigger.ImageChangeParams).Prefix("imageChangeParams")...) } } return errs }
func validateCustomStrategy(strategy *buildapi.CustomBuildStrategy) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if strategy.From == nil || len(strategy.From.Name) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("from")) } allErrs = append(allErrs, validateSecretRef(strategy.PullSecret).Prefix("pullSecret")...) return allErrs }
func ValidateClientNameField(value string, field string) fielderrors.ValidationErrorList { if len(value) == 0 { return fielderrors.ValidationErrorList{fielderrors.NewFieldRequired(field)} } else if ok, msg := validation.NameIsDNSSubdomain(value, false); !ok { return fielderrors.ValidationErrorList{fielderrors.NewFieldInvalid(field, value, msg)} } return fielderrors.ValidationErrorList{} }
func ValidateUserNameField(value string, field string) fielderrors.ValidationErrorList { if len(value) == 0 { return fielderrors.ValidationErrorList{fielderrors.NewFieldRequired(field)} } else if ok, msg := uservalidation.ValidateUserName(value, false); !ok { return fielderrors.ValidationErrorList{fielderrors.NewFieldInvalid(field, value, msg)} } return fielderrors.ValidationErrorList{} }
func validateExecNewPod(hook *deployapi.ExecNewPodHook) fielderrors.ValidationErrorList { errs := fielderrors.ValidationErrorList{} if len(hook.Command) == 0 { errs = append(errs, fielderrors.NewFieldRequired("command")) } if len(hook.ContainerName) == 0 { errs = append(errs, fielderrors.NewFieldRequired("containerName")) } if len(hook.Env) > 0 { errs = append(errs, validateEnv(hook.Env).Prefix("env")...) } return errs }
func validateRevision(revision *buildapi.SourceRevision) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(revision.Type) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("type")) } // TODO: validate other stuff return allErrs }
func validateGitSource(git *buildapi.GitBuildSource) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(git.URI) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("uri")) } else if !isValidURL(git.URI) { allErrs = append(allErrs, fielderrors.NewFieldInvalid("uri", git.URI, "uri is not a valid url")) } return allErrs }
func ValidateImageConfig(config api.ImageConfig) fielderrors.ValidationErrorList { allErrs := fielderrors.ValidationErrorList{} if len(config.Format) == 0 { allErrs = append(allErrs, fielderrors.NewFieldRequired("format")) } return allErrs }
func validateCustomParams(params *deployapi.CustomDeploymentStrategyParams) fielderrors.ValidationErrorList { errs := fielderrors.ValidationErrorList{} if len(params.Image) == 0 { errs = append(errs, fielderrors.NewFieldRequired("image")) } return errs }