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

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: 3157855, 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, "/")...)...)
}