bump(github.com/jteeuwen/go-bindata): 79847ab3e91ae5d2e1b18796c1795c78f29565d7

.gitignore

@@ -2,4 +2,5 @@ src/
 pkg/
 /etcd
 /server/release_version.go
+/go-bindata
 /machine*

dashboard/.gitignore

@@ -3,3 +3,4 @@ dist
 .tmp
 .sass-cache
 app/bower_components
+/go-bindata

third_party/deps

@@ -11,4 +11,5 @@ packages="
 	bitbucket.org/kardianos/osext
 	code.google.com/p/go.net
 	code.google.com/p/goprotobuf
+	github.com/jteeuwen/go-bindata
 "

third_party/github.com/jteeuwen/go-bindata/CONTRIBUTORS

@@ -0,0 +1,10 @@
+# This is the list of people who can contribute (or have contributed) to this
+# project. This includes code, documentation, testing, content creation and 
+# bugfixes.
+#
+# Names should be added to this file like so:
+#     Name [<email address>]
+#
+# Please keep the list sorted.
+
+Jim Teeuwen <jimteeuwen at gmail dot com>

third_party/github.com/jteeuwen/go-bindata/LICENSE

@@ -0,0 +1,3 @@
+This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+license. Its contents can be found at:
+http://creativecommons.org/publicdomain/zero/1.0

third_party/github.com/jteeuwen/go-bindata/README.md

