github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2026-07-17 11:28:58 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #137678 from aaron-prindle/flowcontrol-discriminator-and-member-dv-migration

Browse Source 
feat: flowcontrol LimitResponse and PriorityLevelConfigurationSpec discriminator and member dv migration
This commit is contained in:
Kubernetes Prow Robot
2026-03-16 09:15:37 +05:30
committed by GitHub
parent a274c27dd3 ccaab0cfd1
commit 8cfc85428a
20 changed files with 1717 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
pkg/apis/flowcontrol/v1/doc.go
View File

@@ -18,6 +18,8 @@ limitations under the License.
// +k8s:conversion-gen-external-types=k8s.io/api/flowcontrol/v1
// +k8s:defaulter-gen=TypeMeta
// +k8s:defaulter-gen-input=k8s.io/api/flowcontrol/v1
// +k8s:validation-gen=TypeMeta
// +k8s:validation-gen-input=k8s.io/api/flowcontrol/v1
// +groupName=flowcontrol.apiserver.k8s.io

325
pkg/apis/flowcontrol/v1/zz_generated.validations.go generated Normal file
View File

@@ -0,0 +1,325 @@
//go:build !ignore_autogenerated
// +build !ignore_autogenerated
/*
Copyright 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.
*/
// Code generated by validation-gen. DO NOT EDIT.
package v1
import (
context "context"
fmt "fmt"
flowcontrolv1 "k8s.io/api/flowcontrol/v1"
equality "k8s.io/apimachinery/pkg/api/equality"
operation "k8s.io/apimachinery/pkg/api/operation"
safe "k8s.io/apimachinery/pkg/api/safe"
validate "k8s.io/apimachinery/pkg/api/validate"
runtime "k8s.io/apimachinery/pkg/runtime"
field "k8s.io/apimachinery/pkg/util/validation/field"
)
func init() { localSchemeBuilder.Register(RegisterValidations) }
// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
// type PriorityLevelConfiguration
scheme.AddValidationFunc((*flowcontrolv1.PriorityLevelConfiguration)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
switch op.Request.SubresourcePath() {
case "/":
return Validate_PriorityLevelConfiguration(ctx, op, nil /* fldPath */, obj.(*flowcontrolv1.PriorityLevelConfiguration), safe.Cast[*flowcontrolv1.PriorityLevelConfiguration](oldObj))
}
return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
})
return nil
}
// Validate_LimitResponse validates an instance of LimitResponse according
// to declarative validation rules in the API schema.
func Validate_LimitResponse(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitResponse) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "queuing", func(obj *flowcontrolv1.LimitResponse) *flowcontrolv1.QueuingConfiguration { return obj.Queuing }, func(obj *flowcontrolv1.LimitResponse) flowcontrolv1.LimitResponseType { return obj.Type }, validate.DirectEqualPtr, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1.QueuingConfiguration, flowcontrolv1.LimitResponseType]{
{
Value: "Queue", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Reject", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1.LimitResponse.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitResponseType, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1.LimitResponse) *flowcontrolv1.LimitResponseType { return &oldObj.Type }), oldObj != nil)...)
// field flowcontrolv1.LimitResponse.Queuing
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.QueuingConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("queuing"), obj.Queuing, safe.Field(oldObj, func(oldObj *flowcontrolv1.LimitResponse) *flowcontrolv1.QueuingConfiguration { return oldObj.Queuing }), oldObj != nil)...)
return errs
}
// Validate_LimitedPriorityLevelConfiguration validates an instance of LimitedPriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_LimitedPriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitedPriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1.LimitedPriorityLevelConfiguration.NominalConcurrencyShares has no validation
// field flowcontrolv1.LimitedPriorityLevelConfiguration.LimitResponse
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitResponse, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_LimitResponse(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limitResponse"), &obj.LimitResponse, safe.Field(oldObj, func(oldObj *flowcontrolv1.LimitedPriorityLevelConfiguration) *flowcontrolv1.LimitResponse {
return &oldObj.LimitResponse
}), oldObj != nil)...)
// field flowcontrolv1.LimitedPriorityLevelConfiguration.LendablePercent has no validation
// field flowcontrolv1.LimitedPriorityLevelConfiguration.BorrowingLimitPercent has no validation
return errs
}
// Validate_PriorityLevelConfiguration validates an instance of PriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.PriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1.PriorityLevelConfiguration.TypeMeta has no validation
// field flowcontrolv1.PriorityLevelConfiguration.ObjectMeta has no validation
// field flowcontrolv1.PriorityLevelConfiguration.Spec
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.PriorityLevelConfigurationSpec, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_PriorityLevelConfigurationSpec(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *flowcontrolv1.PriorityLevelConfiguration) *flowcontrolv1.PriorityLevelConfigurationSpec {
return &oldObj.Spec
}), oldObj != nil)...)
// field flowcontrolv1.PriorityLevelConfiguration.Status has no validation
return errs
}
// Validate_PriorityLevelConfigurationSpec validates an instance of PriorityLevelConfigurationSpec according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfigurationSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.PriorityLevelConfigurationSpec) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "exempt", func(obj *flowcontrolv1.PriorityLevelConfigurationSpec) *flowcontrolv1.ExemptPriorityLevelConfiguration {
return obj.Exempt
}, func(obj *flowcontrolv1.PriorityLevelConfigurationSpec) flowcontrolv1.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1.ExemptPriorityLevelConfiguration, flowcontrolv1.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "limited", func(obj *flowcontrolv1.PriorityLevelConfigurationSpec) *flowcontrolv1.LimitedPriorityLevelConfiguration {
return obj.Limited
}, func(obj *flowcontrolv1.PriorityLevelConfigurationSpec) flowcontrolv1.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1.LimitedPriorityLevelConfiguration, flowcontrolv1.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1.PriorityLevelConfigurationSpec.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.PriorityLevelEnablement, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1.PriorityLevelConfigurationSpec) *flowcontrolv1.PriorityLevelEnablement {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1.PriorityLevelConfigurationSpec.Limited
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.LimitedPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
// call the type's validation function
errs = append(errs, Validate_LimitedPriorityLevelConfiguration(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limited"), obj.Limited, safe.Field(oldObj, func(oldObj *flowcontrolv1.PriorityLevelConfigurationSpec) *flowcontrolv1.LimitedPriorityLevelConfiguration {
return oldObj.Limited
}), oldObj != nil)...)
// field flowcontrolv1.PriorityLevelConfigurationSpec.Exempt
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1.ExemptPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("exempt"), obj.Exempt, safe.Field(oldObj, func(oldObj *flowcontrolv1.PriorityLevelConfigurationSpec) *flowcontrolv1.ExemptPriorityLevelConfiguration {
return oldObj.Exempt
}), oldObj != nil)...)
return errs
}

