Add validate function to crd resource and do validate before creation/update (#580)

2018-04-08 00:56:13 +08:00
parent 12299df811
commit d01b309fc7
26 changed files with 718 additions and 118 deletions
@@ -0,0 +1,458 @@
+/*
+Copyright 2018 The Fission Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package fission
+
+import (
+	"fmt"
+	"net/http"
+	"regexp"
+	"strings"
+
+	"github.com/hashicorp/go-multierror"
+	nsUtil "github.com/nats-io/nats-streaming-server/util"
+	"github.com/robfig/cron"
+	"k8s.io/apimachinery/pkg/util/validation"
+)
+
+const (
+	ErrorUnsupportedType = iota
+	ErrorInvalidValue
+	ErrorInvalidObject
+)
+
+var (
+	validAzureQueueName = regexp.MustCompile("^[a-z0-9][a-z0-9\\-]*[a-z0-9]$")
+)
+
+type ValidationErrorType int
+
+// ValidationError is a custom error type for resource validation.
+// It indicate which field is invalid or illegal in the fission resource.
+// Also, it shows what kind of error type, bad value and detail error messages.
+type ValidationError struct {
+	// Type of validation error.
+	// It indicates what kind of error of field in error output.
+	Type ValidationErrorType
+
+	// Name of error field.
+	// Example: FunctionReference.Name
+	Field string
+
+	// Error field value.
+	BadValue interface{}
+
+	// Detail error message
+	Detail string
+}
+
+func (e ValidationError) Error() string {
+	// Example error message
+	// Failed to create HTTP trigger: Invalid fission HTTPTrigger object:
+	// * FunctionReference.Name: Invalid value: findped.ts: [...]
+
+	errMsg := fmt.Sprintf("%v: ", e.Field)
+
+	switch e.Type {
+	case ErrorUnsupportedType:
+		errMsg += fmt.Sprintf("Unsupported type: %v", e.BadValue)
+	case ErrorInvalidValue:
+		errMsg += fmt.Sprintf("Invalid value: %v", e.BadValue)
+	case ErrorInvalidObject:
+		errMsg += fmt.Sprintf("Invalid object: %v", e.BadValue)
+	default:
+		errMsg += fmt.Sprintf("Unknown error type: %v", e.BadValue)
+	}
+
+	if len(e.Detail) > 0 {
+		errMsg += fmt.Sprintf(": %v", e.Detail)
+	}
+
+	return errMsg
+}
+
+func AggregateValidationErrors(objName string, err error) error {
+	var result *multierror.Error
+
+	result = multierror.Append(result, err)
+
+	result.ErrorFormat = func(errs []error) string {
+		errMsg := fmt.Sprintf("Invalid fission %v object:\n", objName)
+		for _, err := range errs {
+			errMsg += fmt.Sprintf("* %v\n", err.Error())
+		}
+		return errMsg
+	}
+
+	return result.ErrorOrNil()
+}
+
+func MakeValidationErr(errType ValidationErrorType, field string, val interface{}, detail ...string) ValidationError {
+	return ValidationError{
+		Type:     errType,
+		Field:    field,
+		BadValue: val,
+		Detail:   fmt.Sprintf("%v", detail),
+	}
+}
+
+func ValidateKubeLabel(field string, labels map[string]string) error {
+	var result *multierror.Error
+
+	for k, v := range labels {
+		// Example: XXX -> YYY
+		// KubernetesWatchTriggerSpec.LabelSelector.Key: Invalid value: XXX
+		// KubernetesWatchTriggerSpec.LabelSelector.Value: Invalid value: YYY
+		result = multierror.Append(result,
+			MakeValidationErr(ErrorInvalidValue, fmt.Sprintf("%v.Key", field), k, validation.IsQualifiedName(k)...),
+			MakeValidationErr(ErrorInvalidValue, fmt.Sprintf("%v.Value", field), v, validation.IsValidLabelValue(v)...))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func ValidateKubePort(field string, port int) error {
+	var result *multierror.Error
+
+	e := validation.IsValidPortNum(port)
+	if len(e) > 0 {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, field, port, e...))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func ValidateKubeName(field string, val string) error {
+	var result *multierror.Error
+
+	e := validation.IsDNS1123Label(val)
+	if len(e) > 0 {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, field, val, e...))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func ValidateKubeReference(refName string, name string, namespace string) error {
+	var result *multierror.Error
+
+	result = multierror.Append(result,
+		ValidateKubeName(fmt.Sprintf("%v.Name", refName), name),
+		ValidateKubeName(fmt.Sprintf("%v.Namespace", refName), namespace))
+
+	return result.ErrorOrNil()
+}
+
+func IsTopicValid(mqType MessageQueueType, topic string) bool {
+	switch mqType {
+	case MessageQueueTypeNats:
+		return nsUtil.IsChannelNameValid(topic, false)
+	case MessageQueueTypeASQ:
+		return len(topic) >= 3 && len(topic) <= 63 && validAzureQueueName.MatchString(topic)
+	}
+	return false
+}
+
+func IsValidCronSpec(spec string) error {
+	_, err := cron.Parse(spec)
+	return err
+}
+
+/* Resource validation function */
+
+func (checksum Checksum) Validate() error {
+	var result *multierror.Error
+
+	switch checksum.Type {
+	case ChecksumTypeSHA256: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "Checksum.Type", checksum.Type, "not a valid checksum type"))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (archive Archive) Validate() error {
+	var result *multierror.Error
+
+	if len(archive.Type) > 0 {
+		switch archive.Type {
+		case ArchiveTypeLiteral, ArchiveTypeUrl: // no op
+		default:
+			result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "Archive.Type", archive.Type, "not a valid archive type"))
+		}
+	}
+
+	if archive.Checksum != (Checksum{}) {
+		result = multierror.Append(result, archive.Checksum.Validate())
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (ref EnvironmentReference) Validate() error {
+	var result *multierror.Error
+	result = multierror.Append(result, ValidateKubeReference("EnvironmentReference", ref.Name, ref.Namespace))
+	return result.ErrorOrNil()
+}
+
+func (ref SecretReference) Validate() error {
+	var result *multierror.Error
+	result = multierror.Append(result, ValidateKubeReference("SecretReference", ref.Name, ref.Namespace))
+	return result.ErrorOrNil()
+}
+
+func (ref ConfigMapReference) Validate() error {
+	var result *multierror.Error
+	result = multierror.Append(result, ValidateKubeReference("ConfigMapReference", ref.Name, ref.Namespace))
+	return result.ErrorOrNil()
+}
+
+func (spec PackageSpec) Validate() error {
+	var result *multierror.Error
+
+	result = multierror.Append(result, spec.Environment.Validate())
+
+	for _, r := range []Archive{spec.Source, spec.Deployment} {
+		if len(r.URL) > 0 || len(r.Literal) > 0 {
+			result = multierror.Append(result, r.Validate())
+		}
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (sts PackageStatus) Validate() error {
+	var result *multierror.Error
+
+	switch sts.BuildStatus {
+	case BuildStatusPending, BuildStatusRunning, BuildStatusSucceeded, BuildStatusFailed, BuildStatusNone: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "PackageStatus.BuildStatus", sts.BuildStatus, "not a valid build status"))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (ref PackageRef) Validate() error {
+	var result *multierror.Error
+	result = multierror.Append(result, ValidateKubeReference("PackageRef", ref.Name, ref.Namespace))
+	return result.ErrorOrNil()
+}
+
+func (ref FunctionPackageRef) Validate() error {
+	var result *multierror.Error
+	result = multierror.Append(result, ref.PackageRef.Validate())
+	return result.ErrorOrNil()
+}
+
+func (spec FunctionSpec) Validate() error {
+	var result *multierror.Error
+
+	if spec.Environment != (EnvironmentReference{}) {
+		result = multierror.Append(result, spec.Environment.Validate())
+	}
+
+	if spec.Package != (FunctionPackageRef{}) {
+		result = multierror.Append(result, spec.Package.Validate())
+	}
+
+	for _, s := range spec.Secrets {
+		result = multierror.Append(result, s.Validate())
+	}
+	for _, c := range spec.ConfigMaps {
+		result = multierror.Append(result, c.Validate())
+	}
+
+	if spec.InvokeStrategy != (InvokeStrategy{}) {
+		result = multierror.Append(result, spec.InvokeStrategy.Validate())
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (is InvokeStrategy) Validate() error {
+	var result *multierror.Error
+
+	switch is.StrategyType {
+	case StrategyTypeExecution: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "InvokeStrategy.StrategyType", is.StrategyType, "not a valid valid strategy"))
+	}
+
+	result = multierror.Append(result, is.ExecutionStrategy.Validate())
+
+	return result.ErrorOrNil()
+}
+
+func (es ExecutionStrategy) Validate() error {
+	var result *multierror.Error
+
+	switch es.ExecutorType {
+	case ExecutorTypeNewdeploy, ExecutorTypePoolmgr: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "ExecutionStrategy.ExecutorType", es.ExecutorType, "not a valid executor type"))
+	}
+
+	if es.MinScale < 0 {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "ExecutionStrategy.MinScale", es.MinScale, "minimum scale must be greater or equal to 0"))
+	}
+
+	if es.MaxScale < es.MinScale {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "ExecutionStrategy.MaxScale", es.MaxScale, "maximum scale must be greater or equal to minimum scale"))
+	}
+
+	if es.TargetCPUPercent <= 0 || es.TargetCPUPercent > 100 {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "ExecutionStrategy.TargetCPUPercent", es.TargetCPUPercent, "TargetCPUPercent must be a value between 1 - 100"))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (ref FunctionReference) Validate() error {
+	var result *multierror.Error
+
+	switch ref.Type {
+	case FunctionReferenceTypeFunctionName: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "FunctionReference.Type", ref.Type, "not a valid function reference type"))
+	}
+
+	result = multierror.Append(result, ValidateKubeName("FunctionReference.Name", ref.Name))
+
+	return result.ErrorOrNil()
+}
+
+func (runtime Runtime) Validate() error {
+	var result *multierror.Error
+
+	if runtime.LoadEndpointPort > 0 {
+		result = multierror.Append(result, ValidateKubePort("Runtime.LoadEndpointPort", int(runtime.LoadEndpointPort)))
+	}
+
+	if runtime.FunctionEndpointPort > 0 {
+		result = multierror.Append(result, ValidateKubePort("Runtime.FunctionEndpointPort", int(runtime.FunctionEndpointPort)))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (builder Builder) Validate() error {
+	// do nothing for now
+	return nil
+}
+
+func (spec EnvironmentSpec) Validate() error {
+	var result *multierror.Error
+
+	if spec.Version < 1 && spec.Version > 3 {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "EnvironmentSpec.Version", spec.Version, "not a valid environment version"))
+	}
+
+	result = multierror.Append(result, spec.Runtime.Validate())
+
+	if spec.Builder != (Builder{}) {
+		result = multierror.Append(result, spec.Builder.Validate())
+	}
+
+	if len(spec.AllowedFunctionsPerContainer) > 0 {
+		switch spec.AllowedFunctionsPerContainer {
+		case AllowedFunctionsPerContainerSingle, AllowedFunctionsPerContainerInfinite: // no op
+		default:
+			result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "EnvironmentSpec.AllowedFunctionsPerContainer", spec.AllowedFunctionsPerContainer, "not a valid value"))
+		}
+	}
+
+	if spec.Poolsize < 0 {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "EnvironmentSpec.Poolsize", spec.Poolsize, "Poolsize must be greater or equal to 0"))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (spec HTTPTriggerSpec) Validate() error {
+	var result *multierror.Error
+
+	switch spec.Method {
+	case http.MethodGet, http.MethodHead, http.MethodPost, http.MethodPut, http.MethodPatch,
+		http.MethodDelete, http.MethodConnect, http.MethodOptions, http.MethodTrace: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "HTTPTriggerSpec.Method", spec.Method, "not a valid HTTP method"))
+	}
+
+	result = multierror.Append(result, spec.FunctionReference.Validate())
+
+	if len(spec.Host) > 0 {
+		e := validation.IsDNS1123Subdomain(spec.Host)
+		if len(e) > 0 {
+			result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "HTTPTriggerSpec.Host", spec.Host, e...))
+		}
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (spec KubernetesWatchTriggerSpec) Validate() error {
+	var result *multierror.Error
+
+	switch strings.ToUpper(spec.Type) {
+	case "POD", "SERVICE", "REPLICATIONCONTROLLER", "JOB":
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "KubernetesWatchTriggerSpec.Type", spec.Type, "not a valid supported type"))
+	}
+
+	result = multierror.Append(result,
+		ValidateKubeName("KubernetesWatchTriggerSpec.Namespace", spec.Namespace),
+		ValidateKubeLabel("KubernetesWatchTriggerSpec.LabelSelector", spec.LabelSelector),
+		spec.FunctionReference.Validate())
+
+	return result.ErrorOrNil()
+}
+
+func (spec MessageQueueTriggerSpec) Validate() error {
+	var result *multierror.Error
+
+	result = multierror.Append(result, spec.FunctionReference.Validate())
+
+	switch spec.MessageQueueType {
+	case MessageQueueTypeNats, MessageQueueTypeASQ: // no op
+	default:
+		result = multierror.Append(result, MakeValidationErr(ErrorUnsupportedType, "MessageQueueTriggerSpec.MessageQueueType", spec.MessageQueueType, "not a supported message queue type"))
+	}
+
+	if !IsTopicValid(spec.MessageQueueType, spec.Topic) {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "MessageQueueTriggerSpec.Topic", spec.Topic, "not a valid topic"))
+	}
+
+	if len(spec.ResponseTopic) > 0 && !IsTopicValid(spec.MessageQueueType, spec.ResponseTopic) {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "MessageQueueTriggerSpec.ResponseTopic", spec.ResponseTopic, "not a valid topic"))
+	}
+
+	return result.ErrorOrNil()
+}
+
+func (spec TimeTriggerSpec) Validate() error {
+	var result *multierror.Error
+
+	err := IsValidCronSpec(spec.Cron)
+	if err != nil {
+		result = multierror.Append(result, MakeValidationErr(ErrorInvalidValue, "TimeTriggerSpec.Cron", spec.Cron, "not a valid cron spec"))
+	}
+
+	result = multierror.Append(result, spec.FunctionReference.Validate())
+
+	return result.ErrorOrNil()
+}