@@ -0,0 +1,173 @@
+## bindata
+
+This tool converts any file into managable Go source code. Useful for embedding
+binary data into a go program. The file data is optionally gzip compressed
+before being converted to a raw byte slice.
+
+### Usage
+
+The simplest invocation is to pass it only the input file name.
+The output file and code settings are inferred from this automatically.
+
+    $ go-bindata testdata/gophercolor.png
+    [w] No output file specified. Using 'testdata/gophercolor.png.go'.
+    [w] No package name specified. Using 'main'.
+    [w] No function name specified. Using 'testdata_gophercolor_png'.
+
+This creates the `testdata/gophercolor.png.go` file which has a package
+declaration with name `main` and one function named `testdata_gophercolor_png` with
+the following signature:
+
+```go
+func testdata_gophercolor_png() []byte
+```
+
+You can now simply include the new .go file in your program and call
+`testdata_gophercolor_png()` to get the (uncompressed) image data. The function panics
+if something went wrong during decompression. See the testdata directory for
+example input and output files for various modes.
+
+Aternatively, you can pipe the input file data into stdin. `go-bindata` will
+then spit out the generated Go code to stdout. This does require explicitly
+naming the desired function name, as it can not be inferred from the
+input data. The package name will still default to 'main'.
+
+     $ cat testdata/gophercolor.png | go-bindata -f gophercolor_png | gofmt
+
+Invoke the program with the `-h` flag for more options.
+
+In order to strip off a part of the generated function name, we can use the `-prefix` flag.
+In the above example, the input file `testdata/gophercolor.png` yields a function named
+`testdata_gophercolor_png`. If we want the `testdata` component to be left out, we invoke
+the program as follows:
+
+    $ go-bindata -prefix "testdata/" testdata/gophercolor.png
+
+
+### Lower memory footprint
+
+Using the `-nomemcopy` flag, will alter the way the output file is generated.
+It will employ a hack that allows us to read the file data directly from
+the compiled program's `.rodata` section. This ensures that when we call
+call our generated function, we omit unnecessary memcopies.
+
+The downside of this, is that it requires dependencies on the `reflect` and
+`unsafe` packages. These may be restricted on platforms like AppEngine and
+thus prevent you from using this mode.
+
+Another disadvantage is that the byte slice we create, is strictly read-only.
+For most use-cases this is not a problem, but if you ever try to alter the
+returned byte slice, a runtime panic is thrown. Use this mode only on target
+platforms where memory constraints are an issue.
+
+The default behaviour is to use the old code generation method. This
+prevents the two previously mentioned issues, but will employ at least one
+extra memcopy and thus increase memory requirements.
+
+For instance, consider the following two examples:
+
+This would be the default mode, using an extra memcopy but gives a safe
+implementation without dependencies on `reflect` and `unsafe`:
+
+```go
+func myfile() []byte {
+    return []byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a}
+}
+```
+
+Here is the same functionality, but uses the `.rodata` hack.
+The byte slice returned from this example can not be written to without
+generating a runtime error.
+
+```go
+var _myfile = "\x89\x50\x4e\x47\x0d\x0a\x1a"
+
+func myfile() []byte {
+    var empty [0]byte
+    sx := (*reflect.StringHeader)(unsafe.Pointer(&_myfile))
+    b := empty[:]
+    bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+    bx.Data = sx.Data
+    bx.Len = len(_myfile)
+    bx.Cap = bx.Len
+    return b
+}
+```
+
+
+### Optional compression
+
+When the `-uncompressed` flag is given, the supplied resource is *not* GZIP compressed
+before being turned into Go code. The data should still be accessed through
+a function call, so nothing changes in the usage of the generated file.
+
+This feature is useful if you do not care for compression, or the supplied
+resource is already compressed. Doing it again would not add any value and may
+even increase the size of the data.
+
+The default behaviour of the program is to use compression.
+
+
+### Table of Contents
+
+With the `-toc` flag, we can have `go-bindata` create a table of contents for all the files
+which have been generated by the tool. It does this by first generating a new file named
+`bindata-toc.go`. This contains a global map of type `map[string] func() []byte`. It uses the
+input filename as the key and the data function as the value. We can use this
+to fetch all data for our files, matching a given pattern.
+
+It then appands an `init` function to each generated file, which simply makes the data
+function append itself to the global `bindata` map.
+
+Once you have compiled your program with all these new files and run it, the map will
+be populated by all generated data files.
+
+**Note**: The `bindata-toc.go` file will not be created when we run in `pipe` mode.
+The reason being, that the tool does not write any files at all, as it has no idea
+where to save them. The data file is written to `stdout` instead after all.
+
+
+#### Table of Contents keys
+
+The keys used in the `go_bindata` map, are the same as the input file name passed to `go-bindata`.
+This includes the fully qualified (absolute) path. In most cases, this is not desireable, as it
+puts potentially sensitive information in your code base. For this purpose, the tool supplies
+another command line flag `-prefix`. This accepts a portion of a path name, which should be
+stripped off from the map keys and function names.
+
+For example, running without the `-prefix` flag, we get:
+
+	$ go-bindata /path/to/templates/foo.html
+    
+	go_bindata["/path/to/templates/foo.html"] = path_to_templates_foo_html
+
+Running with the `-prefix` flag, we get:
+
+	$ go-bindata -prefix "/path/to/" /path/to/templates/foo.html
+    
+	go_bindata["templates/foo.html"] = templates_foo_html
+
+
+#### bindata-toc.go
+
+The `bindata-toc.go` file is very simple and looks as follows:
+
+```go
+package $PACKAGENAME
+
+// Global Table of Contents map. Generated by go-bindata.
+// After startup of the program, all generated data files will
+// put themselves in this map. The key is the full filename, as
+// supplied to go-bindata.
+var go_bindata = make(map[string] func() []byte)
+```
+
+#### Build tags
+
+With the optional -tags flag, you can specify any go build tags that
+must be fulfilled for the output file to be included in a build. This
+is useful for including binary data in multiple formats, where the desired
+format is specified at build time with the appropriate tag(s).
+
+The tags are appended to a `// +build` line in the beginning of the output file
+and must follow the build tags syntax specified by the go tool.

third_party/github.com/jteeuwen/go-bindata/lib/bytewriter.go

@@ -0,0 +1,37 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"io"
+)
+
+var newline = []byte{'\n'}
+
+type ByteWriter struct {
+	io.Writer
+	c int
+}
+
+func (w *ByteWriter) Write(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return
+	}
+
+	for n = range p {
+		if w.c%12 == 0 {
+			w.Writer.Write(newline)
+			w.c = 0
+		}
+
+		fmt.Fprintf(w.Writer, "0x%02x,", p[n])
+		w.c++
+	}
+
+	n++
+
+	return
+}

third_party/github.com/jteeuwen/go-bindata/lib/stringwriter.go

