k3s/pkg/deploy/zz_generated_bindata.go

// Code generated for package deploy by go-bindata DO NOT EDIT. (@generated)
// sources:
// manifests/coredns.yaml
// manifests/rolebindings.yaml
// manifests/traefik.yaml
package deploy

import (
	"bytes"
	"compress/gzip"
	"fmt"
	"io"
	"io/ioutil"
	"os"
	"path/filepath"
	"strings"
	"time"
)

func bindataRead(data []byte, name string) ([]byte, error) {
	gz, err := gzip.NewReader(bytes.NewBuffer(data))
	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}

	var buf bytes.Buffer
	_, err = io.Copy(&buf, gz)
	clErr := gz.Close()

	if err != nil {
		return nil, fmt.Errorf("Read %q: %v", name, err)
	}
	if clErr != nil {
		return nil, err
	}

	return buf.Bytes(), nil
}

type asset struct {
	bytes []byte
	info  os.FileInfo
}

type bindataFileInfo struct {
	name    string
	size    int64
	mode    os.FileMode
	modTime time.Time
}

// Name return file name
func (fi bindataFileInfo) Name() string {
	return fi.name
}

// Size return file size
func (fi bindataFileInfo) Size() int64 {
	return fi.size
}

// Mode return file mode
func (fi bindataFileInfo) Mode() os.FileMode {
	return fi.mode
}

// Mode return file modify time
func (fi bindataFileInfo) ModTime() time.Time {
	return fi.modTime
}

// IsDir return file whether a directory
func (fi bindataFileInfo) IsDir() bool {
	return fi.mode&os.ModeDir != 0
}

// Sys return file is sys mode
func (fi bindataFileInfo) Sys() interface{} {
	return nil
}

