Moved to google.golang.org/genproto/googleapis/api/annotations

Fixes #52

vendor/github.com/go-kit/kit/log/term/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Simon Eskildsen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/github.com/go-kit/kit/log/term/colorlogger.go

@@ -0,0 +1,144 @@
+package term
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"sync"
+
+	"github.com/go-kit/kit/log"
+)
+
+// Color represents an ANSI color. The zero value is Default.
+type Color uint8
+
+// ANSI colors.
+const (
+	Default = Color(iota)
+
+	Black
+	DarkRed
+	DarkGreen
+	Brown
+	DarkBlue
+	DarkMagenta
+	DarkCyan
+	Gray
+
+	DarkGray
+	Red
+	Green
+	Yellow
+	Blue
+	Magenta
+	Cyan
+	White
+
+	numColors
+)
+
+// For more on ANSI escape codes see
+// https://en.wikipedia.org/wiki/ANSI_escape_code. See in particular
+// https://en.wikipedia.org/wiki/ANSI_escape_code#Colors.
+
+var (
+	resetColorBytes = []byte("\x1b[39;49;22m")
+	fgColorBytes    [][]byte
+	bgColorBytes    [][]byte
+)
+
+func init() {
+	// Default
+	fgColorBytes = append(fgColorBytes, []byte("\x1b[39m"))
+	bgColorBytes = append(bgColorBytes, []byte("\x1b[49m"))
+
+	// dark colors
+	for color := Black; color < DarkGray; color++ {
+		fgColorBytes = append(fgColorBytes, []byte(fmt.Sprintf("\x1b[%dm", 30+color-Black)))
+		bgColorBytes = append(bgColorBytes, []byte(fmt.Sprintf("\x1b[%dm", 40+color-Black)))
+	}
+
+	// bright colors
+	for color := DarkGray; color < numColors; color++ {
+		fgColorBytes = append(fgColorBytes, []byte(fmt.Sprintf("\x1b[%d;1m", 30+color-DarkGray)))
+		bgColorBytes = append(bgColorBytes, []byte(fmt.Sprintf("\x1b[%d;1m", 40+color-DarkGray)))
+	}
+}
+
+// FgBgColor represents a foreground and background color.
+type FgBgColor struct {
+	Fg, Bg Color
+}
+
+func (c FgBgColor) isZero() bool {
+	return c.Fg == Default && c.Bg == Default
+}
+
+// NewColorLogger returns a Logger which writes colored logs to w. ANSI color
+// codes for the colors returned by color are added to the formatted output
+// from the Logger returned by newLogger and the combined result written to w.
+func NewColorLogger(w io.Writer, newLogger func(io.Writer) log.Logger, color func(keyvals ...interface{}) FgBgColor) log.Logger {
+	if color == nil {
+		panic("color func nil")
+	}
+	return &colorLogger{
+		w:             w,
+		newLogger:     newLogger,
+		color:         color,
+		bufPool:       sync.Pool{New: func() interface{} { return &loggerBuf{} }},
+		noColorLogger: newLogger(w),
+	}
+}
+
+type colorLogger struct {
+	w             io.Writer
+	newLogger     func(io.Writer) log.Logger
+	color         func(keyvals ...interface{}) FgBgColor
+	bufPool       sync.Pool
+	noColorLogger log.Logger
+}
+
+func (l *colorLogger) Log(keyvals ...interface{}) error {
+	color := l.color(keyvals...)
+	if color.isZero() {
+		return l.noColorLogger.Log(keyvals...)
+	}
+
+	lb := l.getLoggerBuf()
+	defer l.putLoggerBuf(lb)
+	if color.Fg != Default {
+		lb.buf.Write(fgColorBytes[color.Fg])
+	}
+	if color.Bg != Default {
+		lb.buf.Write(bgColorBytes[color.Bg])
+	}
+	err := lb.logger.Log(keyvals...)
+	if err != nil {
+		return err
+	}
+	if color.Fg != Default || color.Bg != Default {
+		lb.buf.Write(resetColorBytes)
+	}
+	_, err = io.Copy(l.w, lb.buf)
+	return err
+}
+
+type loggerBuf struct {
+	buf    *bytes.Buffer
+	logger log.Logger
+}
+
+func (l *colorLogger) getLoggerBuf() *loggerBuf {
+	lb := l.bufPool.Get().(*loggerBuf)
+	if lb.buf == nil {
+		lb.buf = &bytes.Buffer{}
+		lb.logger = l.newLogger(lb.buf)
+	} else {
+		lb.buf.Reset()
+	}
+	return lb
+}
+
+func (l *colorLogger) putLoggerBuf(cb *loggerBuf) {
+	l.bufPool.Put(cb)
+}

