Add a marker to support field defaulting in crd schema

Author: marun

pkg/crd/markers/validation.go

@@ -72,6 +72,9 @@ var FieldOnlyMarkers = []*definitionWithHelp{
 
 	must(markers.MakeDefinition("nullable", markers.DescribesField, Nullable{})).
 		WithHelp(Nullable{}.Help()),
+
+	must(markers.MakeAnyTypeDefinition("kubebuilder:validation:Default", markers.DescribesField, Default{})).
+		WithHelp(Default{}.Help()),
 }
 
 func init() {
@@ -159,6 +162,19 @@ type Type string
 // This is often not necessary, but may be helpful with custom serialization.
 type Nullable struct{}
 
+// +controllertools:marker:generateHelp:category="CRD validation"
+// Default sets the default value for this field.
+//
+// A default value will be accepted as any value valid for the
+// field. Formatting for common types include: boolean: `true`, string:
+// `Cluster`, numerical: `1.24`, array: `{1,2}`, object: `{policy:
+// "delete"}`). Defaults should be defined in pruned form, and only best-effort
+// validation will be performed. Full validation of a default requires
+// submission of the containing CRD to an apiserver.
+type Default struct {
+	Value interface{}
+}
+
 func (m Maximum) ApplyToSchema(schema *v1beta1.JSONSchemaProps) error {
 	if schema.Type != "integer" {
 		return fmt.Errorf("must apply maximum to an integer")
@@ -284,3 +300,13 @@ func (m Nullable) ApplyToSchema(schema *v1beta1.JSONSchemaProps) error {
 	schema.Nullable = true
 	return nil
 }
+
+// Defaults are only valid CRDs created with the v1 API
+func (m Default) ApplyToSchema(schema *v1beta1.JSONSchemaProps) error {
+	marshalledDefault, err := json.Marshal(m.Value)
+	if err != nil {
+		return err
+	}
+	schema.Default = &v1beta1.JSON{Raw: marshalledDefault}
+	return nil
+}

pkg/crd/testdata/cronjob_types.go

@@ -93,6 +93,27 @@ type CronJobSpec struct {
 
 	// This tests that markers that are allowed on both fields and types are applied to types
 	TwoOfAKindPart1 LongerString `json:"twoOfAKindPart1"`
+
+	// This tests that primitive defaulting can be performed.
+	// +kubebuilder:validation:Default=forty-two
+	DefaultedString string `json:"defaultedString"`
+
+	// This tests that slice defaulting can be performed.
+	// +kubebuilder:validation:Default={a,b}
+	DefaultedSlice []string `json:"defaultedSlice"`
+
+	// This tests that object defaulting can be performed.
+	// +kubebuilder:validation:Default={{nested: {foo: "baz", bar: true}},{nested: {bar: false}}}
+	DefaultedObject []RootObject `json:"defaultedObject"`
+}
+
+type NestedObject struct {
+	Foo string `json:"foo"`
+	Bar bool   `json:"bar"`
+}
+
+type RootObject struct {
+	Nested NestedObject `json:"nested"`
 }
 
 // +kubebuilder:validation:MinLength=4

pkg/markers/parse.go

@@ -865,6 +865,19 @@ func MakeDefinition(name string, target TargetType, output interface{}) (*Defini
 	return def, nil
 }
 
+// MakeAnyTypeDefinition constructs a definition for an output struct with a
+// field named `Value` of type `interface{}`. The argument to the marker will
+// be parsed as AnyType and assigned to the field named `Value`.
+func MakeAnyTypeDefinition(name string, target TargetType, output interface{}) (*Definition, error) {
+	defn, err := MakeDefinition(name, target, output)
+	if err != nil {
+		return nil, err
+	}
+	defn.FieldNames = map[string]string{"": "Value"}
+	defn.Fields = map[string]Argument{"": defn.Fields["value"]}
+	return defn, nil
+}
+
 // splitMarker takes a marker in the form of `+a:b:c=arg,d=arg` and splits it
 // into the name (`a:b`), the name if it's not a struct (`a:b:c`), and the parts
 // that are definitely fields (`arg,d=arg`).

pkg/markers/parse_test.go

@@ -76,10 +76,8 @@ var _ = Describe("Parsing", func() {
 			mustDefine(reg, "testing:tripleDefined", DescribesField, "")
 			mustDefine(reg, "testing:tripleDefined", DescribesType, false)
 
-			defn, err := MakeDefinition("testing:custom", DescribesPackage, CustomType{})
+			defn, err := MakeAnyTypeDefinition("testing:custom", DescribesPackage, CustomType{})
 			Expect(err).NotTo(HaveOccurred())
-			defn.FieldNames = map[string]string{"": "Value"}
-			defn.Fields = map[string]Argument{"": defn.Fields["value"]}
 
 			Expect(reg.Register(defn)).To(Succeed())
 		})

test.sh

@@ -109,6 +109,11 @@ setup_envs
 
 header_text "running golangci-lint"
 
+header_text "generating marker help"
+pushd cmd/controller-gen > /dev/null
+  go generate
+popd > /dev/null
+
 golangci-lint run --disable-all \
     --enable=misspell \
     --enable=golint \