2
pkg/apis/flowcontrol/v1beta1/doc.go
View File

@@ -18,6 +18,8 @@ limitations under the License.
// +k8s:conversion-gen-external-types=k8s.io/api/flowcontrol/v1beta1
// +k8s:defaulter-gen=TypeMeta
// +k8s:defaulter-gen-input=k8s.io/api/flowcontrol/v1beta1
// +k8s:validation-gen=TypeMeta
// +k8s:validation-gen-input=k8s.io/api/flowcontrol/v1beta1
// +groupName=flowcontrol.apiserver.k8s.io

331
pkg/apis/flowcontrol/v1beta1/zz_generated.validations.go generated Normal file
View File

@@ -0,0 +1,331 @@
//go:build !ignore_autogenerated
// +build !ignore_autogenerated
/*
Copyright 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.
*/
// Code generated by validation-gen. DO NOT EDIT.
package v1beta1
import (
context "context"
fmt "fmt"
flowcontrolv1beta1 "k8s.io/api/flowcontrol/v1beta1"
equality "k8s.io/apimachinery/pkg/api/equality"
operation "k8s.io/apimachinery/pkg/api/operation"
safe "k8s.io/apimachinery/pkg/api/safe"
validate "k8s.io/apimachinery/pkg/api/validate"
runtime "k8s.io/apimachinery/pkg/runtime"
field "k8s.io/apimachinery/pkg/util/validation/field"
)
func init() { localSchemeBuilder.Register(RegisterValidations) }
// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
// type PriorityLevelConfiguration
scheme.AddValidationFunc((*flowcontrolv1beta1.PriorityLevelConfiguration)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
switch op.Request.SubresourcePath() {
case "/":
return Validate_PriorityLevelConfiguration(ctx, op, nil /* fldPath */, obj.(*flowcontrolv1beta1.PriorityLevelConfiguration), safe.Cast[*flowcontrolv1beta1.PriorityLevelConfiguration](oldObj))
}
return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
})
return nil
}
// Validate_LimitResponse validates an instance of LimitResponse according
// to declarative validation rules in the API schema.
func Validate_LimitResponse(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitResponse) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "queuing", func(obj *flowcontrolv1beta1.LimitResponse) *flowcontrolv1beta1.QueuingConfiguration {
return obj.Queuing
}, func(obj *flowcontrolv1beta1.LimitResponse) flowcontrolv1beta1.LimitResponseType { return obj.Type }, validate.DirectEqualPtr, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta1.QueuingConfiguration, flowcontrolv1beta1.LimitResponseType]{
{
Value: "Queue", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Reject", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1beta1.LimitResponse.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitResponseType, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.LimitResponse) *flowcontrolv1beta1.LimitResponseType {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1beta1.LimitResponse.Queuing
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.QueuingConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("queuing"), obj.Queuing, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.LimitResponse) *flowcontrolv1beta1.QueuingConfiguration {
return oldObj.Queuing
}), oldObj != nil)...)
return errs
}
// Validate_LimitedPriorityLevelConfiguration validates an instance of LimitedPriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_LimitedPriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1beta1.LimitedPriorityLevelConfiguration.AssuredConcurrencyShares has no validation
// field flowcontrolv1beta1.LimitedPriorityLevelConfiguration.LimitResponse
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitResponse, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_LimitResponse(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limitResponse"), &obj.LimitResponse, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) *flowcontrolv1beta1.LimitResponse {
return &oldObj.LimitResponse
}), oldObj != nil)...)
// field flowcontrolv1beta1.LimitedPriorityLevelConfiguration.LendablePercent has no validation
// field flowcontrolv1beta1.LimitedPriorityLevelConfiguration.BorrowingLimitPercent has no validation
return errs
}
// Validate_PriorityLevelConfiguration validates an instance of PriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.PriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1beta1.PriorityLevelConfiguration.TypeMeta has no validation
// field flowcontrolv1beta1.PriorityLevelConfiguration.ObjectMeta has no validation
// field flowcontrolv1beta1.PriorityLevelConfiguration.Spec
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.PriorityLevelConfigurationSpec, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_PriorityLevelConfigurationSpec(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.PriorityLevelConfiguration) *flowcontrolv1beta1.PriorityLevelConfigurationSpec {
return &oldObj.Spec
}), oldObj != nil)...)
// field flowcontrolv1beta1.PriorityLevelConfiguration.Status has no validation
return errs
}
// Validate_PriorityLevelConfigurationSpec validates an instance of PriorityLevelConfigurationSpec according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfigurationSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "exempt", func(obj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) *flowcontrolv1beta1.ExemptPriorityLevelConfiguration {
return obj.Exempt
}, func(obj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) flowcontrolv1beta1.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta1.ExemptPriorityLevelConfiguration, flowcontrolv1beta1.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "limited", func(obj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) *flowcontrolv1beta1.LimitedPriorityLevelConfiguration {
return obj.Limited
}, func(obj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) flowcontrolv1beta1.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta1.LimitedPriorityLevelConfiguration, flowcontrolv1beta1.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1beta1.PriorityLevelConfigurationSpec.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.PriorityLevelEnablement, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) *flowcontrolv1beta1.PriorityLevelEnablement {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1beta1.PriorityLevelConfigurationSpec.Limited
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.LimitedPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
// call the type's validation function
errs = append(errs, Validate_LimitedPriorityLevelConfiguration(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limited"), obj.Limited, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) *flowcontrolv1beta1.LimitedPriorityLevelConfiguration {
return oldObj.Limited
}), oldObj != nil)...)
// field flowcontrolv1beta1.PriorityLevelConfigurationSpec.Exempt
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta1.ExemptPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("exempt"), obj.Exempt, safe.Field(oldObj, func(oldObj *flowcontrolv1beta1.PriorityLevelConfigurationSpec) *flowcontrolv1beta1.ExemptPriorityLevelConfiguration {
return oldObj.Exempt
}), oldObj != nil)...)
return errs
}

