✨ move webhook generator from CR to CT

Author: Mengqi Yu

cmd/controller-gen/main.go

@@ -167,7 +167,7 @@ Usage:
 }
 
 func newWebhookCmd() *cobra.Command {
-	o := &webhook.ManifestOptions{}
+	o := &webhook.Options{}
 	o.SetDefaults()
 
 	cmd := &cobra.Command{

pkg/internal/codegen/parse/apis.go

@@ -120,7 +120,7 @@ func (b *APIs) parseStructs(apigroup *codegen.APIGroup) {
 		}
 		done.Insert(next.Type.Name.Name)
 
-		// Generate the struct and append to the list
+		// GenerateObjects the struct and append to the list
 		result, additionalTypes := parseType(next.Type)
 
 		// This is a resource, so generate the client
@@ -153,7 +153,7 @@ func parseType(t *types.Type) (*codegen.Struct, []*types.Type) {
 	s := &codegen.Struct{
 		Name:           t.Name.Name,
 		GenClient:      false,
-		GenUnversioned: true, // Generate unversioned structs by default
+		GenUnversioned: true, // GenerateObjects unversioned structs by default
 	}
 
 	for _, c := range t.CommentLines {

pkg/rbac/manifests.go

@@ -67,7 +67,7 @@ func (o *ManifestOptions) Validate() error {
 	return nil
 }
 
-// Generate generates RBAC manifests by parsing the RBAC annotations in Go source
+// GenerateObjects generates RBAC manifests by parsing the RBAC annotations in Go source
 // files specified in the input directory.
 func Generate(o *ManifestOptions) error {
 	if err := o.Validate(); err != nil {

pkg/webhook/admission.go

@@ -0,0 +1,104 @@
+/*
+Copyright 2018 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 webhook
+
+import (
+	"errors"
+	"fmt"
+	"regexp"
+	"strings"
+	"sync"
+
+	admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// AdmissionWebhook contains bits needed for generating a AdmissionWebhook Configuration
+type AdmissionWebhook struct {
+	// Name is the name of the webhook
+	Name string
+	// Type is the webhook type, i.e. mutating, validating
+	Type WebhookType
+	// Path is the path this webhook will serve.
+	Path string
+	// Rules maps to the Rules field in admissionregistrationv1beta1.AdmissionWebhook
+	Rules []admissionregistrationv1beta1.RuleWithOperations
+	// FailurePolicy maps to the FailurePolicy field in admissionregistrationv1beta1.AdmissionWebhook
+	// This optional. If not set, will be defaulted to Ignore (fail-open) by the server.
+	// More details: https://github.com/kubernetes/api/blob/f5c295feaba2cbc946f0bbb8b535fc5f6a0345ee/admissionregistration/v1beta1/types.go#L144-L147
+	FailurePolicy *admissionregistrationv1beta1.FailurePolicyType
+	// NamespaceSelector maps to the NamespaceSelector field in admissionregistrationv1beta1.AdmissionWebhook
+	// This optional.
+	NamespaceSelector *metav1.LabelSelector
+
+	once sync.Once
+}
+
+func (w *AdmissionWebhook) setDefaults() {
+	if len(w.Path) == 0 {
+		if len(w.Rules) == 0 || len(w.Rules[0].Resources) == 0 {
+			// can't do defaulting, skip it.
+			return
+		}
+		if w.Type == WebhookTypeMutating {
+			w.Path = "/mutate-" + w.Rules[0].Resources[0]
+		} else if w.Type == WebhookTypeValidating {
+			w.Path = "/validate-" + w.Rules[0].Resources[0]
+		}
+	}
+	if len(w.Name) == 0 {
+		reg := regexp.MustCompile("[^a-zA-Z0-9]+")
+		processedPath := strings.ToLower(reg.ReplaceAllString(w.Path, ""))
+		w.Name = processedPath + ".example.com"
+	}
+}
+
+// GetName returns the name of the webhook.
+func (w *AdmissionWebhook) GetName() string {
+	w.once.Do(w.setDefaults)
+	return w.Name
+}
+
+// GetPath returns the path that the webhook registered.
+func (w *AdmissionWebhook) GetPath() string {
+	w.once.Do(w.setDefaults)
+	return w.Path
+}
+
+// GetType returns the type of the webhook.
+func (w *AdmissionWebhook) GetType() WebhookType {
+	w.once.Do(w.setDefaults)
+	return w.Type
+}
+
+// Validate validates if the webhook is valid.
+func (w *AdmissionWebhook) Validate() error {
+	w.once.Do(w.setDefaults)
+	if len(w.Rules) == 0 {
+		return errors.New("field Rules should not be empty")
+	}
+	if len(w.Name) == 0 {
+		return errors.New("field Name should not be empty")
+	}
+	if w.Type != WebhookTypeMutating && w.Type != WebhookTypeValidating {
+		return fmt.Errorf("unsupported Type: %v, only WebhookTypeMutating and WebhookTypeValidating are supported", w.Type)
+	}
+	if len(w.Path) == 0 {
+		return errors.New("field Path should not be empty")
+	}
+	return nil
+}