| 1 |
/* |
| 2 |
Copyright 2015 The Kubernetes 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 generator |
| 18 |
|
| 19 |
import ( |
| 20 |
"bytes" |
| 21 |
"errors" |
| 22 |
"fmt" |
| 23 |
"io" |
| 24 |
"os" |
| 25 |
"path/filepath" |
| 26 |
"strings" |
| 27 |
|
| 28 |
"golang.org/x/tools/imports" |
| 29 |
|
| 30 |
"k8s.io/gengo/v2/namer" |
| 31 |
"k8s.io/gengo/v2/types" |
| 32 |
"k8s.io/klog/v2" |
| 33 |
) |
| 34 |
|
| 35 |
// ExecuteTargets runs the generators for the provided targets. |
| 36 |
func (c *Context) ExecuteTargets(targets []Target) error { |
| 37 |
klog.V(5).Infof("ExecuteTargets: %d targets", len(targets)) |
| 38 |
|
| 39 |
var errs []error |
| 40 |
for _, tgt := range targets { |
| 41 |
if err := c.ExecuteTarget(tgt); err != nil { |
| 42 |
errs = append(errs, err) |
| 43 |
} |
| 44 |
} |
| 45 |
if len(errs) > 0 { |
| 46 |
return fmt.Errorf("some targets had errors: %w", errors.Join(errs...)) |
| 47 |
} |
| 48 |
return nil |
| 49 |
} |
| 50 |
|
| 51 |
type DefaultFileType struct { |
| 52 |
Format func([]byte) ([]byte, error) |
| 53 |
Assemble func(io.Writer, *File) |
| 54 |
} |
| 55 |
|
| 56 |
func (ft DefaultFileType) AssembleFile(f *File, pathname string) error { |
| 57 |
klog.V(5).Infof("Assembling file %q", pathname) |
| 58 |
|
| 59 |
destFile, err := os.Create(pathname) |
| 60 |
if err != nil { |
| 61 |
return err |
| 62 |
} |
| 63 |
defer destFile.Close() |
| 64 |
|
| 65 |
b := &bytes.Buffer{} |
| 66 |
et := NewErrorTracker(b) |
| 67 |
ft.Assemble(et, f) |
| 68 |
if et.Error() != nil { |
| 69 |
return et.Error() |
| 70 |
} |
| 71 |
if formatted, err := ft.Format(b.Bytes()); err != nil { |
| 72 |
err = fmt.Errorf("unable to format file %q (%v)", pathname, err) |
| 73 |
// Write the file anyway, so they can see what's going wrong and fix the generator. |
| 74 |
if _, err2 := destFile.Write(b.Bytes()); err2 != nil { |
| 75 |
return err2 |
| 76 |
} |
| 77 |
return err |
| 78 |
} else { |
| 79 |
_, err = destFile.Write(formatted) |
| 80 |
return err |
| 81 |
} |
| 82 |
} |
| 83 |
|
| 84 |
func assembleGoFile(w io.Writer, f *File) { |
| 85 |
w.Write(f.Header) |
| 86 |
fmt.Fprintf(w, "package %v\n\n", f.PackageName) |
| 87 |
|
| 88 |
if len(f.Imports) > 0 { |
| 89 |
fmt.Fprint(w, "import (\n") |
| 90 |
for i := range f.Imports { |
| 91 |
if strings.Contains(i, "\"") { |
| 92 |
// they included quotes, or are using the |
| 93 |
// `name "path/to/pkg"` format. |
| 94 |
fmt.Fprintf(w, "\t%s\n", i) |
| 95 |
} else { |
| 96 |
fmt.Fprintf(w, "\t%q\n", i) |
| 97 |
} |
| 98 |
} |
| 99 |
fmt.Fprint(w, ")\n\n") |
| 100 |
} |
| 101 |
|
| 102 |
if f.Vars.Len() > 0 { |
| 103 |
fmt.Fprint(w, "var (\n") |
| 104 |
w.Write(f.Vars.Bytes()) |
| 105 |
fmt.Fprint(w, ")\n\n") |
| 106 |
} |
| 107 |
|
| 108 |
if f.Consts.Len() > 0 { |
| 109 |
fmt.Fprint(w, "const (\n") |
| 110 |
w.Write(f.Consts.Bytes()) |
| 111 |
fmt.Fprint(w, ")\n\n") |
| 112 |
} |
| 113 |
|
| 114 |
w.Write(f.Body.Bytes()) |
| 115 |
} |
| 116 |
|
| 117 |
func importsWrapper(src []byte) ([]byte, error) { |
| 118 |
opt := imports.Options{ |
| 119 |
Comments: true, |
| 120 |
TabIndent: true, |
| 121 |
TabWidth: 8, |
| 122 |
FormatOnly: true, // Disable the insertion and deletion of imports |
| 123 |
} |
| 124 |
return imports.Process("", src, &opt) |
| 125 |
} |
| 126 |
|
| 127 |
func NewGoFile() *DefaultFileType { |
| 128 |
return &DefaultFileType{ |
| 129 |
Format: importsWrapper, |
| 130 |
Assemble: assembleGoFile, |
| 131 |
} |
| 132 |
} |
| 133 |
|
| 134 |
// format should be one line only, and not end with \n. |
| 135 |
func addIndentHeaderComment(b *bytes.Buffer, format string, args ...interface{}) { |
| 136 |
if b.Len() > 0 { |
| 137 |
fmt.Fprintf(b, "\n// "+format+"\n", args...) |
| 138 |
} else { |
| 139 |
fmt.Fprintf(b, "// "+format+"\n", args...) |
| 140 |
} |
| 141 |
} |
| 142 |
|
| 143 |
func (c *Context) filteredBy(f func(*Context, *types.Type) bool) *Context { |
| 144 |
c2 := *c |
| 145 |
c2.Order = []*types.Type{} |
| 146 |
for _, t := range c.Order { |
| 147 |
if f(c, t) { |
| 148 |
c2.Order = append(c2.Order, t) |
| 149 |
} |
| 150 |
} |
| 151 |
return &c2 |
| 152 |
} |
| 153 |
|
| 154 |
// make a new context; inheret c.Namers, but add on 'namers'. In case of a name |
| 155 |
// collision, the namer in 'namers' wins. |
| 156 |
func (c *Context) addNameSystems(namers namer.NameSystems) *Context { |
| 157 |
if namers == nil { |
| 158 |
return c |
| 159 |
} |
| 160 |
c2 := *c |
| 161 |
// Copy the existing name systems so we don't corrupt a parent context |
| 162 |
c2.Namers = namer.NameSystems{} |
| 163 |
for k, v := range c.Namers { |
| 164 |
c2.Namers[k] = v |
| 165 |
} |
| 166 |
|
| 167 |
for name, namer := range namers { |
| 168 |
c2.Namers[name] = namer |
| 169 |
} |
| 170 |
return &c2 |
| 171 |
} |
| 172 |
|
| 173 |
// ExecuteTarget runs the generators for a single target. |
| 174 |
func (c *Context) ExecuteTarget(tgt Target) error { |
| 175 |
tgtDir := tgt.Dir() |
| 176 |
if tgtDir == "" { |
| 177 |
return fmt.Errorf("no directory for target %s", tgt.Path()) |
| 178 |
} |
| 179 |
klog.V(5).Infof("Executing target %q (%q)", tgt.Name(), tgtDir) |
| 180 |
|
| 181 |
// Filter out any types the *package* doesn't care about. |
| 182 |
packageContext := c.filteredBy(tgt.Filter) |
| 183 |
|
| 184 |
if err := os.MkdirAll(tgtDir, 0755); err != nil { |
| 185 |
return err |
| 186 |
} |
| 187 |
|
| 188 |
files := map[string]*File{} |
| 189 |
for _, g := range tgt.Generators(packageContext) { |
| 190 |
// Filter out types the *generator* doesn't care about. |
| 191 |
genContext := packageContext.filteredBy(g.Filter) |
| 192 |
// Now add any extra name systems defined by this generator |
| 193 |
genContext = genContext.addNameSystems(g.Namers(genContext)) |
| 194 |
|
| 195 |
fileType := g.FileType() |
| 196 |
if len(fileType) == 0 { |
| 197 |
return fmt.Errorf("generator %q must specify a file type", g.Name()) |
| 198 |
} |
| 199 |
f := files[g.Filename()] |
| 200 |
if f == nil { |
| 201 |
// This is the first generator to reference this file, so start it. |
| 202 |
f = &File{ |
| 203 |
Name: g.Filename(), |
| 204 |
FileType: fileType, |
| 205 |
PackageName: tgt.Name(), |
| 206 |
PackagePath: tgt.Path(), |
| 207 |
PackageDir: tgt.Dir(), |
| 208 |
Header: tgt.Header(g.Filename()), |
| 209 |
Imports: map[string]struct{}{}, |
| 210 |
} |
| 211 |
files[f.Name] = f |
| 212 |
} else if f.FileType != g.FileType() { |
| 213 |
return fmt.Errorf("file %q already has type %q, but generator %q wants to use type %q", f.Name, f.FileType, g.Name(), g.FileType()) |
| 214 |
} |
| 215 |
|
| 216 |
if vars := g.PackageVars(genContext); len(vars) > 0 { |
| 217 |
addIndentHeaderComment(&f.Vars, "Package-wide variables from generator %q.", g.Name()) |
| 218 |
for _, v := range vars { |
| 219 |
if _, err := fmt.Fprintf(&f.Vars, "%s\n", v); err != nil { |
| 220 |
return err |
| 221 |
} |
| 222 |
} |
| 223 |
} |
| 224 |
if consts := g.PackageConsts(genContext); len(consts) > 0 { |
| 225 |
addIndentHeaderComment(&f.Consts, "Package-wide consts from generator %q.", g.Name()) |
| 226 |
for _, v := range consts { |
| 227 |
if _, err := fmt.Fprintf(&f.Consts, "%s\n", v); err != nil { |
| 228 |
return err |
| 229 |
} |
| 230 |
} |
| 231 |
} |
| 232 |
if err := genContext.executeBody(&f.Body, g); err != nil { |
| 233 |
return err |
| 234 |
} |
| 235 |
if imports := g.Imports(genContext); len(imports) > 0 { |
| 236 |
for _, i := range imports { |
| 237 |
f.Imports[i] = struct{}{} |
| 238 |
} |
| 239 |
} |
| 240 |
} |
| 241 |
|
| 242 |
var errs []error |
| 243 |
for _, f := range files { |
| 244 |
finalPath := filepath.Join(tgtDir, f.Name) |
| 245 |
assembler, ok := c.FileTypes[f.FileType] |
| 246 |
if !ok { |
| 247 |
return fmt.Errorf("the file type %q registered for file %q does not exist in the context", f.FileType, f.Name) |
| 248 |
} |
| 249 |
if err := assembler.AssembleFile(f, finalPath); err != nil { |
| 250 |
errs = append(errs, err) |
| 251 |
} |
| 252 |
} |
| 253 |
if len(errs) > 0 { |
| 254 |
return fmt.Errorf("errors in target %q: %w", tgt.Path(), errors.Join(errs...)) |
| 255 |
} |
| 256 |
return nil |
| 257 |
} |
| 258 |
|
| 259 |
func (c *Context) executeBody(w io.Writer, generator Generator) error { |
| 260 |
et := NewErrorTracker(w) |
| 261 |
if err := generator.Init(c, et); err != nil { |
| 262 |
return err |
| 263 |
} |
| 264 |
for _, t := range c.Order { |
| 265 |
if err := generator.GenerateType(c, t, et); err != nil { |
| 266 |
return err |
| 267 |
} |
| 268 |
} |
| 269 |
if err := generator.Finalize(c, et); err != nil { |
| 270 |
return err |
| 271 |
} |
| 272 |
return et.Error() |
| 273 |
} |