common/prpc, tools/cmd/cproto: prpc client

server/prpc/encoding.go

 // Copyright 2016 The Chromium 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 prpc
 
 // This file implements encoding of RPC results to HTTP responses.
 
 import (
         "bytes"
         "io"
         "net/http"
         "sort"
+        "strconv"
 
         "github.com/golang/protobuf/jsonpb"
         "github.com/golang/protobuf/proto"
         "golang.org/x/net/context"
         "google.golang.org/grpc"
         "google.golang.org/grpc/codes"
 
+        "github.com/luci/luci-go/common/errors"
         "github.com/luci/luci-go/common/logging"
+        "github.com/luci/luci-go/common/prpc"
 )
 
 const (
         headerAccept = "Accept"
 )
 
 // responseFormat returns the format to be used in a response.
 // Can return only formatBinary (preferred), formatJSONPB or formatText.
 // In case of an error, format is undefined and the error has an HTTP status.
 func responseFormat(acceptHeader string) (format, *httpError) {
@@ skipping 75 matching lines @@
                 res = buf.Bytes()
         }
         if err != nil {
                 return err
         }
         w.Header().Set(headerContentType, contentType)
         _, err = w.Write(res)
         return err
 }
 
-// codeToStatus maps gRPC codes to HTTP statuses.
-// This map may need to be corrected when
-// https://github.com/grpc/grpc-common/issues/210
-// is closed.
-var codeToStatus = map[codes.Code]int{
-        codes.OK:                 http.StatusOK,
-        codes.Canceled:           http.StatusNoContent,
-        codes.Unknown:            http.StatusInternalServerError,
-        codes.InvalidArgument:    http.StatusBadRequest,
-        codes.DeadlineExceeded:   http.StatusServiceUnavailable,
-        codes.NotFound:           http.StatusNotFound,
-        codes.AlreadyExists:      http.StatusConflict,
-        codes.PermissionDenied:   http.StatusForbidden,
-        codes.Unauthenticated:    http.StatusUnauthorized,
-        codes.ResourceExhausted:  http.StatusServiceUnavailable,
-        codes.FailedPrecondition: http.StatusPreconditionFailed,
-        codes.Aborted:            http.StatusInternalServerError,
-        codes.OutOfRange:         http.StatusBadRequest,
-        codes.Unimplemented:      http.StatusNotImplemented,
-        codes.Internal:           http.StatusInternalServerError,
-        codes.Unavailable:        http.StatusServiceUnavailable,
-        codes.DataLoss:           http.StatusInternalServerError,
-}
-
 // ErrorStatus returns HTTP status for an error.
 // In particular, it maps gRPC codes to HTTP statuses.
 // Status of nil is 200.
 //
 // See also grpc.Code.
 func ErrorStatus(err error) int {
         if err, ok := err.(*httpError); ok {
                 return err.status
         }
 
-        status, ok := codeToStatus[grpc.Code(err)]
+        status, ok := prpc.CodeStatus(grpc.Code(err))
         if !ok {
                 status = http.StatusInternalServerError
         }
         return status
 }
 
 // ErrorDesc returns the error description of err if it was produced by pRPC or gRPC.
 // Otherwise, it returns err.Error() or empty string when err is nil.
 //
 // See also grpc.ErrorDesc.
@@ skipping 17 matching lines @@
 func writeError(c context.Context, w http.ResponseWriter, err error) {
         if err == nil {
                 panic("err is nil")
         }
 
         status := ErrorStatus(err)
         if status >= 500 {
                 logging.Errorf(c, "HTTP %d: %s", status, ErrorDesc(err))
         }
 
+        w.Header().Set(prpc.HeaderGrpcCode, strconv.Itoa(int(grpcCode(err))))
         w.Header().Set(headerContentType, "text/plain")
         w.WriteHeader(status)
 
         var body string
         if status == http.StatusInternalServerError {
                 body = "Internal server error"
         } else {
                 body = ErrorDesc(err)
         }
         if _, err := io.WriteString(w, body+"\n"); err != nil {
                 logging.Errorf(c, "could not write error: %s", err)
         }
 }
 
+// returns the most appropriate gRPC code for an error.
+func grpcCode(err error) codes.Code {
+        if err == nil {
+                return codes.OK
+        }
+
+        for ; err != nil; err = errors.Unwrap(err) {
+                if code := grpc.Code(err); code != codes.Unknown {
+                        return code
+                }
+
+                switch err {
+
+                case context.Canceled:
+                        return codes.Canceled
+
+                case context.DeadlineExceeded:
+                        return codes.DeadlineExceeded
+
+                }
+        }
+        return codes.Unknown
+}
+
 func assert(condition bool) {
         if !condition {
                 panicf("assertion failed")
         }
 }