2
pkg/apis/flowcontrol/v1beta2/doc.go
View File

@@ -18,6 +18,8 @@ limitations under the License.
// +k8s:conversion-gen-external-types=k8s.io/api/flowcontrol/v1beta2
// +k8s:defaulter-gen=TypeMeta
// +k8s:defaulter-gen-input=k8s.io/api/flowcontrol/v1beta2
// +k8s:validation-gen=TypeMeta
// +k8s:validation-gen-input=k8s.io/api/flowcontrol/v1beta2
// +groupName=flowcontrol.apiserver.k8s.io

331
pkg/apis/flowcontrol/v1beta2/zz_generated.validations.go generated Normal file
View File

@@ -0,0 +1,331 @@
//go:build !ignore_autogenerated
// +build !ignore_autogenerated
/*
Copyright 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.
*/
// Code generated by validation-gen. DO NOT EDIT.
package v1beta2
import (
context "context"
fmt "fmt"
flowcontrolv1beta2 "k8s.io/api/flowcontrol/v1beta2"
equality "k8s.io/apimachinery/pkg/api/equality"
operation "k8s.io/apimachinery/pkg/api/operation"
safe "k8s.io/apimachinery/pkg/api/safe"
validate "k8s.io/apimachinery/pkg/api/validate"
runtime "k8s.io/apimachinery/pkg/runtime"
field "k8s.io/apimachinery/pkg/util/validation/field"
)
func init() { localSchemeBuilder.Register(RegisterValidations) }
// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
// type PriorityLevelConfiguration
scheme.AddValidationFunc((*flowcontrolv1beta2.PriorityLevelConfiguration)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
switch op.Request.SubresourcePath() {
case "/":
return Validate_PriorityLevelConfiguration(ctx, op, nil /* fldPath */, obj.(*flowcontrolv1beta2.PriorityLevelConfiguration), safe.Cast[*flowcontrolv1beta2.PriorityLevelConfiguration](oldObj))
}
return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
})
return nil
}
// Validate_LimitResponse validates an instance of LimitResponse according
// to declarative validation rules in the API schema.
func Validate_LimitResponse(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitResponse) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "queuing", func(obj *flowcontrolv1beta2.LimitResponse) *flowcontrolv1beta2.QueuingConfiguration {
return obj.Queuing
}, func(obj *flowcontrolv1beta2.LimitResponse) flowcontrolv1beta2.LimitResponseType { return obj.Type }, validate.DirectEqualPtr, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta2.QueuingConfiguration, flowcontrolv1beta2.LimitResponseType]{
{
Value: "Queue", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Reject", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1beta2.LimitResponse.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitResponseType, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.LimitResponse) *flowcontrolv1beta2.LimitResponseType {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1beta2.LimitResponse.Queuing
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.QueuingConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("queuing"), obj.Queuing, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.LimitResponse) *flowcontrolv1beta2.QueuingConfiguration {
return oldObj.Queuing
}), oldObj != nil)...)
return errs
}
// Validate_LimitedPriorityLevelConfiguration validates an instance of LimitedPriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_LimitedPriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitedPriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1beta2.LimitedPriorityLevelConfiguration.AssuredConcurrencyShares has no validation
// field flowcontrolv1beta2.LimitedPriorityLevelConfiguration.LimitResponse
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitResponse, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_LimitResponse(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limitResponse"), &obj.LimitResponse, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.LimitedPriorityLevelConfiguration) *flowcontrolv1beta2.LimitResponse {
return &oldObj.LimitResponse
}), oldObj != nil)...)
// field flowcontrolv1beta2.LimitedPriorityLevelConfiguration.LendablePercent has no validation
// field flowcontrolv1beta2.LimitedPriorityLevelConfiguration.BorrowingLimitPercent has no validation
return errs
}
// Validate_PriorityLevelConfiguration validates an instance of PriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.PriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1beta2.PriorityLevelConfiguration.TypeMeta has no validation
// field flowcontrolv1beta2.PriorityLevelConfiguration.ObjectMeta has no validation
// field flowcontrolv1beta2.PriorityLevelConfiguration.Spec
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.PriorityLevelConfigurationSpec, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_PriorityLevelConfigurationSpec(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.PriorityLevelConfiguration) *flowcontrolv1beta2.PriorityLevelConfigurationSpec {
return &oldObj.Spec
}), oldObj != nil)...)
// field flowcontrolv1beta2.PriorityLevelConfiguration.Status has no validation
return errs
}
// Validate_PriorityLevelConfigurationSpec validates an instance of PriorityLevelConfigurationSpec according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfigurationSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "exempt", func(obj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) *flowcontrolv1beta2.ExemptPriorityLevelConfiguration {
return obj.Exempt
}, func(obj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) flowcontrolv1beta2.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta2.ExemptPriorityLevelConfiguration, flowcontrolv1beta2.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "limited", func(obj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) *flowcontrolv1beta2.LimitedPriorityLevelConfiguration {
return obj.Limited
}, func(obj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) flowcontrolv1beta2.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta2.LimitedPriorityLevelConfiguration, flowcontrolv1beta2.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1beta2.PriorityLevelConfigurationSpec.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.PriorityLevelEnablement, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) *flowcontrolv1beta2.PriorityLevelEnablement {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1beta2.PriorityLevelConfigurationSpec.Limited
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.LimitedPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
// call the type's validation function
errs = append(errs, Validate_LimitedPriorityLevelConfiguration(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limited"), obj.Limited, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) *flowcontrolv1beta2.LimitedPriorityLevelConfiguration {
return oldObj.Limited
}), oldObj != nil)...)
// field flowcontrolv1beta2.PriorityLevelConfigurationSpec.Exempt
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta2.ExemptPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("exempt"), obj.Exempt, safe.Field(oldObj, func(oldObj *flowcontrolv1beta2.PriorityLevelConfigurationSpec) *flowcontrolv1beta2.ExemptPriorityLevelConfiguration {
return oldObj.Exempt
}), oldObj != nil)...)
return errs
}