var _corednsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xac\x56\x4b\x6f\x1b\x37\x10\xbe\xeb\x57\x10\x5b\xe4\xd6\x95\x2d\x18\x49\x5d\xde\x12\xdb\x4d\x0c\xc4\x8a\xe0\x47\x2e\x45\x11\x8c\xb8\x23\x89\x35\x97\xc3\x92\xb3\x8a\xd5\xd4\xff\xbd\xe0\xbe\xb4\x94\xd7\x41\x12\x64\x4f\x5c\x0e\xe7\x9b\xe1\x3c\xbe\x21\x38\xfd\x11\x7d\xd0\x64\xa5\xd8\xce\x26\xf7\xda\x16\x52\xdc\xa0\xdf\x6a\x85\xaf\x95\xa2\xca\xf2\xa4\x44\x86\x02\x18\xe4\x44\x08\x0b\x25\x4a\xa1\xc8\x63\x61\x43\xfb\x1f\x1c\x28\x94\xe2\xbe\x5a\x62\x1e\x76\x81\xb1\x9c\xe4\x79\x3e\x19\x42\xfb\x25\xa8\x29\x54\xbc\x21\xaf\xff\x05\xd6\x64\xa7\xf7\xa7\x61\xaa\xe9\x68\x3b\x5b\x22\x43\x67\xf9\xcc\x54\x81\xd1\x5f\x93\xc1\xc4\xac\x81\x25\x9a\x10\x57\xa2\xb6\xe3\x2d\x32\xd6\xfa\x4b\x22\x0e\xec\xc1\x39\x6d\xd7\x8d\xa1\xbc\xc0\x15\x54\x86\x43\xef\x6f\xe3\x95\xec\xdc\xf6\x95\xc1\x20\x27\xb9\x00\xa7\xdf\x7a\xaa\x5c\x8d\x9c\x8b\x2c\x9b\x08\xe1\x31\x50\xe5\x15\xb6\x7b\x68\x0b\x47\xda\xd6\x60\xb9\x08\x4d\x64\x9a\x1f\x47\x45\xb3\xe8\x83\x10\x7f\xb7\xe8\x97\xad\xae\xd1\x81\xeb\xc5\x67\x60\xb5\xf9\x36\x7b\x96\x8a\x43\x98\x35\xf2\xcf\x08\xe8\x1b\x6d\x0b\x6d\xd7\x49\x5c\xc1\x5a\xe2\x5a\xbd\x0d\xee\x18\x6e\x12\x6f\xa8\x98\x2a\x57\x00\xa3\x14\x19\xfb\x0a\xb3\x9f\x9f\x1e\x32\x78\x8d\xab\xda\xbf\x36\x60\x5f\xb9\xf0\x44\x88\xa7\xb5\xf3\x0c\x72\xa8\x96\x7f\xa3\xe2\x3a\xf7\xa3\xa5\xfe\xc3\x05\xde\xf7\xce\x19\xd9\x95\x5e\x5f\x81\xfb\x91\xb6\xe9\x8e\x9f\x91\xc7\x95\x36\x28\xc5\x7f\x75\x4c\xa7\xf2\xe5\x89\xf8\x52\x2f\xe3\x87\xde\x93\x0f\xfd\xef\x06\xc1\xf0\xa6\xff\xdd\x27\x40\xbc\xf8\x72\xf6\xfe\xee\xe6\xf6\xe2\xfa\xd3\xf9\x87\xab\xd7\x97\xf3\xc7\x17\x42\xdb\x1c\x8a\xc2\x4f\xc1\x3b\x10\xda\xbd\x6a\x16\x7b\x6c\x51\x97\xb5\xd0\x36\xa0\xaa\x3c\x0e\xf6\x2b\x17\xd8\x23\x94\x83\xad\x15\x18\xc3\x1b\x4f\xd5\x7a\x33\x0e\xdc\x9f\x7d\xdc\x7b\x4b\x81\x83\x38\x42\x56\x47\x6d\x3c\x8e\xe6\x54\xe0\xbb\x7a\x7b\xe8\x87\x47\x43\x50\x88\x59\x18\x37\x38\x02\xed\x3c\x95\xc8\x1b\xac\x82\x90\xbf\xcf\x5e\x9e\xf4\x82\x15\xf9\xcf\xe0\x0b\x31\x6d\xec\xc6\x96\x33\xdb\xa9\x22\xbb\xea\x8f\x28\x50\x1b\x14\x27\xc7\xfd\x86\x21\x72\x93\xd4\x97\x81\x0c\x8a\x25\x18\xb0\xaa\x09\xd0\xe3\x93\x7a\xc0\x07\x46\x1b\x97\xe1\xa0\x21\xcf\xd1\x19\xda\x95\xf8\x63\xbc\x7a\xd0\x6a\xa7\x21\x07\xe7\xda\x23\x8d\xe2\x61\x03\x36\xc0\x59\xac\xa8\xf3\xf9\x4d\x36\x09\x0e\x55\xd4\xfe\xc5\xa3\x33\x5a\x41\x90\x62\x36\x11\x22\xf6\x28\xe3\x7a\xd7\x00\xf3\xce\xa1\x14\xd7\x64\x8c\xb6\xeb\xbb\xba\xdb\x1b\x76\x18\xee\xc8\x36\x1c\x25\x3c\xdc\x59\xd8\x82\x36\xb0\x8c\x25\x5b\xc3\xa1\x41\xc5\xe4\x9b\x33\x65\xa4\xbf\xf7\x03\xc7\xc7\x5d\x67\x2c\x9d\xe9\x81\x87\xd1\xa9\x63\x9e\xe8\x3f\x77\xf9\xee\x7a\xf5\x3a\xe9\xed\xf9\x41\x84\xeb\x7b\x92\x41\x3f\xa4\xbf\xf8\xe5\xe2\x1e\x77\x31\x64\x5e\xb3\x56\x60\x5e\x17\x05\xd9\xf0\xc1\x9a\x5d\x36\xa8\x44\x72\x51\x93\xbc\x14\xd9\xc5\x83\x0e\x1c\x3a\x61\x24\xf0\x9b\xe4\xfa\xf1\x8b\x25\x70\xc0\xa4\x14\xa4\x30\xda\x56\x0f\xed\x21\x45\x96\x41\x5b\xf4\xbd\x2f\xf9\x93\xb2\x68\x3e\x5d\xc2\x7a\xbf\xdd\xb5\x91\x9c\x4d\x5f\x4d\x4f\xd2\x43\x8b\xca\x98\x05\x19\xad\x76\x52\x5c\xae\xe6\xc4\x0b\x8f\x01\x6b\xa2\xeb\x0a\x7b\x30\x7d\xfa\xf2\xd6\xa5\xe6\x64\x27\xa6\xa3\x24\xbf\x93\x62\xf6\xdb\xf1\x95\x4e\xba\xf4\x9f\x0a\xc3\xe1\x69\xe5\x2a\x29\x66\xc7\xc7\xe5\x28\x46\x02\x01\x7e\x1d\xa4\xf8\x53\x64\x79\xec\xc7\xec\x57\x91\x25\xdc\xd0\x51\x61\x26\xfe\xea\x55\xb6\x64\xaa\x12\xaf\x62\x56\x93\xbc\x75\xd1\x8a\x0c\x9c\x37\x87\x06\xf6\xcb\x78\x7e\x01\xbc\x91\x09\xfb\x24\x77\x81\x22\xe6\x59\x8a\x38\xd8\xf6\xb4\x42\x3e\xb5\xd3\x67\x6a\x41\x9e\xa5\x18\x10\x4d\xd7\xc8\x29\xae\xf3\xc4\xa4\xc8\x48\x71\x77\xbe\xf8\x5e\x9c\x9c\x95\x1b\xc5\xba\x3d\xfb\x0a\x56\x42\x7f\x1d\x5a\x89\xec\xb5\x1a\xf7\x6c\x88\x56\x53\xbf\xe6\xdd\x19\x59\xc6\x07\x1e\xa6\x16\x8c\xa1\xcf\x0b\xaf\xb7\xda\xe0\x1a\x2f\x82\x02\x53\xf7\x8f\x8c\xd4\x1c\x86\xe1\x56\xe0\x60\xa9\x8d\x66\x8d\x07\xc5\x01\x45\x91\x6e\xe4\x62\x7e\x71\xfb\xe9\xcd\xe5\xfc\xfc\xd3\xcd\xc5\xf5\xc7\xcb\xb3\x8b\x44\x5c\x78\x72\x87\x0a\x60\xcc\x48\xe2\xae\x89\xf8\x0f\x6d\xb0\x1d\xfb\x69\x1a\x8d\xde\xa2\xc5\x10\x16\x9e\x96\x38\xc4\xdb\x30\xbb\xb7\xc8\xa9\x09\xd7\x14\xca\xc1\x6c\x15\x6d\x39\x48\x71\x7a\x7c\x7a\x9c\x6c\x07\xb5\xc1

