knative.dev/pkg@v0.0.0-20260602142205-ac97e43f6622/codegen/cmd/injection-gen/generators/informers/targets.go (about)

     1  /*
     2  Copyright 2025 The Knative Authors
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package informers
    18  
    19  import (
    20  	"path/filepath"
    21  	"strings"
    22  
    23  	clientgentypes "k8s.io/code-generator/cmd/client-gen/types"
    24  	"k8s.io/gengo/v2/generator"
    25  	"k8s.io/gengo/v2/types"
    26  	"knative.dev/pkg/codegen/cmd/injection-gen/args"
    27  	"knative.dev/pkg/codegen/cmd/injection-gen/tags"
    28  )
    29  
    30  func Targets(
    31  	args *args.Args,
    32  	groupPkgName string,
    33  	gv clientgentypes.GroupVersion,
    34  	groupGoName string,
    35  	typesToGenerate []*types.Type,
    36  ) []generator.Target {
    37  	factoryPackagePath := filepath.Join(args.GetOutputPackagePath(), "informers", "factory")
    38  	filteredFactoryPackagePath := filepath.Join(args.GetOutputPackagePath(), "informers", "factory", "filtered")
    39  
    40  	packagePath := filepath.Join(args.GetOutputPackagePath(), "informers", groupPkgName, strings.ToLower(gv.Version.NonEmpty()))
    41  	packageDir := filepath.Join(args.GetOutputDir(), "informers", groupPkgName, strings.ToLower(gv.Version.NonEmpty()))
    42  
    43  	vers := make([]generator.Target, 0, 2*len(typesToGenerate))
    44  
    45  	for _, t := range typesToGenerate {
    46  		packagePath := filepath.Join(packagePath, strings.ToLower(t.Name.Name))
    47  		packageDir := filepath.Join(packageDir, strings.ToLower(t.Name.Name))
    48  		typedInformerPackage := typedInformerPackage(groupPkgName, gv, args.ExternalVersionsInformersPackage)
    49  
    50  		// Impl
    51  		vers = append(vers, &generator.SimpleTarget{
    52  			PkgName:       strings.ToLower(t.Name.Name),
    53  			PkgPath:       packagePath,
    54  			PkgDir:        packageDir,
    55  			HeaderComment: args.Boilerplate,
    56  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
    57  				// Impl
    58  				return []generator.Generator{&injectionGenerator{
    59  					GoGenerator: generator.GoGenerator{
    60  						OutputFilename: strings.ToLower(t.Name.Name) + ".go",
    61  					},
    62  					outputPackage:               packagePath,
    63  					groupVersion:                gv,
    64  					groupGoName:                 groupGoName,
    65  					typeToGenerate:              t,
    66  					imports:                     generator.NewImportTracker(),
    67  					typedInformerPackage:        typedInformerPackage,
    68  					groupInformerFactoryPackage: factoryPackagePath,
    69  					disableInformerInit:         args.DisableInformerInit,
    70  				}}
    71  			},
    72  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
    73  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
    74  				return tags.NeedsInformerInjection()
    75  			},
    76  		})
    77  
    78  		// Fake
    79  		vers = append(vers, &generator.SimpleTarget{
    80  			PkgName:       "fake",
    81  			PkgPath:       filepath.Join(packagePath, "fake"),
    82  			PkgDir:        filepath.Join(packageDir, "fake"),
    83  			HeaderComment: args.Boilerplate,
    84  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
    85  				// Impl
    86  				return []generator.Generator{&fakeInformerGenerator{
    87  					GoGenerator: generator.GoGenerator{
    88  						OutputFilename: "fake.go",
    89  					},
    90  					outputPackage:           filepath.Join(packagePath, "fake"),
    91  					imports:                 generator.NewImportTracker(),
    92  					typeToGenerate:          t,
    93  					groupVersion:            gv,
    94  					groupGoName:             groupGoName,
    95  					informerInjectionPkg:    packagePath,
    96  					fakeFactoryInjectionPkg: filepath.Join(factoryPackagePath, "fake"),
    97  				}}
    98  			},
    99  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
   100  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
   101  				return tags.NeedsInformerInjection()
   102  			},
   103  		})
   104  		// FilteredInformer
   105  		vers = append(vers, &generator.SimpleTarget{
   106  			PkgName:       "filtered",
   107  			PkgPath:       filepath.Join(packagePath, "filtered"),
   108  			PkgDir:        filepath.Join(packageDir, "filtered"),
   109  			HeaderComment: args.Boilerplate,
   110  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
   111  				// Impl
   112  				return []generator.Generator{&filteredInjectionGenerator{
   113  					GoGenerator: generator.GoGenerator{
   114  						OutputFilename: strings.ToLower(t.Name.Name) + ".go",
   115  					},
   116  					outputPackage:               filepath.Join(packagePath, "filtered"),
   117  					groupVersion:                gv,
   118  					groupGoName:                 groupGoName,
   119  					typeToGenerate:              t,
   120  					imports:                     generator.NewImportTracker(),
   121  					typedInformerPackage:        typedInformerPackage,
   122  					groupInformerFactoryPackage: filteredFactoryPackagePath,
   123  				}}
   124  			},
   125  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
   126  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
   127  				return tags.NeedsInformerInjection()
   128  			},
   129  		})
   130  
   131  		// FakeFilteredInformer
   132  		vers = append(vers, &generator.SimpleTarget{
   133  			PkgName:       "fake",
   134  			PkgPath:       filepath.Join(packagePath, "filtered", "fake"),
   135  			PkgDir:        filepath.Join(packageDir, "filtered", "fake"),
   136  			HeaderComment: args.Boilerplate,
   137  			GeneratorsFunc: func(c *generator.Context) []generator.Generator {
   138  				// Impl
   139  				return []generator.Generator{&fakeFilteredInformerGenerator{
   140  					GoGenerator: generator.GoGenerator{
   141  						OutputFilename: "fake.go",
   142  					},
   143  					outputPackage:           filepath.Join(packagePath, "filtered", "fake"),
   144  					imports:                 generator.NewImportTracker(),
   145  					typeToGenerate:          t,
   146  					groupVersion:            gv,
   147  					groupGoName:             groupGoName,
   148  					informerInjectionPkg:    filepath.Join(packagePath, "filtered"),
   149  					fakeFactoryInjectionPkg: filteredFactoryPackagePath,
   150  				}}
   151  			},
   152  			FilterFunc: func(c *generator.Context, t *types.Type) bool {
   153  				tags := tags.MustParseClientGenTags(append(t.SecondClosestCommentLines, t.CommentLines...))
   154  				return tags.NeedsInformerInjection()
   155  			},
   156  		})
   157  	}
   158  	return vers
   159  }
   160  
   161  func typedInformerPackage(groupPkgName string, gv clientgentypes.GroupVersion, externalVersionsInformersPackage string) string {
   162  	return filepath.Join(externalVersionsInformersPackage, groupPkgName, gv.Version.String())
   163  }