feat: Support maxItems validation

staging/src/k8s.io/apimachinery/pkg/api/validate/schema.go

@@ -17,6 +17,8 @@ limitations under the License.
 package validate
 
 import (
+	"reflect"
+
 	"k8s.io/apimachinery/pkg/api/operation"
 	"k8s.io/apimachinery/pkg/api/validate/content"
 	"k8s.io/apimachinery/pkg/util/validation/field"
@@ -72,3 +74,16 @@ func Optional[T comparable](_ operation.Context, fldPath *field.Path, value, _ *
 	}
 	return field.ErrorList{field.Required(fldPath, "optional value was not specified")}
 }
+
+// MaxItems verifies that the specified slice is not longer than max items.
+func MaxItems[T any](_ operation.Context, fldPath *field.Path, value, _ T, max int) field.ErrorList {
+	size := 0
+
+	if reflect.TypeOf(value).Kind() == reflect.Slice {
+		size = reflect.ValueOf(value).Len()
+	}
+	if size > max {
+		return field.ErrorList{field.TooMany(fldPath, size, max)}
+	}
+	return nil
+}

staging/src/k8s.io/code-generator/cmd/validation-gen/output_tests/maxitems/doc.go

@@ -0,0 +1,46 @@
+/*
+Copyright 2024 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.
+*/
+
+// +k8s:validation-gen=TypeMeta
+// +k8s:validation-gen-scheme-registry=k8s.io/code-generator/cmd/validation-gen/testscheme.Scheme
+
+// This is a test package.
+package maxitems
+
+import "k8s.io/code-generator/cmd/validation-gen/testscheme"
+
+var localSchemeBuilder = testscheme.New()
+
+// Maxitems
+type M struct {
+	TypeMeta int
+
+	// +k8s:validation:maxItems=3
+	M1 LT `json:"m1"`
+
+	// +k8s:validation:maxItems=1
+	M2 LT `json:"m2"`
+
+	// +k8s:validation:maxItems=1
+	M3 []T `json:"m3"`
+
+	M4 LT `json:"m4"`
+}
+
+// +k8s:validation:maxItems=2
+type LT []T
+
+type T struct{}

staging/src/k8s.io/code-generator/cmd/validation-gen/output_tests/maxitems/doc_test.go

@@ -0,0 +1,54 @@
+/*
+Copyright 2024 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 maxitems
+
+import (
+	"testing"
+
+	"k8s.io/apimachinery/pkg/util/validation/field"
+)
+
+func Test(t *testing.T) {
+	st := localSchemeBuilder.Test(t)
+
+	// Testing M1
+	st.Value(&M{M1: []T{{}, {}}}).ExpectValid()
+	st.Value(&M{M1: []T{{}, {}, {}}}).ExpectInvalid(
+		field.TooMany(field.NewPath("m1"), 3, 2),
+	)
+	st.Value(&M{M1: []T{{}, {}, {}}}).ExpectInvalid(
+		field.TooMany(field.NewPath("m1"), 3, 2),
+	)
+
+	// Testing M2
+	st.Value(&M{M2: []T{{}}}).ExpectValid()
+	st.Value(&M{M2: []T{{}, {}, {}, {}}}).ExpectInvalid(
+		field.TooMany(field.NewPath("m2"), 4, 1),
+	)
+
+	// Testing M3
+	st.Value(&M{M3: []T{{}}}).ExpectValid()
+	st.Value(&M{M3: []T{{}, {}}}).ExpectInvalid(
+		field.TooMany(field.NewPath("m3"), 2, 1),
+	)
+
+	// Testing M4
+	st.Value(&M{M4: []T{{}, {}}}).ExpectValid()
+	st.Value(&M{M4: []T{{}, {}, {}}}).ExpectInvalid(
+		field.TooMany(field.NewPath("m4"), 3, 2),
+	)
+}

staging/src/k8s.io/code-generator/cmd/validation-gen/validators/openapi.go

@@ -35,12 +35,14 @@ const (
 	markerPrefix     = "k8s:validation:"
 	formatTagName    = markerPrefix + ":format"
 	maxLengthTagName = markerPrefix + ":maxLength"
+	maxItemsTagName  = markerPrefix + ":maxItems"
 )
 
 var (
 	ipValidator        = types.Name{Package: libValidationPkg, Name: "IP"}
 	dnsLabelValidator  = types.Name{Package: libValidationPkg, Name: "DNSLabel"}
 	maxLengthValidator = types.Name{Package: libValidationPkg, Name: "MaxLength"}
+	maxItemsValidator  = types.Name{Package: libValidationPkg, Name: "MaxItems"}
 )
 
 func (openAPIDeclarativeValidator) ExtractValidations(t *types.Type, comments []string) (Validations, error) {
@@ -53,6 +55,9 @@ func (openAPIDeclarativeValidator) ExtractValidations(t *types.Type, comments []
 	if schema.MaxLength != nil {
 		result.AddFunction(Function(maxLengthTagName, DefaultFlags, maxLengthValidator, *schema.MaxLength))
 	}
+	if schema.MaxItems != nil {
+		result.AddFunction(Function(maxItemsTagName, ShortCircuit, maxItemsValidator, *schema.MaxItems))
+	}
 	if len(schema.Format) > 0 {
 		formatFunction := FormatValidationFunction(schema.Format)
 		if formatFunction != nil {
@@ -83,6 +88,16 @@ func (openAPIDeclarativeValidator) Docs() []TagDoc {
 			Description: "<non-negative integer>",
 			Docs:        "This field must be no more than X characters long.",
 		}},
+	}, {
+		Tag:         maxItemsTagName,
+		Description: "Indidates that a slice field has a limit on its size.",
+		Contexts:    []TagContext{TagContextType, TagContextField},
+		Payloads: []TagPayloadDoc{
+			{
+				Description: "<non-negative integer>",
+				Docs:        "This field must be no more than X items long.",
+			},
+		},
 	}}
 }