vendor/github.com/go-kit/kit/log/term/colorlogger_test.go

@@ -0,0 +1,88 @@
+package term_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"strconv"
+	"sync"
+	"testing"
+
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/log/term"
+)
+
+func TestColorLogger(t *testing.T) {
+	var buf bytes.Buffer
+	logger := newColorLogger(&buf)
+
+	if err := logger.Log("hello", "world"); err != nil {
+		t.Fatal(err)
+	}
+	if want, have := "hello=world\n", buf.String(); want != have {
+		t.Errorf("\nwant %#v\nhave %#v", want, have)
+	}
+
+	buf.Reset()
+	if err := logger.Log("a", 1); err != nil {
+		t.Fatal(err)
+	}
+	if want, have := "\x1b[32;1m\x1b[47;1ma=1\n\x1b[39;49;22m", buf.String(); want != have {
+		t.Errorf("\nwant %#v\nhave %#v", want, have)
+	}
+}
+
+func newColorLogger(w io.Writer) log.Logger {
+	return term.NewColorLogger(w, log.NewLogfmtLogger,
+		func(keyvals ...interface{}) term.FgBgColor {
+			if keyvals[0] == "a" {
+				return term.FgBgColor{Fg: term.Green, Bg: term.White}
+			}
+			return term.FgBgColor{}
+		})
+}
+
+func BenchmarkColorLoggerSimple(b *testing.B) {
+	benchmarkRunner(b, newColorLogger(ioutil.Discard), baseMessage)
+}
+
+func BenchmarkColorLoggerContextual(b *testing.B) {
+	benchmarkRunner(b, newColorLogger(ioutil.Discard), withMessage)
+}
+
+func TestColorLoggerConcurrency(t *testing.T) {
+	testConcurrency(t, newColorLogger(ioutil.Discard))
+}
+
+// copied from log/benchmark_test.go
+func benchmarkRunner(b *testing.B, logger log.Logger, f func(log.Logger)) {
+	lc := log.With(logger, "common_key", "common_value")
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		f(lc)
+	}
+}
+
+var (
+	baseMessage = func(logger log.Logger) { logger.Log("foo_key", "foo_value") }
+	withMessage = func(logger log.Logger) { log.With(logger, "a", "b").Log("c", "d") }
+)
+
+// copied from log/concurrency_test.go
+func testConcurrency(t *testing.T, logger log.Logger) {
+	for _, n := range []int{10, 100, 500} {
+		wg := sync.WaitGroup{}
+		wg.Add(n)
+		for i := 0; i < n; i++ {
+			go func() { spam(logger); wg.Done() }()
+		}
+		wg.Wait()
+	}
+}
+
+func spam(logger log.Logger) {
+	for i := 0; i < 100; i++ {
+		logger.Log("a", strconv.FormatInt(int64(i), 10))
+	}
+}

vendor/github.com/go-kit/kit/log/term/colorwriter_others.go

@@ -0,0 +1,12 @@
+// +build !windows
+
+package term
+
+import "io"
+
+// NewColorWriter returns an io.Writer that writes to w and provides cross
+// platform support for ANSI color codes. If w is not a terminal it is
+// returned unmodified.
+func NewColorWriter(w io.Writer) io.Writer {
+	return w
+}

vendor/github.com/go-kit/kit/log/term/colorwriter_windows.go

