From 23b2c5aba666738dacb07071a96ee0505501a04f Mon Sep 17 00:00:00 2001 From: ramnar Date: Thu, 12 Nov 2020 07:21:46 +0530 Subject: [PATCH] remove generator dependency in create service account Kubernetes-commit: 7000c28b74b6069fd3b5179d89178271b9fafe42 --- pkg/cmd/create/create_serviceaccount.go | 158 ++++++++++++++++--- pkg/cmd/create/create_serviceaccount_test.go | 67 ++++---- 2 files changed, 170 insertions(+), 55 deletions(-) diff --git a/pkg/cmd/create/create_serviceaccount.go b/pkg/cmd/create/create_serviceaccount.go index 2c45cb11..84a4d8e2 100644 --- a/pkg/cmd/create/create_serviceaccount.go +++ b/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" - generateversioned "k8s.io/kubectl/pkg/generate/versioned" + "k8s.io/kubectl/pkg/scheme" + "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{ - CreateSubcommandOptions: NewCreateSubcommandOptions(ioStreams), - } + o := NewServiceAccountOpts(ioStreams) cmd := &cobra.Command{ Use: "serviceaccount NAME [--dry-run=server|client|none]", @@ -55,41 +86,126 @@ 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(options.Run()) + cmdutil.CheckErr(o.Complete(f, cmd, args)) + 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.AddFieldManagerFlagVar(cmd, &options.CreateSubcommandOptions.FieldManager, "kubectl-create") + cmdutil.AddDryRunFlag(cmd) + 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 - switch generatorName := cmdutil.GetFlagString(cmd, "generator"); generatorName { - case generateversioned.ServiceAccountV1GeneratorName: - generator = &generateversioned.ServiceAccountGeneratorV1{Name: name} - default: - return errUnsupportedGenerator(cmd, generatorName) + restConfig, err := f.ToRESTConfig() + if err != nil { + return err + } + o.Client, err = coreclient.NewForConfig(restConfig) + 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) Validate() error { + 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 { - return o.CreateSubcommandOptions.Run() + 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 } func errUnsupportedGenerator(cmd *cobra.Command, generatorName string) error { diff --git a/pkg/cmd/create/create_serviceaccount_test.go b/pkg/cmd/create/create_serviceaccount_test.go index 5d511788..6029357a 100644 --- a/pkg/cmd/create/create_serviceaccount_test.go +++ b/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" - "k8s.io/apimachinery/pkg/runtime/schema" - "k8s.io/cli-runtime/pkg/genericclioptions" - "k8s.io/client-go/rest/fake" - cmdtesting "k8s.io/kubectl/pkg/cmd/testing" - "k8s.io/kubectl/pkg/scheme" + corev1 "k8s.io/api/core/v1" + apiequality "k8s.io/apimachinery/pkg/api/equality" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" ) func TestCreateServiceAccount(t *testing.T) { - serviceAccountObject := &v1.ServiceAccount{} - serviceAccountObject.Name = "my-service-account" - tf := cmdtesting.NewTestFactory().WithNamespace("test") - defer tf.Cleanup() - - codec := scheme.Codecs.LegacyCodec(scheme.Scheme.PrioritizedVersionsAllGroups()...) - ns := scheme.Codecs.WithoutConversion() - - tf.Client = &fake.RESTClient{ - GroupVersion: schema.GroupVersion{Version: "v1"}, - NegotiatedSerializer: ns, - Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) { - switch p, m := req.URL.Path, req.Method; { - case p == "/namespaces/test/serviceaccounts" && m == "POST": - return &http.Response{StatusCode: http.StatusCreated, Header: cmdtesting.DefaultHeader(), Body: cmdtesting.ObjBody(codec, serviceAccountObject)}, nil - default: - t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) - return nil, nil - } - }), + tests := map[string]struct { + options *ServiceAccountOpts + expected *corev1.ServiceAccount + }{ + "service account": { + options: &ServiceAccountOpts{ + Name: "my-service-account", + }, + expected: &corev1.ServiceAccount{ + TypeMeta: metav1.TypeMeta{ + Kind: "ServiceAccount", + APIVersion: "v1", + }, + ObjectMeta: metav1.ObjectMeta{ + Name: "my-service-account", + }, + }, + }, } - ioStreams, _, buf, _ := genericclioptions.NewTestIOStreams() - cmd := NewCmdCreateServiceAccount(tf, ioStreams) - cmd.Flags().Set("output", "name") - cmd.Run(cmd, []string{serviceAccountObject.Name}) - expectedOutput := "serviceaccount/" + serviceAccountObject.Name + "\n" - if buf.String() != expectedOutput { - t.Errorf("expected output: %s, but got: %s", expectedOutput, buf.String()) + + for name, tc := range tests { + t.Run(name, func(t *testing.T) { + serviceAccount, err := tc.options.createServiceAccount() + if err != nil { + t.Errorf("unexpected error:\n%#v\n", err) + return + } + if !apiequality.Semantic.DeepEqual(serviceAccount, tc.expected) { + t.Errorf("expected:\n%#v\ngot:\n%#v", tc.expected, serviceAccount) + } + }) } }