Merge pull request #17247 from thockin/airplane_validation_pt3

Auto commit by PR queue bot

examples/examples_test.go

@@ -33,12 +33,13 @@ import (
 	expvalidation "k8s.io/kubernetes/pkg/apis/extensions/validation"
 	"k8s.io/kubernetes/pkg/capabilities"
 	"k8s.io/kubernetes/pkg/runtime"
+	utilvalidation "k8s.io/kubernetes/pkg/util/validation"
 	"k8s.io/kubernetes/pkg/util/yaml"
 	schedulerapi "k8s.io/kubernetes/plugin/pkg/scheduler/api"
 	schedulerapilatest "k8s.io/kubernetes/plugin/pkg/scheduler/api/latest"
 )
 
-func validateObject(obj runtime.Object) (errors []error) {
+func validateObject(obj runtime.Object) (errors utilvalidation.ErrorList) {
 	switch t := obj.(type) {
 	case *api.ReplicationController:
 		if t.Namespace == "" {
@@ -122,7 +123,7 @@ func validateObject(obj runtime.Object) (errors []error) {
 		}
 		errors = expvalidation.ValidateDaemonSet(t)
 	default:
-		return []error{fmt.Errorf("no validation defined for %#v", obj)}
+		return utilvalidation.ErrorList{utilvalidation.NewInternalError("", fmt.Errorf("no validation defined for %#v", obj))}
 	}
 	return errors
 }

pkg/api/errors/errors.go

@@ -24,7 +24,6 @@ import (
 
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/runtime"
-	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/util/validation"
 )
 
@@ -162,13 +161,12 @@ func NewConflict(kind, name string, err error) error {
 func NewInvalid(kind, name string, errs validation.ErrorList) error {
 	causes := make([]unversioned.StatusCause, 0, len(errs))
 	for i := range errs {
-		if err, ok := errs[i].(*validation.Error); ok {
+		err := errs[i]
-			causes = append(causes, unversioned.StatusCause{
+		causes = append(causes, unversioned.StatusCause{
-				Type:    unversioned.CauseType(err.Type),
+			Type:    unversioned.CauseType(err.Type),
-				Message: err.ErrorBody(),
+			Message: err.ErrorBody(),
-				Field:   err.Field,
+			Field:   err.Field,
-			})
+		})
-		}
 	}
 	return &StatusError{unversioned.Status{
 		Status: unversioned.StatusFailure,
@@ -179,7 +177,7 @@ func NewInvalid(kind, name string, errs validation.ErrorList) error {
 			Name:   name,
 			Causes: causes,
 		},
-		Message: fmt.Sprintf("%s %q is invalid: %v", kind, name, utilerrors.NewAggregate(errs)),
+		Message: fmt.Sprintf("%s %q is invalid: %v", kind, name, errs.ToAggregate()),
 	}}
 }
 

pkg/api/errors/errors_test.go

@@ -92,7 +92,7 @@ func TestNewInvalid(t *testing.T) {
 		Details *unversioned.StatusDetails
 	}{
 		{
-			validation.NewFieldDuplicate("field[0].name", "bar"),
+			validation.NewDuplicateError("field[0].name", "bar"),
 			&unversioned.StatusDetails{
 				Kind: "kind",
 				Name: "name",
@@ -103,7 +103,7 @@ func TestNewInvalid(t *testing.T) {
 			},
 		},
 		{
-			validation.NewFieldInvalid("field[0].name", "bar", "detail"),
+			validation.NewInvalidError("field[0].name", "bar", "detail"),
 			&unversioned.StatusDetails{
 				Kind: "kind",
 				Name: "name",
@@ -114,7 +114,7 @@ func TestNewInvalid(t *testing.T) {
 			},
 		},
 		{
-			validation.NewFieldNotFound("field[0].name", "bar"),
+			validation.NewNotFoundError("field[0].name", "bar"),
 			&unversioned.StatusDetails{
 				Kind: "kind",
 				Name: "name",
@@ -125,7 +125,7 @@ func TestNewInvalid(t *testing.T) {
 			},
 		},
 		{
-			validation.NewFieldNotSupported("field[0].name", "bar", nil),
+			validation.NewNotSupportedError("field[0].name", "bar", nil),
 			&unversioned.StatusDetails{
 				Kind: "kind",
 				Name: "name",
@@ -136,7 +136,7 @@ func TestNewInvalid(t *testing.T) {
 			},
 		},
 		{
-			validation.NewFieldRequired("field[0].name"),
+			validation.NewRequiredError("field[0].name"),
 			&unversioned.StatusDetails{
 				Kind: "kind",
 				Name: "name",

pkg/api/rest/update.go

@@ -57,11 +57,11 @@ func validateCommonFields(obj, old runtime.Object) utilvalidation.ErrorList {
 	allErrs := utilvalidation.ErrorList{}
 	objectMeta, err := api.ObjectMetaFor(obj)
 	if err != nil {
-		return append(allErrs, errors.NewInternalError(err))
+		return append(allErrs, utilvalidation.NewInternalError("metadata", err))
 	}
 	oldObjectMeta, err := api.ObjectMetaFor(old)
 	if err != nil {
-		return append(allErrs, errors.NewInternalError(err))
+		return append(allErrs, utilvalidation.NewInternalError("metadata", err))
 	}
 	allErrs = append(allErrs, validation.ValidateObjectMetaUpdate(objectMeta, oldObjectMeta)...)
 

pkg/api/validation/events.go

@@ -27,10 +27,10 @@ func ValidateEvent(event *api.Event) validation.ErrorList {
 	// TODO: There is no namespace required for node.
 	if event.InvolvedObject.Kind != "Node" &&
 		event.Namespace != event.InvolvedObject.Namespace {
-		allErrs = append(allErrs, validation.NewFieldInvalid("involvedObject.namespace", event.InvolvedObject.Namespace, "namespace does not match involvedObject"))
+		allErrs = append(allErrs, validation.NewInvalidError("involvedObject.namespace", event.InvolvedObject.Namespace, "namespace does not match involvedObject"))
 	}
 	if !validation.IsDNS1123Subdomain(event.Namespace) {
-		allErrs = append(allErrs, validation.NewFieldInvalid("namespace", event.Namespace, ""))
+		allErrs = append(allErrs, validation.NewInvalidError("namespace", event.Namespace, ""))
 	}
 	return allErrs
 }

pkg/api/validation/schema.go

@@ -27,7 +27,6 @@ import (
 	"github.com/golang/glog"
 	apiutil "k8s.io/kubernetes/pkg/api/util"
 	utilerrors "k8s.io/kubernetes/pkg/util/errors"
-	"k8s.io/kubernetes/pkg/util/validation"
 	"k8s.io/kubernetes/pkg/util/yaml"
 )
 
@@ -67,11 +66,11 @@ func NewSwaggerSchemaFromBytes(data []byte) (Schema, error) {
 	return schema, nil
 }
 
-// validateList unpack a list and validate every item in the list.
+// validateList unpacks a list and validate every item in the list.
 // It return nil if every item is ok.
 // Otherwise it return an error list contain errors of every item.
-func (s *SwaggerSchema) validateList(obj map[string]interface{}) validation.ErrorList {
+func (s *SwaggerSchema) validateList(obj map[string]interface{}) []error {
-	allErrs := validation.ErrorList{}
+	allErrs := []error{}
 	items, exists := obj["items"]
 	if !exists {
 		return append(allErrs, fmt.Errorf("no items field in %#v", obj))
@@ -160,8 +159,8 @@ func (s *SwaggerSchema) ValidateBytes(data []byte) error {
 	return utilerrors.NewAggregate(allErrs)
 }
 
-func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName string) validation.ErrorList {
+func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName string) []error {
-	allErrs := validation.ErrorList{}
+	allErrs := []error{}
 	models := s.api.Models
 	model, ok := models.At(typeName)
 	if !ok {
@@ -215,7 +214,7 @@ func (s *SwaggerSchema) ValidateObject(obj interface{}, fieldName, typeName stri
 // This matches type name in the swagger spec, such as "v1.Binding".
 var versionRegexp = regexp.MustCompile(`^v.+\..*`)
 
-func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType string, fieldDetails *swagger.ModelProperty) validation.ErrorList {
+func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType string, fieldDetails *swagger.ModelProperty) []error {
 	// TODO: caesarxuchao: because we have multiple group/versions and objects
 	// may reference objects in other group, the commented out way of checking
 	// if a filedType is a type defined by us is outdated. We use a hacky way
@@ -229,7 +228,7 @@ func (s *SwaggerSchema) validateField(value interface{}, fieldName, fieldType st
 		// if strings.HasPrefix(fieldType, apiVersion) {
 		return s.ValidateObject(value, fieldName, fieldType)
 	}
-	allErrs := validation.ErrorList{}
+	allErrs := []error{}
 	switch fieldType {
 	case "string":
 		// Be loose about what we accept for 'string' since we use IntOrString in a couple of places

pkg/api/validation/validation_test.go

@@ -28,7 +28,6 @@ import (
 	"k8s.io/kubernetes/pkg/api/testapi"
 	"k8s.io/kubernetes/pkg/api/unversioned"
 	"k8s.io/kubernetes/pkg/capabilities"
-	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/util/intstr"
 	"k8s.io/kubernetes/pkg/util/sets"
 	"k8s.io/kubernetes/pkg/util/validation"
@@ -36,7 +35,7 @@ import (
 
 func expectPrefix(t *testing.T, prefix string, errs validation.ErrorList) {
 	for i := range errs {
-		if f, p := errs[i].(*validation.Error).Field, prefix; !strings.HasPrefix(f, p) {
+		if f, p := errs[i].Field, prefix; !strings.HasPrefix(f, p) {
 			t.Errorf("expected prefix '%s' for field '%s' (%v)", p, f, errs[i])
 		}
 	}
@@ -150,7 +149,7 @@ func TestValidateLabels(t *testing.T) {
 		if len(errs) != 1 {
 			t.Errorf("case[%d] expected failure", i)
 		} else {
-			detail := errs[0].(*validation.Error).Detail
+			detail := errs[0].Detail
 			if detail != qualifiedNameErrorMsg {
 				t.Errorf("error detail %s should be equal %s", detail, qualifiedNameErrorMsg)
 			}
@@ -168,7 +167,7 @@ func TestValidateLabels(t *testing.T) {
 		if len(errs) != 1 {
 			t.Errorf("case[%d] expected failure", i)
 		} else {
-			detail := errs[0].(*validation.Error).Detail
+			detail := errs[0].Detail
 			if detail != labelValueErrorMsg {
 				t.Errorf("error detail %s should be equal %s", detail, labelValueErrorMsg)
 			}
@@ -215,7 +214,7 @@ func TestValidateAnnotations(t *testing.T) {
 		if len(errs) != 1 {
 			t.Errorf("case[%d] expected failure", i)
 		}
-		detail := errs[0].(*validation.Error).Detail
+		detail := errs[0].Detail
 		if detail != qualifiedNameErrorMsg {
 			t.Errorf("error detail %s should be equal %s", detail, qualifiedNameErrorMsg)
 		}
@@ -568,13 +567,13 @@ func TestValidateVolumes(t *testing.T) {
 			continue
 		}
 		for i := range errs {
-			if errs[i].(*validation.Error).Type != v.T {
+			if errs[i].Type != v.T {
 				t.Errorf("%s: expected errors to have type %s: %v", k, v.T, errs[i])
 			}
-			if errs[i].(*validation.Error).Field != v.F {
+			if errs[i].Field != v.F {
 				t.Errorf("%s: expected errors to have field %s: %v", k, v.F, errs[i])
 			}
-			detail := errs[i].(*validation.Error).Detail
+			detail := errs[i].Detail
 			if detail != v.D {
 				t.Errorf("%s: expected error detail \"%s\", got \"%s\"", k, v.D, detail)
 			}
@@ -627,13 +626,13 @@ func TestValidatePorts(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		}
 		for i := range errs {
-			if errs[i].(*validation.Error).Type != v.T {
+			if errs[i].Type != v.T {
 				t.Errorf("%s: expected errors to have type %s: %v", k, v.T, errs[i])
 			}
-			if errs[i].(*validation.Error).Field != v.F {
+			if errs[i].Field != v.F {
 				t.Errorf("%s: expected errors to have field %s: %v", k, v.F, errs[i])
 			}
-			detail := errs[i].(*validation.Error).Detail
+			detail := errs[i].Detail
 			if detail != v.D {
 				t.Errorf("%s: expected error detail either empty or %s, got %s", k, v.D, detail)
 			}
@@ -772,7 +771,7 @@ func TestValidateEnv(t *testing.T) {
 			t.Errorf("expected failure for %s", tc.name)
 		} else {
 			for i := range errs {
-				str := errs[i].(*validation.Error).Error()
+				str := errs[i].Error()
 				if str != "" && str != tc.expectedError {
 					t.Errorf("%s: expected error detail either empty or %s, got %s", tc.name, tc.expectedError, str)
 				}
@@ -2108,7 +2107,7 @@ func TestValidateService(t *testing.T) {
 		tc.tweakSvc(&svc)
 		errs := ValidateService(&svc)
 		if len(errs) != tc.numErrs {
-			t.Errorf("Unexpected error list for case %q: %v", tc.name, utilerrors.NewAggregate(errs))
+			t.Errorf("Unexpected error list for case %q: %v", tc.name, errs.ToAggregate())
 		}
 	}
 }
@@ -2560,7 +2559,7 @@ func TestValidateReplicationController(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		}
 		for i := range errs {
-			field := errs[i].(*validation.Error).Field
+			field := errs[i].Field
 			if !strings.HasPrefix(field, "spec.template.") &&
 				field != "metadata.name" &&
 				field != "metadata.namespace" &&
@@ -2676,7 +2675,7 @@ func TestValidateNode(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		}
 		for i := range errs {
-			field := errs[i].(*validation.Error).Field
+			field := errs[i].Field
 			expectedFields := map[string]bool{
 				"metadata.name":        true,
 				"metadata.labels":      true,
@@ -2974,7 +2973,7 @@ func TestValidateServiceUpdate(t *testing.T) {
 		tc.tweakSvc(&oldSvc, &newSvc)
 		errs := ValidateServiceUpdate(&newSvc, &oldSvc)
 		if len(errs) != tc.numErrs {
-			t.Errorf("Unexpected error list for case %q: %v", tc.name, utilerrors.NewAggregate(errs))
+			t.Errorf("Unexpected error list for case %q: %v", tc.name, errs.ToAggregate())
 		}
 	}
 }
@@ -3008,7 +3007,7 @@ func TestValidateResourceNames(t *testing.T) {
 		} else if len(err) == 0 && !item.success {
 			t.Errorf("expected failure for input %q", item.input)
 			for i := range err {
-				detail := err[i].(*validation.Error).Detail
+				detail := err[i].Detail
 				if detail != "" && detail != qualifiedNameErrorMsg {
 					t.Errorf("%d: expected error detail either empty or %s, got %s", k, qualifiedNameErrorMsg, detail)
 				}
@@ -3224,7 +3223,7 @@ func TestValidateLimitRange(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		}
 		for i := range errs {
-			detail := errs[i].(*validation.Error).Detail
+			detail := errs[i].Detail
 			if detail != v.D {
 				t.Errorf("%s: expected error detail either empty or %s, got %s", k, v.D, detail)
 			}
@@ -3329,8 +3328,8 @@ func TestValidateResourceQuota(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		}
 		for i := range errs {
-			field := errs[i].(*validation.Error).Field
+			field := errs[i].Field
-			detail := errs[i].(*validation.Error).Detail
+			detail := errs[i].Detail
 			if field != "metadata.name" && field != "metadata.namespace" && !api.IsStandardResourceName(field) {
 				t.Errorf("%s: missing prefix for: %v", k, field)
 			}
@@ -3937,7 +3936,7 @@ func TestValidateEndpoints(t *testing.T) {
 	}
 
 	for k, v := range errorCases {
-		if errs := ValidateEndpoints(&v.endpoints); len(errs) == 0 || errs[0].(*validation.Error).Type != v.errorType || !strings.Contains(errs[0].(*validation.Error).Detail, v.errorDetail) {
+		if errs := ValidateEndpoints(&v.endpoints); len(errs) == 0 || errs[0].Type != v.errorType || !strings.Contains(errs[0].Detail, v.errorDetail) {
 			t.Errorf("Expected error type %s with detail %s for %s, got %v", v.errorType, v.errorDetail, k, errs)
 		}
 	}
@@ -4017,7 +4016,7 @@ func TestValidateSecurityContext(t *testing.T) {
 		},
 	}
 	for k, v := range errorCases {
-		if errs := ValidateSecurityContext(v.sc); len(errs) == 0 || errs[0].(*validation.Error).Type != v.errorType || errs[0].(*validation.Error).Detail != v.errorDetail {
+		if errs := ValidateSecurityContext(v.sc); len(errs) == 0 || errs[0].Type != v.errorType || errs[0].Detail != v.errorDetail {
 			t.Errorf("Expected error type %s with detail %s for %s, got %v", v.errorType, v.errorDetail, k, errs)
 		}
 	}

pkg/apis/extensions/validation/validation.go

@@ -42,21 +42,21 @@ func ValidateHorizontalPodAutoscalerName(name string, prefix bool) (bool, string
 func validateHorizontalPodAutoscalerSpec(autoscaler extensions.HorizontalPodAutoscalerSpec) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if autoscaler.MinReplicas != nil && *autoscaler.MinReplicas < 1 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("minReplicas", autoscaler.MinReplicas, `must be bigger or equal to 1`))
+		allErrs = append(allErrs, validation.NewInvalidError("minReplicas", autoscaler.MinReplicas, `must be bigger or equal to 1`))
 	}
 	if autoscaler.MaxReplicas < 1 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("maxReplicas", autoscaler.MaxReplicas, `must be bigger or equal to 1`))
+		allErrs = append(allErrs, validation.NewInvalidError("maxReplicas", autoscaler.MaxReplicas, `must be bigger or equal to 1`))
 	}
 	if autoscaler.MinReplicas != nil && autoscaler.MaxReplicas < *autoscaler.MinReplicas {
-		allErrs = append(allErrs, validation.NewFieldInvalid("maxReplicas", autoscaler.MaxReplicas, `must be bigger or equal to minReplicas`))
+		allErrs = append(allErrs, validation.NewInvalidError("maxReplicas", autoscaler.MaxReplicas, `must be bigger or equal to minReplicas`))
 	}
 	if autoscaler.CPUUtilization != nil && autoscaler.CPUUtilization.TargetPercentage < 1 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("cpuUtilization.targetPercentage", autoscaler.CPUUtilization.TargetPercentage, `must be bigger or equal to 1`))
+		allErrs = append(allErrs, validation.NewInvalidError("cpuUtilization.targetPercentage", autoscaler.CPUUtilization.TargetPercentage, `must be bigger or equal to 1`))
 	}
 	if refErrs := ValidateSubresourceReference(autoscaler.ScaleRef); len(refErrs) > 0 {
 		allErrs = append(allErrs, refErrs.Prefix("scaleRef")...)
 	} else if autoscaler.ScaleRef.Subresource != "scale" {
-		allErrs = append(allErrs, validation.NewFieldNotSupported("scaleRef.subresource", autoscaler.ScaleRef.Subresource, []string{"scale"}))
+		allErrs = append(allErrs, validation.NewNotSupportedError("scaleRef.subresource", autoscaler.ScaleRef.Subresource, []string{"scale"}))
 	}
 	return allErrs
 }
@@ -64,21 +64,21 @@ func validateHorizontalPodAutoscalerSpec(autoscaler extensions.HorizontalPodAuto
 func ValidateSubresourceReference(ref extensions.SubresourceReference) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if len(ref.Kind) == 0 {
-		allErrs = append(allErrs, validation.NewFieldRequired("kind"))
+		allErrs = append(allErrs, validation.NewRequiredError("kind"))
 	} else if ok, msg := apivalidation.IsValidPathSegmentName(ref.Kind); !ok {
-		allErrs = append(allErrs, validation.NewFieldInvalid("kind", ref.Kind, msg))
+		allErrs = append(allErrs, validation.NewInvalidError("kind", ref.Kind, msg))
 	}
 
 	if len(ref.Name) == 0 {
-		allErrs = append(allErrs, validation.NewFieldRequired("name"))
+		allErrs = append(allErrs, validation.NewRequiredError("name"))
 	} else if ok, msg := apivalidation.IsValidPathSegmentName(ref.Name); !ok {
-		allErrs = append(allErrs, validation.NewFieldInvalid("name", ref.Name, msg))
+		allErrs = append(allErrs, validation.NewInvalidError("name", ref.Name, msg))
 	}
 
 	if len(ref.Subresource) == 0 {
-		allErrs = append(allErrs, validation.NewFieldRequired("subresource"))
+		allErrs = append(allErrs, validation.NewRequiredError("subresource"))
 	} else if ok, msg := apivalidation.IsValidPathSegmentName(ref.Subresource); !ok {
-		allErrs = append(allErrs, validation.NewFieldInvalid("subresource", ref.Subresource, msg))
+		allErrs = append(allErrs, validation.NewInvalidError("subresource", ref.Subresource, msg))
 	}
 	return allErrs
 }
@@ -126,10 +126,10 @@ func ValidateThirdPartyResource(obj *extensions.ThirdPartyResource) validation.E
 	for ix := range obj.Versions {
 		version := &obj.Versions[ix]
 		if len(version.Name) == 0 {
-			allErrs = append(allErrs, validation.NewFieldInvalid("name", version, "name can not be empty"))
+			allErrs = append(allErrs, validation.NewInvalidError("name", version, "name can not be empty"))
 		}
 		if versions.Has(version.Name) {
-			allErrs = append(allErrs, validation.NewFieldDuplicate("version", version))
+			allErrs = append(allErrs, validation.NewDuplicateError("version", version))
 		}
 		versions.Insert(version.Name)
 	}
@@ -180,7 +180,7 @@ func ValidateDaemonSetTemplateUpdate(podTemplate, oldPodTemplate *api.PodTemplat
 	// In particular, we do not allow updates to container images at this point.
 	if !api.Semantic.DeepEqual(oldPodTemplate.Spec, podSpec) {
 		// TODO: Pinpoint the specific field that causes the invalid error after we have strategic merge diff
-		allErrs = append(allErrs, validation.NewFieldInvalid("spec", "content of spec is not printed out, please refer to the \"details\"", "may not update fields other than spec.nodeSelector"))
+		allErrs = append(allErrs, validation.NewInvalidError("spec", "content of spec is not printed out, please refer to the \"details\"", "may not update fields other than spec.nodeSelector"))
 	}
 	return allErrs
 }
@@ -192,13 +192,13 @@ func ValidateDaemonSetSpec(spec *extensions.DaemonSetSpec) validation.ErrorList
 	allErrs = append(allErrs, ValidatePodSelector(spec.Selector)...)
 
 	if spec.Template == nil {
-		allErrs = append(allErrs, validation.NewFieldRequired("template"))
+		allErrs = append(allErrs, validation.NewRequiredError("template"))
 		return allErrs
 	}
 
 	selector, err := extensions.PodSelectorAsSelector(spec.Selector)
 	if err == nil && !selector.Matches(labels.Set(spec.Template.Labels)) {
-		allErrs = append(allErrs, validation.NewFieldInvalid("template.metadata.labels", spec.Template.Labels, "selector does not match template"))
+		allErrs = append(allErrs, validation.NewInvalidError("template.metadata.labels", spec.Template.Labels, "selector does not match template"))
 	}
 
 	allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(spec.Template).Prefix("template")...)
@@ -206,7 +206,7 @@ func ValidateDaemonSetSpec(spec *extensions.DaemonSetSpec) validation.ErrorList
 	allErrs = append(allErrs, apivalidation.ValidateReadOnlyPersistentDisks(spec.Template.Spec.Volumes).Prefix("template.spec.volumes")...)
 	// RestartPolicy has already been first-order validated as per ValidatePodTemplateSpec().
 	if spec.Template.Spec.RestartPolicy != api.RestartPolicyAlways {
-		allErrs = append(allErrs, validation.NewFieldNotSupported("template.spec.restartPolicy", spec.Template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
+		allErrs = append(allErrs, validation.NewNotSupportedError("template.spec.restartPolicy", spec.Template.Spec.RestartPolicy, []string{string(api.RestartPolicyAlways)}))
 	}
 
 	return allErrs
@@ -228,7 +228,7 @@ func ValidatePositiveIntOrPercent(intOrPercent intstr.IntOrString, fieldName str
 	allErrs := validation.ErrorList{}
 	if intOrPercent.Type == intstr.String {
 		if !validation.IsValidPercent(intOrPercent.StrVal) {
-			allErrs = append(allErrs, validation.NewFieldInvalid(fieldName, intOrPercent, "value should be int(5) or percentage(5%)"))
+			allErrs = append(allErrs, validation.NewInvalidError(fieldName, intOrPercent, "value should be int(5) or percentage(5%)"))
 		}
 	} else if intOrPercent.Type == intstr.Int {
 		allErrs = append(allErrs, apivalidation.ValidatePositiveField(int64(intOrPercent.IntVal), fieldName)...)
@@ -258,7 +258,7 @@ func IsNotMoreThan100Percent(intOrStringValue intstr.IntOrString, fieldName stri
 	if !isPercent || value <= 100 {
 		return nil
 	}
-	allErrs = append(allErrs, validation.NewFieldInvalid(fieldName, intOrStringValue, "should not be more than 100%"))
+	allErrs = append(allErrs, validation.NewInvalidError(fieldName, intOrStringValue, "should not be more than 100%"))
 	return allErrs
 }
 
@@ -268,7 +268,7 @@ func ValidateRollingUpdateDeployment(rollingUpdate *extensions.RollingUpdateDepl
 	allErrs = append(allErrs, ValidatePositiveIntOrPercent(rollingUpdate.MaxSurge, fieldName+".maxSurge")...)
 	if getIntOrPercentValue(rollingUpdate.MaxUnavailable) == 0 && getIntOrPercentValue(rollingUpdate.MaxSurge) == 0 {
 		// Both MaxSurge and MaxUnavailable cannot be zero.
-		allErrs = append(allErrs, validation.NewFieldInvalid(fieldName+".maxUnavailable", rollingUpdate.MaxUnavailable, "cannot be 0 when maxSurge is 0 as well"))
+		allErrs = append(allErrs, validation.NewInvalidError(fieldName+".maxUnavailable", rollingUpdate.MaxUnavailable, "cannot be 0 when maxSurge is 0 as well"))
 	}
 	// Validate that MaxUnavailable is not more than 100%.
 	allErrs = append(allErrs, IsNotMoreThan100Percent(rollingUpdate.MaxUnavailable, fieldName+".maxUnavailable")...)
@@ -283,7 +283,7 @@ func ValidateDeploymentStrategy(strategy *extensions.DeploymentStrategy, fieldNa
 	}
 	switch strategy.Type {
 	case extensions.RecreateDeploymentStrategyType:
-		allErrs = append(allErrs, validation.NewFieldForbidden("rollingUpdate", "rollingUpdate should be nil when strategy type is "+extensions.RecreateDeploymentStrategyType))
+		allErrs = append(allErrs, validation.NewForbiddenError("rollingUpdate", "rollingUpdate should be nil when strategy type is "+extensions.RecreateDeploymentStrategyType))
 	case extensions.RollingUpdateDeploymentStrategyType:
 		allErrs = append(allErrs, ValidateRollingUpdateDeployment(strategy.RollingUpdate, "rollingUpdate")...)
 	}
@@ -325,7 +325,7 @@ func ValidateThirdPartyResourceDataUpdate(update, old *extensions.ThirdPartyReso
 func ValidateThirdPartyResourceData(obj *extensions.ThirdPartyResourceData) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if len(obj.Name) == 0 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("name", obj.Name, "name must be non-empty"))
+		allErrs = append(allErrs, validation.NewInvalidError("name", obj.Name, "name must be non-empty"))
 	}
 	return allErrs
 }
@@ -348,7 +348,7 @@ func ValidateJobSpec(spec *extensions.JobSpec) validation.ErrorList {
 		allErrs = append(allErrs, apivalidation.ValidatePositiveField(int64(*spec.Completions), "completions")...)
 	}
 	if spec.Selector == nil {
-		allErrs = append(allErrs, validation.NewFieldRequired("selector"))
+		allErrs = append(allErrs, validation.NewRequiredError("selector"))
 	} else {
 		allErrs = append(allErrs, ValidatePodSelector(spec.Selector).Prefix("selector")...)
 	}
@@ -356,14 +356,14 @@ func ValidateJobSpec(spec *extensions.JobSpec) validation.ErrorList {
 	if selector, err := extensions.PodSelectorAsSelector(spec.Selector); err == nil {
 		labels := labels.Set(spec.Template.Labels)
 		if !selector.Matches(labels) {
-			allErrs = append(allErrs, validation.NewFieldInvalid("template.metadata.labels", spec.Template.Labels, "selector does not match template"))
+			allErrs = append(allErrs, validation.NewInvalidError("template.metadata.labels", spec.Template.Labels, "selector does not match template"))
 		}
 	}
 
 	allErrs = append(allErrs, apivalidation.ValidatePodTemplateSpec(&spec.Template).Prefix("template")...)
 	if spec.Template.Spec.RestartPolicy != api.RestartPolicyOnFailure &&
 		spec.Template.Spec.RestartPolicy != api.RestartPolicyNever {
-		allErrs = append(allErrs, validation.NewFieldNotSupported("template.spec.restartPolicy",
+		allErrs = append(allErrs, validation.NewNotSupportedError("template.spec.restartPolicy",
 			spec.Template.Spec.RestartPolicy, []string{string(api.RestartPolicyOnFailure), string(api.RestartPolicyNever)}))
 	}
 	return allErrs
@@ -426,7 +426,7 @@ func ValidateIngressSpec(spec *extensions.IngressSpec) validation.ErrorList {
 	if spec.Backend != nil {
 		allErrs = append(allErrs, validateIngressBackend(spec.Backend).Prefix("backend")...)
 	} else if len(spec.Rules) == 0 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("rules", spec.Rules, "Either a default backend or a set of host rules are required for ingress."))
+		allErrs = append(allErrs, validation.NewInvalidError("rules", spec.Rules, "Either a default backend or a set of host rules are required for ingress."))
 	}
 	if len(spec.Rules) > 0 {
 		allErrs = append(allErrs, validateIngressRules(spec.Rules).Prefix("rules")...)
@@ -453,17 +453,17 @@ func ValidateIngressStatusUpdate(ingress, oldIngress *extensions.Ingress) valida
 func validateIngressRules(IngressRules []extensions.IngressRule) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if len(IngressRules) == 0 {
-		return append(allErrs, validation.NewFieldRequired("IngressRules"))
+		return append(allErrs, validation.NewRequiredError("IngressRules"))
 	}
 	for _, ih := range IngressRules {
 		if len(ih.Host) > 0 {
 			// TODO: Ports and ips are allowed in the host part of a url
 			// according to RFC 3986, consider allowing them.
 			if valid, errMsg := apivalidation.NameIsDNSSubdomain(ih.Host, false); !valid {
-				allErrs = append(allErrs, validation.NewFieldInvalid("host", ih.Host, errMsg))
+				allErrs = append(allErrs, validation.NewInvalidError("host", ih.Host, errMsg))
 			}
 			if isIP := (net.ParseIP(ih.Host) != nil); isIP {
-				allErrs = append(allErrs, validation.NewFieldInvalid("host", ih.Host, "Host must be a DNS name, not ip address"))
+				allErrs = append(allErrs, validation.NewInvalidError("host", ih.Host, "Host must be a DNS name, not ip address"))
 			}
 		}
 		allErrs = append(allErrs, validateIngressRuleValue(&ih.IngressRuleValue).Prefix("ingressRule")...)
@@ -482,12 +482,12 @@ func validateIngressRuleValue(ingressRule *extensions.IngressRuleValue) validati
 func validateHTTPIngressRuleValue(httpIngressRuleValue *extensions.HTTPIngressRuleValue) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if len(httpIngressRuleValue.Paths) == 0 {
-		allErrs = append(allErrs, validation.NewFieldRequired("paths"))
+		allErrs = append(allErrs, validation.NewRequiredError("paths"))
 	}
 	for _, rule := range httpIngressRuleValue.Paths {
 		if len(rule.Path) > 0 {
 			if !strings.HasPrefix(rule.Path, "/") {
-				allErrs = append(allErrs, validation.NewFieldInvalid("path", rule.Path, "path must begin with /"))
+				allErrs = append(allErrs, validation.NewInvalidError("path", rule.Path, "path must begin with /"))
 			}
 			// TODO: More draconian path regex validation.
 			// Path must be a valid regex. This is the basic requirement.
@@ -500,7 +500,7 @@ func validateHTTPIngressRuleValue(httpIngressRuleValue *extensions.HTTPIngressRu
 			// the user is confusing url regexes with path regexes.
 			_, err := regexp.CompilePOSIX(rule.Path)
 			if err != nil {
-				allErrs = append(allErrs, validation.NewFieldInvalid("path", rule.Path, "httpIngressRuleValue.path must be a valid regex."))
+				allErrs = append(allErrs, validation.NewInvalidError("path", rule.Path, "httpIngressRuleValue.path must be a valid regex."))
 			}
 		}
 		allErrs = append(allErrs, validateIngressBackend(&rule.Backend).Prefix("backend")...)
@@ -514,19 +514,19 @@ func validateIngressBackend(backend *extensions.IngressBackend) validation.Error
 
 	// All backends must reference a single local service by name, and a single service port by name or number.
 	if len(backend.ServiceName) == 0 {
-		return append(allErrs, validation.NewFieldRequired("serviceName"))
+		return append(allErrs, validation.NewRequiredError("serviceName"))
 	} else if ok, errMsg := apivalidation.ValidateServiceName(backend.ServiceName, false); !ok {
-		allErrs = append(allErrs, validation.NewFieldInvalid("serviceName", backend.ServiceName, errMsg))
+		allErrs = append(allErrs, validation.NewInvalidError("serviceName", backend.ServiceName, errMsg))
 	}
 	if backend.ServicePort.Type == intstr.String {
 		if !validation.IsDNS1123Label(backend.ServicePort.StrVal) {
-			allErrs = append(allErrs, validation.NewFieldInvalid("servicePort", backend.ServicePort.StrVal, apivalidation.DNS1123LabelErrorMsg))
+			allErrs = append(allErrs, validation.NewInvalidError("servicePort", backend.ServicePort.StrVal, apivalidation.DNS1123LabelErrorMsg))
 		}
 		if !validation.IsValidPortName(backend.ServicePort.StrVal) {
-			allErrs = append(allErrs, validation.NewFieldInvalid("servicePort", backend.ServicePort.StrVal, apivalidation.PortNameErrorMsg))
+			allErrs = append(allErrs, validation.NewInvalidError("servicePort", backend.ServicePort.StrVal, apivalidation.PortNameErrorMsg))
 		}
 	} else if !validation.IsValidPortNum(backend.ServicePort.IntVal) {
-		allErrs = append(allErrs, validation.NewFieldInvalid("servicePort", backend.ServicePort, apivalidation.PortRangeErrorMsg))
+		allErrs = append(allErrs, validation.NewInvalidError("servicePort", backend.ServicePort, apivalidation.PortRangeErrorMsg))
 	}
 	return allErrs
 }
@@ -534,23 +534,23 @@ func validateIngressBackend(backend *extensions.IngressBackend) validation.Error
 func validateClusterAutoscalerSpec(spec extensions.ClusterAutoscalerSpec) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if spec.MinNodes < 0 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("minNodes", spec.MinNodes, `must be non-negative`))
+		allErrs = append(allErrs, validation.NewInvalidError("minNodes", spec.MinNodes, `must be non-negative`))
 	}
 	if spec.MaxNodes < spec.MinNodes {
-		allErrs = append(allErrs, validation.NewFieldInvalid("maxNodes", spec.MaxNodes, `must be bigger or equal to minNodes`))
+		allErrs = append(allErrs, validation.NewInvalidError("maxNodes", spec.MaxNodes, `must be bigger or equal to minNodes`))
 	}
 	if len(spec.TargetUtilization) == 0 {
-		allErrs = append(allErrs, validation.NewFieldRequired("targetUtilization"))
+		allErrs = append(allErrs, validation.NewRequiredError("targetUtilization"))
 	}
 	for _, target := range spec.TargetUtilization {
 		if len(target.Resource) == 0 {
-			allErrs = append(allErrs, validation.NewFieldRequired("targetUtilization.resource"))
+			allErrs = append(allErrs, validation.NewRequiredError("targetUtilization.resource"))
 		}
 		if target.Value <= 0 {
-			allErrs = append(allErrs, validation.NewFieldInvalid("targetUtilization.value", target.Value, "must be greater than 0"))
+			allErrs = append(allErrs, validation.NewInvalidError("targetUtilization.value", target.Value, "must be greater than 0"))
 		}
 		if target.Value > 1 {
-			allErrs = append(allErrs, validation.NewFieldInvalid("targetUtilization.value", target.Value, "must be less or equal 1"))
+			allErrs = append(allErrs, validation.NewInvalidError("targetUtilization.value", target.Value, "must be less or equal 1"))
 		}
 	}
 	return allErrs
@@ -559,10 +559,10 @@ func validateClusterAutoscalerSpec(spec extensions.ClusterAutoscalerSpec) valida
 func ValidateClusterAutoscaler(autoscaler *extensions.ClusterAutoscaler) validation.ErrorList {
 	allErrs := validation.ErrorList{}
 	if autoscaler.Name != "ClusterAutoscaler" {
-		allErrs = append(allErrs, validation.NewFieldInvalid("name", autoscaler.Name, `name must be ClusterAutoscaler`))
+		allErrs = append(allErrs, validation.NewInvalidError("name", autoscaler.Name, `name must be ClusterAutoscaler`))
 	}
 	if autoscaler.Namespace != api.NamespaceDefault {
-		allErrs = append(allErrs, validation.NewFieldInvalid("namespace", autoscaler.Namespace, `namespace must be default`))
+		allErrs = append(allErrs, validation.NewInvalidError("namespace", autoscaler.Namespace, `namespace must be default`))
 	}
 	allErrs = append(allErrs, validateClusterAutoscalerSpec(autoscaler.Spec)...)
 	return allErrs
@@ -585,14 +585,14 @@ func ValidatePodSelectorRequirement(sr extensions.PodSelectorRequirement) valida
 	switch sr.Operator {
 	case extensions.PodSelectorOpIn, extensions.PodSelectorOpNotIn:
 		if len(sr.Values) == 0 {
-			allErrs = append(allErrs, validation.NewFieldInvalid("values", sr.Values, "must be non-empty when operator is In or NotIn"))
+			allErrs = append(allErrs, validation.NewInvalidError("values", sr.Values, "must be non-empty when operator is In or NotIn"))
 		}
 	case extensions.PodSelectorOpExists, extensions.PodSelectorOpDoesNotExist:
 		if len(sr.Values) > 0 {
-			allErrs = append(allErrs, validation.NewFieldInvalid("values", sr.Values, "must be empty when operator is Exists or DoesNotExist"))
+			allErrs = append(allErrs, validation.NewInvalidError("values", sr.Values, "must be empty when operator is Exists or DoesNotExist"))
 		}
 	default:
-		allErrs = append(allErrs, validation.NewFieldInvalid("operator", sr.Operator, "not a valid pod selector operator"))
+		allErrs = append(allErrs, validation.NewInvalidError("operator", sr.Operator, "not a valid pod selector operator"))
 	}
 	allErrs = append(allErrs, apivalidation.ValidateLabelName(sr.Key, "key")...)
 	return allErrs
@@ -603,7 +603,7 @@ func ValidateScale(scale *extensions.Scale) validation.ErrorList {
 	allErrs = append(allErrs, apivalidation.ValidateObjectMeta(&scale.ObjectMeta, true, apivalidation.NameIsDNSSubdomain).Prefix("metadata")...)
 
 	if scale.Spec.Replicas < 0 {
-		allErrs = append(allErrs, validation.NewFieldInvalid("spec.replicas", scale.Spec.Replicas, "must be non-negative"))
+		allErrs = append(allErrs, validation.NewInvalidError("spec.replicas", scale.Spec.Replicas, "must be non-negative"))
 	}
 
 	return allErrs

pkg/apis/extensions/validation/validation_test.go

@@ -24,7 +24,6 @@ import (
 	"k8s.io/kubernetes/pkg/api"
 	"k8s.io/kubernetes/pkg/apis/extensions"
 	"k8s.io/kubernetes/pkg/util/intstr"
-	"k8s.io/kubernetes/pkg/util/validation"
 )
 
 func TestValidateHorizontalPodAutoscaler(t *testing.T) {
@@ -675,7 +674,7 @@ func TestValidateDaemonSet(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		}
 		for i := range errs {
-			field := errs[i].(*validation.Error).Field
+			field := errs[i].Field
 			if !strings.HasPrefix(field, "spec.template.") &&
 				field != "metadata.name" &&
 				field != "metadata.namespace" &&
@@ -918,9 +917,9 @@ func TestValidateJob(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		} else {
 			s := strings.Split(k, ":")
-			err := errs[0].(*validation.Error)
+			err := errs[0]
 			if err.Field != s[0] || !strings.Contains(err.Error(), s[1]) {
-				t.Errorf("unexpected error: %v, expected: %s", errs[0], k)
+				t.Errorf("unexpected error: %v, expected: %s", err, k)
 			}
 		}
 	}
@@ -1019,9 +1018,9 @@ func TestValidateIngress(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		} else {
 			s := strings.Split(k, ":")
-			err := errs[0].(*validation.Error)
+			err := errs[0]
 			if err.Field != s[0] || !strings.Contains(err.Error(), s[1]) {
-				t.Errorf("unexpected error: %v, expected: %s", errs[0], k)
+				t.Errorf("unexpected error: %v, expected: %s", err, k)
 			}
 		}
 	}
@@ -1111,9 +1110,9 @@ func TestValidateIngressStatusUpdate(t *testing.T) {
 			t.Errorf("expected failure for %s", k)
 		} else {
 			s := strings.Split(k, ":")
-			err := errs[0].(*validation.Error)
+			err := errs[0]
 			if err.Field != s[0] || !strings.Contains(err.Error(), s[1]) {
-				t.Errorf("unexpected error: %v, expected: %s", errs[0], k)
+				t.Errorf("unexpected error: %v, expected: %s", err, k)
 			}
 		}
 	}

pkg/kubectl/cmd/log.go

@@ -32,7 +32,6 @@ import (
 	cmdutil "k8s.io/kubernetes/pkg/kubectl/cmd/util"
 	"k8s.io/kubernetes/pkg/kubectl/resource"
 	"k8s.io/kubernetes/pkg/runtime"
-	kerrors "k8s.io/kubernetes/pkg/util/errors"
 )
 
 const (
@@ -169,7 +168,7 @@ func (o LogsOptions) Validate() error {
 		return errors.New("unexpected log options object")
 	}
 	if errs := validation.ValidatePodLogOptions(logOptions); len(errs) > 0 {
-		return kerrors.NewAggregate(errs)
+		return errs.ToAggregate()
 	}
 
 	return nil

pkg/kubectl/cmd/util/helpers_test.go

@@ -274,11 +274,11 @@ func TestCheckInvalidErr(t *testing.T) {
 		expected string
 	}{
 		{
-			errors.NewInvalid("Invalid1", "invalidation", validation.ErrorList{validation.NewFieldInvalid("Cause", "single", "details")}),
+			errors.NewInvalid("Invalid1", "invalidation", validation.ErrorList{validation.NewInvalidError("Cause", "single", "details")}),
 			`Error from server: Invalid1 "invalidation" is invalid: Cause: invalid value 'single', Details: details`,
 		},
 		{
-			errors.NewInvalid("Invalid2", "invalidation", validation.ErrorList{validation.NewFieldInvalid("Cause", "multi1", "details"), validation.NewFieldInvalid("Cause", "multi2", "details")}),
+			errors.NewInvalid("Invalid2", "invalidation", validation.ErrorList{validation.NewInvalidError("Cause", "multi1", "details"), validation.NewInvalidError("Cause", "multi2", "details")}),
 			`Error from server: Invalid2 "invalidation" is invalid: [Cause: invalid value 'multi1', Details: details, Cause: invalid value 'multi2', Details: details]`,
 		},
 		{

pkg/kubelet/config/config.go

@@ -29,7 +29,6 @@ import (
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 	kubeletutil "k8s.io/kubernetes/pkg/kubelet/util"
 	"k8s.io/kubernetes/pkg/util/config"
-	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 	"k8s.io/kubernetes/pkg/util/sets"
 	utilvalidation "k8s.io/kubernetes/pkg/util/validation"
 )
@@ -310,7 +309,7 @@ func (s *podStorage) seenSources(sources ...string) bool {
 func filterInvalidPods(pods []*api.Pod, source string, recorder record.EventRecorder) (filtered []*api.Pod) {
 	names := sets.String{}
 	for i, pod := range pods {
-		var errlist []error
+		var errlist utilvalidation.ErrorList
 		if errs := validation.ValidatePod(pod); len(errs) != 0 {
 			errlist = append(errlist, errs...)
 			// If validation fails, don't trust it any further -
@@ -318,14 +317,14 @@ func filterInvalidPods(pods []*api.Pod, source string, recorder record.EventReco
 		} else {
 			name := kubecontainer.GetPodFullName(pod)
 			if names.Has(name) {
-				errlist = append(errlist, utilvalidation.NewFieldDuplicate("name", pod.Name))
+				errlist = append(errlist, utilvalidation.NewDuplicateError("name", pod.Name))
 			} else {
 				names.Insert(name)
 			}
 		}
 		if len(errlist) > 0 {
 			name := bestPodIdentString(pod)
-			err := utilerrors.NewAggregate(errlist)
+			err := errlist.ToAggregate()
 			glog.Warningf("Pod[%d] (%s) from %s failed validation, ignoring: %v", i+1, name, source, err)
 			recorder.Eventf(pod, api.EventTypeWarning, kubecontainer.FailedValidation, "Error validating pod %s from %s, ignoring: %v", name, source, err)
 			continue

pkg/kubelet/config/http_test.go

@@ -30,7 +30,6 @@ import (
 	kubetypes "k8s.io/kubernetes/pkg/kubelet/types"
 	"k8s.io/kubernetes/pkg/runtime"
 	"k8s.io/kubernetes/pkg/util"
-	utilerrors "k8s.io/kubernetes/pkg/util/errors"
 )
 
 func TestURLErrorNotExistNoUpdate(t *testing.T) {
@@ -286,7 +285,7 @@ func TestExtractPodsFromHTTP(t *testing.T) {
 		}
 		for _, pod := range update.Pods {
 			if errs := validation.ValidatePod(pod); len(errs) != 0 {
-				t.Errorf("%s: Expected no validation errors on %#v, Got %v", testCase.desc, pod, utilerrors.NewAggregate(errs))
+				t.Errorf("%s: Expected no validation errors on %#v, Got %v", testCase.desc, pod, errs.ToAggregate())
 			}
 		}
 	}

pkg/labels/selector.go

@@ -701,14 +701,14 @@ const qualifiedNameErrorMsg string = "must match regex [" + validation.DNS1123Su
 
 func validateLabelKey(k string) error {
 	if !validation.IsQualifiedName(k) {
-		return validation.NewFieldInvalid("label key", k, qualifiedNameErrorMsg)
+		return validation.NewInvalidError("label key", k, qualifiedNameErrorMsg)
 	}
 	return nil
 }
 
 func validateLabelValue(v string) error {
 	if !validation.IsValidLabelValue(v) {
-		return validation.NewFieldInvalid("label value", v, qualifiedNameErrorMsg)
+		return validation.NewInvalidError("label value", v, qualifiedNameErrorMsg)
 	}
 	return nil
 }

pkg/registry/pod/etcd/etcd.go

@@ -129,10 +129,10 @@ func (r *BindingREST) Create(ctx api.Context, obj runtime.Object) (out runtime.O
 	binding := obj.(*api.Binding)
 	// TODO: move me to a binding strategy
 	if len(binding.Target.Kind) != 0 && binding.Target.Kind != "Node" {
-		return nil, errors.NewInvalid("binding", binding.Name, validation.ErrorList{validation.NewFieldInvalid("to.kind", binding.Target.Kind, "must be empty or 'Node'")})
+		return nil, errors.NewInvalid("binding", binding.Name, validation.ErrorList{validation.NewInvalidError("to.kind", binding.Target.Kind, "must be empty or 'Node'")})
 	}
 	if len(binding.Target.Name) == 0 {
-		return nil, errors.NewInvalid("binding", binding.Name, validation.ErrorList{validation.NewFieldRequired("to.name")})
+		return nil, errors.NewInvalid("binding", binding.Name, validation.ErrorList{validation.NewRequiredError("to.name")})
 	}
 	err = r.assignPod(ctx, binding.Name, binding.Target.Name, binding.Annotations)
 	out = &unversioned.Status{Status: unversioned.StatusSuccess}

pkg/registry/service/rest.go

@@ -84,7 +84,7 @@ func (rs *REST) Create(ctx api.Context, obj runtime.Object) (runtime.Object, err
 		// Allocate next available.
 		ip, err := rs.serviceIPs.AllocateNext()
 		if err != nil {
-			el := utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("spec.clusterIP", service.Spec.ClusterIP, err.Error())}
+			el := utilvalidation.ErrorList{utilvalidation.NewInvalidError("spec.clusterIP", service.Spec.ClusterIP, err.Error())}
 			return nil, errors.NewInvalid("Service", service.Name, el)
 		}
 		service.Spec.ClusterIP = ip.String()
@@ -92,7 +92,7 @@ func (rs *REST) Create(ctx api.Context, obj runtime.Object) (runtime.Object, err
 	} else if api.IsServiceIPSet(service) {
 		// Try to respect the requested IP.
 		if err := rs.serviceIPs.Allocate(net.ParseIP(service.Spec.ClusterIP)); err != nil {
-			el := utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("spec.clusterIP", service.Spec.ClusterIP, err.Error())}
+			el := utilvalidation.ErrorList{utilvalidation.NewInvalidError("spec.clusterIP", service.Spec.ClusterIP, err.Error())}
 			return nil, errors.NewInvalid("Service", service.Name, el)
 		}
 		releaseServiceIP = true
@@ -104,13 +104,13 @@ func (rs *REST) Create(ctx api.Context, obj runtime.Object) (runtime.Object, err
 		if servicePort.NodePort != 0 {
 			err := nodePortOp.Allocate(servicePort.NodePort)
 			if err != nil {
-				el := utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("nodePort", servicePort.NodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
+				el := utilvalidation.ErrorList{utilvalidation.NewInvalidError("nodePort", servicePort.NodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
 				return nil, errors.NewInvalid("Service", service.Name, el)
 			}
 		} else if assignNodePorts {
 			nodePort, err := nodePortOp.AllocateNext()
 			if err != nil {
-				el := utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("nodePort", servicePort.NodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
+				el := utilvalidation.ErrorList{utilvalidation.NewInvalidError("nodePort", servicePort.NodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
 				return nil, errors.NewInvalid("Service", service.Name, el)
 			}
 			servicePort.NodePort = nodePort
@@ -223,14 +223,14 @@ func (rs *REST) Update(ctx api.Context, obj runtime.Object) (runtime.Object, boo
 				if !contains(oldNodePorts, nodePort) {
 					err := nodePortOp.Allocate(nodePort)
 					if err != nil {
-						el := utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("nodePort", nodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
+						el := utilvalidation.ErrorList{utilvalidation.NewInvalidError("nodePort", nodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
 						return nil, false, errors.NewInvalid("Service", service.Name, el)
 					}
 				}
 			} else {
 				nodePort, err = nodePortOp.AllocateNext()
 				if err != nil {
-					el := utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("nodePort", nodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
+					el := utilvalidation.ErrorList{utilvalidation.NewInvalidError("nodePort", nodePort, err.Error())}.PrefixIndex(i).Prefix("spec.ports")
 					return nil, false, errors.NewInvalid("Service", service.Name, el)
 				}
 				servicePort.NodePort = nodePort

pkg/storage/util.go

@@ -48,7 +48,7 @@ func ParseWatchResourceVersion(resourceVersion, kind string) (uint64, error) {
 	version, err := strconv.ParseUint(resourceVersion, 10, 64)
 	if err != nil {
 		// TODO: Does this need to be a ErrorList?  I can't convince myself it does.
-		return 0, errors.NewInvalid(kind, "", utilvalidation.ErrorList{utilvalidation.NewFieldInvalid("resourceVersion", resourceVersion, err.Error())})
+		return 0, errors.NewInvalid(kind, "", utilvalidation.ErrorList{utilvalidation.NewInvalidError("resourceVersion", resourceVersion, err.Error())})
 	}
 	return version + 1, nil
 }

pkg/util/validation/errors.go

@@ -46,7 +46,7 @@ func (v *Error) Error() string {
 func (v *Error) ErrorBody() string {
 	var s string
 	switch v.Type {
-	case ErrorTypeRequired, ErrorTypeTooLong:
+	case ErrorTypeRequired, ErrorTypeTooLong, ErrorTypeInternal:
 		s = spew.Sprintf("%s", v.Type)
 	default:
 		s = spew.Sprintf("%s '%+v'", v.Type, v.BadValue)
@@ -65,30 +65,33 @@ type ErrorType string
 // TODO: These values are duplicated in api/types.go, but there's a circular dep.  Fix it.
 const (
 	// ErrorTypeNotFound is used to report failure to find a requested value
-	// (e.g. looking up an ID).  See NewFieldNotFound.
+	// (e.g. looking up an ID).  See NewNotFoundError.
 	ErrorTypeNotFound ErrorType = "FieldValueNotFound"
 	// ErrorTypeRequired is used to report required values that are not
 	// provided (e.g. empty strings, null values, or empty arrays).  See
-	// NewFieldRequired.
+	// NewRequiredError.
 	ErrorTypeRequired ErrorType = "FieldValueRequired"
 	// ErrorTypeDuplicate is used to report collisions of values that must be
-	// unique (e.g. unique IDs).  See NewFieldDuplicate.
+	// unique (e.g. unique IDs).  See NewDuplicateError.
 	ErrorTypeDuplicate ErrorType = "FieldValueDuplicate"
 	// ErrorTypeInvalid is used to report malformed values (e.g. failed regex
-	// match, too long, out of bounds).  See NewFieldInvalid.
+	// match, too long, out of bounds).  See NewInvalidError.
 	ErrorTypeInvalid ErrorType = "FieldValueInvalid"
 	// ErrorTypeNotSupported is used to report unknown values for enumerated
-	// fields (e.g. a list of valid values).  See NewFieldNotSupported.
+	// fields (e.g. a list of valid values).  See NewNotSupportedError.
 	ErrorTypeNotSupported ErrorType = "FieldValueNotSupported"
 	// ErrorTypeForbidden is used to report valid (as per formatting rules)
 	// values which would be accepted under some conditions, but which are not
 	// permitted by the current conditions (such as security policy).  See
-	// NewFieldForbidden.
+	// NewForbiddenError.
 	ErrorTypeForbidden ErrorType = "FieldValueForbidden"
 	// ErrorTypeTooLong is used to report that the given value is too long.
 	// This is similar to ErrorTypeInvalid, but the error will not include the
-	// too-long value.  See NewFieldTooLong.
+	// too-long value.  See NewTooLongError.
 	ErrorTypeTooLong ErrorType = "FieldValueTooLong"
+	// ErrorTypeInternal is used to report other errors that are not related
+	// to user input.
+	ErrorTypeInternal ErrorType = "InternalError"
 )
 
 // String converts a ErrorType into its corresponding canonical error message.
@@ -108,41 +111,43 @@ func (t ErrorType) String() string {
 		return "forbidden"
 	case ErrorTypeTooLong:
 		return "too long"
+	case ErrorTypeInternal:
+		return "internal error"
 	default:
 		panic(fmt.Sprintf("unrecognized validation error: %q", t))
 		return ""
 	}
 }
 
-// NewFieldNotFound returns a *Error indicating "value not found".  This is
+// NewNotFoundError returns a *Error indicating "value not found".  This is
 // used to report failure to find a requested value (e.g. looking up an ID).
-func NewFieldNotFound(field string, value interface{}) *Error {
+func NewNotFoundError(field string, value interface{}) *Error {
 	return &Error{ErrorTypeNotFound, field, value, ""}
 }
 
-// NewFieldRequired returns a *Error indicating "value required".  This is used
+// NewRequiredError returns a *Error indicating "value required".  This is used
 // to report required values that are not provided (e.g. empty strings, null
 // values, or empty arrays).
-func NewFieldRequired(field string) *Error {
+func NewRequiredError(field string) *Error {
 	return &Error{ErrorTypeRequired, field, "", ""}
 }
 
-// NewFieldDuplicate returns a *Error indicating "duplicate value".  This is
+// NewDuplicateError returns a *Error indicating "duplicate value".  This is
 // used to report collisions of values that must be unique (e.g. names or IDs).
-func NewFieldDuplicate(field string, value interface{}) *Error {
+func NewDuplicateError(field string, value interface{}) *Error {
 	return &Error{ErrorTypeDuplicate, field, value, ""}
 }
 
-// NewFieldInvalid returns a *Error indicating "invalid value".  This is used
+// NewInvalidError returns a *Error indicating "invalid value".  This is used
 // to report malformed values (e.g. failed regex match, too long, out of bounds).
-func NewFieldInvalid(field string, value interface{}, detail string) *Error {
+func NewInvalidError(field string, value interface{}, detail string) *Error {
 	return &Error{ErrorTypeInvalid, field, value, detail}
 }
 
-// NewFieldNotSupported returns a *Error indicating "unsupported value".
+// NewNotSupportedError returns a *Error indicating "unsupported value".
 // This is used to report unknown values for enumerated fields (e.g. a list of
 // valid values).
-func NewFieldNotSupported(field string, value interface{}, validValues []string) *Error {
+func NewNotSupportedError(field string, value interface{}, validValues []string) *Error {
 	detail := ""
 	if validValues != nil && len(validValues) > 0 {
 		detail = "supported values: " + strings.Join(validValues, ", ")
@@ -150,40 +155,43 @@ func NewFieldNotSupported(field string, value interface{}, validValues []string)
 	return &Error{ErrorTypeNotSupported, field, value, detail}
 }
 
-// NewFieldForbidden returns a *Error indicating "forbidden".  This is used to
+// NewForbiddenError returns a *Error indicating "forbidden".  This is used to
 // report valid (as per formatting rules) values which would be accepted under
 // some conditions, but which are not permitted by current conditions (e.g.
 // security policy).
-func NewFieldForbidden(field string, value interface{}) *Error {
+func NewForbiddenError(field string, value interface{}) *Error {
 	return &Error{ErrorTypeForbidden, field, value, ""}
 }
 
-// NewFieldTooLong returns a *Error indicating "too long".  This is used to
+// NewTooLongError returns a *Error indicating "too long".  This is used to
 // report that the given value is too long.  This is similar to
-// NewFieldInvalid, but the returned error will not include the too-long
+// NewInvalidError, but the returned error will not include the too-long
 // value.
-func NewFieldTooLong(field string, value interface{}, maxLength int) *Error {
+func NewTooLongError(field string, value interface{}, maxLength int) *Error {
 	return &Error{ErrorTypeTooLong, field, value, fmt.Sprintf("must have at most %d characters", maxLength)}
 }
 
+// NewInternalError returns a *Error indicating "internal error".  This is used
+// to signal that an error was found that was not directly related to user
+// input.  The err argument must be non-nil.
+func NewInternalError(field string, err error) *Error {
+	return &Error{ErrorTypeInternal, field, nil, err.Error()}
+}
+
 // ErrorList holds a set of errors.
-type ErrorList []error
+type ErrorList []*Error
 
 // Prefix adds a prefix to the Field of every Error in the list.
 // Returns the list for convenience.
 func (list ErrorList) Prefix(prefix string) ErrorList {
 	for i := range list {
-		if err, ok := list[i].(*Error); ok {
+		err := list[i]
-			if strings.HasPrefix(err.Field, "[") {
+		if strings.HasPrefix(err.Field, "[") {
-				err.Field = prefix + err.Field
+			err.Field = prefix + err.Field
-			} else if len(err.Field) != 0 {
+		} else if len(err.Field) != 0 {
-				err.Field = prefix + "." + err.Field
+			err.Field = prefix + "." + err.Field
-			} else {
-				err.Field = prefix
-			}
-			list[i] = err
 		} else {
-			panic(fmt.Sprintf("Programmer error: ErrorList holds non-Error: %#v", list[i]))
+			err.Field = prefix
 		}
 	}
 	return list
@@ -206,13 +214,30 @@ func NewErrorTypeMatcher(t ErrorType) utilerrors.Matcher {
 	}
 }
 
+// ToAggregate converts the ErrorList into an errors.Aggregate.
+func (list ErrorList) ToAggregate() utilerrors.Aggregate {
+	errs := make([]error, len(list))
+	for i := range list {
+		errs[i] = list[i]
+	}
+	return utilerrors.NewAggregate(errs)
+}
+
+func fromAggregate(agg utilerrors.Aggregate) ErrorList {
+	errs := agg.Errors()
+	list := make(ErrorList, len(errs))
+	for i := range errs {
+		list[i] = errs[i].(*Error)
+	}
+	return list
+}
+
 // Filter removes items from the ErrorList that match the provided fns.
 func (list ErrorList) Filter(fns ...utilerrors.Matcher) ErrorList {
-	err := utilerrors.FilterOut(utilerrors.NewAggregate(list), fns...)
+	err := utilerrors.FilterOut(list.ToAggregate(), fns...)
 	if err == nil {
 		return nil
 	}
-	// FilterOut that takes an Aggregate returns an Aggregate
+	// FilterOut takes an Aggregate and returns an Aggregate
-	agg := err.(utilerrors.Aggregate)
+	return fromAggregate(err.(utilerrors.Aggregate))
-	return ErrorList(agg.Errors())
 }

pkg/util/validation/errors_test.go

@@ -17,6 +17,7 @@ limitations under the License.
 package validation
 
 import (
+	"fmt"
 	"strings"
 	"testing"
 )
@@ -27,25 +28,29 @@ func TestMakeFuncs(t *testing.T) {
 		expected ErrorType
 	}{
 		{
-			func() *Error { return NewFieldInvalid("f", "v", "d") },
+			func() *Error { return NewInvalidError("f", "v", "d") },
 			ErrorTypeInvalid,
 		},
 		{
-			func() *Error { return NewFieldNotSupported("f", "v", nil) },
+			func() *Error { return NewNotSupportedError("f", "v", nil) },
 			ErrorTypeNotSupported,
 		},
 		{
-			func() *Error { return NewFieldDuplicate("f", "v") },
+			func() *Error { return NewDuplicateError("f", "v") },
 			ErrorTypeDuplicate,
 		},
 		{
-			func() *Error { return NewFieldNotFound("f", "v") },
+			func() *Error { return NewNotFoundError("f", "v") },
 			ErrorTypeNotFound,
 		},
 		{
-			func() *Error { return NewFieldRequired("f") },
+			func() *Error { return NewRequiredError("f") },
 			ErrorTypeRequired,
 		},
+		{
+			func() *Error { return NewInternalError("f", fmt.Errorf("e")) },
+			ErrorTypeInternal,
+		},
 	}
 
 	for _, testCase := range testCases {
@@ -57,7 +62,7 @@ func TestMakeFuncs(t *testing.T) {
 }
 
 func TestErrorUsefulMessage(t *testing.T) {
-	s := NewFieldInvalid("foo", "bar", "deet").Error()
+	s := NewInvalidError("foo", "bar", "deet").Error()
 	t.Logf("message: %v", s)
 	for _, part := range []string{"foo", "bar", "deet", ErrorTypeInvalid.String()} {
 		if !strings.Contains(s, part) {
@@ -71,7 +76,7 @@ func TestErrorUsefulMessage(t *testing.T) {
 		Inner interface{}
 		KV    map[string]int
 	}
-	s = NewFieldInvalid(
+	s = NewInvalidError(
 		"foo",
 		&complicated{
 			Baz:   1,
@@ -93,11 +98,32 @@ func TestErrorUsefulMessage(t *testing.T) {
 	}
 }
 
+func TestToAggregate(t *testing.T) {
+	testCases := []ErrorList{
+		nil,
+		{},
+		{NewInvalidError("f", "v", "d")},
+		{NewInvalidError("f", "v", "d"), NewInternalError("", fmt.Errorf("e"))},
+	}
+	for i, tc := range testCases {
+		agg := tc.ToAggregate()
+		if len(tc) == 0 {
+			if agg != nil {
+				t.Errorf("[%d] Expected nil, got %#v", i, agg)
+			}
+		} else if agg == nil {
+			t.Errorf("[%d] Expected non-nil", i)
+		} else if len(tc) != len(agg.Errors()) {
+			t.Errorf("[%d] Expected %d, got %d", i, len(tc), len(agg.Errors()))
+		}
+	}
+}
+
 func TestErrListFilter(t *testing.T) {
 	list := ErrorList{
-		NewFieldInvalid("test.field", "", ""),
+		NewInvalidError("test.field", "", ""),
-		NewFieldInvalid("field.test", "", ""),
+		NewInvalidError("field.test", "", ""),
-		NewFieldDuplicate("test", "value"),
+		NewDuplicateError("test", "value"),
 	}
 	if len(list.Filter(NewErrorTypeMatcher(ErrorTypeDuplicate))) != 2 {
 		t.Errorf("should not filter")
@@ -113,15 +139,15 @@ func TestErrListPrefix(t *testing.T) {
 		Expected string
 	}{
 		{
-			NewFieldNotFound("[0].bar", "value"),
+			NewNotFoundError("[0].bar", "value"),
 			"foo[0].bar",
 		},
 		{
-			NewFieldInvalid("field", "value", ""),
+			NewInvalidError("field", "value", ""),
 			"foo.field",
 		},
 		{
-			NewFieldDuplicate("", "value"),
+			NewDuplicateError("", "value"),
 			"foo",
 		},
 	}
@@ -131,7 +157,7 @@ func TestErrListPrefix(t *testing.T) {
 		if prefix == nil || len(prefix) != len(errList) {
 			t.Errorf("Prefix should return self")
 		}
-		if e, a := testCase.Expected, errList[0].(*Error).Field; e != a {
+		if e, a := testCase.Expected, errList[0].Field; e != a {
 			t.Errorf("expected %s, got %s", e, a)
 		}
 	}
@@ -143,15 +169,15 @@ func TestErrListPrefixIndex(t *testing.T) {
 		Expected string
 	}{
 		{
-			NewFieldNotFound("[0].bar", "value"),
+			NewNotFoundError("[0].bar", "value"),
 			"[1][0].bar",
 		},
 		{
-			NewFieldInvalid("field", "value", ""),
+			NewInvalidError("field", "value", ""),
 			"[1].field",
 		},
 		{
-			NewFieldDuplicate("", "value"),
+			NewDuplicateError("", "value"),
 			"[1]",
 		},
 	}
@@ -161,7 +187,7 @@ func TestErrListPrefixIndex(t *testing.T) {
 		if prefix == nil || len(prefix) != len(errList) {
 			t.Errorf("PrefixIndex should return self")
 		}
-		if e, a := testCase.Expected, errList[0].(*Error).Field; e != a {
+		if e, a := testCase.Expected, errList[0].Field; e != a {
 			t.Errorf("expected %s, got %s", e, a)
 		}
 	}