@@ -0,0 +1,190 @@
+// The code in this file is adapted from github.com/mattn/go-colorable.
+
+// +build windows
+
+package term
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"strconv"
+	"strings"
+	"syscall"
+	"unsafe"
+)
+
+type colorWriter struct {
+	out     io.Writer
+	handle  syscall.Handle
+	lastbuf bytes.Buffer
+	oldattr word
+}
+
+// NewColorWriter returns an io.Writer that writes to w and provides cross
+// platform support for ANSI color codes. If w is not a terminal it is
+// returned unmodified.
+func NewColorWriter(w io.Writer) io.Writer {
+	if !IsTerminal(w) {
+		return w
+	}
+
+	var csbi consoleScreenBufferInfo
+	handle := syscall.Handle(w.(fder).Fd())
+	procGetConsoleScreenBufferInfo.Call(uintptr(handle), uintptr(unsafe.Pointer(&csbi)))
+
+	return &colorWriter{
+		out:     w,
+		handle:  handle,
+		oldattr: csbi.attributes,
+	}
+}
+
+func (w *colorWriter) Write(data []byte) (n int, err error) {
+	var csbi consoleScreenBufferInfo
+	procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+
+	er := bytes.NewBuffer(data)
+loop:
+	for {
+		r1, _, err := procGetConsoleScreenBufferInfo.Call(uintptr(w.handle), uintptr(unsafe.Pointer(&csbi)))
+		if r1 == 0 {
+			break loop
+		}
+
+		c1, _, err := er.ReadRune()
+		if err != nil {
+			break loop
+		}
+		if c1 != 0x1b {
+			fmt.Fprint(w.out, string(c1))
+			continue
+		}
+		c2, _, err := er.ReadRune()
+		if err != nil {
+			w.lastbuf.WriteRune(c1)
+			break loop
+		}
+		if c2 != 0x5b {
+			w.lastbuf.WriteRune(c1)
+			w.lastbuf.WriteRune(c2)
+			continue
+		}
+
+		var buf bytes.Buffer
+		var m rune
+		for {
+			c, _, err := er.ReadRune()
+			if err != nil {
+				w.lastbuf.WriteRune(c1)
+				w.lastbuf.WriteRune(c2)
+				w.lastbuf.Write(buf.Bytes())
+				break loop
+			}
+			if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '@' {
+				m = c
+				break
+			}
+			buf.Write([]byte(string(c)))
+		}
+
+		switch m {
+		case 'm':
+			attr := csbi.attributes
+			cs := buf.String()
+			if cs == "" {
+				procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(w.oldattr))
+				continue
+			}
+			token := strings.Split(cs, ";")
+			intensityMode := word(0)
+			for _, ns := range token {
+				if n, err = strconv.Atoi(ns); err == nil {
+					switch {
+					case n == 0:
+						attr = w.oldattr
+					case n == 1:
+						attr |= intensityMode
+					case 30 <= n && n <= 37:
+						attr = (attr & backgroundMask)
+						if (n-30)&1 != 0 {
+							attr |= foregroundRed
+						}
+						if (n-30)&2 != 0 {
+							attr |= foregroundGreen
+						}
+						if (n-30)&4 != 0 {
+							attr |= foregroundBlue
+						}
+						intensityMode = foregroundIntensity
+					case n == 39: // reset foreground color
+						attr &= backgroundMask
+						attr |= w.oldattr & foregroundMask
+					case 40 <= n && n <= 47:
+						attr = (attr & foregroundMask)
+						if (n-40)&1 != 0 {
+							attr |= backgroundRed
+						}
+						if (n-40)&2 != 0 {
+							attr |= backgroundGreen
+						}
+						if (n-40)&4 != 0 {
+							attr |= backgroundBlue
+						}
+						intensityMode = backgroundIntensity
+					case n == 49: // reset background color
+						attr &= foregroundMask
+						attr |= w.oldattr & backgroundMask
+					}
+					procSetConsoleTextAttribute.Call(uintptr(w.handle), uintptr(attr))
+				}
+			}
+		}
+	}
+	return len(data) - w.lastbuf.Len(), nil
+}
+
+var (
+	procGetConsoleScreenBufferInfo = kernel32.NewProc("GetConsoleScreenBufferInfo")
+	procSetConsoleTextAttribute    = kernel32.NewProc("SetConsoleTextAttribute")
+)
+
+const (
+	foregroundBlue      = 0x1
+	foregroundGreen     = 0x2
+	foregroundRed       = 0x4
+	foregroundIntensity = 0x8
+	foregroundMask      = (foregroundRed | foregroundBlue | foregroundGreen | foregroundIntensity)
+	backgroundBlue      = 0x10
+	backgroundGreen     = 0x20
+	backgroundRed       = 0x40
+	backgroundIntensity = 0x80
+	backgroundMask      = (backgroundRed | backgroundBlue | backgroundGreen | backgroundIntensity)
+)
+
+type (
+	wchar uint16
+	short int16
+	dword uint32
+	word  uint16
+)
+
+type coord struct {
+	x short
+	y short
+}
+
+type smallRect struct {
+	left   short
+	top    short
+	right  short
+	bottom short
+}
+
+type consoleScreenBufferInfo struct {
+	size              coord
+	cursorPosition    coord
+	attributes        word
+	window            smallRect
+	maximumWindowSize coord
+}

vendor/github.com/go-kit/kit/log/term/example_test.go

