From b961b39efa7d3ad04788ac5a9b1744a1bf080b0f Mon Sep 17 00:00:00 2001 From: Tim Hockin Date: Thu, 21 Dec 2023 13:13:42 -0800 Subject: [PATCH] Fix client-gen wrt gengo/v2 --- .../cmd/client-gen/args/args.go | 22 ++-- .../client-gen/generators/client_generator.go | 105 +++++++++++++----- .../generators/fake/fake_client_generator.go | 34 +++--- .../fake/generator_fake_for_clientset.go | 7 +- .../fake/generator_fake_for_group.go | 4 +- .../fake/generator_fake_for_type.go | 2 +- .../generators/generator_for_clientset.go | 5 +- .../generators/generator_for_group.go | 2 +- .../generators/generator_for_type.go | 6 +- .../generators/scheme/generator_for_scheme.go | 4 +- .../code-generator/cmd/client-gen/main.go | 4 - 11 files changed, 122 insertions(+), 73 deletions(-) diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/args/args.go b/staging/src/k8s.io/code-generator/cmd/client-gen/args/args.go index 4fff439fe85..4365f789656 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/args/args.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/args/args.go @@ -18,19 +18,20 @@ package args import ( "fmt" - "path" "github.com/spf13/pflag" "k8s.io/gengo/v2/args" "k8s.io/code-generator/cmd/client-gen/types" - codegenutil "k8s.io/code-generator/pkg/util" ) var DefaultInputDirs = []string{} // CustomArgs is a wrapper for arguments to client-gen. type CustomArgs struct { + // The Go import-path of the generated results. + OutputPackage string + // A sorted list of group versions to generate. For each of them the package path is found // in GroupVersionToInputPath. Groups []types.GroupVersions @@ -72,15 +73,12 @@ func NewDefaults() (*args.GeneratorArgs, *CustomArgs) { genericArgs.CustomArgs = customArgs genericArgs.InputDirs = DefaultInputDirs - if pkg := codegenutil.CurrentPackage(); len(pkg) != 0 { - genericArgs.OutputPackagePath = path.Join(pkg, "pkg/client/clientset") - } - return genericArgs, customArgs } func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet, inputBase string) { gvsBuilder := NewGroupVersionsBuilder(&ca.Groups) + fs.StringVar(&ca.OutputPackage, "output-package", ca.OutputPackage, "the Go import-path of the generated results") fs.Var(NewGVPackagesValue(gvsBuilder, nil), "input", "group/versions that client-gen will generate clients for. At most one version per group is allowed. Specified in the format \"group1/version1,group2/version2...\".") fs.Var(NewGVTypesValue(&ca.IncludedTypesOverrides, []string{}), "included-types-overrides", "list of group/version/type for which client should be generated. By default, client is generated for all types which have genclient in types.go. This overrides that. For each groupVersion in this list, only the types mentioned here will be included. The default check of genclient will be used for other group versions.") fs.Var(NewInputBasePathValue(gvsBuilder, inputBase), "input-base", "base path to look for the api group.") @@ -97,16 +95,20 @@ func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet, inputBase string) { } func Validate(genericArgs *args.GeneratorArgs) error { + if len(genericArgs.OutputBase) == 0 { + return fmt.Errorf("--output-base must be specified") + } + customArgs := genericArgs.CustomArgs.(*CustomArgs) - if len(genericArgs.OutputPackagePath) == 0 { - return fmt.Errorf("output package cannot be empty") + if len(customArgs.OutputPackage) == 0 { + return fmt.Errorf("--output-package must be specified") } if len(customArgs.ClientsetName) == 0 { - return fmt.Errorf("clientset name cannot be empty") + return fmt.Errorf("--clientset-name must be specified") } if len(customArgs.ClientsetAPIPath) == 0 { - return fmt.Errorf("clientset API path cannot be empty") + return fmt.Errorf("--clientset-api-path cannot be empty") } return nil diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go index d64ea04dff8..a1c9c4edb3f 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go @@ -18,6 +18,7 @@ limitations under the License. package generators import ( + "fmt" "path/filepath" "strings" @@ -128,11 +129,15 @@ func DefaultNameSystem() string { return "public" } -func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetPackage string, groupPackageName string, groupGoName string, apiPath string, srcTreePath string, inputPackage string, applyBuilderPackage string, boilerplate []byte) generator.Package { - groupVersionClientPackage := filepath.Join(clientsetPackage, "typed", strings.ToLower(groupPackageName), strings.ToLower(gv.Version.NonEmpty())) +func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetDir, clientsetPkg string, groupPkgName string, groupGoName string, apiPath string, inputPkg string, applyBuilderPkg string, boilerplate []byte) generator.Package { + subdir := filepath.Join("typed", strings.ToLower(groupPkgName), strings.ToLower(gv.Version.NonEmpty())) + gvDir := filepath.Join(clientsetDir, subdir) + gvPkg := filepath.Join(clientsetPkg, subdir) + return &generator.DefaultPackage{ PackageName: strings.ToLower(gv.Version.NonEmpty()), - PackagePath: groupVersionClientPackage, + PackagePath: gvPkg, + Source: gvDir, HeaderText: boilerplate, PackageDocumentation: []byte("// This package has the automatically generated typed clients.\n"), // GeneratorFunc returns a list of generators. Each generator makes a @@ -149,10 +154,10 @@ func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli DefaultGen: generator.DefaultGen{ OptionalName: strings.ToLower(c.Namers["private"].Name(t)), }, - outputPackage: groupVersionClientPackage, - inputPackage: inputPackage, - clientsetPackage: clientsetPackage, - applyConfigurationPackage: applyBuilderPackage, + outputPackage: gvPkg, + inputPackage: inputPkg, + clientsetPackage: clientsetPkg, + applyConfigurationPackage: applyBuilderPkg, group: gv.Group.NonEmpty(), version: gv.Version.String(), groupGoName: groupGoName, @@ -163,11 +168,11 @@ func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli generators = append(generators, &genGroup{ DefaultGen: generator.DefaultGen{ - OptionalName: groupPackageName + "_client", + OptionalName: groupPkgName + "_client", }, - outputPackage: groupVersionClientPackage, - inputPackage: inputPackage, - clientsetPackage: clientsetPackage, + outputPackage: gvPkg, + inputPackage: inputPkg, + clientsetPackage: clientsetPkg, group: gv.Group.NonEmpty(), version: gv.Version.String(), groupGoName: groupGoName, @@ -178,7 +183,7 @@ func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli expansionFileName := "generated_expansion" generators = append(generators, &genExpansion{ - groupPackagePath: filepath.Join(srcTreePath, groupVersionClientPackage), + groupPackagePath: gvDir, DefaultGen: generator.DefaultGen{ OptionalName: expansionFileName, }, @@ -193,10 +198,11 @@ func packageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli } } -func packageForClientset(customArgs *clientgenargs.CustomArgs, clientsetPackage string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package { +func packageForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package { return &generator.DefaultPackage{ PackageName: customArgs.ClientsetName, - PackagePath: clientsetPackage, + PackagePath: clientsetPkg, + Source: clientsetDir, HeaderText: boilerplate, // GeneratorFunc returns a list of generators. Each generator generates a // single file. @@ -208,8 +214,7 @@ func packageForClientset(customArgs *clientgenargs.CustomArgs, clientsetPackage }, groups: customArgs.Groups, groupGoNames: groupGoNames, - clientsetPackage: clientsetPackage, - outputPackage: customArgs.ClientsetName, + clientsetPackage: clientsetPkg, imports: generator.NewImportTracker(), }, } @@ -218,8 +223,9 @@ func packageForClientset(customArgs *clientgenargs.CustomArgs, clientsetPackage } } -func packageForScheme(customArgs *clientgenargs.CustomArgs, clientsetPackage string, srcTreePath string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package { - schemePackage := filepath.Join(clientsetPackage, "scheme") +func packageForScheme(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package { + schemeDir := filepath.Join(clientsetDir, "scheme") + schemePkg := filepath.Join(clientsetPkg, "scheme") // create runtime.Registry for internal client because it has to know about group versions internalClient := false @@ -235,7 +241,8 @@ NextGroup: return &generator.DefaultPackage{ PackageName: "scheme", - PackagePath: schemePackage, + PackagePath: schemePkg, + Source: schemeDir, HeaderText: boilerplate, PackageDocumentation: []byte("// This package contains the scheme of the automatically generated clientset.\n"), // GeneratorFunc returns a list of generators. Each generator generates a @@ -250,8 +257,8 @@ NextGroup: OptionalName: "register", }, InputPackages: customArgs.GroupVersionPackages(), - OutputPackage: schemePackage, - OutputPath: filepath.Join(srcTreePath, schemePackage), + OutputPackage: schemePkg, + OutputPath: schemeDir, Groups: customArgs.Groups, GroupGoNames: groupGoNames, ImportTracker: generator.NewImportTracker(), @@ -305,6 +312,35 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust customArgs.Groups = newGroups } +// Because we try to assemble inputs from an input-base and a set of +// group-version arguments, sometimes that comes in as a filesystem path. This +// function rewrites them all as their canonical Go import-paths. +// +// TODO: Change this tool to just take inputs as Go "patterns" like every other +// gengo tool, then extract GVs from those. +func sanitizePackagePaths(context *generator.Context, ca *clientgenargs.CustomArgs) error { + for i := range ca.Groups { + pkg := &ca.Groups[i] + for j := range pkg.Versions { + ver := &pkg.Versions[j] + input := ver.Package + p := context.Universe[path.Vendorless(input)] + if p == nil || p.Name == "" { + pkgs, err := context.FindPackages(input) + if err != nil { + return fmt.Errorf("can't find input package %q: %w", input, err) + } + p = context.Universe[pkgs[0]] + if p == nil { + return fmt.Errorf("can't find input package %q in universe", input) + } + ver.Package = p.Path + } + } + } + return nil +} + // Packages makes the client package definition. func Packages(context *generator.Context, arguments *args.GeneratorArgs) generator.Packages { boilerplate, err := arguments.LoadGoBoilerplate() @@ -318,6 +354,9 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } includedTypesOverrides := customArgs.IncludedTypesOverrides + if err := sanitizePackagePaths(context, customArgs); err != nil { + klog.Fatalf("cannot sanitize inputs: %v", err) + } applyGroupOverrides(context.Universe, customArgs) gvToTypes := map[clientgentypes.GroupVersion][]*types.Type{} @@ -361,13 +400,18 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat } } - var packageList []generator.Package - clientsetPackage := filepath.Join(arguments.OutputPackagePath, customArgs.ClientsetName) + clientsetDir := filepath.Join(arguments.OutputBase, customArgs.ClientsetName) + clientsetPkg := filepath.Join(customArgs.OutputPackage, customArgs.ClientsetName) - packageList = append(packageList, packageForClientset(customArgs, clientsetPackage, groupGoNames, boilerplate)) - packageList = append(packageList, packageForScheme(customArgs, clientsetPackage, arguments.OutputBase, groupGoNames, boilerplate)) + var packageList []generator.Package + + packageList = append(packageList, + packageForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate)) + packageList = append(packageList, + packageForScheme(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate)) if customArgs.FakeClient { - packageList = append(packageList, fake.PackageForClientset(customArgs, clientsetPackage, groupGoNames, boilerplate)) + packageList = append(packageList, + fake.PackageForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate)) } // If --clientset-only=true, we don't regenerate the individual typed clients. @@ -382,9 +426,14 @@ func Packages(context *generator.Context, arguments *args.GeneratorArgs) generat gv := clientgentypes.GroupVersion{Group: group.Group, Version: version.Version} types := gvToTypes[gv] inputPath := gvPackages[gv] - packageList = append(packageList, packageForGroup(gv, orderer.OrderTypes(types), clientsetPackage, group.PackageName, groupGoNames[gv], customArgs.ClientsetAPIPath, arguments.OutputBase, inputPath, customArgs.ApplyConfigurationPackage, boilerplate)) + packageList = append(packageList, + packageForGroup( + gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg, + group.PackageName, groupGoNames[gv], customArgs.ClientsetAPIPath, + inputPath, customArgs.ApplyConfigurationPackage, boilerplate)) if customArgs.FakeClient { - packageList = append(packageList, fake.PackageForGroup(gv, orderer.OrderTypes(types), clientsetPackage, group.PackageName, groupGoNames[gv], inputPath, customArgs.ApplyConfigurationPackage, boilerplate)) + packageList = append(packageList, + fake.PackageForGroup(gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg, group.PackageName, groupGoNames[gv], inputPath, customArgs.ApplyConfigurationPackage, boilerplate)) } } } diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/fake_client_generator.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/fake_client_generator.go index 0b66d21e11c..f7151dcefaa 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/fake_client_generator.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/fake_client_generator.go @@ -29,13 +29,17 @@ import ( clientgentypes "k8s.io/code-generator/cmd/client-gen/types" ) -func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetPackage string, groupPackageName string, groupGoName string, inputPackage string, applyBuilderPackage string, boilerplate []byte) generator.Package { - outputPackage := filepath.Join(clientsetPackage, "typed", strings.ToLower(groupPackageName), strings.ToLower(gv.Version.NonEmpty()), "fake") +func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clientsetDir, clientsetPkg string, groupPkgName string, groupGoName string, inputPkg string, applyBuilderPackage string, boilerplate []byte) generator.Package { // TODO: should make this a function, called by here and in client-generator.go - realClientPackage := filepath.Join(clientsetPackage, "typed", strings.ToLower(groupPackageName), strings.ToLower(gv.Version.NonEmpty())) + subdir := filepath.Join("typed", strings.ToLower(groupPkgName), strings.ToLower(gv.Version.NonEmpty())) + outputDir := filepath.Join(clientsetDir, subdir, "fake") + outputPkg := filepath.Join(clientsetPkg, subdir, "fake") + realClientPkg := filepath.Join(clientsetPkg, subdir) + return &generator.DefaultPackage{ PackageName: "fake", - PackagePath: outputPackage, + PackagePath: outputPkg, + Source: outputDir, HeaderText: boilerplate, PackageDocumentation: []byte( `// Package fake has the automatically generated clients. @@ -54,8 +58,8 @@ func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli DefaultGen: generator.DefaultGen{ OptionalName: "fake_" + strings.ToLower(c.Namers["private"].Name(t)), }, - outputPackage: outputPackage, - inputPackage: inputPackage, + outputPackage: outputPkg, + inputPackage: inputPkg, group: gv.Group.NonEmpty(), version: gv.Version.String(), groupGoName: groupGoName, @@ -67,10 +71,10 @@ func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli generators = append(generators, &genFakeForGroup{ DefaultGen: generator.DefaultGen{ - OptionalName: "fake_" + groupPackageName + "_client", + OptionalName: "fake_" + groupPkgName + "_client", }, - outputPackage: outputPackage, - realClientPackage: realClientPackage, + outputPackage: outputPkg, + realClientPackage: realClientPkg, group: gv.Group.NonEmpty(), version: gv.Version.String(), groupGoName: groupGoName, @@ -85,12 +89,13 @@ func PackageForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, cli } } -func PackageForClientset(customArgs *clientgenargs.CustomArgs, clientsetPackage string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package { +func PackageForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Package { return &generator.DefaultPackage{ // TODO: we'll generate fake clientset for different release in the future. // Package name and path are hard coded for now. PackageName: "fake", - PackagePath: filepath.Join(clientsetPackage, "fake"), + PackagePath: filepath.Join(clientsetPkg, "fake"), + Source: filepath.Join(clientsetDir, "fake"), HeaderText: boilerplate, PackageDocumentation: []byte( `// This package has the automatically generated fake clientset. @@ -108,17 +113,16 @@ func PackageForClientset(customArgs *clientgenargs.CustomArgs, clientsetPackage }, groups: customArgs.Groups, groupGoNames: groupGoNames, - fakeClientsetPackage: clientsetPackage, - outputPackage: "fake", + fakeClientsetPackage: clientsetPkg, imports: generator.NewImportTracker(), - realClientsetPackage: clientsetPackage, + realClientsetPackage: clientsetPkg, }, &scheme.GenScheme{ DefaultGen: generator.DefaultGen{ OptionalName: "register", }, InputPackages: customArgs.GroupVersionPackages(), - OutputPackage: clientsetPackage, + OutputPackage: clientsetPkg, Groups: customArgs.Groups, GroupGoNames: groupGoNames, ImportTracker: generator.NewImportTracker(), diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_clientset.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_clientset.go index 0357c57e018..12bf0a856ef 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_clientset.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_clientset.go @@ -33,19 +33,18 @@ type genClientset struct { generator.DefaultGen groups []clientgentypes.GroupVersions groupGoNames map[clientgentypes.GroupVersion]string - fakeClientsetPackage string - outputPackage string + fakeClientsetPackage string // must be a Go import-path imports namer.ImportTracker clientsetGenerated bool // the import path of the generated real clientset. - realClientsetPackage string + realClientsetPackage string // must be a Go import-path } var _ generator.Generator = &genClientset{} func (g *genClientset) Namers(c *generator.Context) namer.NameSystems { return namer.NameSystems{ - "raw": namer.NewRawNamer(g.outputPackage, g.imports), + "raw": namer.NewRawNamer(g.fakeClientsetPackage, g.imports), } } diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_group.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_group.go index d8ad01f79fa..b4d7586835b 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_group.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_group.go @@ -32,8 +32,8 @@ import ( // genFakeForGroup produces a file for a group client, e.g. ExtensionsClient for the extension group. type genFakeForGroup struct { generator.DefaultGen - outputPackage string - realClientPackage string + outputPackage string // must be a Go import-path + realClientPackage string // must be a Go import-path group string version string groupGoName string diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go index 0776d2dd1db..a9b6af1c4e3 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/generator_fake_for_type.go @@ -32,7 +32,7 @@ import ( // genFakeForType produces a file for each top-level type. type genFakeForType struct { generator.DefaultGen - outputPackage string + outputPackage string // Must be a Go import-path group string version string groupGoName string diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go index b1175abc3ae..5feb24b7516 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_clientset.go @@ -33,8 +33,7 @@ type genClientset struct { generator.DefaultGen groups []clientgentypes.GroupVersions groupGoNames map[clientgentypes.GroupVersion]string - clientsetPackage string - outputPackage string + clientsetPackage string // must be a Go import-path imports namer.ImportTracker clientsetGenerated bool } @@ -43,7 +42,7 @@ var _ generator.Generator = &genClientset{} func (g *genClientset) Namers(c *generator.Context) namer.NameSystems { return namer.NameSystems{ - "raw": namer.NewRawNamer(g.outputPackage, g.imports), + "raw": namer.NewRawNamer(g.clientsetPackage, g.imports), } } diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go index 70ec92ac963..c5a75676c73 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_group.go @@ -40,7 +40,7 @@ type genGroup struct { types []*types.Type imports namer.ImportTracker inputPackage string - clientsetPackage string + clientsetPackage string // must be a Go import-path // If the genGroup has been called. This generator should only execute once. called bool } diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_type.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_type.go index 5f6098865bc..34fe32d6db8 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_type.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/generator_for_type.go @@ -32,10 +32,10 @@ import ( // genClientForType produces a file for each top-level type. type genClientForType struct { generator.DefaultGen - outputPackage string + outputPackage string // must be a Go import-path inputPackage string - clientsetPackage string - applyConfigurationPackage string + clientsetPackage string // must be a Go import-path + applyConfigurationPackage string // must be a Go import-path group string version string groupGoName string diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/scheme/generator_for_scheme.go b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/scheme/generator_for_scheme.go index b2f09559371..8bfe7f625be 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/generators/scheme/generator_for_scheme.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/generators/scheme/generator_for_scheme.go @@ -33,11 +33,11 @@ import ( // GenScheme produces a package for a clientset with the scheme, codecs and parameter codecs. type GenScheme struct { generator.DefaultGen - OutputPackage string + OutputPackage string // Must be a Go import-path + OutputPath string // optional Groups []clientgentypes.GroupVersions GroupGoNames map[clientgentypes.GroupVersion]string InputPackages map[clientgentypes.GroupVersion]string - OutputPath string ImportTracker namer.ImportTracker PrivateScheme bool CreateRegistry bool diff --git a/staging/src/k8s.io/code-generator/cmd/client-gen/main.go b/staging/src/k8s.io/code-generator/cmd/client-gen/main.go index 64a1274dfc0..7d6630de3da 100644 --- a/staging/src/k8s.io/code-generator/cmd/client-gen/main.go +++ b/staging/src/k8s.io/code-generator/cmd/client-gen/main.go @@ -32,10 +32,6 @@ func main() { klog.InitFlags(nil) genericArgs, customArgs := generatorargs.NewDefaults() - // Override defaults. - // TODO: move this out of client-gen - genericArgs.OutputPackagePath = "k8s.io/kubernetes/pkg/client/clientset_generated/" - genericArgs.AddFlags(pflag.CommandLine) customArgs.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of client-gen flag.Set("logtostderr", "true")