2
pkg/apis/flowcontrol/v1beta3/doc.go
View File

@@ -18,6 +18,8 @@ limitations under the License.
// +k8s:conversion-gen-external-types=k8s.io/api/flowcontrol/v1beta3
// +k8s:defaulter-gen=TypeMeta
// +k8s:defaulter-gen-input=k8s.io/api/flowcontrol/v1beta3
// +k8s:validation-gen=TypeMeta
// +k8s:validation-gen-input=k8s.io/api/flowcontrol/v1beta3
// +groupName=flowcontrol.apiserver.k8s.io

331
pkg/apis/flowcontrol/v1beta3/zz_generated.validations.go generated Normal file
View File

@@ -0,0 +1,331 @@
//go:build !ignore_autogenerated
// +build !ignore_autogenerated
/*
Copyright 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.
*/
// Code generated by validation-gen. DO NOT EDIT.
package v1beta3
import (
context "context"
fmt "fmt"
flowcontrolv1beta3 "k8s.io/api/flowcontrol/v1beta3"
equality "k8s.io/apimachinery/pkg/api/equality"
operation "k8s.io/apimachinery/pkg/api/operation"
safe "k8s.io/apimachinery/pkg/api/safe"
validate "k8s.io/apimachinery/pkg/api/validate"
runtime "k8s.io/apimachinery/pkg/runtime"
field "k8s.io/apimachinery/pkg/util/validation/field"
)
func init() { localSchemeBuilder.Register(RegisterValidations) }
// RegisterValidations adds validation functions to the given scheme.
// Public to allow building arbitrary schemes.
func RegisterValidations(scheme *runtime.Scheme) error {
// type PriorityLevelConfiguration
scheme.AddValidationFunc((*flowcontrolv1beta3.PriorityLevelConfiguration)(nil), func(ctx context.Context, op operation.Operation, obj, oldObj interface{}) field.ErrorList {
switch op.Request.SubresourcePath() {
case "/":
return Validate_PriorityLevelConfiguration(ctx, op, nil /* fldPath */, obj.(*flowcontrolv1beta3.PriorityLevelConfiguration), safe.Cast[*flowcontrolv1beta3.PriorityLevelConfiguration](oldObj))
}
return field.ErrorList{field.InternalError(nil, fmt.Errorf("no validation found for %T, subresource: %v", obj, op.Request.SubresourcePath()))}
})
return nil
}
// Validate_LimitResponse validates an instance of LimitResponse according
// to declarative validation rules in the API schema.
func Validate_LimitResponse(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitResponse) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "queuing", func(obj *flowcontrolv1beta3.LimitResponse) *flowcontrolv1beta3.QueuingConfiguration {
return obj.Queuing
}, func(obj *flowcontrolv1beta3.LimitResponse) flowcontrolv1beta3.LimitResponseType { return obj.Type }, validate.DirectEqualPtr, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta3.QueuingConfiguration, flowcontrolv1beta3.LimitResponseType]{
{
Value: "Queue", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Reject", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.QueuingConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1beta3.LimitResponse.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitResponseType, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.LimitResponse) *flowcontrolv1beta3.LimitResponseType {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1beta3.LimitResponse.Queuing
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.QueuingConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("queuing"), obj.Queuing, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.LimitResponse) *flowcontrolv1beta3.QueuingConfiguration {
return oldObj.Queuing
}), oldObj != nil)...)
return errs
}
// Validate_LimitedPriorityLevelConfiguration validates an instance of LimitedPriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_LimitedPriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitedPriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1beta3.LimitedPriorityLevelConfiguration.NominalConcurrencyShares has no validation
// field flowcontrolv1beta3.LimitedPriorityLevelConfiguration.LimitResponse
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitResponse, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_LimitResponse(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limitResponse"), &obj.LimitResponse, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.LimitedPriorityLevelConfiguration) *flowcontrolv1beta3.LimitResponse {
return &oldObj.LimitResponse
}), oldObj != nil)...)
// field flowcontrolv1beta3.LimitedPriorityLevelConfiguration.LendablePercent has no validation
// field flowcontrolv1beta3.LimitedPriorityLevelConfiguration.BorrowingLimitPercent has no validation
return errs
}
// Validate_PriorityLevelConfiguration validates an instance of PriorityLevelConfiguration according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfiguration(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.PriorityLevelConfiguration) (errs field.ErrorList) {
// field flowcontrolv1beta3.PriorityLevelConfiguration.TypeMeta has no validation
// field flowcontrolv1beta3.PriorityLevelConfiguration.ObjectMeta has no validation
// field flowcontrolv1beta3.PriorityLevelConfiguration.Spec
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.PriorityLevelConfigurationSpec, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call the type's validation function
errs = append(errs, Validate_PriorityLevelConfigurationSpec(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("spec"), &obj.Spec, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.PriorityLevelConfiguration) *flowcontrolv1beta3.PriorityLevelConfigurationSpec {
return &oldObj.Spec
}), oldObj != nil)...)
// field flowcontrolv1beta3.PriorityLevelConfiguration.Status has no validation
return errs
}
// Validate_PriorityLevelConfigurationSpec validates an instance of PriorityLevelConfigurationSpec according
// to declarative validation rules in the API schema.
func Validate_PriorityLevelConfigurationSpec(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) (errs field.ErrorList) {
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "exempt", func(obj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) *flowcontrolv1beta3.ExemptPriorityLevelConfiguration {
return obj.Exempt
}, func(obj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) flowcontrolv1beta3.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta3.ExemptPriorityLevelConfiguration, flowcontrolv1beta3.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.ExemptPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
errs = append(errs, validate.Discriminated(ctx, op, fldPath, obj, oldObj, "limited", func(obj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) *flowcontrolv1beta3.LimitedPriorityLevelConfiguration {
return obj.Limited
}, func(obj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) flowcontrolv1beta3.PriorityLevelEnablement {
return obj.Type
}, validate.SemanticDeepEqual, func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
errs = append(errs, validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha()...)
return errs
}, []validate.DiscriminatedRule[*flowcontrolv1beta3.LimitedPriorityLevelConfiguration, flowcontrolv1beta3.PriorityLevelEnablement]{
{
Value: "Exempt", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.ForbiddenPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
{
Value: "Limited", Validation: func(ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitedPriorityLevelConfiguration) field.ErrorList {
errs := field.ErrorList{}
earlyReturn := false
if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return errs
}
return errs
}},
})...)
// field flowcontrolv1beta3.PriorityLevelConfigurationSpec.Type
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.PriorityLevelEnablement, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && (obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj)) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
errs = append(errs, e...)
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("type"), &obj.Type, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) *flowcontrolv1beta3.PriorityLevelEnablement {
return &oldObj.Type
}), oldObj != nil)...)
// field flowcontrolv1beta3.PriorityLevelConfigurationSpec.Limited
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.LimitedPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
// call the type's validation function
errs = append(errs, Validate_LimitedPriorityLevelConfiguration(ctx, op, fldPath, obj, oldObj)...)
return
}(fldPath.Child("limited"), obj.Limited, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) *flowcontrolv1beta3.LimitedPriorityLevelConfiguration {
return oldObj.Limited
}), oldObj != nil)...)
// field flowcontrolv1beta3.PriorityLevelConfigurationSpec.Exempt
errs = append(errs,
func(fldPath *field.Path, obj, oldObj *flowcontrolv1beta3.ExemptPriorityLevelConfiguration, oldValueCorrelated bool) (errs field.ErrorList) {
// don't revalidate unchanged data
if oldValueCorrelated && op.Type == operation.Update && equality.Semantic.DeepEqual(obj, oldObj) {
return nil
}
// call field-attached validations
earlyReturn := false
if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkAlpha(); len(e) != 0 {
earlyReturn = true
}
if earlyReturn {
return // do not proceed
}
return
}(fldPath.Child("exempt"), obj.Exempt, safe.Field(oldObj, func(oldObj *flowcontrolv1beta3.PriorityLevelConfigurationSpec) *flowcontrolv1beta3.ExemptPriorityLevelConfiguration {
return oldObj.Exempt
}), oldObj != nil)...)
return errs
}

