rke/data/bindata.go

// Code generated for package data by go-bindata DO NOT EDIT. (@generated)
// sources:
// data/data.json
package data

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

func dataDataJsonBytes() ([]byte, error) {
	return bindataRead(
		_dataDataJson,
		"data/data.json",
	)
}

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

	info := bindataFileInfo{name: "data/data.json", size: 1146339, mode: os.FileMode(420), modTime: time.Unix(1557785965, 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){
	"data/data.json": dataDataJson,
}

// 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{
	"data": &bintree{nil, map[string]*bintree{
		"data.json": &bintree{dataDataJson, 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, "/")...)...)
}