func corednsYamlBytes() ([]byte, error) {
	return bindataRead(
		_corednsYaml,
		"coredns.yaml",
	)
}

func corednsYaml() (*asset, error) {
	bytes, err := corednsYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "coredns.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _rolebindingsYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\xcf\xbd\x0a\xc2\x40\x10\x04\xe0\xfe\x9e\xe2\x5e\xe0\x22\x76\x72\xa5\x16\xf6\x01\xed\x37\xb9\x55\xd7\xdc\x1f\xbb\x7b\x01\x7d\x7a\x09\x48\x1a\x51\xb0\x1c\x18\xe6\x63\xa0\xd2\x19\x59\xa8\x64\x6f\x79\x80\xb1\x83\xa6\xb7\xc2\xf4\x04\xa5\x92\xbb\x69\x27\x1d\x95\xcd\xbc\x35\x13\xe5\xe0\xed\x21\x36\x51\xe4\xbe\x44\xdc\x53\x0e\x94\xaf\x26\xa1\x42\x00\x05\x6f\xac\xcd\x90\xd0\xdb\xa9\x0d\xe8\xa0\x92\x20\xcf\xc8\x6e\x89\x11\xd5\x41\x48\x94\x0d\x97\x88\x3d\x5e\x96\x36\x54\x3a\x72\x69\xf5\x87\x6c\xac\xfd\x80\x57\x47\x1e\xa2\x98\xfc\xba\x5f\xe9\x6d\x48\x1b\xee\x38\xaa\x78\xe3\xfe\x42\x4e\x82\xfc\xe5\x85\x79\x05\x00\x00\xff\xff\x54\xf2\x55\xe2\x29\x01\x00\x00")

func rolebindingsYamlBytes() ([]byte, error) {
	return bindataRead(
		_rolebindingsYaml,
		"rolebindings.yaml",
	)
}

func rolebindingsYaml() (*asset, error) {
	bytes, err := rolebindingsYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "rolebindings.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

var _traefikYaml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x6c\x8f\xcd\x6a\xc3\x30\x10\x84\xef\x7e\x8a\x25\x90\x63\x64\x72\x0a\xe8\xd6\x1f\x43\x4b\xa1\x84\xa6\xed\xb5\xac\xe5\x49\x2c\x22\xc9\x42\xbb\x0a\xb4\xa5\xef\x5e\x1c\x7c\xcc\x71\x77\x3e\x3e\x66\x38\xfb\x4f\x14\xf1\x53\xb2\x34\x22\x44\xe3\x58\x35\xc0\xf8\xa9\xbd\x6c\x9b\xb3\x4f\x83\xa5\x27\x84\xf8\x30\x72\xd1\x26\x42\x79\x60\x65\xdb\x10\x25\x8e\xb0\xa4\x85\x71\xf4\xe7\xe5\x96\xcc\x0e\x96\xce\xb5\xc7\x46\xbe\x45\x11\x1b\xc9\x70\x33\xee\x66\x81\xa5\x51\x35\x8b\x6d\xdb\xf5\xef\xcb\xc7\x7d\xf7\xf6\xda\xbd\x77\x87\xaf\xbb\xfd\xf3\xdf\xba\x15\x65\xf5\xae\xbd\x82\xd2\x2e\xe2\xcd\xd6\xec\x76\x66\x6b\xf4\xf4\xd3\x10\x09\x74\x76\x11\x95\x9e\x9d\x41\xe2\x3e\x60\xb0\xb4\xd2\x52\xb1\xba\x06\x22\xe1\xe6\x3f\x42\x8b\x77\x62\x72\x99\x22\x74\x44\x95\x9b\xd8\xdc\xbc\x24\x28\xc4\xf8\x74\x2a\x10\xe9\xd2\x90\x27\x9f\xd4\x54\xc1\x23\x8e\x5c\x83\xee\x6b\x1f\xbc\x8c\x18\x0e\x28\x17\x3f\x0f\x5e\x0c\xff\x01\x00\x00\xff\xff\xd8\x40\x47\x8d\x4d\x01\x00\x00")

func traefikYamlBytes() ([]byte, error) {
	return bindataRead(
		_traefikYaml,
		"traefik.yaml",
	)
}

func traefikYaml() (*asset, error) {
	bytes, err := traefikYamlBytes()
	if err != nil {
		return nil, err
	}

	info := bindataFileInfo{name: "traefik.yaml", size: 0, mode: os.FileMode(0), modTime: time.Unix(0, 0)}
	a := &asset{bytes: bytes, info: info}
	return a, nil
}

// Asset loads and returns the asset for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func Asset(name string) ([]byte, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
		}
		return a.bytes, nil
	}
	return nil, fmt.Errorf("Asset %s not found", name)
}

