remove generator dependency in create service account

staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount.go

@@ -17,12 +17,21 @@ limitations under the License.
 package create
 
 import (
+	"context"
+	"fmt"
+
 	"github.com/spf13/cobra"
 
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/meta"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/runtime"
 	"k8s.io/cli-runtime/pkg/genericclioptions"
+	resourcecli "k8s.io/cli-runtime/pkg/resource"
+	coreclient "k8s.io/client-go/kubernetes/typed/core/v1"
 	cmdutil "k8s.io/kubectl/pkg/cmd/util"
-	"k8s.io/kubectl/pkg/generate"
+	"k8s.io/kubectl/pkg/scheme"
-	generateversioned "k8s.io/kubectl/pkg/generate/versioned"
+	"k8s.io/kubectl/pkg/util"
 	"k8s.io/kubectl/pkg/util/i18n"
 	"k8s.io/kubectl/pkg/util/templates"
 )
@@ -38,14 +47,36 @@ var (
 
 // ServiceAccountOpts holds the options for 'create serviceaccount' sub command
 type ServiceAccountOpts struct {
-	CreateSubcommandOptions *CreateSubcommandOptions
+	// PrintFlags holds options necessary for obtaining a printer
+	PrintFlags *genericclioptions.PrintFlags
+	PrintObj   func(obj runtime.Object) error
+	// Name of resource being created
+	Name             string
+	DryRunStrategy   cmdutil.DryRunStrategy
+	DryRunVerifier   *resourcecli.DryRunVerifier
+	CreateAnnotation bool
+	FieldManager     string
+
+	Namespace        string
+	EnforceNamespace bool
+
+	Mapper meta.RESTMapper
+	Client *coreclient.CoreV1Client
+
+	genericclioptions.IOStreams
+}
+
+// NewServiceAccountOpts creates a new *ServiceAccountOpts with sane defaults
+func NewServiceAccountOpts(ioStreams genericclioptions.IOStreams) *ServiceAccountOpts {
+	return &ServiceAccountOpts{
+		PrintFlags: genericclioptions.NewPrintFlags("created").WithTypeSetter(scheme.Scheme),
+		IOStreams:  ioStreams,
+	}
 }
 
 // NewCmdCreateServiceAccount is a macro command to create a new service account
 func NewCmdCreateServiceAccount(f cmdutil.Factory, ioStreams genericclioptions.IOStreams) *cobra.Command {
-	options := &ServiceAccountOpts{
+	o := NewServiceAccountOpts(ioStreams)
-		CreateSubcommandOptions: NewCreateSubcommandOptions(ioStreams),
-	}
 
 	cmd := &cobra.Command{
 		Use:                   "serviceaccount NAME [--dry-run=server|client|none]",
@@ -55,39 +86,124 @@ func NewCmdCreateServiceAccount(f cmdutil.Factory, ioStreams genericclioptions.I
 		Long:                  serviceAccountLong,
 		Example:               serviceAccountExample,
 		Run: func(cmd *cobra.Command, args []string) {
-			cmdutil.CheckErr(options.Complete(f, cmd, args))
+			cmdutil.CheckErr(o.Complete(f, cmd, args))
-			cmdutil.CheckErr(options.Run())
+			cmdutil.CheckErr(o.Validate())
+			cmdutil.CheckErr(o.Run())
 		},
 	}
 
-	options.CreateSubcommandOptions.PrintFlags.AddFlags(cmd)
+	o.PrintFlags.AddFlags(cmd)
 
 	cmdutil.AddApplyAnnotationFlags(cmd)
 	cmdutil.AddValidateFlags(cmd)
-	cmdutil.AddGeneratorFlags(cmd, generateversioned.ServiceAccountV1GeneratorName)
+	cmdutil.AddDryRunFlag(cmd)
-	cmdutil.AddFieldManagerFlagVar(cmd, &options.CreateSubcommandOptions.FieldManager, "kubectl-create")
+	cmdutil.AddFieldManagerFlagVar(cmd, &o.FieldManager, "kubectl-create")
 	return cmd
 }
 
 // Complete completes all the required options
 func (o *ServiceAccountOpts) Complete(f cmdutil.Factory, cmd *cobra.Command, args []string) error {
-	name, err := NameFromCommandArgs(cmd, args)
+	var err error
+	o.Name, err = NameFromCommandArgs(cmd, args)
 	if err != nil {
 		return err
 	}
 
-	var generator generate.StructuredGenerator
+	restConfig, err := f.ToRESTConfig()
-	switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName {
+	if err != nil {
-	case generateversioned.ServiceAccountV1GeneratorName:
+		return err
-		generator = &generateversioned.ServiceAccountGeneratorV1{Name: name}
+	}
-	default:
+	o.Client, err = coreclient.NewForConfig(restConfig)
-		return errUnsupportedGenerator(cmd, generatorName)
+	if err != nil {
+		return err
 	}
 
-	return o.CreateSubcommandOptions.Complete(f, cmd, args, generator)
+	o.CreateAnnotation = cmdutil.GetFlagBool(cmd, cmdutil.ApplyAnnotationsFlag)
+
+	o.DryRunStrategy, err = cmdutil.GetDryRunStrategy(cmd)
+	if err != nil {
+		return err
+	}
+	dynamicClient, err := f.DynamicClient()
+	if err != nil {
+		return err
+	}
+	discoveryClient, err := f.ToDiscoveryClient()
+	if err != nil {
+		return err
+	}
+	o.DryRunVerifier = resourcecli.NewDryRunVerifier(dynamicClient, discoveryClient)
+
+	o.Namespace, o.EnforceNamespace, err = f.ToRawKubeConfigLoader().Namespace()
+	if err != nil {
+		return err
+	}
+
+	cmdutil.PrintFlagsWithDryRunStrategy(o.PrintFlags, o.DryRunStrategy)
+
+	printer, err := o.PrintFlags.ToPrinter()
+	if err != nil {
+		return err
+	}
+
+	o.PrintObj = func(obj runtime.Object) error {
+		return printer.PrintObj(obj, o.Out)
+	}
+
+	return nil
 }
 
-// Run calls the CreateSubcommandOptions.Run in ServiceAccountOpts instance
+// Validate checks ServiceAccountOpts to see if there is sufficient information run the command.
-func (o *ServiceAccountOpts) Run() error {
+func (o *ServiceAccountOpts) Validate() error {
-	return o.CreateSubcommandOptions.Run()
+	if len(o.Name) == 0 {
+		return fmt.Errorf("name must be specified")
+	}
+	return nil
+}
+
+// Run makes the api call to the server
+func (o *ServiceAccountOpts) Run() error {
+	serviceAccount, err := o.createServiceAccount()
+	if err != nil {
+		return err
+	}
+
+	if err := util.CreateOrUpdateAnnotation(o.CreateAnnotation, serviceAccount, scheme.DefaultJSONEncoder()); err != nil {
+		return err
+	}
+
+	if o.DryRunStrategy != cmdutil.DryRunClient {
+		createOptions := metav1.CreateOptions{}
+		if o.FieldManager != "" {
+			createOptions.FieldManager = o.FieldManager
+		}
+		if o.DryRunStrategy == cmdutil.DryRunServer {
+			if err := o.DryRunVerifier.HasSupport(serviceAccount.GroupVersionKind()); err != nil {
+				return err
+			}
+			createOptions.DryRun = []string{metav1.DryRunAll}
+		}
+		serviceAccount, err = o.Client.ServiceAccounts(o.Namespace).Create(context.TODO(), serviceAccount, createOptions)
+		if err != nil {
+			return fmt.Errorf("failed to create serviceaccount: %v", err)
+		}
+	}
+	return o.PrintObj(serviceAccount)
+}
+
+func (o *ServiceAccountOpts) createServiceAccount() (*corev1.ServiceAccount, error) {
+	namespace := ""
+	if o.EnforceNamespace {
+		namespace = o.Namespace
+	}
+	fmt.Println(corev1.SchemeGroupVersion.String())
+	serviceAccount := &corev1.ServiceAccount{
+		TypeMeta: metav1.TypeMeta{APIVersion: corev1.SchemeGroupVersion.String(), Kind: "ServiceAccount"},
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      o.Name,
+			Namespace: namespace,
+		},
+	}
+	serviceAccount.Name = o.Name
+	return serviceAccount, nil
 }

staging/src/k8s.io/kubectl/pkg/cmd/create/create_serviceaccount_test.go

@@ -17,45 +17,44 @@ limitations under the License.
 package create
 
 import (
-	"net/http"
 	"testing"
 
-	"k8s.io/api/core/v1"
+	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/runtime/schema"
+	apiequality "k8s.io/apimachinery/pkg/api/equality"
-	"k8s.io/cli-runtime/pkg/genericclioptions"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	"k8s.io/client-go/rest/fake"
-	cmdtesting "k8s.io/kubectl/pkg/cmd/testing"
-	"k8s.io/kubectl/pkg/scheme"
 )
 
 func TestCreateServiceAccount(t *testing.T) {
-	serviceAccountObject := &v1.ServiceAccount{}
+	tests := map[string]struct {
-	serviceAccountObject.Name = "my-service-account"
+		options  *ServiceAccountOpts
-	tf := cmdtesting.NewTestFactory().WithNamespace("test")
+		expected *corev1.ServiceAccount
-	defer tf.Cleanup()
+	}{
-
+		"service account": {
-	codec := scheme.Codecs.LegacyCodec(scheme.Scheme.PrioritizedVersionsAllGroups()...)
+			options: &ServiceAccountOpts{
-	ns := scheme.Codecs.WithoutConversion()
+				Name: "my-service-account",
-
+			},
-	tf.Client = &fake.RESTClient{
+			expected: &corev1.ServiceAccount{
-		GroupVersion:         schema.GroupVersion{Version: "v1"},
+				TypeMeta: metav1.TypeMeta{
-		NegotiatedSerializer: ns,
+					Kind:       "ServiceAccount",
-		Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
+					APIVersion: "v1",
-			switch p, m := req.URL.Path, req.Method; {
+				},
-			case p == "/namespaces/test/serviceaccounts" && m == "POST":
+				ObjectMeta: metav1.ObjectMeta{
-				return &http.Response{StatusCode: http.StatusCreated, Header: cmdtesting.DefaultHeader(), Body: cmdtesting.ObjBody(codec, serviceAccountObject)}, nil
+					Name: "my-service-account",
-			default:
+				},
-				t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
+			},
-				return nil, nil
+		},
-			}
-		}),
 	}
-	ioStreams, _, buf, _ := genericclioptions.NewTestIOStreams()
+
-	cmd := NewCmdCreateServiceAccount(tf, ioStreams)
+	for name, tc := range tests {
-	cmd.Flags().Set("output", "name")
+		t.Run(name, func(t *testing.T) {
-	cmd.Run(cmd, []string{serviceAccountObject.Name})
+			serviceAccount, err := tc.options.createServiceAccount()
-	expectedOutput := "serviceaccount/" + serviceAccountObject.Name + "\n"
+			if err != nil {
-	if buf.String() != expectedOutput {
+				t.Errorf("unexpected error:\n%#v\n", err)
-		t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String())
+				return
+			}
+			if !apiequality.Semantic.DeepEqual(serviceAccount, tc.expected) {
+				t.Errorf("expected:\n%#v\ngot:\n%#v", tc.expected, serviceAccount)
+			}
+		})
 	}
 }