3 files changed, 401 insertions, 0 deletions

diff --git a/vendor/google.golang.org/grpc/grpclog/grpclog.go b/vendor/google.golang.org/grpc/grpclog/grpclog.go
new file mode 100644
index 0000000..16a7d88
--- /dev/null
+++ b/vendor/google.golang.org/grpc/grpclog/grpclog.go
@@ -0,0 +1,123 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package grpclog defines logging for grpc.
+//
+// All logs in transport package only go to verbose level 2.
+// All logs in other packages in grpc are logged in spite of the verbosity level.
+//
+// In the default logger,
+// severity level can be set by environment variable GRPC_GO_LOG_SEVERITY_LEVEL,
+// verbosity level can be set by GRPC_GO_LOG_VERBOSITY_LEVEL.
+package grpclog // import "google.golang.org/grpc/grpclog"
+
+import "os"
+
+var logger = newLoggerV2()
+
+// V reports whether verbosity level l is at least the requested verbose level.
+func V(l int) bool {
+        return logger.V(l)
+}
+
+// Info logs to the INFO log.
+func Info(args ...interface{}) {
+        logger.Info(args...)
+}
+
+// Infof logs to the INFO log. Arguments are handled in the manner of fmt.Printf.
+func Infof(format string, args ...interface{}) {
+        logger.Infof(format, args...)
+}
+
+// Infoln logs to the INFO log. Arguments are handled in the manner of fmt.Println.
+func Infoln(args ...interface{}) {
+        logger.Infoln(args...)
+}
+
+// Warning logs to the WARNING log.
+func Warning(args ...interface{}) {
+        logger.Warning(args...)
+}
+
+// Warningf logs to the WARNING log. Arguments are handled in the manner of fmt.Printf.
+func Warningf(format string, args ...interface{}) {
+        logger.Warningf(format, args...)
+}
+
+// Warningln logs to the WARNING log. Arguments are handled in the manner of fmt.Println.
+func Warningln(args ...interface{}) {
+        logger.Warningln(args...)
+}
+
+// Error logs to the ERROR log.
+func Error(args ...interface{}) {
+        logger.Error(args...)
+}
+
+// Errorf logs to the ERROR log. Arguments are handled in the manner of fmt.Printf.
+func Errorf(format string, args ...interface{}) {
+        logger.Errorf(format, args...)
+}
+
+// Errorln logs to the ERROR log. Arguments are handled in the manner of fmt.Println.
+func Errorln(args ...interface{}) {
+        logger.Errorln(args...)
+}
+
+// Fatal logs to the FATAL log. Arguments are handled in the manner of fmt.Print.
+// It calls os.Exit() with exit code 1.
+func Fatal(args ...interface{}) {
+        logger.Fatal(args...)
+        // Make sure fatal logs will exit.
+        os.Exit(1)
+}
+
+// Fatalf logs to the FATAL log. Arguments are handled in the manner of fmt.Printf.
+// It calles os.Exit() with exit code 1.
+func Fatalf(format string, args ...interface{}) {
+        logger.Fatalf(format, args...)
+        // Make sure fatal logs will exit.
+        os.Exit(1)
+}
+
+// Fatalln logs to the FATAL log. Arguments are handled in the manner of fmt.Println.
+// It calle os.Exit()) with exit code 1.
+func Fatalln(args ...interface{}) {
+        logger.Fatalln(args...)
+        // Make sure fatal logs will exit.
+        os.Exit(1)
+}
+
+// Print prints to the logger. Arguments are handled in the manner of fmt.Print.
+// Deprecated: use Info.
+func Print(args ...interface{}) {
+        logger.Info(args...)
+}
+
+// Printf prints to the logger. Arguments are handled in the manner of fmt.Printf.
+// Deprecated: use Infof.
+func Printf(format string, args ...interface{}) {
+        logger.Infof(format, args...)
+}
+
+// Println prints to the logger. Arguments are handled in the manner of fmt.Println.
+// Deprecated: use Infoln.
+func Println(args ...interface{}) {
+        logger.Infoln(args...)
+}
diff --git a/vendor/google.golang.org/grpc/grpclog/logger.go b/vendor/google.golang.org/grpc/grpclog/logger.go
new file mode 100644
index 0000000..d03b239
--- /dev/null
+++ b/vendor/google.golang.org/grpc/grpclog/logger.go
@@ -0,0 +1,83 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpclog
+
+// Logger mimics golang's standard Logger as an interface.
+// Deprecated: use LoggerV2.
+type Logger interface {
+        Fatal(args ...interface{})
+        Fatalf(format string, args ...interface{})
+        Fatalln(args ...interface{})
+        Print(args ...interface{})
+        Printf(format string, args ...interface{})
+        Println(args ...interface{})
+}
+
+// SetLogger sets the logger that is used in grpc. Call only from
+// init() functions.
+// Deprecated: use SetLoggerV2.
+func SetLogger(l Logger) {
+        logger = &loggerWrapper{Logger: l}
+}
+
+// loggerWrapper wraps Logger into a LoggerV2.
+type loggerWrapper struct {
+        Logger
+}
+
+func (g *loggerWrapper) Info(args ...interface{}) {
+        g.Logger.Print(args...)
+}
+
+func (g *loggerWrapper) Infoln(args ...interface{}) {
+        g.Logger.Println(args...)
+}
+
+func (g *loggerWrapper) Infof(format string, args ...interface{}) {
+        g.Logger.Printf(format, args...)
+}
+
+func (g *loggerWrapper) Warning(args ...interface{}) {
+        g.Logger.Print(args...)
+}
+
+func (g *loggerWrapper) Warningln(args ...interface{}) {
+        g.Logger.Println(args...)
+}
+
+func (g *loggerWrapper) Warningf(format string, args ...interface{}) {
+        g.Logger.Printf(format, args...)
+}
+
+func (g *loggerWrapper) Error(args ...interface{}) {
+        g.Logger.Print(args...)
+}
+
+func (g *loggerWrapper) Errorln(args ...interface{}) {
+        g.Logger.Println(args...)
+}
+
+func (g *loggerWrapper) Errorf(format string, args ...interface{}) {
+        g.Logger.Printf(format, args...)
+}
+
+func (g *loggerWrapper) V(l int) bool {
+        // Returns true for all verbose level.
+        return true
+}
diff --git a/vendor/google.golang.org/grpc/grpclog/loggerv2.go b/vendor/google.golang.org/grpc/grpclog/loggerv2.go
new file mode 100644
index 0000000..d493257
--- /dev/null
+++ b/vendor/google.golang.org/grpc/grpclog/loggerv2.go
@@ -0,0 +1,195 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package grpclog
+
+import (
+        "io"
+        "io/ioutil"
+        "log"
+        "os"
+        "strconv"
+)
+
+// LoggerV2 does underlying logging work for grpclog.
+type LoggerV2 interface {
+        // Info logs to INFO log. Arguments are handled in the manner of fmt.Print.
+        Info(args ...interface{})
+        // Infoln logs to INFO log. Arguments are handled in the manner of fmt.Println.
+        Infoln(args ...interface{})
+        // Infof logs to INFO log. Arguments are handled in the manner of fmt.Printf.
+        Infof(format string, args ...interface{})
+        // Warning logs to WARNING log. Arguments are handled in the manner of fmt.Print.
+        Warning(args ...interface{})
+        // Warningln logs to WARNING log. Arguments are handled in the manner of fmt.Println.
+        Warningln(args ...interface{})
+        // Warningf logs to WARNING log. Arguments are handled in the manner of fmt.Printf.
+        Warningf(format string, args ...interface{})
+        // Error logs to ERROR log. Arguments are handled in the manner of fmt.Print.
+        Error(args ...interface{})
+        // Errorln logs to ERROR log. Arguments are handled in the manner of fmt.Println.
+        Errorln(args ...interface{})
+        // Errorf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
+        Errorf(format string, args ...interface{})
+        // Fatal logs to ERROR log. Arguments are handled in the manner of fmt.Print.
+        // gRPC ensures that all Fatal logs will exit with os.Exit(1).
+        // Implementations may also call os.Exit() with a non-zero exit code.
+        Fatal(args ...interface{})
+        // Fatalln logs to ERROR log. Arguments are handled in the manner of fmt.Println.
+        // gRPC ensures that all Fatal logs will exit with os.Exit(1).
+        // Implementations may also call os.Exit() with a non-zero exit code.
+        Fatalln(args ...interface{})
+        // Fatalf logs to ERROR log. Arguments are handled in the manner of fmt.Printf.
+        // gRPC ensures that all Fatal logs will exit with os.Exit(1).
+        // Implementations may also call os.Exit() with a non-zero exit code.
+        Fatalf(format string, args ...interface{})
+        // V reports whether verbosity level l is at least the requested verbose level.
+        V(l int) bool
+}
+
+// SetLoggerV2 sets logger that is used in grpc to a V2 logger.
+// Not mutex-protected, should be called before any gRPC functions.
+func SetLoggerV2(l LoggerV2) {
+        logger = l
+}
+
+const (
+        // infoLog indicates Info severity.
+        infoLog int = iota
+        // warningLog indicates Warning severity.
+        warningLog
+        // errorLog indicates Error severity.
+        errorLog
+        // fatalLog indicates Fatal severity.
+        fatalLog
+)
+
+// severityName contains the string representation of each severity.
+var severityName = []string{
+        infoLog:    "INFO",
+        warningLog: "WARNING",
+        errorLog:   "ERROR",
+        fatalLog:   "FATAL",
+}
+
+// loggerT is the default logger used by grpclog.
+type loggerT struct {
+        m []*log.Logger
+        v int
+}
+
+// NewLoggerV2 creates a loggerV2 with the provided writers.
+// Fatal logs will be written to errorW, warningW, infoW, followed by exit(1).
+// Error logs will be written to errorW, warningW and infoW.
+// Warning logs will be written to warningW and infoW.
+// Info logs will be written to infoW.
+func NewLoggerV2(infoW, warningW, errorW io.Writer) LoggerV2 {
+        return NewLoggerV2WithVerbosity(infoW, warningW, errorW, 0)
+}
+
+// NewLoggerV2WithVerbosity creates a loggerV2 with the provided writers and
+// verbosity level.
+func NewLoggerV2WithVerbosity(infoW, warningW, errorW io.Writer, v int) LoggerV2 {
+        var m []*log.Logger
+        m = append(m, log.New(infoW, severityName[infoLog]+": ", log.LstdFlags))
+        m = append(m, log.New(io.MultiWriter(infoW, warningW), severityName[warningLog]+": ", log.LstdFlags))
+        ew := io.MultiWriter(infoW, warningW, errorW) // ew will be used for error and fatal.
+        m = append(m, log.New(ew, severityName[errorLog]+": ", log.LstdFlags))
+        m = append(m, log.New(ew, severityName[fatalLog]+": ", log.LstdFlags))
+        return &loggerT{m: m, v: v}
+}
+
+// newLoggerV2 creates a loggerV2 to be used as default logger.
+// All logs are written to stderr.
+func newLoggerV2() LoggerV2 {
+        errorW := ioutil.Discard
+        warningW := ioutil.Discard
+        infoW := ioutil.Discard
+
+        logLevel := os.Getenv("GRPC_GO_LOG_SEVERITY_LEVEL")
+        switch logLevel {
+        case "", "ERROR", "error": // If env is unset, set level to ERROR.
+                errorW = os.Stderr
+        case "WARNING", "warning":
+                warningW = os.Stderr
+        case "INFO", "info":
+                infoW = os.Stderr
+        }
+
+        var v int
+        vLevel := os.Getenv("GRPC_GO_LOG_VERBOSITY_LEVEL")
+        if vl, err := strconv.Atoi(vLevel); err == nil {
+                v = vl
+        }
+        return NewLoggerV2WithVerbosity(infoW, warningW, errorW, v)
+}
+
+func (g *loggerT) Info(args ...interface{}) {
+        g.m[infoLog].Print(args...)
+}
+
+func (g *loggerT) Infoln(args ...interface{}) {
+        g.m[infoLog].Println(args...)
+}
+
+func (g *loggerT) Infof(format string, args ...interface{}) {
+        g.m[infoLog].Printf(format, args...)
+}
+
+func (g *loggerT) Warning(args ...interface{}) {
+        g.m[warningLog].Print(args...)
+}
+
+func (g *loggerT) Warningln(args ...interface{}) {
+        g.m[warningLog].Println(args...)
+}
+
+func (g *loggerT) Warningf(format string, args ...interface{}) {
+        g.m[warningLog].Printf(format, args...)
+}
+
+func (g *loggerT) Error(args ...interface{}) {
+        g.m[errorLog].Print(args...)
+}
+
+func (g *loggerT) Errorln(args ...interface{}) {
+        g.m[errorLog].Println(args...)
+}
+
+func (g *loggerT) Errorf(format string, args ...interface{}) {
+        g.m[errorLog].Printf(format, args...)
+}
+
+func (g *loggerT) Fatal(args ...interface{}) {
+        g.m[fatalLog].Fatal(args...)
+        // No need to call os.Exit() again because log.Logger.Fatal() calls os.Exit().
+}
+
+func (g *loggerT) Fatalln(args ...interface{}) {
+        g.m[fatalLog].Fatalln(args...)
+        // No need to call os.Exit() again because log.Logger.Fatal() calls os.Exit().
+}
+
+func (g *loggerT) Fatalf(format string, args ...interface{}) {
+        g.m[fatalLog].Fatalf(format, args...)
+        // No need to call os.Exit() again because log.Logger.Fatal() calls os.Exit().
+}
+
+func (g *loggerT) V(l int) bool {
+        return l <= g.v
+}