// MustAsset is like Asset but panics when Asset would return an error.
// It simplifies safe initialization of global variables.
func MustAsset(name string) []byte {
	a, err := Asset(name)
	if err != nil {
		panic("asset: Asset(" + name + "): " + err.Error())
	}

	return a
}

// AssetInfo loads and returns the asset info for the given name.
// It returns an error if the asset could not be found or
// could not be loaded.
func AssetInfo(name string) (os.FileInfo, error) {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	if f, ok := _bindata[cannonicalName]; ok {
		a, err := f()
		if err != nil {
			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
		}
		return a.info, nil
	}
	return nil, fmt.Errorf("AssetInfo %s not found", name)
}

// AssetNames returns the names of the assets.
func AssetNames() []string {
	names := make([]string, 0, len(_bindata))
	for name := range _bindata {
		names = append(names, name)
	}
	return names
}

// _bindata is a table, holding each asset generator, mapped to its name.
var _bindata = map[string]func() (*asset, error){
	"coredns.yaml":      corednsYaml,
	"rolebindings.yaml": rolebindingsYaml,
	"traefik.yaml":      traefikYaml,
}

// AssetDir returns the file names below a certain
// directory embedded in the file by go-bindata.
// For example if you run go-bindata on data/... and data contains the
// following hierarchy:
//     data/
//       foo.txt
//       img/
//         a.png
//         b.png
// then AssetDir("data") would return []string{"foo.txt", "img"}
// AssetDir("data/img") would return []string{"a.png", "b.png"}
// AssetDir("foo.txt") and AssetDir("notexist") would return an error
// AssetDir("") will return []string{"data"}.
func AssetDir(name string) ([]string, error) {
	node := _bintree
	if len(name) != 0 {
		cannonicalName := strings.Replace(name, "\\", "/", -1)
		pathList := strings.Split(cannonicalName, "/")
		for _, p := range pathList {
			node = node.Children[p]
			if node == nil {
				return nil, fmt.Errorf("Asset %s not found", name)
			}
		}
	}
	if node.Func != nil {
		return nil, fmt.Errorf("Asset %s not found", name)
	}
	rv := make([]string, 0, len(node.Children))
	for childName := range node.Children {
		rv = append(rv, childName)
	}
	return rv, nil
}

type bintree struct {
	Func     func() (*asset, error)
	Children map[string]*bintree
}

var _bintree = &bintree{nil, map[string]*bintree{
	"coredns.yaml":      &bintree{corednsYaml, map[string]*bintree{}},
	"rolebindings.yaml": &bintree{rolebindingsYaml, map[string]*bintree{}},
	"traefik.yaml":      &bintree{traefikYaml, map[string]*bintree{}},
}}

// RestoreAsset restores an asset under the given directory
func RestoreAsset(dir, name string) error {
	data, err := Asset(name)
	if err != nil {
		return err
	}
	info, err := AssetInfo(name)
	if err != nil {
		return err
	}
	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
	if err != nil {
		return err
	}
	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
	if err != nil {
		return err
	}
	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
	if err != nil {
		return err
	}
	return nil
}

// RestoreAssets restores an asset under the given directory recursively
func RestoreAssets(dir, name string) error {
	children, err := AssetDir(name)
	// File
	if err != nil {
		return RestoreAsset(dir, name)
	}
	// Dir
	for _, child := range children {
		err = RestoreAssets(dir, filepath.Join(name, child))
		if err != nil {
			return err
		}
	}
	return nil
}

func _filePath(dir, name string) string {
	cannonicalName := strings.Replace(name, "\\", "/", -1)
	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
}