From 34ac165a44b7fcae22f35580d0fddd6fb3e93ce6 Mon Sep 17 00:00:00 2001 From: Jordan Liggitt Date: Tue, 5 Feb 2019 18:07:06 -0500 Subject: [PATCH 1/2] Move conditional validation for SCTPSupport to validation functions with knowledge of old objects --- pkg/apis/core/validation/BUILD | 3 + .../core/validation/conditional_validation.go | 148 ++++++++++ .../validation/conditional_validation_test.go | 253 ++++++++++++++++++ pkg/apis/core/validation/validation.go | 10 +- pkg/apis/networking/validation/BUILD | 11 +- .../validation/conditional_validation.go | 59 ++++ .../validation/conditional_validation_test.go | 108 ++++++++ pkg/apis/networking/validation/validation.go | 10 +- 8 files changed, 583 insertions(+), 19 deletions(-) create mode 100644 pkg/apis/core/validation/conditional_validation.go create mode 100644 pkg/apis/core/validation/conditional_validation_test.go create mode 100644 pkg/apis/networking/validation/conditional_validation.go create mode 100644 pkg/apis/networking/validation/conditional_validation_test.go diff --git a/pkg/apis/core/validation/BUILD b/pkg/apis/core/validation/BUILD index ed546217cf6..bbdd8b7a32d 100644 --- a/pkg/apis/core/validation/BUILD +++ b/pkg/apis/core/validation/BUILD @@ -7,6 +7,7 @@ load( go_library( name = "go_default_library", srcs = [ + "conditional_validation.go", "doc.go", "events.go", "validation.go", @@ -46,6 +47,7 @@ go_library( go_test( name = "go_default_test", srcs = [ + "conditional_validation_test.go", "events_test.go", "validation_test.go", ], @@ -59,6 +61,7 @@ go_test( "//staging/src/k8s.io/api/core/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/validation:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/validation/field:go_default_library", diff --git a/pkg/apis/core/validation/conditional_validation.go b/pkg/apis/core/validation/conditional_validation.go new file mode 100644 index 00000000000..e11731686bb --- /dev/null +++ b/pkg/apis/core/validation/conditional_validation.go @@ -0,0 +1,148 @@ +/* +Copyright 2019 The Kubernetes 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 validation + +import ( + "k8s.io/apimachinery/pkg/util/validation/field" + utilfeature "k8s.io/apiserver/pkg/util/feature" + api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/features" +) + +// ValidateConditionalService validates conditionally valid fields. +func ValidateConditionalService(service, oldService *api.Service) field.ErrorList { + var errs field.ErrorList + // If the SCTPSupport feature is disabled, and the old object isn't using the SCTP feature, prevent the new object from using it + if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && len(serviceSCTPFields(oldService)) == 0 { + for _, f := range serviceSCTPFields(service) { + errs = append(errs, field.NotSupported(f, api.ProtocolSCTP, []string{string(api.ProtocolTCP), string(api.ProtocolUDP)})) + } + } + return errs +} + +func serviceSCTPFields(service *api.Service) []*field.Path { + if service == nil { + return nil + } + fields := []*field.Path{} + for pIndex, p := range service.Spec.Ports { + if p.Protocol == api.ProtocolSCTP { + fields = append(fields, field.NewPath("spec.ports").Index(pIndex).Child("protocol")) + } + } + return fields +} + +// ValidateConditionalEndpoints validates conditionally valid fields. +func ValidateConditionalEndpoints(endpoints, oldEndpoints *api.Endpoints) field.ErrorList { + var errs field.ErrorList + // If the SCTPSupport feature is disabled, and the old object isn't using the SCTP feature, prevent the new object from using it + if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && len(endpointsSCTPFields(oldEndpoints)) == 0 { + for _, f := range endpointsSCTPFields(endpoints) { + errs = append(errs, field.NotSupported(f, api.ProtocolSCTP, []string{string(api.ProtocolTCP), string(api.ProtocolUDP)})) + } + } + return errs +} + +func endpointsSCTPFields(endpoints *api.Endpoints) []*field.Path { + if endpoints == nil { + return nil + } + fields := []*field.Path{} + for sIndex, s := range endpoints.Subsets { + for pIndex, p := range s.Ports { + if p.Protocol == api.ProtocolSCTP { + fields = append(fields, field.NewPath("subsets").Index(sIndex).Child("ports").Index(pIndex).Child("protocol")) + } + } + } + return fields +} + +// ValidateConditionalPodTemplate validates conditionally valid fields. +// This should be called from Validate/ValidateUpdate for all resources containing a PodTemplateSpec +func ValidateConditionalPodTemplate(podTemplate, oldPodTemplate *api.PodTemplateSpec, fldPath *field.Path) field.ErrorList { + var ( + podSpec *api.PodSpec + oldPodSpec *api.PodSpec + ) + if podTemplate != nil { + podSpec = &podTemplate.Spec + } + if oldPodTemplate != nil { + oldPodSpec = &oldPodTemplate.Spec + } + return validateConditionalPodSpec(podSpec, oldPodSpec, fldPath.Child("spec")) +} + +// ValidateConditionalPod validates conditionally valid fields. +// This should be called from Validate/ValidateUpdate for all resources containing a Pod +func ValidateConditionalPod(pod, oldPod *api.Pod, fldPath *field.Path) field.ErrorList { + var ( + podSpec *api.PodSpec + oldPodSpec *api.PodSpec + ) + if pod != nil { + podSpec = &pod.Spec + } + if oldPod != nil { + oldPodSpec = &oldPod.Spec + } + return validateConditionalPodSpec(podSpec, oldPodSpec, fldPath.Child("spec")) +} + +func validateConditionalPodSpec(podSpec, oldPodSpec *api.PodSpec, fldPath *field.Path) field.ErrorList { + // Always make sure we have a non-nil current pod spec + if podSpec == nil { + podSpec = &api.PodSpec{} + } + + errs := field.ErrorList{} + + // If the SCTPSupport feature is disabled, and the old object isn't using the SCTP feature, prevent the new object from using it + if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && len(podSCTPFields(oldPodSpec, nil)) == 0 { + for _, f := range podSCTPFields(podSpec, fldPath) { + errs = append(errs, field.NotSupported(f, api.ProtocolSCTP, []string{string(api.ProtocolTCP), string(api.ProtocolUDP)})) + } + } + + return errs +} + +func podSCTPFields(podSpec *api.PodSpec, fldPath *field.Path) []*field.Path { + if podSpec == nil { + return nil + } + fields := []*field.Path{} + for cIndex, c := range podSpec.InitContainers { + for pIndex, p := range c.Ports { + if p.Protocol == api.ProtocolSCTP { + fields = append(fields, fldPath.Child("initContainers").Index(cIndex).Child("ports").Index(pIndex).Child("protocol")) + } + } + } + for cIndex, c := range podSpec.Containers { + for pIndex, p := range c.Ports { + if p.Protocol == api.ProtocolSCTP { + fields = append(fields, fldPath.Child("containers").Index(cIndex).Child("ports").Index(pIndex).Child("protocol")) + } + } + } + return fields +} diff --git a/pkg/apis/core/validation/conditional_validation_test.go b/pkg/apis/core/validation/conditional_validation_test.go new file mode 100644 index 00000000000..e33cd07f002 --- /dev/null +++ b/pkg/apis/core/validation/conditional_validation_test.go @@ -0,0 +1,253 @@ +/* +Copyright 2019 The Kubernetes 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 validation + +import ( + "fmt" + "reflect" + "testing" + + "k8s.io/apimachinery/pkg/util/diff" + utilfeature "k8s.io/apiserver/pkg/util/feature" + utilfeaturetesting "k8s.io/apiserver/pkg/util/feature/testing" + api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/features" +) + +func TestValidatePodSCTP(t *testing.T) { + objectWithValue := func() *api.Pod { + return &api.Pod{ + Spec: api.PodSpec{ + Containers: []api.Container{{Name: "container1", Image: "testimage", Ports: []api.ContainerPort{{ContainerPort: 80, Protocol: api.ProtocolSCTP}}}}, + InitContainers: []api.Container{{Name: "container2", Image: "testimage", Ports: []api.ContainerPort{{ContainerPort: 90, Protocol: api.ProtocolSCTP}}}}, + }, + } + } + objectWithoutValue := func() *api.Pod { + return &api.Pod{ + Spec: api.PodSpec{ + Containers: []api.Container{{Name: "container1", Image: "testimage", Ports: []api.ContainerPort{{ContainerPort: 80, Protocol: api.ProtocolTCP}}}}, + InitContainers: []api.Container{{Name: "container2", Image: "testimage", Ports: []api.ContainerPort{{ContainerPort: 90, Protocol: api.ProtocolTCP}}}}, + }, + } + } + + objectInfo := []struct { + description string + hasValue bool + object func() *api.Pod + }{ + { + description: "has value", + hasValue: true, + object: objectWithValue, + }, + { + description: "does not have value", + hasValue: false, + object: objectWithoutValue, + }, + { + description: "is nil", + hasValue: false, + object: func() *api.Pod { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldPodInfo := range objectInfo { + for _, newPodInfo := range objectInfo { + oldPodHasValue, oldPod := oldPodInfo.hasValue, oldPodInfo.object() + newPodHasValue, newPod := newPodInfo.hasValue, newPodInfo.object() + if newPod == nil { + continue + } + + t.Run(fmt.Sprintf("feature enabled=%v, old object %v, new object %v", enabled, oldPodInfo.description, newPodInfo.description), func(t *testing.T) { + defer utilfeaturetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.SCTPSupport, enabled)() + errs := ValidateConditionalPod(newPod, oldPod, nil) + // objects should never be changed + if !reflect.DeepEqual(oldPod, oldPodInfo.object()) { + t.Errorf("old object changed: %v", diff.ObjectReflectDiff(oldPod, oldPodInfo.object())) + } + if !reflect.DeepEqual(newPod, newPodInfo.object()) { + t.Errorf("new object changed: %v", diff.ObjectReflectDiff(newPod, newPodInfo.object())) + } + + switch { + case enabled || oldPodHasValue || !newPodHasValue: + if len(errs) > 0 { + t.Errorf("unexpected errors: %v", errs) + } + default: + if len(errs) != 2 { + t.Errorf("expected 2 errors, got %v", errs) + } + } + }) + } + } + } +} + +func TestValidateServiceSCTP(t *testing.T) { + objectWithValue := func() *api.Service { + return &api.Service{ + Spec: api.ServiceSpec{ + Ports: []api.ServicePort{{Protocol: api.ProtocolSCTP}}, + }, + } + } + objectWithoutValue := func() *api.Service { + return &api.Service{ + Spec: api.ServiceSpec{ + Ports: []api.ServicePort{{Protocol: api.ProtocolTCP}}, + }, + } + } + + objectInfo := []struct { + description string + hasValue bool + object func() *api.Service + }{ + { + description: "has value", + hasValue: true, + object: objectWithValue, + }, + { + description: "does not have value", + hasValue: false, + object: objectWithoutValue, + }, + { + description: "is nil", + hasValue: false, + object: func() *api.Service { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldServiceInfo := range objectInfo { + for _, newServiceInfo := range objectInfo { + oldServiceHasValue, oldService := oldServiceInfo.hasValue, oldServiceInfo.object() + newServiceHasValue, newService := newServiceInfo.hasValue, newServiceInfo.object() + if newService == nil { + continue + } + + t.Run(fmt.Sprintf("feature enabled=%v, old object %v, new object %v", enabled, oldServiceInfo.description, newServiceInfo.description), func(t *testing.T) { + defer utilfeaturetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.SCTPSupport, enabled)() + errs := ValidateConditionalService(newService, oldService) + // objects should never be changed + if !reflect.DeepEqual(oldService, oldServiceInfo.object()) { + t.Errorf("old object changed: %v", diff.ObjectReflectDiff(oldService, oldServiceInfo.object())) + } + if !reflect.DeepEqual(newService, newServiceInfo.object()) { + t.Errorf("new object changed: %v", diff.ObjectReflectDiff(newService, newServiceInfo.object())) + } + + switch { + case enabled || oldServiceHasValue || !newServiceHasValue: + if len(errs) > 0 { + t.Errorf("unexpected errors: %v", errs) + } + default: + if len(errs) != 1 { + t.Errorf("expected 1 error, got %v", errs) + } + } + }) + } + } + } +} + +func TestValidateEndpointsSCTP(t *testing.T) { + objectWithValue := func() *api.Endpoints { + return &api.Endpoints{ + Subsets: []api.EndpointSubset{ + {Ports: []api.EndpointPort{{Protocol: api.ProtocolSCTP}}}, + }, + } + } + objectWithoutValue := func() *api.Endpoints { + return &api.Endpoints{ + Subsets: []api.EndpointSubset{ + {Ports: []api.EndpointPort{{Protocol: api.ProtocolTCP}}}, + }, + } + } + + objectInfo := []struct { + description string + hasValue bool + object func() *api.Endpoints + }{ + { + description: "has value", + hasValue: true, + object: objectWithValue, + }, + { + description: "does not have value", + hasValue: false, + object: objectWithoutValue, + }, + { + description: "is nil", + hasValue: false, + object: func() *api.Endpoints { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldEndpointsInfo := range objectInfo { + for _, newEndpointsInfo := range objectInfo { + oldEndpointsHasValue, oldEndpoints := oldEndpointsInfo.hasValue, oldEndpointsInfo.object() + newEndpointsHasValue, newEndpoints := newEndpointsInfo.hasValue, newEndpointsInfo.object() + if newEndpoints == nil { + continue + } + + t.Run(fmt.Sprintf("feature enabled=%v, old object %v, new object %v", enabled, oldEndpointsInfo.description, newEndpointsInfo.description), func(t *testing.T) { + defer utilfeaturetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.SCTPSupport, enabled)() + errs := ValidateConditionalEndpoints(newEndpoints, oldEndpoints) + // objects should never be changed + if !reflect.DeepEqual(oldEndpoints, oldEndpointsInfo.object()) { + t.Errorf("old object changed: %v", diff.ObjectReflectDiff(oldEndpoints, oldEndpointsInfo.object())) + } + if !reflect.DeepEqual(newEndpoints, newEndpointsInfo.object()) { + t.Errorf("new object changed: %v", diff.ObjectReflectDiff(newEndpoints, newEndpointsInfo.object())) + } + + switch { + case enabled || oldEndpointsHasValue || !newEndpointsHasValue: + if len(errs) > 0 { + t.Errorf("unexpected errors: %v", errs) + } + default: + if len(errs) != 1 { + t.Errorf("expected 1 error, got %v", errs) + } + } + }) + } + } + } +} diff --git a/pkg/apis/core/validation/validation.go b/pkg/apis/core/validation/validation.go index 34b051b4694..cc843a801b6 100644 --- a/pkg/apis/core/validation/validation.go +++ b/pkg/apis/core/validation/validation.go @@ -1969,8 +1969,6 @@ func validateContainerPorts(ports []core.ContainerPort, fldPath *field.Path) fie } if len(port.Protocol) == 0 { allErrs = append(allErrs, field.Required(idxPath.Child("protocol"), "")) - } else if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && port.Protocol == core.ProtocolSCTP { - allErrs = append(allErrs, field.NotSupported(idxPath.Child("protocol"), port.Protocol, []string{string(core.ProtocolTCP), string(core.ProtocolUDP)})) } else if !supportedPortProtocols.Has(string(port.Protocol)) { allErrs = append(allErrs, field.NotSupported(idxPath.Child("protocol"), port.Protocol, supportedPortProtocols.List())) } @@ -3724,9 +3722,7 @@ func ValidateService(service *core.Service) field.ErrorList { includeProtocols := sets.NewString() for i := range service.Spec.Ports { portPath := portsPath.Index(i) - if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && service.Spec.Ports[i].Protocol == core.ProtocolSCTP { - allErrs = append(allErrs, field.NotSupported(portPath.Child("protocol"), service.Spec.Ports[i].Protocol, []string{string(core.ProtocolTCP), string(core.ProtocolUDP)})) - } else if !supportedPortProtocols.Has(string(service.Spec.Ports[i].Protocol)) { + if !supportedPortProtocols.Has(string(service.Spec.Ports[i].Protocol)) { allErrs = append(allErrs, field.Invalid(portPath.Child("protocol"), service.Spec.Ports[i].Protocol, "cannot create an external load balancer with non-TCP/UDP/SCTP ports")) } else { includeProtocols.Insert(string(service.Spec.Ports[i].Protocol)) @@ -3825,8 +3821,6 @@ func validateServicePort(sp *core.ServicePort, requireName, isHeadlessService bo if len(sp.Protocol) == 0 { allErrs = append(allErrs, field.Required(fldPath.Child("protocol"), "")) - } else if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && sp.Protocol == core.ProtocolSCTP { - allErrs = append(allErrs, field.NotSupported(fldPath.Child("protocol"), sp.Protocol, []string{string(core.ProtocolTCP), string(core.ProtocolUDP)})) } else if !supportedPortProtocols.Has(string(sp.Protocol)) { allErrs = append(allErrs, field.NotSupported(fldPath.Child("protocol"), sp.Protocol, supportedPortProtocols.List())) } @@ -5133,8 +5127,6 @@ func validateEndpointPort(port *core.EndpointPort, requireName bool, fldPath *fi } if len(port.Protocol) == 0 { allErrs = append(allErrs, field.Required(fldPath.Child("protocol"), "")) - } else if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && port.Protocol == core.ProtocolSCTP { - allErrs = append(allErrs, field.NotSupported(fldPath.Child("protocol"), port.Protocol, []string{string(core.ProtocolTCP), string(core.ProtocolUDP)})) } else if !supportedPortProtocols.Has(string(port.Protocol)) { allErrs = append(allErrs, field.NotSupported(fldPath.Child("protocol"), port.Protocol, supportedPortProtocols.List())) } diff --git a/pkg/apis/networking/validation/BUILD b/pkg/apis/networking/validation/BUILD index 42021b70aca..babded2052a 100644 --- a/pkg/apis/networking/validation/BUILD +++ b/pkg/apis/networking/validation/BUILD @@ -8,13 +8,17 @@ load( go_test( name = "go_default_test", - srcs = ["validation_test.go"], + srcs = [ + "conditional_validation_test.go", + "validation_test.go", + ], embed = [":go_default_library"], deps = [ "//pkg/apis/core:go_default_library", "//pkg/apis/networking:go_default_library", "//pkg/features:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", + "//staging/src/k8s.io/apimachinery/pkg/util/diff:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/util/intstr:go_default_library", "//staging/src/k8s.io/apiserver/pkg/util/feature:go_default_library", "//staging/src/k8s.io/apiserver/pkg/util/feature/testing:go_default_library", @@ -23,7 +27,10 @@ go_test( go_library( name = "go_default_library", - srcs = ["validation.go"], + srcs = [ + "conditional_validation.go", + "validation.go", + ], importpath = "k8s.io/kubernetes/pkg/apis/networking/validation", deps = [ "//pkg/apis/core:go_default_library", diff --git a/pkg/apis/networking/validation/conditional_validation.go b/pkg/apis/networking/validation/conditional_validation.go new file mode 100644 index 00000000000..90d746756a7 --- /dev/null +++ b/pkg/apis/networking/validation/conditional_validation.go @@ -0,0 +1,59 @@ +/* +Copyright 2019 The Kubernetes 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 validation + +import ( + "k8s.io/apimachinery/pkg/util/validation/field" + utilfeature "k8s.io/apiserver/pkg/util/feature" + api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/apis/networking" + "k8s.io/kubernetes/pkg/features" +) + +// ValidateConditionalNetworkPolicy validates conditionally valid fields. +func ValidateConditionalNetworkPolicy(np, oldNP *networking.NetworkPolicy) field.ErrorList { + var errs field.ErrorList + // If the SCTPSupport feature is disabled, and the old object isn't using the SCTP feature, prevent the new object from using it + if !utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) && len(sctpFields(oldNP)) == 0 { + for _, f := range sctpFields(np) { + errs = append(errs, field.NotSupported(f, api.ProtocolSCTP, []string{string(api.ProtocolTCP), string(api.ProtocolUDP)})) + } + } + return errs +} + +func sctpFields(np *networking.NetworkPolicy) []*field.Path { + if np == nil { + return nil + } + fields := []*field.Path{} + for iIndex, e := range np.Spec.Ingress { + for pIndex, p := range e.Ports { + if p.Protocol != nil && *p.Protocol == api.ProtocolSCTP { + fields = append(fields, field.NewPath("spec.ingress").Index(iIndex).Child("ports").Index(pIndex).Child("protocol")) + } + } + } + for eIndex, e := range np.Spec.Egress { + for pIndex, p := range e.Ports { + if p.Protocol != nil && *p.Protocol == api.ProtocolSCTP { + fields = append(fields, field.NewPath("spec.egress").Index(eIndex).Child("ports").Index(pIndex).Child("protocol")) + } + } + } + return fields +} diff --git a/pkg/apis/networking/validation/conditional_validation_test.go b/pkg/apis/networking/validation/conditional_validation_test.go new file mode 100644 index 00000000000..2cb3d89415f --- /dev/null +++ b/pkg/apis/networking/validation/conditional_validation_test.go @@ -0,0 +1,108 @@ +/* +Copyright 2019 The Kubernetes 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 validation + +import ( + "fmt" + "reflect" + "testing" + + "k8s.io/apimachinery/pkg/util/diff" + utilfeature "k8s.io/apiserver/pkg/util/feature" + utilfeaturetesting "k8s.io/apiserver/pkg/util/feature/testing" + api "k8s.io/kubernetes/pkg/apis/core" + "k8s.io/kubernetes/pkg/apis/networking" + "k8s.io/kubernetes/pkg/features" +) + +func TestValidateNetworkPolicySCTP(t *testing.T) { + sctpProtocol := api.ProtocolSCTP + tcpProtocol := api.ProtocolTCP + objectWithValue := func() *networking.NetworkPolicy { + return &networking.NetworkPolicy{ + Spec: networking.NetworkPolicySpec{ + Ingress: []networking.NetworkPolicyIngressRule{{Ports: []networking.NetworkPolicyPort{{Protocol: &sctpProtocol}}}}, + Egress: []networking.NetworkPolicyEgressRule{{Ports: []networking.NetworkPolicyPort{{Protocol: &sctpProtocol}}}}, + }, + } + } + objectWithoutValue := func() *networking.NetworkPolicy { + return &networking.NetworkPolicy{ + Spec: networking.NetworkPolicySpec{ + Ingress: []networking.NetworkPolicyIngressRule{{Ports: []networking.NetworkPolicyPort{{Protocol: &tcpProtocol}}}}, + Egress: []networking.NetworkPolicyEgressRule{{Ports: []networking.NetworkPolicyPort{{Protocol: &tcpProtocol}}}}, + }, + } + } + + objectInfo := []struct { + description string + hasValue bool + object func() *networking.NetworkPolicy + }{ + { + description: "has value", + hasValue: true, + object: objectWithValue, + }, + { + description: "does not have value", + hasValue: false, + object: objectWithoutValue, + }, + { + description: "is nil", + hasValue: false, + object: func() *networking.NetworkPolicy { return nil }, + }, + } + + for _, enabled := range []bool{true, false} { + for _, oldNetworkPolicyInfo := range objectInfo { + for _, newNetworkPolicyInfo := range objectInfo { + oldNetworkPolicyHasValue, oldNetworkPolicy := oldNetworkPolicyInfo.hasValue, oldNetworkPolicyInfo.object() + newNetworkPolicyHasValue, newNetworkPolicy := newNetworkPolicyInfo.hasValue, newNetworkPolicyInfo.object() + if newNetworkPolicy == nil { + continue + } + + t.Run(fmt.Sprintf("feature enabled=%v, old object %v, new object %v", enabled, oldNetworkPolicyInfo.description, newNetworkPolicyInfo.description), func(t *testing.T) { + defer utilfeaturetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.SCTPSupport, enabled)() + errs := ValidateConditionalNetworkPolicy(newNetworkPolicy, oldNetworkPolicy) + // objects should never be changed + if !reflect.DeepEqual(oldNetworkPolicy, oldNetworkPolicyInfo.object()) { + t.Errorf("old object changed: %v", diff.ObjectReflectDiff(oldNetworkPolicy, oldNetworkPolicyInfo.object())) + } + if !reflect.DeepEqual(newNetworkPolicy, newNetworkPolicyInfo.object()) { + t.Errorf("new object changed: %v", diff.ObjectReflectDiff(newNetworkPolicy, newNetworkPolicyInfo.object())) + } + + switch { + case enabled || oldNetworkPolicyHasValue || !newNetworkPolicyHasValue: + if len(errs) > 0 { + t.Errorf("unexpected errors: %v", errs) + } + default: + if len(errs) != 2 { + t.Errorf("expected 2 errors, got %v", errs) + } + } + }) + } + } + } +} diff --git a/pkg/apis/networking/validation/validation.go b/pkg/apis/networking/validation/validation.go index 0e012f36644..c36932e44d0 100644 --- a/pkg/apis/networking/validation/validation.go +++ b/pkg/apis/networking/validation/validation.go @@ -23,11 +23,9 @@ import ( "k8s.io/apimachinery/pkg/util/sets" "k8s.io/apimachinery/pkg/util/validation" "k8s.io/apimachinery/pkg/util/validation/field" - utilfeature "k8s.io/apiserver/pkg/util/feature" api "k8s.io/kubernetes/pkg/apis/core" apivalidation "k8s.io/kubernetes/pkg/apis/core/validation" "k8s.io/kubernetes/pkg/apis/networking" - "k8s.io/kubernetes/pkg/features" ) // ValidateNetworkPolicyName can be used to check whether the given networkpolicy @@ -39,12 +37,8 @@ func ValidateNetworkPolicyName(name string, prefix bool) []string { // ValidateNetworkPolicyPort validates a NetworkPolicyPort func ValidateNetworkPolicyPort(port *networking.NetworkPolicyPort, portPath *field.Path) field.ErrorList { allErrs := field.ErrorList{} - if utilfeature.DefaultFeatureGate.Enabled(features.SCTPSupport) { - if port.Protocol != nil && *port.Protocol != api.ProtocolTCP && *port.Protocol != api.ProtocolUDP && *port.Protocol != api.ProtocolSCTP { - allErrs = append(allErrs, field.NotSupported(portPath.Child("protocol"), *port.Protocol, []string{string(api.ProtocolTCP), string(api.ProtocolUDP), string(api.ProtocolSCTP)})) - } - } else if port.Protocol != nil && *port.Protocol != api.ProtocolTCP && *port.Protocol != api.ProtocolUDP { - allErrs = append(allErrs, field.NotSupported(portPath.Child("protocol"), *port.Protocol, []string{string(api.ProtocolTCP), string(api.ProtocolUDP)})) + if port.Protocol != nil && *port.Protocol != api.ProtocolTCP && *port.Protocol != api.ProtocolUDP && *port.Protocol != api.ProtocolSCTP { + allErrs = append(allErrs, field.NotSupported(portPath.Child("protocol"), *port.Protocol, []string{string(api.ProtocolTCP), string(api.ProtocolUDP), string(api.ProtocolSCTP)})) } if port.Port != nil { if port.Port.Type == intstr.Int { From 4271384966e34baddabda61e370311e9ea4bbf6c Mon Sep 17 00:00:00 2001 From: Jordan Liggitt Date: Tue, 5 Feb 2019 21:57:16 -0500 Subject: [PATCH 2/2] Call conditional validation from create/update strategies --- pkg/registry/apps/daemonset/BUILD | 1 + pkg/registry/apps/daemonset/strategy.go | 6 +++++- pkg/registry/apps/deployment/BUILD | 1 + pkg/registry/apps/deployment/strategy.go | 6 +++++- pkg/registry/apps/replicaset/BUILD | 1 + pkg/registry/apps/replicaset/strategy.go | 6 +++++- pkg/registry/apps/statefulset/BUILD | 1 + pkg/registry/apps/statefulset/strategy.go | 12 +++++++++--- pkg/registry/batch/cronjob/BUILD | 1 + pkg/registry/batch/cronjob/strategy.go | 14 ++++++++++++-- pkg/registry/batch/job/BUILD | 1 + pkg/registry/batch/job/strategy.go | 12 +++++++++--- pkg/registry/core/endpoint/strategy.go | 8 ++++++-- pkg/registry/core/pod/strategy.go | 8 ++++++-- pkg/registry/core/podtemplate/strategy.go | 13 ++++++++++--- .../core/replicationcontroller/strategy.go | 5 ++++- pkg/registry/core/service/strategy.go | 8 ++++++-- pkg/registry/networking/networkpolicy/strategy.go | 5 ++++- 18 files changed, 87 insertions(+), 22 deletions(-) diff --git a/pkg/registry/apps/daemonset/BUILD b/pkg/registry/apps/daemonset/BUILD index 68ae8aefac1..97fd09d50ad 100644 --- a/pkg/registry/apps/daemonset/BUILD +++ b/pkg/registry/apps/daemonset/BUILD @@ -18,6 +18,7 @@ go_library( "//pkg/api/pod:go_default_library", "//pkg/apis/apps:go_default_library", "//pkg/apis/apps/validation:go_default_library", + "//pkg/apis/core/validation:go_default_library", "//staging/src/k8s.io/api/apps/v1beta2:go_default_library", "//staging/src/k8s.io/api/extensions/v1beta1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/api/equality:go_default_library", diff --git a/pkg/registry/apps/daemonset/strategy.go b/pkg/registry/apps/daemonset/strategy.go index 4edba00eec9..cb621d695af 100644 --- a/pkg/registry/apps/daemonset/strategy.go +++ b/pkg/registry/apps/daemonset/strategy.go @@ -33,6 +33,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/apps/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" ) // daemonSetStrategy implements verification logic for daemon sets. @@ -115,7 +116,9 @@ func (daemonSetStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime. // Validate validates a new daemon set. func (daemonSetStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { daemonSet := obj.(*apps.DaemonSet) - return validation.ValidateDaemonSet(daemonSet) + allErrs := validation.ValidateDaemonSet(daemonSet) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&daemonSet.Spec.Template, nil, field.NewPath("spec.template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -134,6 +137,7 @@ func (daemonSetStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Ob oldDaemonSet := old.(*apps.DaemonSet) allErrs := validation.ValidateDaemonSet(obj.(*apps.DaemonSet)) allErrs = append(allErrs, validation.ValidateDaemonSetUpdate(newDaemonSet, oldDaemonSet)...) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&newDaemonSet.Spec.Template, &oldDaemonSet.Spec.Template, field.NewPath("spec.template"))...) // Update is not allowed to set Spec.Selector for apps/v1 and apps/v1beta2 (allowed for extensions/v1beta1). // If RequestInfo is nil, it is better to revert to old behavior (i.e. allow update to set Spec.Selector) diff --git a/pkg/registry/apps/deployment/BUILD b/pkg/registry/apps/deployment/BUILD index 1ba9a291035..8e67835fde4 100644 --- a/pkg/registry/apps/deployment/BUILD +++ b/pkg/registry/apps/deployment/BUILD @@ -18,6 +18,7 @@ go_library( "//pkg/api/pod:go_default_library", "//pkg/apis/apps:go_default_library", "//pkg/apis/apps/validation:go_default_library", + "//pkg/apis/core/validation:go_default_library", "//staging/src/k8s.io/api/apps/v1beta1:go_default_library", "//staging/src/k8s.io/api/apps/v1beta2:go_default_library", "//staging/src/k8s.io/api/extensions/v1beta1:go_default_library", diff --git a/pkg/registry/apps/deployment/strategy.go b/pkg/registry/apps/deployment/strategy.go index f5e9cfe7115..6477a05c906 100644 --- a/pkg/registry/apps/deployment/strategy.go +++ b/pkg/registry/apps/deployment/strategy.go @@ -34,6 +34,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/apps/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" ) // deploymentStrategy implements behavior for Deployments. @@ -79,7 +80,9 @@ func (deploymentStrategy) PrepareForCreate(ctx context.Context, obj runtime.Obje // Validate validates a new deployment. func (deploymentStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { deployment := obj.(*apps.Deployment) - return validation.ValidateDeployment(deployment) + allErrs := validation.ValidateDeployment(deployment) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&deployment.Spec.Template, nil, field.NewPath("spec.template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -113,6 +116,7 @@ func (deploymentStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.O newDeployment := obj.(*apps.Deployment) oldDeployment := old.(*apps.Deployment) allErrs := validation.ValidateDeploymentUpdate(newDeployment, oldDeployment) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&newDeployment.Spec.Template, &oldDeployment.Spec.Template, field.NewPath("spec.template"))...) // Update is not allowed to set Spec.Selector for all groups/versions except extensions/v1beta1. // If RequestInfo is nil, it is better to revert to old behavior (i.e. allow update to set Spec.Selector) diff --git a/pkg/registry/apps/replicaset/BUILD b/pkg/registry/apps/replicaset/BUILD index bce7b57ba80..5784b261e9b 100644 --- a/pkg/registry/apps/replicaset/BUILD +++ b/pkg/registry/apps/replicaset/BUILD @@ -18,6 +18,7 @@ go_library( "//pkg/api/pod:go_default_library", "//pkg/apis/apps:go_default_library", "//pkg/apis/apps/validation:go_default_library", + "//pkg/apis/core/validation:go_default_library", "//staging/src/k8s.io/api/apps/v1beta2:go_default_library", "//staging/src/k8s.io/api/extensions/v1beta1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/api/equality:go_default_library", diff --git a/pkg/registry/apps/replicaset/strategy.go b/pkg/registry/apps/replicaset/strategy.go index 57aa5ab81ca..2c83176876f 100644 --- a/pkg/registry/apps/replicaset/strategy.go +++ b/pkg/registry/apps/replicaset/strategy.go @@ -41,6 +41,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/apps/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" ) // rsStrategy implements verification logic for ReplicaSets. @@ -108,7 +109,9 @@ func (rsStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) // Validate validates a new ReplicaSet. func (rsStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { rs := obj.(*apps.ReplicaSet) - return validation.ValidateReplicaSet(rs) + allErrs := validation.ValidateReplicaSet(rs) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&rs.Spec.Template, nil, field.NewPath("spec.template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -127,6 +130,7 @@ func (rsStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) f oldReplicaSet := old.(*apps.ReplicaSet) allErrs := validation.ValidateReplicaSet(obj.(*apps.ReplicaSet)) allErrs = append(allErrs, validation.ValidateReplicaSetUpdate(newReplicaSet, oldReplicaSet)...) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&newReplicaSet.Spec.Template, &oldReplicaSet.Spec.Template, field.NewPath("spec.template"))...) // Update is not allowed to set Spec.Selector for all groups/versions except extensions/v1beta1. // If RequestInfo is nil, it is better to revert to old behavior (i.e. allow update to set Spec.Selector) diff --git a/pkg/registry/apps/statefulset/BUILD b/pkg/registry/apps/statefulset/BUILD index 91d62f93092..b20cedbfc39 100644 --- a/pkg/registry/apps/statefulset/BUILD +++ b/pkg/registry/apps/statefulset/BUILD @@ -18,6 +18,7 @@ go_library( "//pkg/api/pod:go_default_library", "//pkg/apis/apps:go_default_library", "//pkg/apis/apps/validation:go_default_library", + "//pkg/apis/core/validation:go_default_library", "//staging/src/k8s.io/api/apps/v1beta1:go_default_library", "//staging/src/k8s.io/api/apps/v1beta2:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/api/equality:go_default_library", diff --git a/pkg/registry/apps/statefulset/strategy.go b/pkg/registry/apps/statefulset/strategy.go index c3dc71d1188..2925702fe41 100644 --- a/pkg/registry/apps/statefulset/strategy.go +++ b/pkg/registry/apps/statefulset/strategy.go @@ -32,6 +32,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" "k8s.io/kubernetes/pkg/apis/apps" "k8s.io/kubernetes/pkg/apis/apps/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" ) // statefulSetStrategy implements verification logic for Replication StatefulSets. @@ -96,7 +97,9 @@ func (statefulSetStrategy) PrepareForUpdate(ctx context.Context, obj, old runtim // Validate validates a new StatefulSet. func (statefulSetStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { statefulSet := obj.(*apps.StatefulSet) - return validation.ValidateStatefulSet(statefulSet) + allErrs := validation.ValidateStatefulSet(statefulSet) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&statefulSet.Spec.Template, nil, field.NewPath("spec.template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -110,8 +113,11 @@ func (statefulSetStrategy) AllowCreateOnUpdate() bool { // ValidateUpdate is the default update validation for an end user. func (statefulSetStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { - validationErrorList := validation.ValidateStatefulSet(obj.(*apps.StatefulSet)) - updateErrorList := validation.ValidateStatefulSetUpdate(obj.(*apps.StatefulSet), old.(*apps.StatefulSet)) + newStatefulSet := obj.(*apps.StatefulSet) + oldStatefulSet := old.(*apps.StatefulSet) + validationErrorList := validation.ValidateStatefulSet(newStatefulSet) + updateErrorList := validation.ValidateStatefulSetUpdate(newStatefulSet, oldStatefulSet) + updateErrorList = append(updateErrorList, corevalidation.ValidateConditionalPodTemplate(&newStatefulSet.Spec.Template, &oldStatefulSet.Spec.Template, field.NewPath("spec.template"))...) return append(validationErrorList, updateErrorList...) } diff --git a/pkg/registry/batch/cronjob/BUILD b/pkg/registry/batch/cronjob/BUILD index 40cc472645c..f92330d56ad 100644 --- a/pkg/registry/batch/cronjob/BUILD +++ b/pkg/registry/batch/cronjob/BUILD @@ -18,6 +18,7 @@ go_library( "//pkg/api/pod:go_default_library", "//pkg/apis/batch:go_default_library", "//pkg/apis/batch/validation:go_default_library", + "//pkg/apis/core/validation:go_default_library", "//staging/src/k8s.io/api/batch/v1beta1:go_default_library", "//staging/src/k8s.io/api/batch/v2alpha1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library", diff --git a/pkg/registry/batch/cronjob/strategy.go b/pkg/registry/batch/cronjob/strategy.go index d23a5cdbdf2..a261bc548de 100644 --- a/pkg/registry/batch/cronjob/strategy.go +++ b/pkg/registry/batch/cronjob/strategy.go @@ -31,6 +31,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/batch/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" ) // cronJobStrategy implements verification logic for Replication Controllers. @@ -83,7 +84,9 @@ func (cronJobStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Ob // Validate validates a new scheduled job. func (cronJobStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { cronJob := obj.(*batch.CronJob) - return validation.ValidateCronJob(cronJob) + allErrs := validation.ValidateCronJob(cronJob) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&cronJob.Spec.JobTemplate.Spec.Template, nil, field.NewPath("spec.jobTemplate.spec.template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -101,7 +104,14 @@ func (cronJobStrategy) AllowCreateOnUpdate() bool { // ValidateUpdate is the default update validation for an end user. func (cronJobStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { - return validation.ValidateCronJobUpdate(obj.(*batch.CronJob), old.(*batch.CronJob)) + newCronJob := obj.(*batch.CronJob) + oldCronJob := old.(*batch.CronJob) + allErrs := validation.ValidateCronJobUpdate(newCronJob, oldCronJob) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate( + &newCronJob.Spec.JobTemplate.Spec.Template, + &oldCronJob.Spec.JobTemplate.Spec.Template, + field.NewPath("spec.jobTemplate.spec.template"))...) + return allErrs } type cronJobStatusStrategy struct { diff --git a/pkg/registry/batch/job/BUILD b/pkg/registry/batch/job/BUILD index d61f5bae717..b70fed923a1 100644 --- a/pkg/registry/batch/job/BUILD +++ b/pkg/registry/batch/job/BUILD @@ -18,6 +18,7 @@ go_library( "//pkg/api/pod:go_default_library", "//pkg/apis/batch:go_default_library", "//pkg/apis/batch/validation:go_default_library", + "//pkg/apis/core/validation:go_default_library", "//pkg/features:go_default_library", "//staging/src/k8s.io/api/batch/v1:go_default_library", "//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library", diff --git a/pkg/registry/batch/job/strategy.go b/pkg/registry/batch/job/strategy.go index 4f4acaa5cfd..e6ece3d538d 100644 --- a/pkg/registry/batch/job/strategy.go +++ b/pkg/registry/batch/job/strategy.go @@ -38,6 +38,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" "k8s.io/kubernetes/pkg/apis/batch" "k8s.io/kubernetes/pkg/apis/batch/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" "k8s.io/kubernetes/pkg/features" ) @@ -103,7 +104,9 @@ func (jobStrategy) Validate(ctx context.Context, obj runtime.Object) field.Error if job.Spec.ManualSelector == nil || *job.Spec.ManualSelector == false { generateSelector(job) } - return validation.ValidateJob(job) + allErrs := validation.ValidateJob(job) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&job.Spec.Template, nil, field.NewPath("spec.template"))...) + return allErrs } // generateSelector adds a selector to a job and labels to its template @@ -171,8 +174,11 @@ func (jobStrategy) AllowCreateOnUpdate() bool { // ValidateUpdate is the default update validation for an end user. func (jobStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { - validationErrorList := validation.ValidateJob(obj.(*batch.Job)) - updateErrorList := validation.ValidateJobUpdate(obj.(*batch.Job), old.(*batch.Job)) + job := obj.(*batch.Job) + oldJob := old.(*batch.Job) + validationErrorList := validation.ValidateJob(job) + updateErrorList := validation.ValidateJobUpdate(job, oldJob) + updateErrorList = append(updateErrorList, corevalidation.ValidateConditionalPodTemplate(&job.Spec.Template, &oldJob.Spec.Template, field.NewPath("spec.template"))...) return append(validationErrorList, updateErrorList...) } diff --git a/pkg/registry/core/endpoint/strategy.go b/pkg/registry/core/endpoint/strategy.go index bd6ede7cd87..3b90fe6afd2 100644 --- a/pkg/registry/core/endpoint/strategy.go +++ b/pkg/registry/core/endpoint/strategy.go @@ -53,7 +53,9 @@ func (endpointsStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime. // Validate validates a new endpoints. func (endpointsStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { - return validation.ValidateEndpoints(obj.(*api.Endpoints)) + allErrs := validation.ValidateEndpoints(obj.(*api.Endpoints)) + allErrs = append(allErrs, validation.ValidateConditionalEndpoints(obj.(*api.Endpoints), nil)...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -70,7 +72,9 @@ func (endpointsStrategy) AllowCreateOnUpdate() bool { // ValidateUpdate is the default update validation for an end user. func (endpointsStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { errorList := validation.ValidateEndpoints(obj.(*api.Endpoints)) - return append(errorList, validation.ValidateEndpointsUpdate(obj.(*api.Endpoints), old.(*api.Endpoints))...) + errorList = append(errorList, validation.ValidateEndpointsUpdate(obj.(*api.Endpoints), old.(*api.Endpoints))...) + errorList = append(errorList, validation.ValidateConditionalEndpoints(obj.(*api.Endpoints), old.(*api.Endpoints))...) + return errorList } func (endpointsStrategy) AllowUnconditionalUpdate() bool { diff --git a/pkg/registry/core/pod/strategy.go b/pkg/registry/core/pod/strategy.go index eed0d70b861..086b0850d51 100644 --- a/pkg/registry/core/pod/strategy.go +++ b/pkg/registry/core/pod/strategy.go @@ -84,7 +84,9 @@ func (podStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object // Validate validates a new pod. func (podStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { pod := obj.(*api.Pod) - return validation.ValidatePod(pod) + allErrs := validation.ValidatePod(pod) + allErrs = append(allErrs, validation.ValidateConditionalPod(pod, nil, field.NewPath(""))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -99,7 +101,9 @@ func (podStrategy) AllowCreateOnUpdate() bool { // ValidateUpdate is the default update validation for an end user. func (podStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { errorList := validation.ValidatePod(obj.(*api.Pod)) - return append(errorList, validation.ValidatePodUpdate(obj.(*api.Pod), old.(*api.Pod))...) + errorList = append(errorList, validation.ValidatePodUpdate(obj.(*api.Pod), old.(*api.Pod))...) + errorList = append(errorList, validation.ValidateConditionalPod(obj.(*api.Pod), old.(*api.Pod), field.NewPath(""))...) + return errorList } // AllowUnconditionalUpdate allows pods to be overwritten diff --git a/pkg/registry/core/podtemplate/strategy.go b/pkg/registry/core/podtemplate/strategy.go index 8ce614cbf3d..ef18f87effb 100644 --- a/pkg/registry/core/podtemplate/strategy.go +++ b/pkg/registry/core/podtemplate/strategy.go @@ -26,6 +26,7 @@ import ( "k8s.io/kubernetes/pkg/api/pod" api "k8s.io/kubernetes/pkg/apis/core" "k8s.io/kubernetes/pkg/apis/core/validation" + corevalidation "k8s.io/kubernetes/pkg/apis/core/validation" ) // podTemplateStrategy implements behavior for PodTemplates @@ -52,8 +53,10 @@ func (podTemplateStrategy) PrepareForCreate(ctx context.Context, obj runtime.Obj // Validate validates a new pod template. func (podTemplateStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { - pod := obj.(*api.PodTemplate) - return validation.ValidatePodTemplate(pod) + template := obj.(*api.PodTemplate) + allErrs := validation.ValidatePodTemplate(template) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&template.Template, nil, field.NewPath("template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -75,7 +78,11 @@ func (podTemplateStrategy) PrepareForUpdate(ctx context.Context, obj, old runtim // ValidateUpdate is the default update validation for an end user. func (podTemplateStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { - return validation.ValidatePodTemplateUpdate(obj.(*api.PodTemplate), old.(*api.PodTemplate)) + template := obj.(*api.PodTemplate) + oldTemplate := old.(*api.PodTemplate) + allErrs := validation.ValidatePodTemplateUpdate(template, oldTemplate) + allErrs = append(allErrs, corevalidation.ValidateConditionalPodTemplate(&template.Template, &oldTemplate.Template, field.NewPath("template"))...) + return allErrs } func (podTemplateStrategy) AllowUnconditionalUpdate() bool { diff --git a/pkg/registry/core/replicationcontroller/strategy.go b/pkg/registry/core/replicationcontroller/strategy.go index 9a718f2a26a..f52bab09358 100644 --- a/pkg/registry/core/replicationcontroller/strategy.go +++ b/pkg/registry/core/replicationcontroller/strategy.go @@ -108,7 +108,9 @@ func (rcStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object) // Validate validates a new replication controller. func (rcStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { controller := obj.(*api.ReplicationController) - return validation.ValidateReplicationController(controller) + allErrs := validation.ValidateReplicationController(controller) + allErrs = append(allErrs, validation.ValidateConditionalPodTemplate(controller.Spec.Template, nil, field.NewPath("spec.template"))...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -128,6 +130,7 @@ func (rcStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) f validationErrorList := validation.ValidateReplicationController(newRc) updateErrorList := validation.ValidateReplicationControllerUpdate(newRc, oldRc) + updateErrorList = append(updateErrorList, validation.ValidateConditionalPodTemplate(newRc.Spec.Template, oldRc.Spec.Template, field.NewPath("spec.template"))...) errs := append(validationErrorList, updateErrorList...) for key, value := range helper.NonConvertibleFields(oldRc.Annotations) { diff --git a/pkg/registry/core/service/strategy.go b/pkg/registry/core/service/strategy.go index 71cdda7f1c5..d296a613116 100644 --- a/pkg/registry/core/service/strategy.go +++ b/pkg/registry/core/service/strategy.go @@ -59,7 +59,9 @@ func (svcStrategy) PrepareForUpdate(ctx context.Context, obj, old runtime.Object // Validate validates a new service. func (svcStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { service := obj.(*api.Service) - return validation.ValidateService(service) + allErrs := validation.ValidateService(service) + allErrs = append(allErrs, validation.ValidateConditionalService(service, nil)...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -71,7 +73,9 @@ func (svcStrategy) AllowCreateOnUpdate() bool { } func (svcStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { - return validation.ValidateServiceUpdate(obj.(*api.Service), old.(*api.Service)) + allErrs := validation.ValidateServiceUpdate(obj.(*api.Service), old.(*api.Service)) + allErrs = append(allErrs, validation.ValidateConditionalService(obj.(*api.Service), old.(*api.Service))...) + return allErrs } func (svcStrategy) AllowUnconditionalUpdate() bool { diff --git a/pkg/registry/networking/networkpolicy/strategy.go b/pkg/registry/networking/networkpolicy/strategy.go index 8dc3ea7edea..521c37585b8 100644 --- a/pkg/registry/networking/networkpolicy/strategy.go +++ b/pkg/registry/networking/networkpolicy/strategy.go @@ -64,7 +64,9 @@ func (networkPolicyStrategy) PrepareForUpdate(ctx context.Context, obj, old runt // Validate validates a new NetworkPolicy. func (networkPolicyStrategy) Validate(ctx context.Context, obj runtime.Object) field.ErrorList { networkPolicy := obj.(*networking.NetworkPolicy) - return validation.ValidateNetworkPolicy(networkPolicy) + allErrs := validation.ValidateNetworkPolicy(networkPolicy) + allErrs = append(allErrs, validation.ValidateConditionalNetworkPolicy(networkPolicy, nil)...) + return allErrs } // Canonicalize normalizes the object after validation. @@ -79,6 +81,7 @@ func (networkPolicyStrategy) AllowCreateOnUpdate() bool { func (networkPolicyStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList { validationErrorList := validation.ValidateNetworkPolicy(obj.(*networking.NetworkPolicy)) updateErrorList := validation.ValidateNetworkPolicyUpdate(obj.(*networking.NetworkPolicy), old.(*networking.NetworkPolicy)) + updateErrorList = append(updateErrorList, validation.ValidateConditionalNetworkPolicy(obj.(*networking.NetworkPolicy), old.(*networking.NetworkPolicy))...) return append(validationErrorList, updateErrorList...) }