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

common/prpc/timeout.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
 
 import (
         "fmt"
         "strconv"
         "time"
 )
 
-// headerTimeout is HTTP header used to set pRPC request timeout.
-// The single value should match regexp `\d+[HMSmun]`.
-const headerTimeout = "X-Prpc-Timeout"
-
 // The rest of this file is adapted from
 // https://github.com/grpc/grpc-go/blob/6a026b9f108b49838491178e5d9bf7a4dcf32cf2/transport/http_util.go#L295
 
 type timeoutUnit uint8
 
 const (
         hour        timeoutUnit = 'H'
         minute      timeoutUnit = 'M'
         second      timeoutUnit = 'S'
         millisecond timeoutUnit = 'm'
@@ skipping 13 matching lines @@
                 return time.Millisecond, true
         case microsecond:
                 return time.Microsecond, true
         case nanosecond:
                 return time.Nanosecond, true
         default:
         }
         return
 }
 
-func decodeTimeout(s string) (time.Duration, error) {
+// DecodeTimeout decodes a gRPC/pRPC timeout header string into a time.Duration.
+func DecodeTimeout(s string) (time.Duration, error) {
         size := len(s)
         if size < 2 {
                 return 0, fmt.Errorf("too short: %q", s)
         }
         unit := timeoutUnit(s[size-1])
         d, ok := timeoutUnitToDuration(unit)
         if !ok {
                 return 0, fmt.Errorf("unit is not recognized: %q", s)
         }
         t, err := strconv.ParseInt(s[:size-1], 10, 64)
         if err != nil {
                 return 0, err
         }
         return d * time.Duration(t), nil
 }
+
+const maxTimeoutValue int64 = 100000000 - 1
+
+// div does integer division and round-up the result. Note that this is
+// equivalent to (d+r-1)/r but has less chance to overflow.
+func div(d, r time.Duration) int64 {
+        if m := d % r; m > 0 {
+                return int64(d/r + 1)
+        }
+        return int64(d / r)
+}
+
+// EncodeTimeout encodes a gRPC/pRPC timeout into a timeout header
+// time.Duration.
+//
+// This rounds the time.Duration to the smallest time unit that can represent
+// it.
+func EncodeTimeout(t time.Duration) string {
+        if d := div(t, time.Nanosecond); d <= maxTimeoutValue {
+                return strconv.FormatInt(d, 10) + "n"
+        }
+        if d := div(t, time.Microsecond); d <= maxTimeoutValue {
+                return strconv.FormatInt(d, 10) + "u"
+        }
+        if d := div(t, time.Millisecond); d <= maxTimeoutValue {
+                return strconv.FormatInt(d, 10) + "m"
+        }
+        if d := div(t, time.Second); d <= maxTimeoutValue {
+                return strconv.FormatInt(d, 10) + "S"
+        }
+        if d := div(t, time.Minute); d <= maxTimeoutValue {
+                return strconv.FormatInt(d, 10) + "M"
+        }
+        // Note that maxTimeoutValue * time.Hour > MaxInt64.
+        return strconv.FormatInt(div(t, time.Hour), 10) + "H"
+}