10
pkg/apis/flowcontrol/validation/validation.go
View File

@@ -400,18 +400,18 @@ func ValidatePriorityLevelConfigurationSpec(spec *flowcontrol.PriorityLevelConfi
switch spec.Type {
case flowcontrol.PriorityLevelEnablementExempt:
if spec.Limited != nil {
allErrs = append(allErrs, field.Forbidden(fldPath.Child("limited"), "must be nil if the type is not Limited"))
allErrs = append(allErrs, field.Forbidden(fldPath.Child("limited"), "must be nil if the type is not Limited").MarkCoveredByDeclarative())
}
if spec.Exempt != nil {
allErrs = append(allErrs, ValidateExemptPriorityLevelConfiguration(spec.Exempt, fldPath.Child("exempt"))...)
}
case flowcontrol.PriorityLevelEnablementLimited:
if spec.Exempt != nil {
allErrs = append(allErrs, field.Forbidden(fldPath.Child("exempt"), "must be nil if the type is Limited"))
allErrs = append(allErrs, field.Forbidden(fldPath.Child("exempt"), "must be nil if the type is Limited").MarkCoveredByDeclarative())
}
if spec.Limited == nil {
allErrs = append(allErrs, field.Required(fldPath.Child("limited"), "must not be empty when type is Limited"))
allErrs = append(allErrs, field.Required(fldPath.Child("limited"), "must not be empty when type is Limited").MarkCoveredByDeclarative())
} else {
allErrs = append(allErrs, ValidateLimitedPriorityLevelConfiguration(spec.Limited, requestGV, fldPath.Child("limited"), opts)...)
}
@@ -466,11 +466,11 @@ func ValidateLimitResponse(lr flowcontrol.LimitResponse, fldPath *field.Path) fi
switch lr.Type {
case flowcontrol.LimitResponseTypeReject:
if lr.Queuing != nil {
allErrs = append(allErrs, field.Forbidden(fldPath.Child("queuing"), "must be nil if limited.limitResponse.type is not Limited"))
allErrs = append(allErrs, field.Forbidden(fldPath.Child("queuing"), "must be nil if limited.limitResponse.type is not Limited").MarkCoveredByDeclarative())
}
case flowcontrol.LimitResponseTypeQueue:
if lr.Queuing == nil {
allErrs = append(allErrs, field.Required(fldPath.Child("queuing"), "must not be empty if limited.limitResponse.type is Limited"))
allErrs = append(allErrs, field.Required(fldPath.Child("queuing"), "must not be empty if limited.limitResponse.type is Limited").MarkCoveredByDeclarative())
} else {
allErrs = append(allErrs, ValidatePriorityLevelQueuingConfiguration(lr.Queuing, fldPath.Child("queuing"))...)
}

14
pkg/apis/flowcontrol/validation/validation_test.go
View File

@@ -856,7 +856,7 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
priorityLevelConfiguration: exemptTypeRepurposed,
expectedErrors: field.ErrorList{
field.Invalid(field.NewPath("spec").Child("type"), flowcontrol.PriorityLevelEnablementLimited, "must be 'Exempt' if and only if `name` is 'exempt'"),
field.Forbidden(field.NewPath("spec").Child("exempt"), "must be nil if the type is Limited"),
field.Forbidden(field.NewPath("spec").Child("exempt"), "must be nil if the type is Limited").MarkCoveredByDeclarative(),
field.Invalid(field.NewPath("spec"), exemptTypeRepurposed.Spec, "spec of 'exempt' except the 'spec.exempt' field must equal the fixed value"),
},
}, {
@@ -869,7 +869,7 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
},
expectedErrors: field.ErrorList{
field.Invalid(field.NewPath("spec"), badExemptSpec3, "spec of 'exempt' except the 'spec.exempt' field must equal the fixed value"),
field.Forbidden(field.NewPath("spec").Child("limited"), "must be nil if the type is not Limited"),
field.Forbidden(field.NewPath("spec").Child("limited"), "must be nil if the type is not Limited").MarkCoveredByDeclarative(),
},
}, {
name: "admins are allowed to change the Exempt field of the 'exempt' pl",
@@ -892,8 +892,8 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
},
},
expectedErrors: field.ErrorList{
field.Forbidden(field.NewPath("spec").Child("exempt"), "must be nil if the type is Limited"),
field.Required(field.NewPath("spec").Child("limited"), "must not be empty when type is Limited"),
field.Forbidden(field.NewPath("spec").Child("exempt"), "must be nil if the type is Limited").MarkCoveredByDeclarative(),
field.Required(field.NewPath("spec").Child("limited"), "must not be empty when type is Limited").MarkCoveredByDeclarative(),
},
}, {
name: "limited requires more details",
@@ -905,7 +905,7 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Type: flowcontrol.PriorityLevelEnablementLimited,
},
},
expectedErrors: field.ErrorList{field.Required(field.NewPath("spec").Child("limited"), "must not be empty when type is Limited")},
expectedErrors: field.ErrorList{field.Required(field.NewPath("spec").Child("limited"), "must not be empty when type is Limited").MarkCoveredByDeclarative()},
}, {
name: "max-in-flight should work",
priorityLevelConfiguration: &flowcontrol.PriorityLevelConfiguration{
@@ -940,7 +940,7 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
QueueLengthLimit: 100,
}}}},
},
expectedErrors: field.ErrorList{field.Forbidden(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing"), "must be nil if limited.limitResponse.type is not Limited")},
expectedErrors: field.ErrorList{field.Forbidden(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing"), "must be nil if limited.limitResponse.type is not Limited").MarkCoveredByDeclarative()},
}, {
name: "wrong backstop spec should fail",
priorityLevelConfiguration: &flowcontrol.PriorityLevelConfiguration{
@@ -980,7 +980,7 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Type: flowcontrol.LimitResponseTypeQueue,
}}},
},
expectedErrors: field.ErrorList{field.Required(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing"), "must not be empty if limited.limitResponse.type is Limited")},
expectedErrors: field.ErrorList{field.Required(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing"), "must not be empty if limited.limitResponse.type is Limited").MarkCoveredByDeclarative()},
}, {
name: "normal customized priority level should work",
priorityLevelConfiguration: &flowcontrol.PriorityLevelConfiguration{

267
pkg/registry/flowcontrol/prioritylevelconfiguration/declarative_validation_test.go Normal file
View File

@@ -0,0 +1,267 @@
/*
Copyright 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 prioritylevelconfiguration
import (
"testing"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/validation/field"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
apitesting "k8s.io/kubernetes/pkg/api/testing"
"k8s.io/kubernetes/pkg/apis/flowcontrol"
)
var apiVersions = []string{"v1", "v1beta1", "v1beta2", "v1beta3"}
func TestDeclarativeValidate(t *testing.T) {
for _, apiVersion := range apiVersions {
t.Run(apiVersion, func(t *testing.T) {
testDeclarativeValidate(t, apiVersion)
})
}
}
func testDeclarativeValidate(t *testing.T, apiVersion string) {
ctx := genericapirequest.WithRequestInfo(genericapirequest.NewDefaultContext(), &genericapirequest.RequestInfo{
APIGroup: "flowcontrol.apiserver.k8s.io",
APIVersion: apiVersion,
})
specPath := field.NewPath("spec")
testCases := map[string]struct {
input flowcontrol.PriorityLevelConfiguration
expectedErrs field.ErrorList
}{
"valid: Limited allows Reject without queuing": {
input: mkPLC(),
},
"valid: Queue requires queuing": {
input: mkPLC(tweakLimitResponseType(flowcontrol.LimitResponseTypeQueue)),
},
"valid: Exempt without exempt config": {
input: mkPLC(tweakExempt()),
},
"valid: Exempt with exempt config": {
input: mkPLC(tweakExempt(), tweakExemptConfig(&flowcontrol.ExemptPriorityLevelConfiguration{
NominalConcurrencyShares: ptrInt32(100),
})),
},
"spec.type: Limited with limited=nil": {
input: mkPLC(tweakLimited(nil)),
expectedErrs: field.ErrorList{
field.Required(specPath.Child("limited"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"spec.type: Exempt with limited set": {
input: mkPLC(tweakExempt(), tweakLimited(&flowcontrol.LimitedPriorityLevelConfiguration{
NominalConcurrencyShares: 100,
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeReject,
},
})),
expectedErrs: field.ErrorList{
// Mandatory object check: spec of 'exempt' differs from bootstrap (HW-only)
field.Invalid(specPath, nil, "").MarkFromImperative(),
field.Forbidden(specPath.Child("limited"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"spec.type: Limited with exempt set": {
input: mkPLC(tweakExemptConfig(&flowcontrol.ExemptPriorityLevelConfiguration{})),
expectedErrs: field.ErrorList{
field.Forbidden(specPath.Child("exempt"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"limitResponse.type: Queue with queuing=nil": {
input: mkPLC(tweakLimitResponseType(flowcontrol.LimitResponseTypeQueue), tweakQueuing(nil)),
expectedErrs: field.ErrorList{
field.Required(specPath.Child("limited", "limitResponse", "queuing"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"limitResponse.type: Reject with queuing set": {
input: mkPLC(tweakQueuing(&flowcontrol.QueuingConfiguration{
Queues: 64,
HandSize: 8,
QueueLengthLimit: 50,
})),
expectedErrs: field.ErrorList{
field.Forbidden(specPath.Child("limited", "limitResponse", "queuing"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
apitesting.VerifyValidationEquivalence(t, ctx, &tc.input, Strategy.Validate, tc.expectedErrs)
})
}
}
func TestDeclarativeValidateUpdate(t *testing.T) {
for _, apiVersion := range apiVersions {
t.Run(apiVersion, func(t *testing.T) {
testDeclarativeValidateUpdate(t, apiVersion)
})
}
}
func testDeclarativeValidateUpdate(t *testing.T, apiVersion string) {
specPath := field.NewPath("spec")
testCases := map[string]struct {
old flowcontrol.PriorityLevelConfiguration
update flowcontrol.PriorityLevelConfiguration
expectedErrs field.ErrorList
}{
"valid update (no changes)": {
old: mkPLC(),
update: mkPLC(),
},
"valid update: Reject to Queue": {
old: mkPLC(),
update: mkPLC(tweakLimitResponseType(flowcontrol.LimitResponseTypeQueue)),
},
"update: limited set to nil": {
old: mkPLC(),
update: mkPLC(tweakLimited(nil)),
expectedErrs: field.ErrorList{
field.Required(specPath.Child("limited"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"update: add exempt field to Limited PLC": {
old: mkPLC(),
update: mkPLC(tweakExemptConfig(&flowcontrol.ExemptPriorityLevelConfiguration{})),
expectedErrs: field.ErrorList{
field.Forbidden(specPath.Child("exempt"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"update: Queue with queuing set to nil": {
old: mkPLC(tweakLimitResponseType(flowcontrol.LimitResponseTypeQueue)),
update: mkPLC(tweakLimitResponseType(flowcontrol.LimitResponseTypeQueue), tweakQueuing(nil)),
expectedErrs: field.ErrorList{
field.Required(specPath.Child("limited", "limitResponse", "queuing"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
"update: Reject with queuing added": {
old: mkPLC(),
update: mkPLC(tweakQueuing(&flowcontrol.QueuingConfiguration{
Queues: 64,
HandSize: 8,
QueueLengthLimit: 50,
})),
expectedErrs: field.ErrorList{
field.Forbidden(specPath.Child("limited", "limitResponse", "queuing"), "").MarkCoveredByDeclarative().MarkAlpha(),
},
},
}
for name, tc := range testCases {
t.Run(name, func(t *testing.T) {
tc.old.ResourceVersion = "1"
tc.update.ResourceVersion = "2"
ctx := genericapirequest.WithRequestInfo(genericapirequest.NewDefaultContext(), &genericapirequest.RequestInfo{
APIPrefix: "apis",
APIGroup: "flowcontrol.apiserver.k8s.io",
APIVersion: apiVersion,
Resource: "prioritylevelconfigurations",
Name: tc.old.Name,
IsResourceRequest: true,
Verb: "update",
})
apitesting.VerifyUpdateValidationEquivalence(t, ctx, &tc.update, &tc.old, Strategy.ValidateUpdate, tc.expectedErrs)
})
}
}
// mkPLC creates a valid Limited PriorityLevelConfiguration with Reject limit response.
func mkPLC(tweaks ...func(*flowcontrol.PriorityLevelConfiguration)) flowcontrol.PriorityLevelConfiguration {
obj := flowcontrol.PriorityLevelConfiguration{
ObjectMeta: metav1.ObjectMeta{
Name: "test-limited",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
NominalConcurrencyShares: 100,
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeReject,
},
},
},
}
for _, tweak := range tweaks {
tweak(&obj)
}
return obj
}
// tweakExempt switches the PLC to Exempt type with the mandatory "exempt" name.
func tweakExempt() func(*flowcontrol.PriorityLevelConfiguration) {
return func(obj *flowcontrol.PriorityLevelConfiguration) {
obj.Name = "exempt"
obj.Spec.Type = flowcontrol.PriorityLevelEnablementExempt
obj.Spec.Limited = nil
}
}
// tweakLimited sets the Limited field directly.
func tweakLimited(limited *flowcontrol.LimitedPriorityLevelConfiguration) func(*flowcontrol.PriorityLevelConfiguration) {
return func(obj *flowcontrol.PriorityLevelConfiguration) {
obj.Spec.Limited = limited
}
}
// tweakExemptConfig sets the Exempt configuration field.
func tweakExemptConfig(exempt *flowcontrol.ExemptPriorityLevelConfiguration) func(*flowcontrol.PriorityLevelConfiguration) {
return func(obj *flowcontrol.PriorityLevelConfiguration) {
obj.Spec.Exempt = exempt
}
}
// tweakLimitResponseType sets the LimitResponse type and auto-populates Queuing if Queue.
func tweakLimitResponseType(lrt flowcontrol.LimitResponseType) func(*flowcontrol.PriorityLevelConfiguration) {
return func(obj *flowcontrol.PriorityLevelConfiguration) {
if obj.Spec.Limited == nil {
return
}
obj.Spec.Limited.LimitResponse.Type = lrt
if lrt == flowcontrol.LimitResponseTypeQueue {
obj.Spec.Limited.LimitResponse.Queuing = &flowcontrol.QueuingConfiguration{
Queues: 64,
HandSize: 8,
QueueLengthLimit: 50,
}
} else {
obj.Spec.Limited.LimitResponse.Queuing = nil
}
}
}
// tweakQueuing sets the Queuing field directly, overriding auto-population.
func tweakQueuing(queuing *flowcontrol.QueuingConfiguration) func(*flowcontrol.PriorityLevelConfiguration) {
return func(obj *flowcontrol.PriorityLevelConfiguration) {
if obj.Spec.Limited == nil {
return
}
obj.Spec.Limited.LimitResponse.Queuing = queuing
}
}
func ptrInt32(v int32) *int32 {
return &v
}

10
pkg/registry/flowcontrol/prioritylevelconfiguration/strategy.go
View File

@@ -20,10 +20,12 @@ import (
"context"
apiequality "k8s.io/apimachinery/pkg/api/equality"
"k8s.io/apimachinery/pkg/api/operation"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/util/validation/field"
genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
"k8s.io/apiserver/pkg/registry/rest"
"k8s.io/apiserver/pkg/storage/names"
"k8s.io/kubernetes/pkg/api/legacyscheme"
"k8s.io/kubernetes/pkg/apis/flowcontrol"
@@ -94,8 +96,10 @@ func (priorityLevelConfigurationStrategy) Validate(ctx context.Context, obj runt
// That means we should not allow 0 values to be introduced, either
// via v1 or v1beta3(with the roundtrip annotation) until we know
// all servers are at 1.29+ and will honor the zero value correctly.
plc := obj.(*flowcontrol.PriorityLevelConfiguration)
opts := validation.PriorityLevelValidationOptions{}
return validation.ValidatePriorityLevelConfiguration(obj.(*flowcontrol.PriorityLevelConfiguration), getRequestGroupVersion(ctx), opts)
allErrs := validation.ValidatePriorityLevelConfiguration(plc, getRequestGroupVersion(ctx), opts)
return rest.ValidateDeclarativelyWithMigrationChecks(ctx, legacyscheme.Scheme, plc, nil, allErrs, operation.Create)
}
// WarningsOnCreate returns warnings for the creation of the given object.
@@ -119,6 +123,7 @@ func (priorityLevelConfigurationStrategy) AllowCreateOnUpdate() bool {
// ValidateUpdate is the default update validation for an end user.
func (priorityLevelConfigurationStrategy) ValidateUpdate(ctx context.Context, obj, old runtime.Object) field.ErrorList {
newPL := obj.(*flowcontrol.PriorityLevelConfiguration)
oldPL := old.(*flowcontrol.PriorityLevelConfiguration)
// 1.28 server is not aware of the roundtrip annotation, and will
// default any 0 value persisted (for the NominalConcurrencyShares
@@ -128,7 +133,8 @@ func (priorityLevelConfigurationStrategy) ValidateUpdate(ctx context.Context, ob
// via v1 or v1beta3(with the roundtrip annotation) until we know
// all servers are at 1.29+ and will honor the zero value correctly.
opts := validation.PriorityLevelValidationOptions{}
return validation.ValidatePriorityLevelConfiguration(newPL, getRequestGroupVersion(ctx), opts)
allErrs := validation.ValidatePriorityLevelConfiguration(newPL, getRequestGroupVersion(ctx), opts)
return rest.ValidateDeclarativelyWithMigrationChecks(ctx, legacyscheme.Scheme, newPL, oldPL, allErrs, operation.Update)
}
// WarningsOnUpdate returns warnings for the given update.

13
staging/src/k8s.io/api/flowcontrol/v1/generated.proto
View File

@@ -179,11 +179,16 @@ message LimitResponse {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
optional QueuingConfiguration queuing = 2;
}
@@ -367,11 +372,16 @@ message PriorityLevelConfigurationSpec {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
optional LimitedPriorityLevelConfiguration limited = 2;
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -380,6 +390,9 @@ message PriorityLevelConfigurationSpec {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
optional ExemptPriorityLevelConfiguration exempt = 3;
}

13
staging/src/k8s.io/api/flowcontrol/v1/types.go
View File

@@ -429,11 +429,16 @@ type PriorityLevelConfigurationSpec struct {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"`
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"`
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -442,6 +447,9 @@ type PriorityLevelConfigurationSpec struct {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
Exempt *ExemptPriorityLevelConfiguration `json:"exempt,omitempty" protobuf:"bytes,3,opt,name=exempt"`
}
@@ -566,11 +574,16 @@ type LimitResponse struct {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type LimitResponseType `json:"type" protobuf:"bytes,1,opt,name=type"`
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"`
}

13
staging/src/k8s.io/api/flowcontrol/v1beta1/generated.proto
View File

@@ -177,11 +177,16 @@ message LimitResponse {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
optional QueuingConfiguration queuing = 2;
}
@@ -360,11 +365,16 @@ message PriorityLevelConfigurationSpec {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
optional LimitedPriorityLevelConfiguration limited = 2;
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -373,6 +383,9 @@ message PriorityLevelConfigurationSpec {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
optional ExemptPriorityLevelConfiguration exempt = 3;
}

13
staging/src/k8s.io/api/flowcontrol/v1beta1/types.go
View File

@@ -431,11 +431,16 @@ type PriorityLevelConfigurationSpec struct {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"`
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"`
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -444,6 +449,9 @@ type PriorityLevelConfigurationSpec struct {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
Exempt *ExemptPriorityLevelConfiguration `json:"exempt,omitempty" protobuf:"bytes,3,opt,name=exempt"`
}
@@ -563,11 +571,16 @@ type LimitResponse struct {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type LimitResponseType `json:"type" protobuf:"bytes,1,opt,name=type"`
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"`
}

13
staging/src/k8s.io/api/flowcontrol/v1beta2/generated.proto
View File

@@ -177,11 +177,16 @@ message LimitResponse {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
optional QueuingConfiguration queuing = 2;
}
@@ -360,11 +365,16 @@ message PriorityLevelConfigurationSpec {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
optional LimitedPriorityLevelConfiguration limited = 2;
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -373,6 +383,9 @@ message PriorityLevelConfigurationSpec {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
optional ExemptPriorityLevelConfiguration exempt = 3;
}

13
staging/src/k8s.io/api/flowcontrol/v1beta2/types.go
View File

@@ -431,11 +431,16 @@ type PriorityLevelConfigurationSpec struct {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"`
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"`
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -444,6 +449,9 @@ type PriorityLevelConfigurationSpec struct {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
Exempt *ExemptPriorityLevelConfiguration `json:"exempt,omitempty" protobuf:"bytes,3,opt,name=exempt"`
}
@@ -563,11 +571,16 @@ type LimitResponse struct {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type LimitResponseType `json:"type" protobuf:"bytes,1,opt,name=type"`
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"`
}

13
staging/src/k8s.io/api/flowcontrol/v1beta3/generated.proto
View File

@@ -179,11 +179,16 @@ message LimitResponse {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
optional QueuingConfiguration queuing = 2;
}
@@ -362,11 +367,16 @@ message PriorityLevelConfigurationSpec {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
optional string type = 1;
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
optional LimitedPriorityLevelConfiguration limited = 2;
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -375,6 +385,9 @@ message PriorityLevelConfigurationSpec {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
optional ExemptPriorityLevelConfiguration exempt = 3;
}

13
staging/src/k8s.io/api/flowcontrol/v1beta3/types.go
View File

@@ -447,11 +447,16 @@ type PriorityLevelConfigurationSpec struct {
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"`
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:forbidden
Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"`
// `exempt` specifies how requests are handled for an exempt priority level.
@@ -460,6 +465,9 @@ type PriorityLevelConfigurationSpec struct {
// If empty and `type` is `"Exempt"` then the default values
// for `ExemptPriorityLevelConfiguration` apply.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Exempt")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Limited")=+k8s:forbidden
Exempt *ExemptPriorityLevelConfiguration `json:"exempt,omitempty" protobuf:"bytes,3,opt,name=exempt"`
}
@@ -579,11 +587,16 @@ type LimitResponse struct {
// are rejected.
// Required.
// +unionDiscriminator
// +k8s:alpha(since: "1.36")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:discriminator
Type LimitResponseType `json:"type" protobuf:"bytes,1,opt,name=type"`
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
// +k8s:alpha(since: "1.36")=+k8s:optional
// +k8s:alpha(since: "1.36")=+k8s:member("Queue")=+k8s:required
// +k8s:alpha(since: "1.36")=+k8s:member("Reject")=+k8s:forbidden
Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"`
}