github/kubernetes
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Get rid of gengo CustomArgs

Browse Source
This commit is contained in:
Tim Hockin
2024-01-16 21:57:12 -08:00
parent 86d2ecbf9a
commit b40e4d7e70
29 changed files with 389 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
staging/src/k8s.io/code-generator/cmd/applyconfiguration-gen/args/args.go
View File

@@ -20,12 +20,11 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/types"
)
// CustomArgs is a wrapper for arguments to applyconfiguration-gen.
type CustomArgs struct {
// Args is a wrapper for arguments to applyconfiguration-gen.
type Args struct {
OutputDir string // must be a directory path
OutputPkg string // must be a Go import-path
@@ -46,10 +45,9 @@ type CustomArgs struct {
OpenAPISchemaFilePath string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{
// New returns default arguments for the generator.
func New() *Args {
return &Args{
ExternalApplyConfigurations: map[types.Name]string{
// Always include the applyconfigurations we've generated in client-go. They are sufficient for the vast majority of use cases.
{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "Condition"}: "k8s.io/client-go/applyconfigurations/meta/v1",
@@ -62,35 +60,29 @@ func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
{Package: "k8s.io/apimachinery/pkg/apis/meta/v1", Name: "TypeMeta"}: "k8s.io/client-go/applyconfigurations/meta/v1",
},
}
genericArgs.CustomArgs = customArgs
return genericArgs, customArgs
}
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet, inputBase string) {
fs.StringVar(&ca.OutputDir, "output-dir", "",
func (args *Args) AddFlags(fs *pflag.FlagSet, inputBase string) {
fs.StringVar(&args.OutputDir, "output-dir", "",
"the base directory under which to generate results")
fs.StringVar(&ca.OutputPkg, "output-pkg", ca.OutputPkg,
fs.StringVar(&args.OutputPkg, "output-pkg", args.OutputPkg,
"the Go import-path of the generated results")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
fs.Var(NewExternalApplyConfigurationValue(&ca.ExternalApplyConfigurations, nil), "external-applyconfigurations",
fs.Var(NewExternalApplyConfigurationValue(&args.ExternalApplyConfigurations, nil), "external-applyconfigurations",
"list of comma separated external apply configurations locations in <type-package>.<type-name>:<applyconfiguration-package> form."+
"For example: k8s.io/api/apps/v1.Deployment:k8s.io/client-go/applyconfigurations/apps/v1")
fs.StringVar(&ca.OpenAPISchemaFilePath, "openapi-schema", "",
fs.StringVar(&args.OpenAPISchemaFilePath, "openapi-schema", "",
"path to the openapi schema containing all the types that apply configurations will be generated for")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
customArgs := genericArgs.CustomArgs.(*CustomArgs)
if len(customArgs.OutputDir) == 0 {
func (args *Args) Validate() error {
if len(args.OutputDir) == 0 {
return fmt.Errorf("--output-dir must be specified")
}
if len(customArgs.OutputPkg) == 0 {
if len(args.OutputPkg) == 0 {
return fmt.Errorf("--output-pkg must be specified")
}
return nil
}

28
staging/src/k8s.io/code-generator/cmd/applyconfiguration-gen/generators/targets.go
View File

@@ -23,13 +23,13 @@ import (
"sort"
"strings"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
"k8s.io/klog/v2"
applygenargs "k8s.io/code-generator/cmd/applyconfiguration-gen/args"
"k8s.io/code-generator/cmd/applyconfiguration-gen/args"
"k8s.io/code-generator/cmd/client-gen/generators/util"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
)
@@ -55,20 +55,18 @@ func DefaultNameSystem() string {
}
// GetTargets makes the client target definition.
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*applygenargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
pkgTypes := packageTypesForInputs(context, customArgs.OutputPkg)
initialTypes := customArgs.ExternalApplyConfigurations
pkgTypes := packageTypesForInputs(context, args.OutputPkg)
initialTypes := args.ExternalApplyConfigurations
refs := refGraphForReachableTypes(context.Universe, pkgTypes, initialTypes)
typeModels, err := newTypeModels(customArgs.OpenAPISchemaFilePath, pkgTypes)
typeModels, err := newTypeModels(args.OpenAPISchemaFilePath, pkgTypes)
if err != nil {
klog.Fatalf("Failed build type models from typeModels %s: %v", customArgs.OpenAPISchemaFilePath, err)
klog.Fatalf("Failed build type models from typeModels %s: %v", args.OpenAPISchemaFilePath, err)
}
groupVersions := make(map[string]clientgentypes.GroupVersions)
@@ -103,13 +101,13 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
// Apparently we allow the groupName to be overridden in a way that it
// no longer maps to a Go package by name. So we have to figure out
// the offset of this particular output package (pkg) from the base
// output package (customArgs.OutputPkg).
pkgSubdir := strings.TrimPrefix(pkg, customArgs.OutputPkg+"/")
// output package (args.OutputPkg).
pkgSubdir := strings.TrimPrefix(pkg, args.OutputPkg+"/")
// generate the apply configurations
targetList = append(targetList,
targetForApplyConfigurationsPackage(
customArgs.OutputDir, customArgs.OutputPkg, pkgSubdir,
args.OutputDir, args.OutputPkg, pkgSubdir,
boilerplate, gv, toGenerate, refs, typeModels))
// group all the generated apply configurations by gv so ForKind() can be generated
@@ -133,11 +131,11 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
// generate ForKind() utility function
targetList = append(targetList,
targetForUtils(customArgs.OutputDir, customArgs.OutputPkg,
targetForUtils(args.OutputDir, args.OutputPkg,
boilerplate, groupVersions, applyConfigsForGroupVersion, groupGoNames))
// generate internal embedded schema, required for generated Extract functions
targetList = append(targetList,
targetForInternal(customArgs.OutputDir, customArgs.OutputPkg,
targetForInternal(args.OutputDir, args.OutputPkg,
boilerplate, typeModels))
return targetList

25
staging/src/k8s.io/code-generator/cmd/applyconfiguration-gen/main.go
View File

@@ -21,34 +21,37 @@ import (
"flag"
"github.com/spf13/pflag"
"k8s.io/klog/v2"
generatorargs "k8s.io/code-generator/cmd/applyconfiguration-gen/args"
"k8s.io/code-generator/cmd/applyconfiguration-gen/args"
"k8s.io/code-generator/cmd/applyconfiguration-gen/generators"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of applyconfiguration-gen
args := args.New()
args.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of applyconfiguration-gen
if err := flag.Set("logtostderr", "true"); err != nil {
klog.Fatalf("Error: %v", err)
}
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
if err := gengo.Execute(
generators.NameSystems(),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

66
staging/src/k8s.io/code-generator/cmd/client-gen/args/args.go
View File

@@ -20,13 +20,11 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/client-gen/types"
)
// CustomArgs is a wrapper for arguments to client-gen.
type CustomArgs struct {
type Args struct {
// The directory for the generated results.
OutputDir string
@@ -65,9 +63,8 @@ type CustomArgs struct {
ApplyConfigurationPackage string
}
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{
func New() *Args {
return &Args{
ClientsetName: "internalclientset",
ClientsetAPIPath: "/apis",
ClientsetOnly: false,
@@ -75,47 +72,50 @@ func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
PluralExceptions: []string{"Endpoints:Endpoints"},
ApplyConfigurationPackage: "",
}
genericArgs.CustomArgs = customArgs
return genericArgs, customArgs
}
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet, inputBase string) {
gvsBuilder := NewGroupVersionsBuilder(&ca.Groups)
fs.StringVar(&ca.OutputDir, "output-dir", "",
func (args *Args) AddFlags(fs *pflag.FlagSet, inputBase string) {
gvsBuilder := NewGroupVersionsBuilder(&args.Groups)
fs.StringVar(&args.OutputDir, "output-dir", "",
"the base directory under which to generate results")
fs.StringVar(&ca.OutputPkg, "output-pkg", ca.OutputPkg,
fs.StringVar(&args.OutputPkg, "output-pkg", args.OutputPkg,
"the Go import-path of the generated results")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
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.")
fs.StringVarP(&ca.ClientsetName, "clientset-name", "n", ca.ClientsetName, "the name of the generated clientset package.")
fs.StringVarP(&ca.ClientsetAPIPath, "clientset-api-path", "", ca.ClientsetAPIPath, "the value of default API HTTP path, starting with / and without trailing /.")
fs.BoolVar(&ca.ClientsetOnly, "clientset-only", ca.ClientsetOnly, "when set, client-gen only generates the clientset shell, without generating the individual typed clients")
fs.BoolVar(&ca.FakeClient, "fake-clientset", ca.FakeClient, "when set, client-gen will generate the fake clientset that can be used in tests")
fs.StringSliceVar(&ca.PluralExceptions, "plural-exceptions", ca.PluralExceptions, "list of comma separated plural exception definitions in Type:PluralizedType form")
fs.StringVar(&ca.ApplyConfigurationPackage, "apply-configuration-package", ca.ApplyConfigurationPackage, "optional package of apply configurations, generated by applyconfiguration-gen, that are required to generate Apply functions for each type in the clientset. By default Apply functions are not generated.")
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(&args.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.")
fs.StringVarP(&args.ClientsetName, "clientset-name", "n", args.ClientsetName,
"the name of the generated clientset package.")
fs.StringVarP(&args.ClientsetAPIPath, "clientset-api-path", "", args.ClientsetAPIPath,
"the value of default API HTTP path, starting with / and without trailing /.")
fs.BoolVar(&args.ClientsetOnly, "clientset-only", args.ClientsetOnly,
"when set, client-gen only generates the clientset shell, without generating the individual typed clients")
fs.BoolVar(&args.FakeClient, "fake-clientset", args.FakeClient,
"when set, client-gen will generate the fake clientset that can be used in tests")
fs.StringSliceVar(&args.PluralExceptions, "plural-exceptions", args.PluralExceptions,
"list of comma separated plural exception definitions in Type:PluralizedType form")
fs.StringVar(&args.ApplyConfigurationPackage, "apply-configuration-package", args.ApplyConfigurationPackage,
"optional package of apply configurations, generated by applyconfiguration-gen, that are required to generate Apply functions for each type in the clientset. By default Apply functions are not generated.")
// support old flags
fs.SetNormalizeFunc(mapFlagName("clientset-path", "output-pkg", fs.GetNormalizeFunc()))
}
func Validate(genericArgs *args.GeneratorArgs) error {
customArgs := genericArgs.CustomArgs.(*CustomArgs)
if len(customArgs.OutputDir) == 0 {
func (args *Args) Validate() error {
if len(args.OutputDir) == 0 {
return fmt.Errorf("--output-dir must be specified")
}
if len(customArgs.OutputPkg) == 0 {
if len(args.OutputPkg) == 0 {
return fmt.Errorf("--output-pkg must be specified")
}
if len(customArgs.ClientsetName) == 0 {
if len(args.ClientsetName) == 0 {
return fmt.Errorf("--clientset-name must be specified")
}
if len(customArgs.ClientsetAPIPath) == 0 {
if len(args.ClientsetAPIPath) == 0 {
return fmt.Errorf("--clientset-api-path cannot be empty")
}
@@ -123,9 +123,9 @@ func Validate(genericArgs *args.GeneratorArgs) error {
}
// GroupVersionPackages returns a map from GroupVersion to the package with the types.go.
func (ca *CustomArgs) GroupVersionPackages() map[types.GroupVersion]string {
func (args *Args) GroupVersionPackages() map[types.GroupVersion]string {
res := map[types.GroupVersion]string{}
for _, pkg := range ca.Groups {
for _, pkg := range args.Groups {
for _, v := range pkg.Versions {
res[types.GroupVersion{Group: pkg.Group, Version: v.Version}] = v.Package
}

76
staging/src/k8s.io/code-generator/cmd/client-gen/generators/client_generator.go
View File

@@ -22,13 +22,13 @@ import (
"path/filepath"
"strings"
clientgenargs "k8s.io/code-generator/cmd/client-gen/args"
"k8s.io/code-generator/cmd/client-gen/args"
"k8s.io/code-generator/cmd/client-gen/generators/fake"
"k8s.io/code-generator/cmd/client-gen/generators/scheme"
"k8s.io/code-generator/cmd/client-gen/generators/util"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
codegennamer "k8s.io/code-generator/pkg/namer"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
@@ -196,9 +196,9 @@ func targetForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clie
}
}
func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
func targetForClientset(args *args.Args, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
return &generator.SimpleTarget{
PkgName: customArgs.ClientsetName,
PkgName: args.ClientsetName,
PkgPath: clientsetPkg,
PkgDir: clientsetDir,
HeaderComment: boilerplate,
@@ -210,7 +210,7 @@ func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
GoGenerator: generator.GoGenerator{
OutputFilename: "clientset.go",
},
groups: customArgs.Groups,
groups: args.Groups,
groupGoNames: groupGoNames,
clientsetPackage: clientsetPkg,
imports: generator.NewImportTracker(),
@@ -221,14 +221,14 @@ func targetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
}
}
func targetForScheme(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
func targetForScheme(args *args.Args, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
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
NextGroup:
for _, group := range customArgs.Groups {
for _, group := range args.Groups {
for _, v := range group.Versions {
if v.String() == "" {
internalClient = true
@@ -254,10 +254,10 @@ NextGroup:
GoGenerator: generator.GoGenerator{
OutputFilename: "register.go",
},
InputPackages: customArgs.GroupVersionPackages(),
InputPackages: args.GroupVersionPackages(),
OutputPkg: schemePkg,
OutputPath: schemeDir,
Groups: customArgs.Groups,
Groups: args.Groups,
GroupGoNames: groupGoNames,
ImportTracker: generator.NewImportTracker(),
CreateRegistry: internalClient,
@@ -273,10 +273,10 @@ NextGroup:
// first field (somegroup) as the name of the group in Go code, e.g. as the func name in a clientset.
//
// If the first field of the groupName is not unique within the clientset, use "// +groupName=unique
func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.CustomArgs) {
func applyGroupOverrides(universe types.Universe, args *args.Args) {
// Create a map from "old GV" to "new GV" so we know what changes we need to make.
changes := make(map[clientgentypes.GroupVersion]clientgentypes.GroupVersion)
for gv, inputDir := range customArgs.GroupVersionPackages() {
for gv, inputDir := range args.GroupVersionPackages() {
p := universe.Package(inputDir)
if override := types.ExtractCommentTags("+", p.Comments)["groupName"]; override != nil {
newGV := clientgentypes.GroupVersion{
@@ -287,9 +287,9 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust
}
}
// Modify customArgs.Groups based on the groupName overrides.
newGroups := make([]clientgentypes.GroupVersions, 0, len(customArgs.Groups))
for _, gvs := range customArgs.Groups {
// Modify args.Groups based on the groupName overrides.
newGroups := make([]clientgentypes.GroupVersions, 0, len(args.Groups))
for _, gvs := range args.Groups {
gv := clientgentypes.GroupVersion{
Group: gvs.Group,
Version: gvs.Versions[0].Version, // we only need a version, and the first will do
@@ -307,7 +307,7 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust
newGroups = append(newGroups, gvs)
}
}
customArgs.Groups = newGroups
args.Groups = newGroups
}
// Because we try to assemble inputs from an input-base and a set of
@@ -316,9 +316,9 @@ func applyGroupOverrides(universe types.Universe, customArgs *clientgenargs.Cust
//
// 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]
func sanitizePackagePaths(context *generator.Context, args *args.Args) error {
for i := range args.Groups {
pkg := &args.Groups[i]
for j := range pkg.Versions {
ver := &pkg.Versions[j]
input := ver.Package
@@ -340,24 +340,22 @@ func sanitizePackagePaths(context *generator.Context, ca *clientgenargs.CustomAr
}
// GetTargets makes the client target definition.
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*clientgenargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
includedTypesOverrides := customArgs.IncludedTypesOverrides
includedTypesOverrides := args.IncludedTypesOverrides
if err := sanitizePackagePaths(context, customArgs); err != nil {
if err := sanitizePackagePaths(context, args); err != nil {
klog.Fatalf("cannot sanitize inputs: %v", err)
}
applyGroupOverrides(context.Universe, customArgs)
applyGroupOverrides(context.Universe, args)
gvToTypes := map[clientgentypes.GroupVersion][]*types.Type{}
groupGoNames := make(map[clientgentypes.GroupVersion]string)
for gv, inputDir := range customArgs.GroupVersionPackages() {
for gv, inputDir := range args.GroupVersionPackages() {
p := context.Universe.Package(inputDir)
// If there's a comment of the form "// +groupGoName=SomeUniqueShortName", use that as
@@ -395,28 +393,28 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
}
}
clientsetDir := filepath.Join(customArgs.OutputDir, customArgs.ClientsetName)
clientsetPkg := filepath.Join(customArgs.OutputPkg, customArgs.ClientsetName)
clientsetDir := filepath.Join(args.OutputDir, args.ClientsetName)
clientsetPkg := filepath.Join(args.OutputPkg, args.ClientsetName)
var targetList []generator.Target
targetList = append(targetList,
targetForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
targetForClientset(args, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
targetList = append(targetList,
targetForScheme(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
if customArgs.FakeClient {
targetForScheme(args, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
if args.FakeClient {
targetList = append(targetList,
fake.TargetForClientset(customArgs, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
fake.TargetForClientset(args, clientsetDir, clientsetPkg, groupGoNames, boilerplate))
}
// If --clientset-only=true, we don't regenerate the individual typed clients.
if customArgs.ClientsetOnly {
if args.ClientsetOnly {
return []generator.Target(targetList)
}
orderer := namer.Orderer{Namer: namer.NewPrivateNamer(0)}
gvPackages := customArgs.GroupVersionPackages()
for _, group := range customArgs.Groups {
gvPackages := args.GroupVersionPackages()
for _, group := range args.Groups {
for _, version := range group.Versions {
gv := clientgentypes.GroupVersion{Group: group.Group, Version: version.Version}
types := gvToTypes[gv]
@@ -424,11 +422,11 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
targetList = append(targetList,
targetForGroup(
gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg,
group.PackageName, groupGoNames[gv], customArgs.ClientsetAPIPath,
inputPath, customArgs.ApplyConfigurationPackage, boilerplate))
if customArgs.FakeClient {
group.PackageName, groupGoNames[gv], args.ClientsetAPIPath,
inputPath, args.ApplyConfigurationPackage, boilerplate))
if args.FakeClient {
targetList = append(targetList,
fake.TargetForGroup(gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg, group.PackageName, groupGoNames[gv], inputPath, customArgs.ApplyConfigurationPackage, boilerplate))
fake.TargetForGroup(gv, orderer.OrderTypes(types), clientsetDir, clientsetPkg, group.PackageName, groupGoNames[gv], inputPath, args.ApplyConfigurationPackage, boilerplate))
}
}
}

10
staging/src/k8s.io/code-generator/cmd/client-gen/generators/fake/fake_client_generator.go
View File

@@ -23,7 +23,7 @@ import (
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/types"
clientgenargs "k8s.io/code-generator/cmd/client-gen/args"
"k8s.io/code-generator/cmd/client-gen/args"
scheme "k8s.io/code-generator/cmd/client-gen/generators/scheme"
"k8s.io/code-generator/cmd/client-gen/generators/util"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
@@ -87,7 +87,7 @@ func TargetForGroup(gv clientgentypes.GroupVersion, typeList []*types.Type, clie
}
}
func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
func TargetForClientset(args *args.Args, clientsetDir, clientsetPkg string, groupGoNames map[clientgentypes.GroupVersion]string, boilerplate []byte) generator.Target {
return &generator.SimpleTarget{
// TODO: we'll generate fake clientset for different release in the future.
// Package name and path are hard coded for now.
@@ -107,7 +107,7 @@ func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
GoGenerator: generator.GoGenerator{
OutputFilename: "clientset_generated.go",
},
groups: customArgs.Groups,
groups: args.Groups,
groupGoNames: groupGoNames,
fakeClientsetPackage: clientsetPkg,
imports: generator.NewImportTracker(),
@@ -117,9 +117,9 @@ func TargetForClientset(customArgs *clientgenargs.CustomArgs, clientsetDir, clie
GoGenerator: generator.GoGenerator{
OutputFilename: "register.go",
},
InputPackages: customArgs.GroupVersionPackages(),
InputPackages: args.GroupVersionPackages(),
OutputPkg: clientsetPkg,
Groups: customArgs.Groups,
Groups: args.Groups,
GroupGoNames: groupGoNames,
ImportTracker: generator.NewImportTracker(),
PrivateScheme: true,

26
staging/src/k8s.io/code-generator/cmd/client-gen/main.go
View File

@@ -23,39 +23,43 @@ import (
"github.com/spf13/pflag"
"k8s.io/klog/v2"
generatorargs "k8s.io/code-generator/cmd/client-gen/args"
"k8s.io/code-generator/cmd/client-gen/args"
"k8s.io/code-generator/cmd/client-gen/generators"
"k8s.io/code-generator/pkg/util"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of client-gen
args.AddFlags(pflag.CommandLine, "k8s.io/kubernetes/pkg/apis") // TODO: move this input path out of client-gen
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
// add group version package as input dirs for gengo
inputPkgs := []string{}
for _, pkg := range customArgs.Groups {
for _, pkg := range args.Groups {
for _, v := range pkg.Versions {
inputPkgs = append(inputPkgs, v.Package)
}
}
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
if err := genericArgs.Execute(
generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
if err := gengo.Execute(
generators.NameSystems(util.PluralExceptionListToMapOrDie(args.PluralExceptions)),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
inputPkgs,
); err != nil {
klog.Fatalf("Error: %v", err)

34
staging/src/k8s.io/code-generator/cmd/conversion-gen/args/args.go
View File

@@ -20,7 +20,6 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
)
// DefaultBasePeerDirs are the peer-dirs nearly everybody will use, i.e. those coming from
@@ -31,8 +30,7 @@ var DefaultBasePeerDirs = []string{
"k8s.io/apimachinery/pkg/runtime",
}
// CustomArgs is used by the gengo framework to pass args specific to this generator.
type CustomArgs struct {
type Args struct {
// The filename of the generated results.
OutputFile string
@@ -61,40 +59,34 @@ type CustomArgs struct {
GoHeaderFile string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{
// New returns default arguments for the generator.
func New() *Args {
return &Args{
BasePeerDirs: DefaultBasePeerDirs,
SkipUnsafe: false,
}
genericArgs.CustomArgs = customArgs
return genericArgs, customArgs
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputFile, "output-file", "generated.conversion.go",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputFile, "output-file", "generated.conversion.go",
"the name of the file to be generated")
fs.StringSliceVar(&ca.BasePeerDirs, "base-peer-dirs", ca.BasePeerDirs,
fs.StringSliceVar(&args.BasePeerDirs, "base-peer-dirs", args.BasePeerDirs,
"Comma-separated list of apimachinery import paths which are considered, after tag-specified peers, for conversions. Only change these if you have very good reasons.")
fs.StringSliceVar(&ca.ExtraPeerDirs, "extra-peer-dirs", ca.ExtraPeerDirs,
fs.StringSliceVar(&args.ExtraPeerDirs, "extra-peer-dirs", args.ExtraPeerDirs,
"Application specific comma-separated list of import paths which are considered, after tag-specified peers and base-peer-dirs, for conversions.")
fs.StringSliceVar(&ca.ExtraDirs, "extra-dirs", ca.ExtraDirs,
fs.StringSliceVar(&args.ExtraDirs, "extra-dirs", args.ExtraDirs,
"Application specific comma-separated list of import paths which are loaded and considered for callable conversions, but are not considered peers for conversion.")
fs.BoolVar(&ca.SkipUnsafe, "skip-unsafe", ca.SkipUnsafe,
fs.BoolVar(&args.SkipUnsafe, "skip-unsafe", args.SkipUnsafe,
"If true, will not generate code using unsafe pointer conversions; resulting code may be slower.")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
custom := genericArgs.CustomArgs.(*CustomArgs)
if len(custom.OutputFile) == 0 {
func (args *Args) Validate() error {
if len(args.OutputFile) == 0 {
return fmt.Errorf("--output-file must be specified")
}
return nil
}

20
staging/src/k8s.io/code-generator/cmd/conversion-gen/generators/conversion.go
View File

@@ -25,14 +25,12 @@ import (
"sort"
"strings"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/conversion-gen/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
"k8s.io/klog/v2"
conversionargs "k8s.io/code-generator/cmd/conversion-gen/args"
)
// These are the comment tags that carry parameters for conversion generation.
@@ -197,10 +195,8 @@ func getManualConversionFunctions(context *generator.Context, pkg *types.Package
}
}
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*conversionargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
@@ -273,8 +269,8 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
}
// Make sure explicit peer-packages are added.
peers := customArgs.BasePeerDirs
peers = append(peers, customArgs.ExtraPeerDirs...)
peers := args.BasePeerDirs
peers = append(peers, args.ExtraPeerDirs...)
if expanded, err := context.FindPackages(peers...); err != nil {
klog.Fatalf("cannot find peer packages: %v", err)
} else {
@@ -321,7 +317,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
typesPkg = context.Universe[externalTypes]
unsafeEquality := TypesEqual(memoryEquivalentTypes)
if customArgs.SkipUnsafe {
if args.SkipUnsafe {
unsafeEquality = noEquality{}
}
@@ -336,7 +332,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
},
GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
return []generator.Generator{
NewGenConversion(customArgs.OutputFile, typesPkg.Path, pkg.Path, manualConversions, pkgToPeers[pkg.Path], unsafeEquality),
NewGenConversion(args.OutputFile, typesPkg.Path, pkg.Path, manualConversions, pkgToPeers[pkg.Path], unsafeEquality),
}
},
})

20
staging/src/k8s.io/code-generator/cmd/conversion-gen/main.go
View File

@@ -102,29 +102,33 @@ import (
generatorargs "k8s.io/code-generator/cmd/conversion-gen/args"
"k8s.io/code-generator/cmd/conversion-gen/generators"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := generatorargs.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
if err := gengo.Execute(
generators.NameSystems(),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

28
staging/src/k8s.io/code-generator/cmd/deepcopy-gen/args/args.go
View File

@@ -20,41 +20,33 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
)
// CustomArgs is used by the gengo framework to pass args specific to this generator.
type CustomArgs struct {
type Args struct {
OutputFile string
BoundingDirs []string // Only deal with types rooted under these dirs.
GoHeaderFile string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{}
genericArgs.CustomArgs = (*CustomArgs)(customArgs) // convert to upstream type to make type-casts work there
return genericArgs, customArgs
// New returns default arguments for the generator.
func New() *Args {
return &Args{}
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputFile, "output-file", "generated.deepcopy.go",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputFile, "output-file", "generated.deepcopy.go",
"the name of the file to be generated")
fs.StringSliceVar(&ca.BoundingDirs, "bounding-dirs", ca.BoundingDirs,
fs.StringSliceVar(&args.BoundingDirs, "bounding-dirs", args.BoundingDirs,
"Comma-separated list of import paths which bound the types for which deep-copies will be generated.")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
custom := genericArgs.CustomArgs.(*CustomArgs)
if len(custom.OutputFile) == 0 {
func (args *Args) Validate() error {
if len(args.OutputFile) == 0 {
return fmt.Errorf("--output-file must be specified")
}
return nil
}

20
staging/src/k8s.io/code-generator/cmd/deepcopy-gen/generators/deepcopy.go
View File

@@ -23,8 +23,8 @@ import (
"sort"
"strings"
deepcopyargs "k8s.io/code-generator/cmd/deepcopy-gen/args"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/deepcopy-gen/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
@@ -118,22 +118,20 @@ func DefaultNameSystem() string {
return "public"
}
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*deepcopyargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
boundingDirs := []string{}
if customArgs.BoundingDirs == nil {
customArgs.BoundingDirs = context.Inputs
if args.BoundingDirs == nil {
args.BoundingDirs = context.Inputs
}
for i := range customArgs.BoundingDirs {
for i := range args.BoundingDirs {
// Strip any trailing slashes - they are not exactly "correct" but
// this is friendlier.
boundingDirs = append(boundingDirs, strings.TrimRight(customArgs.BoundingDirs[i], "/"))
boundingDirs = append(boundingDirs, strings.TrimRight(args.BoundingDirs[i], "/"))
}
targets := []generator.Target{}
@@ -198,7 +196,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
},
GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
return []generator.Generator{
NewGenDeepCopy(customArgs.OutputFile, pkg.Path, boundingDirs, (ptagValue == tagValuePackage), ptagRegister),
NewGenDeepCopy(args.OutputFile, pkg.Path, boundingDirs, (ptagValue == tagValuePackage), ptagRegister),
}
},
})

22
staging/src/k8s.io/code-generator/cmd/deepcopy-gen/main.go
View File

@@ -72,32 +72,36 @@ import (
"flag"
"github.com/spf13/pflag"
generatorargs "k8s.io/code-generator/cmd/deepcopy-gen/args"
"k8s.io/code-generator/cmd/deepcopy-gen/args"
"k8s.io/code-generator/cmd/deepcopy-gen/generators"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
if err := gengo.Execute(
generators.NameSystems(),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

27
staging/src/k8s.io/code-generator/cmd/defaulter-gen/args/args.go
View File

@@ -20,39 +20,32 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
)
// CustomArgs is used by the gengo framework to pass args specific to this generator.
type CustomArgs struct {
type Args struct {
OutputFile string
ExtraPeerDirs []string // Always consider these as last-ditch possibilities for conversions.
GoHeaderFile string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{}
genericArgs.CustomArgs = (*CustomArgs)(customArgs) // convert to upstream type to make type-casts work there
return genericArgs, customArgs
// New returns default arguments for the generator.
func New() *Args {
return &Args{}
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputFile, "output-file", "generated.defaults.go",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputFile, "output-file", "generated.defaults.go",
"the name of the file to be generated")
fs.StringSliceVar(&ca.ExtraPeerDirs, "extra-peer-dirs", ca.ExtraPeerDirs,
fs.StringSliceVar(&args.ExtraPeerDirs, "extra-peer-dirs", args.ExtraPeerDirs,
"Comma-separated list of import paths which are considered, after tag-specified peers, for conversions.")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
custom := genericArgs.CustomArgs.(*CustomArgs)
if len(custom.OutputFile) == 0 {
func (args *Args) Validate() error {
if len(args.OutputFile) == 0 {
return fmt.Errorf("--output-file must be specified")
}

14
staging/src/k8s.io/code-generator/cmd/defaulter-gen/generators/defaulter.go
View File

@@ -27,8 +27,8 @@ import (
"strconv"
"strings"
defaulterargs "k8s.io/code-generator/cmd/defaulter-gen/args"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/defaulter-gen/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
@@ -221,10 +221,8 @@ func getManualDefaultingFunctions(context *generator.Context, pkg *types.Package
}
}
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*defaulterargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
@@ -275,7 +273,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
// Make sure explicit peer-packages are added.
var peerPkgs []string
for _, pkg := range customArgs.ExtraPeerDirs {
for _, pkg := range args.ExtraPeerDirs {
// In case someone specifies a peer as a path into vendor, convert
// it to its "real" package path.
if i := strings.Index(pkg, "/vendor/"); i != -1 {
@@ -430,7 +428,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
return []generator.Generator{
NewGenDefaulter(customArgs.OutputFile, typesPkg.Path, pkg.Path, existingDefaulters, newDefaulters, peerPkgs),
NewGenDefaulter(args.OutputFile, typesPkg.Path, pkg.Path, existingDefaulters, newDefaulters, peerPkgs),
}
},
})

22
staging/src/k8s.io/code-generator/cmd/defaulter-gen/main.go
View File

@@ -45,32 +45,36 @@ import (
"flag"
"github.com/spf13/pflag"
generatorargs "k8s.io/code-generator/cmd/defaulter-gen/args"
"k8s.io/code-generator/cmd/defaulter-gen/args"
"k8s.io/code-generator/cmd/defaulter-gen/generators"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
if err := gengo.Execute(
generators.NameSystems(),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

51
staging/src/k8s.io/code-generator/cmd/informer-gen/args/args.go
View File

@@ -20,11 +20,10 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
)
// CustomArgs is used by the gengo framework to pass args specific to this generator.
type CustomArgs struct {
// Args is used by the gengo framework to pass args specific to this generator.
type Args struct {
OutputDir string // must be a directory path
OutputPkg string // must be a Go import-path
GoHeaderFile string
@@ -38,49 +37,47 @@ type CustomArgs struct {
PluralExceptions []string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{
// New returns default arguments for the generator.
func New() *Args {
return &Args{
SingleDirectory: false,
PluralExceptions: []string{"Endpoints:Endpoints"},
}
genericArgs.CustomArgs = customArgs
return genericArgs, customArgs
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputDir, "output-dir", "",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputDir, "output-dir", "",
"the base directory under which to generate results")
fs.StringVar(&ca.OutputPkg, "output-pkg", ca.OutputPkg,
fs.StringVar(&args.OutputPkg, "output-pkg", args.OutputPkg,
"the Go import-path of the generated results")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
fs.StringVar(&ca.InternalClientSetPackage, "internal-clientset-package", ca.InternalClientSetPackage, "the Go import-path of the internal clientset to use")
fs.StringVar(&ca.VersionedClientSetPackage, "versioned-clientset-package", ca.VersionedClientSetPackage, "the Go import-path of the versioned clientset to use")
fs.StringVar(&ca.ListersPackage, "listers-package", ca.ListersPackage, "the Go import-path of the listers to use")
fs.BoolVar(&ca.SingleDirectory, "single-directory", ca.SingleDirectory, "if true, omit the intermediate \"internalversion\" and \"externalversions\" subdirectories")
fs.StringSliceVar(&ca.PluralExceptions, "plural-exceptions", ca.PluralExceptions, "list of comma separated plural exception definitions in Type:PluralizedType format")
fs.StringVar(&args.InternalClientSetPackage, "internal-clientset-package", args.InternalClientSetPackage,
"the Go import-path of the internal clientset to use")
fs.StringVar(&args.VersionedClientSetPackage, "versioned-clientset-package", args.VersionedClientSetPackage,
"the Go import-path of the versioned clientset to use")
fs.StringVar(&args.ListersPackage, "listers-package", args.ListersPackage,
"the Go import-path of the listers to use")
fs.BoolVar(&args.SingleDirectory, "single-directory", args.SingleDirectory,
"if true, omit the intermediate \"internalversion\" and \"externalversions\" subdirectories")
fs.StringSliceVar(&args.PluralExceptions, "plural-exceptions", args.PluralExceptions,
"list of comma separated plural exception definitions in Type:PluralizedType format")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
customArgs := genericArgs.CustomArgs.(*CustomArgs)
if len(customArgs.OutputDir) == 0 {
func (args *Args) Validate() error {
if len(args.OutputDir) == 0 {
return fmt.Errorf("--output-dir must be specified")
}
if len(customArgs.OutputPkg) == 0 {
if len(args.OutputPkg) == 0 {
return fmt.Errorf("--output-pkg must be specified")
}
if len(customArgs.VersionedClientSetPackage) == 0 {
if len(args.VersionedClientSetPackage) == 0 {
return fmt.Errorf("--versioned-clientset-package must be specified")
}
if len(customArgs.ListersPackage) == 0 {
if len(args.ListersPackage) == 0 {
return fmt.Errorf("--listers-package must be specified")
}
return nil
}

43
staging/src/k8s.io/code-generator/cmd/informer-gen/generators/targets.go
View File

@@ -22,16 +22,15 @@ import (
"path/filepath"
"strings"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/client-gen/generators/util"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
"k8s.io/code-generator/cmd/informer-gen/args"
genutil "k8s.io/code-generator/pkg/util"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
"k8s.io/klog/v2"
"k8s.io/code-generator/cmd/client-gen/generators/util"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
informergenargs "k8s.io/code-generator/cmd/informer-gen/args"
genutil "k8s.io/code-generator/pkg/util"
)
// NameSystems returns the name system used by the generators in this package.
@@ -93,19 +92,17 @@ func subdirForInternalInterfaces(base string) string {
}
// GetTargets makes the client target definition.
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*informergenargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
internalVersionOutputDir := customArgs.OutputDir
internalVersionOutputPkg := customArgs.OutputPkg
externalVersionOutputDir := customArgs.OutputDir
externalVersionOutputPkg := customArgs.OutputPkg
if !customArgs.SingleDirectory {
internalVersionOutputDir := args.OutputDir
internalVersionOutputPkg := args.OutputPkg
externalVersionOutputDir := args.OutputDir
externalVersionOutputPkg := args.OutputPkg
if !args.SingleDirectory {
internalVersionOutputDir = filepath.Join(internalVersionOutputDir, "internalversion")
internalVersionOutputPkg = filepath.Join(internalVersionOutputPkg, "internalversion")
externalVersionOutputDir = filepath.Join(externalVersionOutputDir, "externalversions")
@@ -200,14 +197,14 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
internalVersionOutputDir, internalVersionOutputPkg,
groupPackageName, gv, groupGoNames[groupPackageName],
boilerplate, typesToGenerate,
customArgs.InternalClientSetPackage, customArgs.ListersPackage))
args.InternalClientSetPackage, args.ListersPackage))
} else {
targetList = append(targetList,
versionTarget(
externalVersionOutputDir, externalVersionOutputPkg,
groupPackageName, gv, groupGoNames[groupPackageName],
boilerplate, typesToGenerate,
customArgs.VersionedClientSetPackage, customArgs.ListersPackage))
args.VersionedClientSetPackage, args.ListersPackage))
}
}
@@ -215,12 +212,12 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
targetList = append(targetList,
factoryInterfaceTarget(
externalVersionOutputDir, externalVersionOutputPkg,
boilerplate, customArgs.VersionedClientSetPackage))
boilerplate, args.VersionedClientSetPackage))
targetList = append(targetList,
factoryTarget(
externalVersionOutputDir, externalVersionOutputPkg,
boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(customArgs.PluralExceptions),
externalGroupVersions, customArgs.VersionedClientSetPackage, typesForGroupVersion))
boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(args.PluralExceptions),
externalGroupVersions, args.VersionedClientSetPackage, typesForGroupVersion))
for _, gvs := range externalGroupVersions {
targetList = append(targetList,
groupTarget(externalVersionOutputDir, externalVersionOutputPkg, gvs, boilerplate))
@@ -229,12 +226,12 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
if len(internalGroupVersions) != 0 {
targetList = append(targetList,
factoryInterfaceTarget(internalVersionOutputDir, internalVersionOutputPkg, boilerplate, customArgs.InternalClientSetPackage))
factoryInterfaceTarget(internalVersionOutputDir, internalVersionOutputPkg, boilerplate, args.InternalClientSetPackage))
targetList = append(targetList,
factoryTarget(
internalVersionOutputDir, internalVersionOutputPkg,
boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(customArgs.PluralExceptions),
internalGroupVersions, customArgs.InternalClientSetPackage, typesForGroupVersion))
boilerplate, groupGoNames, genutil.PluralExceptionListToMapOrDie(args.PluralExceptions),
internalGroupVersions, args.InternalClientSetPackage, typesForGroupVersion))
for _, gvs := range internalGroupVersions {
targetList = append(targetList,
groupTarget(internalVersionOutputDir, internalVersionOutputPkg, gvs, boilerplate))

24
staging/src/k8s.io/code-generator/cmd/informer-gen/main.go
View File

@@ -20,33 +20,37 @@ import (
"flag"
"github.com/spf13/pflag"
generatorargs "k8s.io/code-generator/cmd/informer-gen/args"
"k8s.io/code-generator/cmd/informer-gen/args"
"k8s.io/code-generator/cmd/informer-gen/generators"
"k8s.io/code-generator/pkg/util"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
if err := gengo.Execute(
generators.NameSystems(util.PluralExceptionListToMapOrDie(args.PluralExceptions)),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

34
staging/src/k8s.io/code-generator/cmd/lister-gen/args/args.go
View File

@@ -20,11 +20,10 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
)
// CustomArgs is used by the gengo framework to pass args specific to this generator.
type CustomArgs struct {
// Args is used by the gengo framework to pass args specific to this generator.
type Args struct {
OutputDir string // must be a directory path
OutputPkg string // must be a Go import-path
GoHeaderFile string
@@ -34,39 +33,32 @@ type CustomArgs struct {
PluralExceptions []string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{
// New returns default arguments for the generator.
func New() *Args {
return &Args{
PluralExceptions: []string{"Endpoints:Endpoints"},
}
genericArgs.CustomArgs = customArgs
return genericArgs, customArgs
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputDir, "output-dir", "",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputDir, "output-dir", "",
"the base directory under which to generate results")
fs.StringVar(&ca.OutputPkg, "output-pkg", "",
fs.StringVar(&args.OutputPkg, "output-pkg", "",
"the base Go import-path under which to generate results")
fs.StringSliceVar(&ca.PluralExceptions, "plural-exceptions", ca.PluralExceptions,
fs.StringSliceVar(&args.PluralExceptions, "plural-exceptions", args.PluralExceptions,
"list of comma separated plural exception definitions in Type:PluralizedType format")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
custom := genericArgs.CustomArgs.(*CustomArgs)
if len(custom.OutputDir) == 0 {
func (args *Args) Validate() error {
if len(args.OutputDir) == 0 {
return fmt.Errorf("--output-dir must be specified")
}
if len(custom.OutputPkg) == 0 {
if len(args.OutputPkg) == 0 {
return fmt.Errorf("--output-pkg must be specified")
}
return nil
}

14
staging/src/k8s.io/code-generator/cmd/lister-gen/generators/lister.go
View File

@@ -24,8 +24,8 @@ import (
"k8s.io/code-generator/cmd/client-gen/generators/util"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
listergenargs "k8s.io/code-generator/cmd/lister-gen/args"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/lister-gen/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
@@ -59,10 +59,8 @@ func DefaultNameSystem() string {
}
// GetTargets makes the client target definition.
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*listergenargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, "", args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, "", gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
@@ -121,8 +119,8 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
typesToGenerate = orderer.OrderTypes(typesToGenerate)
subdir := filepath.Join(groupPackageName, strings.ToLower(gv.Version.NonEmpty()))
outputDir := filepath.Join(customArgs.OutputDir, subdir)
outputPkg := filepath.Join(customArgs.OutputPkg, subdir)
outputDir := filepath.Join(args.OutputDir, subdir)
outputPkg := filepath.Join(args.OutputPkg, subdir)
targetList = append(targetList, &generator.SimpleTarget{
PkgName: strings.ToLower(gv.Version.NonEmpty()),
PkgPath: outputPkg,

24
staging/src/k8s.io/code-generator/cmd/lister-gen/main.go
View File

@@ -20,33 +20,37 @@ import (
"flag"
"github.com/spf13/pflag"
generatorargs "k8s.io/code-generator/cmd/lister-gen/args"
"k8s.io/code-generator/cmd/lister-gen/args"
"k8s.io/code-generator/cmd/lister-gen/generators"
"k8s.io/code-generator/pkg/util"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
generators.NameSystems(util.PluralExceptionListToMapOrDie(customArgs.PluralExceptions)),
if err := gengo.Execute(
generators.NameSystems(util.PluralExceptionListToMapOrDie(args.PluralExceptions)),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

22
staging/src/k8s.io/code-generator/cmd/openapi-gen/main.go
View File

@@ -25,32 +25,36 @@ import (
"log"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
generatorargs "k8s.io/kube-openapi/cmd/openapi-gen/args"
"k8s.io/kube-openapi/cmd/openapi-gen/args"
"k8s.io/kube-openapi/pkg/generators"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
log.Fatalf("Arguments validation error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
// Generates the code for the OpenAPIDefinitions.
if err := genericArgs.Execute(
if err := gengo.Execute(
generators.NameSystems(),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
log.Fatalf("OpenAPI code generation error: %v", err)

29
staging/src/k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args/args.go
View File

@@ -20,34 +20,29 @@ import (
"fmt"
"github.com/spf13/pflag"
statusgenerators "k8s.io/code-generator/cmd/prerelease-lifecycle-gen/prerelease-lifecycle-generators"
"k8s.io/gengo/v2/args"
)
// CustomArgs is used by the gengo framework to pass args specific to this generator.
type CustomArgs statusgenerators.CustomArgs
type Args struct {
OutputFile string
GoHeaderFile string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() (*args.GeneratorArgs, *CustomArgs) {
genericArgs := args.Default()
customArgs := &CustomArgs{}
genericArgs.CustomArgs = (*statusgenerators.CustomArgs)(customArgs) // convert to upstream type to make type-casts work there
return genericArgs, customArgs
// New returns default arguments for the generator.
func New() *Args {
return &Args{}
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputFile, "output-file", "generated.prerelease_lifecycle.go",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputFile, "output-file", "generated.prerelease_lifecycle.go",
"the name of the file to be generated")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
custom := genericArgs.CustomArgs.(*statusgenerators.CustomArgs)
if len(custom.OutputFile) == 0 {
func (args *Args) Validate() error {
if len(args.OutputFile) == 0 {
return fmt.Errorf("--output-file must be specified")
}

22
staging/src/k8s.io/code-generator/cmd/prerelease-lifecycle-gen/main.go
View File

@@ -38,32 +38,36 @@ import (
"flag"
"github.com/spf13/pflag"
generatorargs "k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args"
"k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args"
statusgenerators "k8s.io/code-generator/cmd/prerelease-lifecycle-gen/prerelease-lifecycle-generators"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs, customArgs := generatorargs.NewDefaults()
args := args.New()
genericArgs.AddFlags(pflag.CommandLine)
customArgs.AddFlags(pflag.CommandLine)
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
myTargets := func(context *generator.Context) []generator.Target {
return statusgenerators.GetTargets(context, args)
}
// Run it.
if err := genericArgs.Execute(
if err := gengo.Execute(
statusgenerators.NameSystems(),
statusgenerators.DefaultNameSystem(),
statusgenerators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)

17
staging/src/k8s.io/code-generator/cmd/prerelease-lifecycle-gen/prerelease-lifecycle-generators/status.go
View File

@@ -23,7 +23,8 @@ import (
"strconv"
"strings"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/prerelease-lifecycle-gen/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
@@ -31,12 +32,6 @@ import (
"k8s.io/klog/v2"
)
// CustomArgs is used tby the go2idl framework to pass args specific to this generator.
type CustomArgs struct {
OutputFile string
GoHeaderFile string
}
// This is the comment tag that carries parameters for API status generation. Because the cadence is fixed, we can predict
// with near certainty when this lifecycle happens as the API is introduced.
const (
@@ -182,10 +177,8 @@ func DefaultNameSystem() string {
}
// GetTargets makes the target definition.
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
@@ -244,7 +237,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
},
GeneratorsFunc: func(c *generator.Context) (generators []generator.Generator) {
return []generator.Generator{
NewPrereleaseLifecycleGen(customArgs.OutputFile, pkg.Path),
NewPrereleaseLifecycleGen(args.OutputFile, pkg.Path),
}
},
})

22
staging/src/k8s.io/code-generator/cmd/register-gen/args/args.go
View File

@@ -20,33 +20,29 @@ import (
"fmt"
"github.com/spf13/pflag"
"k8s.io/gengo/v2/args"
)
type CustomArgs struct {
type Args struct {
OutputFile string
GoHeaderFile string
}
// NewDefaults returns default arguments for the generator.
func NewDefaults() *args.GeneratorArgs {
genericArgs := args.Default()
genericArgs.CustomArgs = &CustomArgs{}
return genericArgs
// New returns default arguments for the generator.
func New() *Args {
return &Args{}
}
// AddFlags add the generator flags to the flag set.
func (ca *CustomArgs) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&ca.OutputFile, "output-file", "generated.register.go",
func (args *Args) AddFlags(fs *pflag.FlagSet) {
fs.StringVar(&args.OutputFile, "output-file", "generated.register.go",
"the name of the file to be generated")
fs.StringVar(&ca.GoHeaderFile, "go-header-file", "",
fs.StringVar(&args.GoHeaderFile, "go-header-file", "",
"the path to a file containing boilerplate header text; the string \"YEAR\" will be replaced with the current 4-digit year")
}
// Validate checks the given arguments.
func Validate(genericArgs *args.GeneratorArgs) error {
custom := genericArgs.CustomArgs.(*CustomArgs)
if len(custom.OutputFile) == 0 {
func (args *Args) Validate() error {
if len(args.OutputFile) == 0 {
return fmt.Errorf("output file base name cannot be empty")
}

18
staging/src/k8s.io/code-generator/cmd/register-gen/generators/targets.go
View File

@@ -25,8 +25,8 @@ import (
"k8s.io/klog/v2"
clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
registerargs "k8s.io/code-generator/cmd/register-gen/args"
"k8s.io/gengo/v2/args"
"k8s.io/code-generator/cmd/register-gen/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/gengo/v2/namer"
"k8s.io/gengo/v2/types"
@@ -44,10 +44,8 @@ func DefaultNameSystem() string {
}
// GetTargets makes targets to generate.
func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []generator.Target {
customArgs := arguments.CustomArgs.(*registerargs.CustomArgs)
boilerplate, err := args.GoBoilerplate(customArgs.GoHeaderFile, args.StdBuildTag, args.StdGeneratedBy)
func GetTargets(context *generator.Context, args *args.Args) []generator.Target {
boilerplate, err := gengo.GoBoilerplate(args.GoHeaderFile, gengo.StdBuildTag, gengo.StdGeneratedBy)
if err != nil {
klog.Fatalf("Failed loading boilerplate: %v", err)
}
@@ -57,17 +55,17 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
pkg := context.Universe.Package(input)
internal, err := isInternal(pkg)
if err != nil {
klog.V(5).Infof("skipping the generation of %s file, due to err %v", customArgs.OutputFile, err)
klog.V(5).Infof("skipping the generation of %s file, due to err %v", args.OutputFile, err)
continue
}
if internal {
klog.V(5).Infof("skipping the generation of %s file because %s package contains internal types, note that internal types don't have \"json\" tags", customArgs.OutputFile, pkg.Name)
klog.V(5).Infof("skipping the generation of %s file because %s package contains internal types, note that internal types don't have \"json\" tags", args.OutputFile, pkg.Name)
continue
}
registerFileName := "register.go"
searchPath := path.Join(pkg.SourcePath, registerFileName)
if _, err := os.Stat(path.Join(searchPath)); err == nil {
klog.V(5).Infof("skipping the generation of %s file because %s already exists in the path %s", customArgs.OutputFile, registerFileName, searchPath)
klog.V(5).Infof("skipping the generation of %s file because %s already exists in the path %s", args.OutputFile, registerFileName, searchPath)
continue
} else if err != nil && !os.IsNotExist(err) {
klog.Fatalf("an error %v has occurred while checking if %s exists", err, registerFileName)
@@ -112,7 +110,7 @@ func GetTargets(context *generator.Context, arguments *args.GeneratorArgs) []gen
return []generator.Generator{
&registerExternalGenerator{
GoGenerator: generator.GoGenerator{
OutputFilename: customArgs.OutputFile,
OutputFilename: args.OutputFile,
},
gv: gv,
typesToGenerate: typesToRegister,

21
staging/src/k8s.io/code-generator/cmd/register-gen/main.go
View File

@@ -20,29 +20,34 @@ import (
"flag"
"github.com/spf13/pflag"
generatorargs "k8s.io/code-generator/cmd/register-gen/args"
"k8s.io/code-generator/cmd/register-gen/args"
"k8s.io/code-generator/cmd/register-gen/generators"
"k8s.io/gengo/v2/args"
gengo "k8s.io/gengo/v2/args"
"k8s.io/gengo/v2/generator"
"k8s.io/klog/v2"
)
func main() {
klog.InitFlags(nil)
genericArgs := generatorargs.NewDefaults()
genericArgs.AddFlags(pflag.CommandLine)
args := args.New()
args.AddFlags(pflag.CommandLine)
flag.Set("logtostderr", "true")
pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
pflag.Parse()
if err := generatorargs.Validate(genericArgs); err != nil {
if err := args.Validate(); err != nil {
klog.Fatalf("Error: %v", err)
}
if err := genericArgs.Execute(
myTargets := func(context *generator.Context) []generator.Target {
return generators.GetTargets(context, args)
}
if err := gengo.Execute(
generators.NameSystems(),
generators.DefaultNameSystem(),
generators.GetTargets,
args.StdBuildTag,
myTargets,
gengo.StdBuildTag,
pflag.Args(),
); err != nil {
klog.Fatalf("Error: %v", err)