@@ -0,0 +1,57 @@
+package term_test
+
+import (
+	"errors"
+	"os"
+
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/log/term"
+)
+
+func ExampleNewLogger_redErrors() {
+	// Color errors red
+	colorFn := func(keyvals ...interface{}) term.FgBgColor {
+		for i := 1; i < len(keyvals); i += 2 {
+			if _, ok := keyvals[i].(error); ok {
+				return term.FgBgColor{Fg: term.White, Bg: term.Red}
+			}
+		}
+		return term.FgBgColor{}
+	}
+
+	logger := term.NewLogger(os.Stdout, log.NewLogfmtLogger, colorFn)
+
+	logger.Log("msg", "default color", "err", nil)
+	logger.Log("msg", "colored because of error", "err", errors.New("coloring error"))
+}
+
+func ExampleNewLogger_levelColors() {
+	// Color by level value
+	colorFn := func(keyvals ...interface{}) term.FgBgColor {
+		for i := 0; i < len(keyvals)-1; i += 2 {
+			if keyvals[i] != "level" {
+				continue
+			}
+			switch keyvals[i+1] {
+			case "debug":
+				return term.FgBgColor{Fg: term.DarkGray}
+			case "info":
+				return term.FgBgColor{Fg: term.Gray}
+			case "warn":
+				return term.FgBgColor{Fg: term.Yellow}
+			case "error":
+				return term.FgBgColor{Fg: term.Red}
+			case "crit":
+				return term.FgBgColor{Fg: term.Gray, Bg: term.DarkRed}
+			default:
+				return term.FgBgColor{}
+			}
+		}
+		return term.FgBgColor{}
+	}
+
+	logger := term.NewLogger(os.Stdout, log.NewJSONLogger, colorFn)
+
+	logger.Log("level", "warn", "msg", "yellow")
+	logger.Log("level", "debug", "msg", "dark gray")
+}

vendor/github.com/go-kit/kit/log/term/term.go

@@ -0,0 +1,22 @@
+// Package term provides tools for logging to a terminal.
+package term
+
+import (
+	"io"
+
+	"github.com/go-kit/kit/log"
+)
+
+// NewLogger returns a Logger that takes advantage of terminal features if
+// possible. Log events are formatted by the Logger returned by newLogger. If
+// w is a terminal each log event is colored according to the color function.
+func NewLogger(w io.Writer, newLogger func(io.Writer) log.Logger, color func(keyvals ...interface{}) FgBgColor) log.Logger {
+	if !IsTerminal(w) {
+		return newLogger(w)
+	}
+	return NewColorLogger(NewColorWriter(w), newLogger, color)
+}
+
+type fder interface {
+	Fd() uintptr
+}

vendor/github.com/go-kit/kit/log/term/terminal_appengine.go

@@ -0,0 +1,15 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build appengine
+
+package term
+
+import "io"
+
+// IsTerminal always returns false on AppEngine.
+func IsTerminal(w io.Writer) bool {
+	return false
+}

vendor/github.com/go-kit/kit/log/term/terminal_darwin.go

@@ -0,0 +1,10 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA

vendor/github.com/go-kit/kit/log/term/terminal_freebsd.go

@@ -0,0 +1,7 @@
+package term
+
+import (
+	"syscall"
+)
+
+const ioctlReadTermios = syscall.TIOCGETA

vendor/github.com/go-kit/kit/log/term/terminal_linux.go

@@ -0,0 +1,12 @@
+// Based on ssh/terminal:
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build !appengine
+
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TCGETS

vendor/github.com/go-kit/kit/log/term/terminal_notwindows.go

@@ -0,0 +1,25 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build linux,!appengine darwin freebsd openbsd
+
+package term
+
+import (
+	"io"
+	"syscall"
+	"unsafe"
+)
+
+// IsTerminal returns true if w writes to a terminal.
+func IsTerminal(w io.Writer) bool {
+	fw, ok := w.(fder)
+	if !ok {
+		return false
+	}
+	var termios syscall.Termios
+	_, _, err := syscall.Syscall6(syscall.SYS_IOCTL, fw.Fd(), ioctlReadTermios, uintptr(unsafe.Pointer(&termios)), 0, 0, 0)
+	return err == 0
+}

vendor/github.com/go-kit/kit/log/term/terminal_openbsd.go

@@ -0,0 +1,5 @@
+package term
+
+import "syscall"
+
+const ioctlReadTermios = syscall.TIOCGETA

vendor/github.com/go-kit/kit/log/term/terminal_windows.go

@@ -0,0 +1,31 @@
+// Based on ssh/terminal:
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build windows
+
+package term
+
+import (
+	"io"
+	"syscall"
+	"unsafe"
+)
+
+var kernel32 = syscall.NewLazyDLL("kernel32.dll")
+
+var (
+	procGetConsoleMode = kernel32.NewProc("GetConsoleMode")
+)
+
+// IsTerminal returns true if w writes to a terminal.
+func IsTerminal(w io.Writer) bool {
+	fw, ok := w.(fder)
+	if !ok {
+		return false
+	}
+	var st uint32
+	r, _, e := syscall.Syscall(procGetConsoleMode.Addr(), 2, fw.Fd(), uintptr(unsafe.Pointer(&st)), 0)
+	return r != 0 && e == 0
+}