git subrepo clone (merge) https://github.com/kubernetes-incubator/metrics-server.git metrics-server
subrepo:
subdir: "metrics-server"
merged: "92d8412"
upstream:
origin: "https://github.com/kubernetes-incubator/metrics-server.git"
branch: "master"
commit: "92d8412"
git-subrepo:
version: "0.4.0"
origin: "???"
commit: "???"
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/default_generator.go b/metrics-server/vendor/k8s.io/gengo/generator/default_generator.go
new file mode 100644
index 0000000..f947668
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/default_generator.go
@@ -0,0 +1,62 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "io"
+
+ "k8s.io/gengo/namer"
+ "k8s.io/gengo/types"
+)
+
+const (
+ GolangFileType = "golang"
+)
+
+// DefaultGen implements a do-nothing Generator.
+//
+// It can be used to implement static content files.
+type DefaultGen struct {
+ // OptionalName, if present, will be used for the generator's name, and
+ // the filename (with ".go" appended).
+ OptionalName string
+
+ // OptionalBody, if present, will be used as the return from the "Init"
+ // method. This causes it to be static content for the entire file if
+ // no other generator touches the file.
+ OptionalBody []byte
+}
+
+func (d DefaultGen) Name() string { return d.OptionalName }
+func (d DefaultGen) Filter(*Context, *types.Type) bool { return true }
+func (d DefaultGen) Namers(*Context) namer.NameSystems { return nil }
+func (d DefaultGen) Imports(*Context) []string { return []string{} }
+func (d DefaultGen) PackageVars(*Context) []string { return []string{} }
+func (d DefaultGen) PackageConsts(*Context) []string { return []string{} }
+func (d DefaultGen) GenerateType(*Context, *types.Type, io.Writer) error { return nil }
+func (d DefaultGen) Filename() string { return d.OptionalName + ".go" }
+func (d DefaultGen) FileType() string { return GolangFileType }
+func (d DefaultGen) Finalize(*Context, io.Writer) error { return nil }
+
+func (d DefaultGen) Init(c *Context, w io.Writer) error {
+ _, err := w.Write(d.OptionalBody)
+ return err
+}
+
+var (
+ _ = Generator(DefaultGen{})
+)
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/default_package.go b/metrics-server/vendor/k8s.io/gengo/generator/default_package.go
new file mode 100644
index 0000000..11517fc
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/default_package.go
@@ -0,0 +1,72 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "k8s.io/gengo/types"
+)
+
+// DefaultPackage contains a default implementation of Package.
+type DefaultPackage struct {
+ // Short name of package, used in the "package xxxx" line.
+ PackageName string
+ // Import path of the package, and the location on disk of the package.
+ PackagePath string
+
+ // Emitted at the top of every file.
+ HeaderText []byte
+
+ // Emitted only for a "doc.go" file; appended to the HeaderText for
+ // that file.
+ PackageDocumentation []byte
+
+ // If non-nil, will be called on "Generators"; otherwise, the static
+ // list will be used. So you should set only one of these two fields.
+ GeneratorFunc func(*Context) []Generator
+ GeneratorList []Generator
+
+ // Optional; filters the types exposed to the generators.
+ FilterFunc func(*Context, *types.Type) bool
+}
+
+func (d *DefaultPackage) Name() string { return d.PackageName }
+func (d *DefaultPackage) Path() string { return d.PackagePath }
+
+func (d *DefaultPackage) Filter(c *Context, t *types.Type) bool {
+ if d.FilterFunc != nil {
+ return d.FilterFunc(c, t)
+ }
+ return true
+}
+
+func (d *DefaultPackage) Generators(c *Context) []Generator {
+ if d.GeneratorFunc != nil {
+ return d.GeneratorFunc(c)
+ }
+ return d.GeneratorList
+}
+
+func (d *DefaultPackage) Header(filename string) []byte {
+ if filename == "doc.go" {
+ return append(d.HeaderText, d.PackageDocumentation...)
+ }
+ return d.HeaderText
+}
+
+var (
+ _ = Package(&DefaultPackage{})
+)
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/doc.go b/metrics-server/vendor/k8s.io/gengo/generator/doc.go
new file mode 100644
index 0000000..d8e1253
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/doc.go
@@ -0,0 +1,31 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// Package generator defines an interface for code generators to implement.
+//
+// To use this package, you'll implement the "Package" and "Generator"
+// interfaces; you'll call NewContext to load up the types you want to work
+// with, and then you'll call one or more of the Execute methods. See the
+// interface definitions for explanations. All output will have gofmt called on
+// it automatically, so you do not need to worry about generating correct
+// indentation.
+//
+// This package also exposes SnippetWriter. SnippetWriter reduces to a minimum
+// the boilerplate involved in setting up a template from go's text/template
+// package. Additionally, all naming systems in the Context will be added as
+// functions to the parsed template, so that they can be called directly from
+// your templates!
+package generator // import "k8s.io/gengo/generator"
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/error_tracker.go b/metrics-server/vendor/k8s.io/gengo/generator/error_tracker.go
new file mode 100644
index 0000000..964dae3
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/error_tracker.go
@@ -0,0 +1,50 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "io"
+)
+
+// ErrorTracker tracks errors to the underlying writer, so that you can ignore
+// them until you're ready to return.
+type ErrorTracker struct {
+ io.Writer
+ err error
+}
+
+// NewErrorTracker makes a new error tracker; note that it implements io.Writer.
+func NewErrorTracker(w io.Writer) *ErrorTracker {
+ return &ErrorTracker{Writer: w}
+}
+
+// Write intercepts calls to Write.
+func (et *ErrorTracker) Write(p []byte) (n int, err error) {
+ if et.err != nil {
+ return 0, et.err
+ }
+ n, err = et.Writer.Write(p)
+ if err != nil {
+ et.err = err
+ }
+ return n, err
+}
+
+// Error returns nil if no error has occurred, otherwise it returns the error.
+func (et *ErrorTracker) Error() error {
+ return et.err
+}
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/execute.go b/metrics-server/vendor/k8s.io/gengo/generator/execute.go
new file mode 100644
index 0000000..38dffff
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/execute.go
@@ -0,0 +1,312 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+
+ "golang.org/x/tools/imports"
+ "k8s.io/gengo/namer"
+ "k8s.io/gengo/types"
+
+ "github.com/golang/glog"
+)
+
+func errs2strings(errors []error) []string {
+ strs := make([]string, len(errors))
+ for i := range errors {
+ strs[i] = errors[i].Error()
+ }
+ return strs
+}
+
+// ExecutePackages runs the generators for every package in 'packages'. 'outDir'
+// is the base directory in which to place all the generated packages; it
+// should be a physical path on disk, not an import path. e.g.:
+// /path/to/home/path/to/gopath/src/
+// Each package has its import path already, this will be appended to 'outDir'.
+func (c *Context) ExecutePackages(outDir string, packages Packages) error {
+ var errors []error
+ for _, p := range packages {
+ if err := c.ExecutePackage(outDir, p); err != nil {
+ errors = append(errors, err)
+ }
+ }
+ if len(errors) > 0 {
+ return fmt.Errorf("some packages had errors:\n%v\n", strings.Join(errs2strings(errors), "\n"))
+ }
+ return nil
+}
+
+type DefaultFileType struct {
+ Format func([]byte) ([]byte, error)
+ Assemble func(io.Writer, *File)
+}
+
+func (ft DefaultFileType) AssembleFile(f *File, pathname string) error {
+ glog.V(2).Infof("Assembling file %q", pathname)
+ destFile, err := os.Create(pathname)
+ if err != nil {
+ return err
+ }
+ defer destFile.Close()
+
+ b := &bytes.Buffer{}
+ et := NewErrorTracker(b)
+ ft.Assemble(et, f)
+ if et.Error() != nil {
+ return et.Error()
+ }
+ if formatted, err := ft.Format(b.Bytes()); err != nil {
+ err = fmt.Errorf("unable to format file %q (%v).", pathname, err)
+ // Write the file anyway, so they can see what's going wrong and fix the generator.
+ if _, err2 := destFile.Write(b.Bytes()); err2 != nil {
+ return err2
+ }
+ return err
+ } else {
+ _, err = destFile.Write(formatted)
+ return err
+ }
+}
+
+func (ft DefaultFileType) VerifyFile(f *File, pathname string) error {
+ glog.V(2).Infof("Verifying file %q", pathname)
+ friendlyName := filepath.Join(f.PackageName, f.Name)
+ b := &bytes.Buffer{}
+ et := NewErrorTracker(b)
+ ft.Assemble(et, f)
+ if et.Error() != nil {
+ return et.Error()
+ }
+ formatted, err := ft.Format(b.Bytes())
+ if err != nil {
+ return fmt.Errorf("unable to format the output for %q: %v", friendlyName, err)
+ }
+ existing, err := ioutil.ReadFile(pathname)
+ if err != nil {
+ return fmt.Errorf("unable to read file %q for comparison: %v", friendlyName, err)
+ }
+ if bytes.Compare(formatted, existing) == 0 {
+ return nil
+ }
+ // Be nice and find the first place where they differ
+ i := 0
+ for i < len(formatted) && i < len(existing) && formatted[i] == existing[i] {
+ i++
+ }
+ eDiff, fDiff := existing[i:], formatted[i:]
+ if len(eDiff) > 100 {
+ eDiff = eDiff[:100]
+ }
+ if len(fDiff) > 100 {
+ fDiff = fDiff[:100]
+ }
+ return fmt.Errorf("output for %q differs; first existing/expected diff: \n %q\n %q", friendlyName, string(eDiff), string(fDiff))
+}
+
+func assembleGolangFile(w io.Writer, f *File) {
+ w.Write(f.Header)
+ fmt.Fprintf(w, "package %v\n\n", f.PackageName)
+
+ if len(f.Imports) > 0 {
+ fmt.Fprint(w, "import (\n")
+ for i := range f.Imports {
+ if strings.Contains(i, "\"") {
+ // they included quotes, or are using the
+ // `name "path/to/pkg"` format.
+ fmt.Fprintf(w, "\t%s\n", i)
+ } else {
+ fmt.Fprintf(w, "\t%q\n", i)
+ }
+ }
+ fmt.Fprint(w, ")\n\n")
+ }
+
+ if f.Vars.Len() > 0 {
+ fmt.Fprint(w, "var (\n")
+ w.Write(f.Vars.Bytes())
+ fmt.Fprint(w, ")\n\n")
+ }
+
+ if f.Consts.Len() > 0 {
+ fmt.Fprint(w, "const (\n")
+ w.Write(f.Consts.Bytes())
+ fmt.Fprint(w, ")\n\n")
+ }
+
+ w.Write(f.Body.Bytes())
+}
+
+func importsWrapper(src []byte) ([]byte, error) {
+ return imports.Process("", src, nil)
+}
+
+func NewGolangFile() *DefaultFileType {
+ return &DefaultFileType{
+ Format: importsWrapper,
+ Assemble: assembleGolangFile,
+ }
+}
+
+// format should be one line only, and not end with \n.
+func addIndentHeaderComment(b *bytes.Buffer, format string, args ...interface{}) {
+ if b.Len() > 0 {
+ fmt.Fprintf(b, "\n// "+format+"\n", args...)
+ } else {
+ fmt.Fprintf(b, "// "+format+"\n", args...)
+ }
+}
+
+func (c *Context) filteredBy(f func(*Context, *types.Type) bool) *Context {
+ c2 := *c
+ c2.Order = []*types.Type{}
+ for _, t := range c.Order {
+ if f(c, t) {
+ c2.Order = append(c2.Order, t)
+ }
+ }
+ return &c2
+}
+
+// make a new context; inheret c.Namers, but add on 'namers'. In case of a name
+// collision, the namer in 'namers' wins.
+func (c *Context) addNameSystems(namers namer.NameSystems) *Context {
+ if namers == nil {
+ return c
+ }
+ c2 := *c
+ // Copy the existing name systems so we don't corrupt a parent context
+ c2.Namers = namer.NameSystems{}
+ for k, v := range c.Namers {
+ c2.Namers[k] = v
+ }
+
+ for name, namer := range namers {
+ c2.Namers[name] = namer
+ }
+ return &c2
+}
+
+// ExecutePackage executes a single package. 'outDir' is the base directory in
+// which to place the package; it should be a physical path on disk, not an
+// import path. e.g.: '/path/to/home/path/to/gopath/src/' The package knows its
+// import path already, this will be appended to 'outDir'.
+func (c *Context) ExecutePackage(outDir string, p Package) error {
+ path := filepath.Join(outDir, p.Path())
+ glog.V(2).Infof("Processing package %q, disk location %q", p.Name(), path)
+ // Filter out any types the *package* doesn't care about.
+ packageContext := c.filteredBy(p.Filter)
+ os.MkdirAll(path, 0755)
+ files := map[string]*File{}
+ for _, g := range p.Generators(packageContext) {
+ // Filter out types the *generator* doesn't care about.
+ genContext := packageContext.filteredBy(g.Filter)
+ // Now add any extra name systems defined by this generator
+ genContext = genContext.addNameSystems(g.Namers(genContext))
+
+ fileType := g.FileType()
+ if len(fileType) == 0 {
+ return fmt.Errorf("generator %q must specify a file type", g.Name())
+ }
+ f := files[g.Filename()]
+ if f == nil {
+ // This is the first generator to reference this file, so start it.
+ f = &File{
+ Name: g.Filename(),
+ FileType: fileType,
+ PackageName: p.Name(),
+ Header: p.Header(g.Filename()),
+ Imports: map[string]struct{}{},
+ }
+ files[f.Name] = f
+ } else {
+ if f.FileType != g.FileType() {
+ 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())
+ }
+ }
+
+ if vars := g.PackageVars(genContext); len(vars) > 0 {
+ addIndentHeaderComment(&f.Vars, "Package-wide variables from generator %q.", g.Name())
+ for _, v := range vars {
+ if _, err := fmt.Fprintf(&f.Vars, "%s\n", v); err != nil {
+ return err
+ }
+ }
+ }
+ if consts := g.PackageConsts(genContext); len(consts) > 0 {
+ addIndentHeaderComment(&f.Consts, "Package-wide consts from generator %q.", g.Name())
+ for _, v := range consts {
+ if _, err := fmt.Fprintf(&f.Consts, "%s\n", v); err != nil {
+ return err
+ }
+ }
+ }
+ if err := genContext.executeBody(&f.Body, g); err != nil {
+ return err
+ }
+ if imports := g.Imports(genContext); len(imports) > 0 {
+ for _, i := range imports {
+ f.Imports[i] = struct{}{}
+ }
+ }
+ }
+
+ var errors []error
+ for _, f := range files {
+ finalPath := filepath.Join(path, f.Name)
+ assembler, ok := c.FileTypes[f.FileType]
+ if !ok {
+ return fmt.Errorf("the file type %q registered for file %q does not exist in the context", f.FileType, f.Name)
+ }
+ var err error
+ if c.Verify {
+ err = assembler.VerifyFile(f, finalPath)
+ } else {
+ err = assembler.AssembleFile(f, finalPath)
+ }
+ if err != nil {
+ errors = append(errors, err)
+ }
+ }
+ if len(errors) > 0 {
+ return fmt.Errorf("errors in package %q:\n%v\n", p.Path(), strings.Join(errs2strings(errors), "\n"))
+ }
+ return nil
+}
+
+func (c *Context) executeBody(w io.Writer, generator Generator) error {
+ et := NewErrorTracker(w)
+ if err := generator.Init(c, et); err != nil {
+ return err
+ }
+ for _, t := range c.Order {
+ if err := generator.GenerateType(c, t, et); err != nil {
+ return err
+ }
+ }
+ if err := generator.Finalize(c, et); err != nil {
+ return err
+ }
+ return et.Error()
+}
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/generator.go b/metrics-server/vendor/k8s.io/gengo/generator/generator.go
new file mode 100644
index 0000000..05a3f65
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/generator.go
@@ -0,0 +1,219 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "bytes"
+ "io"
+
+ "k8s.io/gengo/namer"
+ "k8s.io/gengo/parser"
+ "k8s.io/gengo/types"
+)
+
+// Package contains the contract for generating a package.
+type Package interface {
+ // Name returns the package short name.
+ Name() string
+ // Path returns the package import path.
+ Path() string
+
+ // Filter should return true if this package cares about this type.
+ // Otherwise, this type will be omitted from the type ordering for
+ // this package.
+ Filter(*Context, *types.Type) bool
+
+ // Header should return a header for the file, including comment markers.
+ // Useful for copyright notices and doc strings. Include an
+ // autogeneration notice! Do not include the "package x" line.
+ Header(filename string) []byte
+
+ // Generators returns the list of generators for this package. It is
+ // allowed for more than one generator to write to the same file.
+ // A Context is passed in case the list of generators depends on the
+ // input types.
+ Generators(*Context) []Generator
+}
+
+type File struct {
+ Name string
+ FileType string
+ PackageName string
+ Header []byte
+ Imports map[string]struct{}
+ Vars bytes.Buffer
+ Consts bytes.Buffer
+ Body bytes.Buffer
+}
+
+type FileType interface {
+ AssembleFile(f *File, path string) error
+ VerifyFile(f *File, path string) error
+}
+
+// Packages is a list of packages to generate.
+type Packages []Package
+
+// Generator is the contract for anything that wants to do auto-generation.
+// It's expected that the io.Writers passed to the below functions will be
+// ErrorTrackers; this allows implementations to not check for io errors,
+// making more readable code.
+//
+// The call order for the functions that take a Context is:
+// 1. Filter() // Subsequent calls see only types that pass this.
+// 2. Namers() // Subsequent calls see the namers provided by this.
+// 3. PackageVars()
+// 4. PackageConsts()
+// 5. Init()
+// 6. GenerateType() // Called N times, once per type in the context's Order.
+// 7. Imports()
+//
+// You may have multiple generators for the same file.
+type Generator interface {
+ // The name of this generator. Will be included in generated comments.
+ Name() string
+
+ // Filter should return true if this generator cares about this type.
+ // (otherwise, GenerateType will not be called.)
+ //
+ // Filter is called before any of the generator's other functions;
+ // subsequent calls will get a context with only the types that passed
+ // this filter.
+ Filter(*Context, *types.Type) bool
+
+ // If this generator needs special namers, return them here. These will
+ // override the original namers in the context if there is a collision.
+ // You may return nil if you don't need special names. These names will
+ // be available in the context passed to the rest of the generator's
+ // functions.
+ //
+ // A use case for this is to return a namer that tracks imports.
+ Namers(*Context) namer.NameSystems
+
+ // Init should write an init function, and any other content that's not
+ // generated per-type. (It's not intended for generator specific
+ // initialization! Do that when your Package constructs the
+ // Generators.)
+ Init(*Context, io.Writer) error
+
+ // Finalize should write finish up functions, and any other content that's not
+ // generated per-type.
+ Finalize(*Context, io.Writer) error
+
+ // PackageVars should emit an array of variable lines. They will be
+ // placed in a var ( ... ) block. There's no need to include a leading
+ // \t or trailing \n.
+ PackageVars(*Context) []string
+
+ // PackageConsts should emit an array of constant lines. They will be
+ // placed in a const ( ... ) block. There's no need to include a leading
+ // \t or trailing \n.
+ PackageConsts(*Context) []string
+
+ // GenerateType should emit the code for a particular type.
+ GenerateType(*Context, *types.Type, io.Writer) error
+
+ // Imports should return a list of necessary imports. They will be
+ // formatted correctly. You do not need to include quotation marks,
+ // return only the package name; alternatively, you can also return
+ // imports in the format `name "path/to/pkg"`. Imports will be called
+ // after Init, PackageVars, PackageConsts, and GenerateType, to allow
+ // you to keep track of what imports you actually need.
+ Imports(*Context) []string
+
+ // Preferred file name of this generator, not including a path. It is
+ // allowed for multiple generators to use the same filename, but it's
+ // up to you to make sure they don't have colliding import names.
+ // TODO: provide per-file import tracking, removing the requirement
+ // that generators coordinate..
+ Filename() string
+
+ // A registered file type in the context to generate this file with. If
+ // the FileType is not found in the context, execution will stop.
+ FileType() string
+}
+
+// Context is global context for individual generators to consume.
+type Context struct {
+ // A map from the naming system to the names for that system. E.g., you
+ // might have public names and several private naming systems.
+ Namers namer.NameSystems
+
+ // All the types, in case you want to look up something.
+ Universe types.Universe
+
+ // All the user-specified packages. This is after recursive expansion.
+ Inputs []string
+
+ // The canonical ordering of the types (will be filtered by both the
+ // Package's and Generator's Filter methods).
+ Order []*types.Type
+
+ // A set of types this context can process. If this is empty or nil,
+ // the default "golang" filetype will be provided.
+ FileTypes map[string]FileType
+
+ // If true, Execute* calls will just verify that the existing output is
+ // correct. (You may set this after calling NewContext.)
+ Verify bool
+
+ // Allows generators to add packages at runtime.
+ builder *parser.Builder
+}
+
+// NewContext generates a context from the given builder, naming systems, and
+// the naming system you wish to construct the canonical ordering from.
+func NewContext(b *parser.Builder, nameSystems namer.NameSystems, canonicalOrderName string) (*Context, error) {
+ universe, err := b.FindTypes()
+ if err != nil {
+ return nil, err
+ }
+
+ c := &Context{
+ Namers: namer.NameSystems{},
+ Universe: universe,
+ Inputs: b.FindPackages(),
+ FileTypes: map[string]FileType{
+ GolangFileType: NewGolangFile(),
+ },
+ builder: b,
+ }
+
+ for name, systemNamer := range nameSystems {
+ c.Namers[name] = systemNamer
+ if name == canonicalOrderName {
+ orderer := namer.Orderer{Namer: systemNamer}
+ c.Order = orderer.OrderUniverse(universe)
+ }
+ }
+ return c, nil
+}
+
+// AddDir adds a Go package to the context. The specified path must be a single
+// go package import path. GOPATH, GOROOT, and the location of your go binary
+// (`which go`) will all be searched, in the normal Go fashion.
+// Deprecated. Please use AddDirectory.
+func (ctxt *Context) AddDir(path string) error {
+ return ctxt.builder.AddDirTo(path, &ctxt.Universe)
+}
+
+// AddDirectory adds a Go package to the context. The specified path must be a
+// single go package import path. GOPATH, GOROOT, and the location of your go
+// binary (`which go`) will all be searched, in the normal Go fashion.
+func (ctxt *Context) AddDirectory(path string) (*types.Package, error) {
+ return ctxt.builder.AddDirectoryTo(path, &ctxt.Universe)
+}
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/import_tracker.go b/metrics-server/vendor/k8s.io/gengo/generator/import_tracker.go
new file mode 100644
index 0000000..d4ba5e9
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/import_tracker.go
@@ -0,0 +1,64 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "strings"
+
+ "github.com/golang/glog"
+
+ "k8s.io/gengo/namer"
+ "k8s.io/gengo/types"
+)
+
+func NewImportTracker(typesToAdd ...*types.Type) namer.ImportTracker {
+ tracker := namer.NewDefaultImportTracker(types.Name{})
+ tracker.IsInvalidType = func(*types.Type) bool { return false }
+ tracker.LocalName = func(name types.Name) string { return golangTrackerLocalName(&tracker, name) }
+ tracker.PrintImport = func(path, name string) string { return name + " \"" + path + "\"" }
+
+ tracker.AddTypes(typesToAdd...)
+ return &tracker
+
+}
+
+func golangTrackerLocalName(tracker namer.ImportTracker, t types.Name) string {
+ path := t.Package
+
+ // Using backslashes in package names causes gengo to produce Go code which
+ // will not compile with the gc compiler. See the comment on GoSeperator.
+ if strings.ContainsRune(path, '\\') {
+ glog.Warningf("Warning: backslash used in import path '%v', this is unsupported.\n", path)
+ }
+
+ dirs := strings.Split(path, namer.GoSeperator)
+ for n := len(dirs) - 1; n >= 0; n-- {
+ // follow kube convention of not having anything between directory names
+ name := strings.Join(dirs[n:], "")
+ name = strings.Replace(name, "_", "", -1)
+ // These characters commonly appear in import paths for go
+ // packages, but aren't legal go names. So we'll sanitize.
+ name = strings.Replace(name, ".", "", -1)
+ name = strings.Replace(name, "-", "", -1)
+ if _, found := tracker.PathOf(name); found {
+ // This name collides with some other package
+ continue
+ }
+ return name
+ }
+ panic("can't find import for " + path)
+}
diff --git a/metrics-server/vendor/k8s.io/gengo/generator/snippet_writer.go b/metrics-server/vendor/k8s.io/gengo/generator/snippet_writer.go
new file mode 100644
index 0000000..eae917c
--- /dev/null
+++ b/metrics-server/vendor/k8s.io/gengo/generator/snippet_writer.go
@@ -0,0 +1,154 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package generator
+
+import (
+ "fmt"
+ "io"
+ "runtime"
+ "text/template"
+)
+
+// SnippetWriter is an attempt to make the template library usable.
+// Methods are chainable, and you don't have to check Error() until you're all
+// done.
+type SnippetWriter struct {
+ w io.Writer
+ context *Context
+ // Left & right delimiters. text/template defaults to "{{" and "}}"
+ // which is totally unusable for go code based templates.
+ left, right string
+ funcMap template.FuncMap
+ err error
+}
+
+// w is the destination; left and right are the delimiters; @ and $ are both
+// reasonable choices.
+//
+// c is used to make a function for every naming system, to which you can pass
+// a type and get the corresponding name.
+func NewSnippetWriter(w io.Writer, c *Context, left, right string) *SnippetWriter {
+ sw := &SnippetWriter{
+ w: w,
+ context: c,
+ left: left,
+ right: right,
+ funcMap: template.FuncMap{},
+ }
+ for name, namer := range c.Namers {
+ sw.funcMap[name] = namer.Name
+ }
+ return sw
+}
+
+// Do parses format and runs args through it. You can have arbitrary logic in
+// the format (see the text/template documentation), but consider running many
+// short templaces, with ordinary go logic in between--this may be more
+// readable. Do is chainable. Any error causes every other call to do to be
+// ignored, and the error will be returned by Error(). So you can check it just
+// once, at the end of your function.
+//
+// 'args' can be quite literally anything; read the text/template documentation
+// for details. Maps and structs work particularly nicely. Conveniently, the
+// types package is designed to have structs that are easily referencable from
+// the template language.
+//
+// Example:
+//
+// sw := generator.NewSnippetWriter(outBuffer, context, "$", "$")
+// sw.Do(`The public type name is: $.type|public$`, map[string]interface{}{"type": t})
+// return sw.Error()
+//
+// Where:
+// * "$" starts a template directive
+// * "." references the entire thing passed as args
+// * "type" therefore sees a map and looks up the key "type"
+// * "|" means "pass the thing on the left to the thing on the right"
+// * "public" is the name of a naming system, so the SnippetWriter has given
+// the template a function called "public" that takes a *types.Type and
+// returns the naming system's name. E.g., if the type is "string" this might
+// return "String".
+// * the second "$" ends the template directive.
+//
+// The map is actually not necessary. The below does the same thing:
+//
+// sw.Do(`The public type name is: $.|public$`, t)
+//
+// You may or may not find it more readable to use the map with a descriptive
+// key, but if you want to pass more than one arg, the map or a custom struct
+// becomes a requirement. You can do arbitrary logic inside these templates,
+// but you should consider doing the logic in go and stitching them together
+// for the sake of your readers.
+//
+// TODO: Change Do() to optionally take a list of pairs of parameters (key, value)
+// and have it construct a combined map with that and args.
+func (s *SnippetWriter) Do(format string, args interface{}) *SnippetWriter {
+ if s.err != nil {
+ return s
+ }
+ // Name the template by source file:line so it can be found when
+ // there's an error.
+ _, file, line, _ := runtime.Caller(1)
+ tmpl, err := template.
+ New(fmt.Sprintf("%s:%d", file, line)).
+ Delims(s.left, s.right).
+ Funcs(s.funcMap).
+ Parse(format)
+ if err != nil {
+ s.err = err
+ return s
+ }
+ err = tmpl.Execute(s.w, args)
+ if err != nil {
+ s.err = err
+ }
+ return s
+}
+
+// Args exists to make it convenient to construct arguments for
+// SnippetWriter.Do.
+type Args map[interface{}]interface{}
+
+// With makes a copy of a and adds the given key, value pair.
+func (a Args) With(key, value interface{}) Args {
+ a2 := Args{key: value}
+ for k, v := range a {
+ a2[k] = v
+ }
+ return a2
+}
+
+// WithArgs makes a copy of a and adds the given arguments.
+func (a Args) WithArgs(rhs Args) Args {
+ a2 := Args{}
+ for k, v := range rhs {
+ a2[k] = v
+ }
+ for k, v := range a {
+ a2[k] = v
+ }
+ return a2
+}
+
+func (s *SnippetWriter) Out() io.Writer {
+ return s.w
+}
+
+// Error returns any encountered error.
+func (s *SnippetWriter) Error() error {
+ return s.err
+}