@@ -0,0 +1,30 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"io"
+)
+
+type StringWriter struct {
+	io.Writer
+	c int
+}
+
+func (w *StringWriter) Write(p []byte) (n int, err error) {
+	if len(p) == 0 {
+		return
+	}
+
+	for n = range p {
+		fmt.Fprintf(w.Writer, "\\x%02x", p[n])
+		w.c++
+	}
+
+	n++
+
+	return
+}

third_party/github.com/jteeuwen/go-bindata/lib/toc.go

@@ -0,0 +1,39 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+)
+
+// createTOC writes a table of contents file to the given location.
+func CreateTOC(dir, pkgname string) error {
+	file := filepath.Join(dir, "bindata-toc.go")
+	code := fmt.Sprintf(`package %s
+
+// Global Table of Contents map. Generated by go-bindata.
+// After startup of the program, all generated data files will
+// put themselves in this map. The key is the full filename, as
+// supplied to go-bindata.
+var go_bindata = make(map[string]func() []byte)`, pkgname)
+
+	return ioutil.WriteFile(file, []byte(code), 0600)
+}
+
+// WriteTOCInit writes the TOC init function for a given data file
+// replacing the prefix in the filename by "", funcname being the translated function name
+func WriteTOCInit(output io.Writer, filename, prefix, funcname string) {
+	filename = strings.Replace(filename, prefix, "", 1)
+	fmt.Fprintf(output, `
+
+func init() {
+	go_bindata[%q] = %s
+}
+`, filename, funcname)
+}

third_party/github.com/jteeuwen/go-bindata/lib/translate.go

@@ -0,0 +1,187 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"compress/gzip"
+	"fmt"
+	"io"
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+var regFuncName = regexp.MustCompile(`[^a-zA-Z0-9_]`)
+
+// translate translates the input file to go source code.
+func Translate(input io.Reader, output io.Writer, pkgname, funcname string, uncompressed, nomemcpy bool) {
+	if nomemcpy {
+		if uncompressed {
+			translate_nomemcpy_uncomp(input, output, pkgname, funcname)
+		} else {
+			translate_nomemcpy_comp(input, output, pkgname, funcname)
+		}
+	} else {
+		if uncompressed {
+			translate_memcpy_uncomp(input, output, pkgname, funcname)
+		} else {
+			translate_memcpy_comp(input, output, pkgname, funcname)
+		}
+	}
+}
+
+// input -> gzip -> gowriter -> output.
+func translate_memcpy_comp(input io.Reader, output io.Writer, pkgname, funcname string) {
+	fmt.Fprintf(output, `package %s
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io"
+)
+
+// %s returns raw, uncompressed file data.
+func %s() []byte {
+	gz, err := gzip.NewReader(bytes.NewBuffer([]byte{`, pkgname, funcname, funcname)
+
+	gz := gzip.NewWriter(&ByteWriter{Writer: output})
+	io.Copy(gz, input)
+	gz.Close()
+
+	fmt.Fprint(output, `
+	}))
+
+	if err != nil {
+		panic("Decompression failed: " + err.Error())
+	}
+
+	var b bytes.Buffer
+	io.Copy(&b, gz)
+	gz.Close()
+
+	return b.Bytes()
+}`)
+}
+
+// input -> gzip -> gowriter -> output.
+func translate_memcpy_uncomp(input io.Reader, output io.Writer, pkgname, funcname string) {
+	fmt.Fprintf(output, `package %s
+
+// %s returns raw file data.
+func %s() []byte {
+	return []byte{`, pkgname, funcname, funcname)
+
+	io.Copy(&ByteWriter{Writer: output}, input)
+
+	fmt.Fprint(output, `
+	}
+}`)
+}
+
+// input -> gzip -> gowriter -> output.
+func translate_nomemcpy_comp(input io.Reader, output io.Writer, pkgname, funcname string) {
+	fmt.Fprintf(output, `package %s
+
+import (
+	"bytes"
+	"compress/gzip"
+	"io"
+	"reflect"
+	"unsafe"
+)
+
+var _%s = "`, pkgname, funcname)
+
+	gz := gzip.NewWriter(&StringWriter{Writer: output})
+	io.Copy(gz, input)
+	gz.Close()
+
+	fmt.Fprintf(output, `"
+
+// %s returns raw, uncompressed file data.
+func %s() []byte {
+	var empty [0]byte
+	sx := (*reflect.StringHeader)(unsafe.Pointer(&_%s))
+	b := empty[:]
+	bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bx.Data = sx.Data
+	bx.Len = len(_%s)
+	bx.Cap = bx.Len
+
+	gz, err := gzip.NewReader(bytes.NewBuffer(b))
+
+	if err != nil {
+		panic("Decompression failed: " + err.Error())
+	}
+
+	var buf bytes.Buffer
+	io.Copy(&buf, gz)
+	gz.Close()
+
+	return buf.Bytes()
+}
+`, funcname, funcname, funcname, funcname)
+}
+
+// input -> gowriter -> output.
+func translate_nomemcpy_uncomp(input io.Reader, output io.Writer, pkgname, funcname string) {
+	fmt.Fprintf(output, `package %s
+
+import (
+	"reflect"
+	"unsafe"
+)
+
+var _%s = "`, pkgname, funcname)
+
+	io.Copy(&StringWriter{Writer: output}, input)
+
+	fmt.Fprintf(output, `"
+
+// %s returns raw file data.
+//
+// WARNING: The returned byte slice is READ-ONLY.
+// Attempting to alter the slice contents will yield a runtime panic.
+func %s() []byte {
+	var empty [0]byte
+	sx := (*reflect.StringHeader)(unsafe.Pointer(&_%s))
+	b := empty[:]
+	bx := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+	bx.Data = sx.Data
+	bx.Len = len(_%s)
+	bx.Cap = bx.Len
+	return b
+}
+`, funcname, funcname, funcname, funcname)
+}
+
+// safeFuncname creates a safe function name from the input path.
+func SafeFuncname(in, prefix string) string {
+	name := strings.Replace(in, prefix, "", 1)
+
+	if len(name) == 0 {
+		name = in
+	}
+
+	name = strings.ToLower(name)
+	name = regFuncName.ReplaceAllString(name, "_")
+
+	if unicode.IsDigit(rune(name[0])) {
+		// Identifier can't start with a digit.
+		name = "_" + name
+	}
+
+	// Get rid of "__" instances for niceness.
+	for strings.Index(name, "__") > -1 {
+		name = strings.Replace(name, "__", "_", -1)
+	}
+
+	// Leading underscore is silly.
+	if name[0] == '_' {
+		name = name[1:]
+	}
+
+	return name
+}

