Upgrade to 0.12

2 files changed, 122 insertions, 23 deletions

diff --git a/vendor/google.golang.org/grpc/codes/code_string.go b/vendor/google.golang.org/grpc/codes/code_string.go
index e6762d0..0b206a5 100644
--- a/vendor/google.golang.org/grpc/codes/code_string.go
+++ b/vendor/google.golang.org/grpc/codes/code_string.go
@@ -1,16 +1,62 @@
-// generated by stringer -type=Code; DO NOT EDIT
+/*
+ *
+ * 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 codes
 
-import "fmt"
+import "strconv"
 
-const _Code_name = "OKCanceledUnknownInvalidArgumentDeadlineExceededNotFoundAlreadyExistsPermissionDeniedResourceExhaustedFailedPreconditionAbortedOutOfRangeUnimplementedInternalUnavailableDataLossUnauthenticated"
-
-var _Code_index = [...]uint8{0, 2, 10, 17, 32, 48, 56, 69, 85, 102, 120, 127, 137, 150, 158, 169, 177, 192}
-
-func (i Code) String() string {
-        if i+1 >= Code(len(_Code_index)) {
-                return fmt.Sprintf("Code(%d)", i)
+func (c Code) String() string {
+        switch c {
+        case OK:
+                return "OK"
+        case Canceled:
+                return "Canceled"
+        case Unknown:
+                return "Unknown"
+        case InvalidArgument:
+                return "InvalidArgument"
+        case DeadlineExceeded:
+                return "DeadlineExceeded"
+        case NotFound:
+                return "NotFound"
+        case AlreadyExists:
+                return "AlreadyExists"
+        case PermissionDenied:
+                return "PermissionDenied"
+        case ResourceExhausted:
+                return "ResourceExhausted"
+        case FailedPrecondition:
+                return "FailedPrecondition"
+        case Aborted:
+                return "Aborted"
+        case OutOfRange:
+                return "OutOfRange"
+        case Unimplemented:
+                return "Unimplemented"
+        case Internal:
+                return "Internal"
+        case Unavailable:
+                return "Unavailable"
+        case DataLoss:
+                return "DataLoss"
+        case Unauthenticated:
+                return "Unauthenticated"
+        default:
+                return "Code(" + strconv.FormatInt(int64(c), 10) + ")"
         }
-        return _Code_name[_Code_index[i]:_Code_index[i+1]]
 }
diff --git a/vendor/google.golang.org/grpc/codes/codes.go b/vendor/google.golang.org/grpc/codes/codes.go
index 21e7733..d9b9d57 100644
--- a/vendor/google.golang.org/grpc/codes/codes.go
+++ b/vendor/google.golang.org/grpc/codes/codes.go
@@ -20,11 +20,14 @@
 // consistent across various languages.
 package codes // import "google.golang.org/grpc/codes"
 
+import (
+        "fmt"
+        "strconv"
+)
+
 // A Code is an unsigned 32-bit error code as defined in the gRPC spec.
 type Code uint32
 
-//go:generate stringer -type=Code
-
 const (
         // OK is returned on success.
         OK Code = 0
@@ -32,9 +35,9 @@ const (
         // Canceled indicates the operation was canceled (typically by the caller).
         Canceled Code = 1
 
-        // Unknown error.  An example of where this error may be returned is
+        // Unknown error. An example of where this error may be returned is
         // if a Status value received from another address space belongs to
-        // an error-space that is not known in this address space.  Also
+        // an error-space that is not known in this address space. Also
         // errors raised by APIs that do not return enough error information
         // may be converted to this error.
         Unknown Code = 2
@@ -63,15 +66,11 @@ const (
         // PermissionDenied indicates the caller does not have permission to
         // execute the specified operation. It must not be used for rejections
         // caused by exhausting some resource (use ResourceExhausted
-        // instead for those errors).  It must not be
+        // instead for those errors). It must not be
         // used if the caller cannot be identified (use Unauthenticated
         // instead for those errors).
         PermissionDenied Code = 7
 
-        // Unauthenticated indicates the request does not have valid
-        // authentication credentials for the operation.
-        Unauthenticated Code = 16
-
         // ResourceExhausted indicates some resource has been exhausted, perhaps
         // a per-user quota, or perhaps the entire file system is out of space.
         ResourceExhausted Code = 8
@@ -87,7 +86,7 @@ const (
         //  (b) Use Aborted if the client should retry at a higher-level
         //      (e.g., restarting a read-modify-write sequence).
         //  (c) Use FailedPrecondition if the client should not retry until
-        //      the system state has been explicitly fixed.  E.g., if an "rmdir"
+        //      the system state has been explicitly fixed. E.g., if an "rmdir"
         //      fails because the directory is non-empty, FailedPrecondition
         //      should be returned since the client should not retry unless
         //      they have first fixed up the directory by deleting files from it.
@@ -116,7 +115,7 @@ const (
         // file size.
         //
         // There is a fair bit of overlap between FailedPrecondition and
-        // OutOfRange.  We recommend using OutOfRange (the more specific
+        // OutOfRange. We recommend using OutOfRange (the more specific
         // error) when it applies so that callers who are iterating through
         // a space can easily look for an OutOfRange error to detect when
         // they are done.
@@ -126,8 +125,8 @@ const (
         // supported/enabled in this service.
         Unimplemented Code = 12
 
-        // Internal errors.  Means some invariants expected by underlying
-        // system has been broken.  If you see one of these errors,
+        // Internal errors. Means some invariants expected by underlying
+        // system has been broken. If you see one of these errors,
         // something is very broken.
         Internal Code = 13
 
@@ -141,4 +140,58 @@ const (
 
         // DataLoss indicates unrecoverable data loss or corruption.
         DataLoss Code = 15
+
+        // Unauthenticated indicates the request does not have valid
+        // authentication credentials for the operation.
+        Unauthenticated Code = 16
+
+        _maxCode = 17
 )
+
+var strToCode = map[string]Code{
+        `"OK"`: OK,
+        `"CANCELLED"`:/* [sic] */ Canceled,
+        `"UNKNOWN"`:             Unknown,
+        `"INVALID_ARGUMENT"`:    InvalidArgument,
+        `"DEADLINE_EXCEEDED"`:   DeadlineExceeded,
+        `"NOT_FOUND"`:           NotFound,
+        `"ALREADY_EXISTS"`:      AlreadyExists,
+        `"PERMISSION_DENIED"`:   PermissionDenied,
+        `"RESOURCE_EXHAUSTED"`:  ResourceExhausted,
+        `"FAILED_PRECONDITION"`: FailedPrecondition,
+        `"ABORTED"`:             Aborted,
+        `"OUT_OF_RANGE"`:        OutOfRange,
+        `"UNIMPLEMENTED"`:       Unimplemented,
+        `"INTERNAL"`:            Internal,
+        `"UNAVAILABLE"`:         Unavailable,
+        `"DATA_LOSS"`:           DataLoss,
+        `"UNAUTHENTICATED"`:     Unauthenticated,
+}
+
+// UnmarshalJSON unmarshals b into the Code.
+func (c *Code) UnmarshalJSON(b []byte) error {
+        // From json.Unmarshaler: By convention, to approximate the behavior of
+        // Unmarshal itself, Unmarshalers implement UnmarshalJSON([]byte("null")) as
+        // a no-op.
+        if string(b) == "null" {
+                return nil
+        }
+        if c == nil {
+                return fmt.Errorf("nil receiver passed to UnmarshalJSON")
+        }
+
+        if ci, err := strconv.ParseUint(string(b), 10, 32); err == nil {
+                if ci >= _maxCode {
+                        return fmt.Errorf("invalid code: %q", ci)
+                }
+
+                *c = Code(ci)
+                return nil
+        }
+
+        if jc, ok := strToCode[string(b)]; ok {
+                *c = jc
+                return nil
+        }
+        return fmt.Errorf("invalid code: %q", string(b))
+}