third_party/github.com/jteeuwen/go-bindata/lib/version.go

@@ -0,0 +1,31 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package bindata
+
+import (
+	"fmt"
+	"runtime"
+)
+
+const (
+	AppName         = "bindata"
+	AppVersionMajor = 2
+	AppVersionMinor = 1
+)
+
+// revision part of the program version.
+// This will be set automatically at build time like so:
+//
+//     go build -ldflags "-X main.AppVersionRev `date -u +%s`"
+var AppVersionRev string
+
+func Version() string {
+	if len(AppVersionRev) == 0 {
+		AppVersionRev = "0"
+	}
+
+	return fmt.Sprintf("%s %d.%d.%s (Go runtime %s).\nCopyright (c) 2010-2013, Jim Teeuwen.",
+		AppName, AppVersionMajor, AppVersionMinor, AppVersionRev, runtime.Version())
+}

third_party/github.com/jteeuwen/go-bindata/main.go

@@ -0,0 +1,157 @@
+// This work is subject to the CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+// license. Its contents can be found at:
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"github.com/jteeuwen/go-bindata/lib"
+	"os"
+	"path"
+	"path/filepath"
+	"unicode"
+)
+
+var (
+	pipe         = false
+	in           = ""
+	out          = flag.String("out", "", "Optional path and name of the output file.")
+	pkgname      = flag.String("pkg", "main", "Name of the package to generate.")
+	funcname     = flag.String("func", "", "Optional name of the function to generate.")
+	prefix       = flag.String("prefix", "", "Optional path prefix to strip off map keys and function names.")
+	uncompressed = flag.Bool("uncompressed", false, "The specified resource will /not/ be GZIP compressed when this flag is specified. This alters the generated output code.")
+	nomemcopy    = flag.Bool("nomemcopy", false, "Use a .rodata hack to get rid of unnecessary memcopies. Refer to the documentation to see what implications this carries.")
+	tags         = flag.String("tags", "", "Optional build tags")
+	toc          = flag.Bool("toc", false, "Generate a table of contents for this and other files. The input filepath becomes the map key. This option is only useable in non-pipe mode.")
+	version      = flag.Bool("version", false, "Display version information.")
+)
+
+func main() {
+	parseArgs()
+
+	if pipe {
+		bindata.Translate(os.Stdin, os.Stdout, *pkgname, *funcname, *uncompressed, *nomemcopy)
+		return
+	}
+
+	fs, err := os.Open(in)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[e] %s\n", err)
+		return
+	}
+
+	defer fs.Close()
+
+	fd, err := os.Create(*out)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "[e] %s\n", err)
+		return
+	}
+
+	defer fd.Close()
+
+	if *tags != "" {
+		fmt.Fprintf(fd, "// +build %s\n\n", *tags)
+	}
+
+	// Translate binary to Go code.
+	bindata.Translate(fs, fd, *pkgname, *funcname, *uncompressed, *nomemcopy)
+
+	// Append the TOC init function to the end of the output file and
+	// write the `bindata-toc.go` file, if applicable.
+	if *toc {
+		dir, _ := filepath.Split(*out)
+		err := bindata.CreateTOC(dir, *pkgname)
+
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "[e] %s\n", err)
+			return
+		}
+
+		bindata.WriteTOCInit(fd, in, *prefix, *funcname)
+	}
+}
+
+// parseArgs processes and verifies commandline arguments.
+func parseArgs() {
+	flag.Usage = func() {
+		fmt.Printf("Usage: %s [options] <filename>\n\n", os.Args[0])
+		flag.PrintDefaults()
+	}
+	flag.Parse()
+
+	if *version {
+		fmt.Printf("%s\n", bindata.Version())
+		os.Exit(0)
+	}
+
+	pipe = flag.NArg() == 0
+
+	if !pipe {
+		*prefix, _ = filepath.Abs(filepath.Clean(*prefix))
+		in, _ = filepath.Abs(filepath.Clean(flag.Args()[0]))
+		*out = safeFilename(*out, in)
+	}
+
+	if len(*pkgname) == 0 {
+		fmt.Fprintln(os.Stderr, "[w] No package name specified. Using 'main'.")
+		*pkgname = "main"
+	} else {
+		if unicode.IsDigit(rune((*pkgname)[0])) {
+			// Identifier can't start with a digit.
+			*pkgname = "_" + *pkgname
+		}
+	}
+
+	if len(*funcname) == 0 {
+		if pipe {
+			// Can't infer from input file name in this mode.
+			fmt.Fprintln(os.Stderr, "[e] No function name specified.")
+			os.Exit(1)
+		}
+
+		*funcname = bindata.SafeFuncname(in, *prefix)
+		fmt.Fprintf(os.Stderr, "[w] No function name specified. Using %s.\n", *funcname)
+	}
+}
+
+// safeFilename creates a safe output filename from the given
+// output and input paths.
+func safeFilename(out, in string) string {
+	var filename string
+
+	if len(out) == 0 {
+		filename = in + ".go"
+
+		_, err := os.Lstat(filename)
+		if err == nil {
+			// File already exists. Pad name with a sequential number until we
+			// find a name that is available.
+			count := 0
+
+			for {
+				filename = path.Join(out, fmt.Sprintf("%s.%d.go", in, count))
+				_, err = os.Lstat(filename)
+
+				if err != nil {
+					break
+				}
+
+				count++
+			}
+		}
+	} else {
+		filename, _ = filepath.Abs(filepath.Clean(out))
+	}
+
+	// Ensure output directory exists while we're here.
+	dir, _ := filepath.Split(filename)
+	_, err := os.Lstat(dir)
+	if err != nil {
+		os.MkdirAll(dir, 0755)
+	}
+
+	return filename
+}

third_party/github.com/jteeuwen/go-bindata/testdata/bindata-toc.go

@@ -0,0 +1,7 @@
+package main
+
+// Global Table of Contents map. Generated by go-bindata.
+// After startup of the program, all generated data files will
+// put themselves in this map. The key is the full filename, as
+// supplied to go-bindata.
+var go_bindata = make(map[string]func() []byte)