make v1 a type alias of v2, add go.mod

call_option.go

@@ -30,37 +30,21 @@
 package gax
 
 import (
- "math/rand"
- "time"
-
+ v2 "github.com/googleapis/gax-go/v2"
  "google.golang.org/grpc"
  "google.golang.org/grpc/codes"
- "google.golang.org/grpc/status"
 )
 
 // CallOption is an option used by Invoke to control behaviors of RPC calls.
 // CallOption works by modifying relevant fields of CallSettings.
-type CallOption interface {
- // Resolve applies the option by modifying cs.
- Resolve(cs *CallSettings)
-}
+type CallOption = v2.CallOption
 
 // Retryer is used by Invoke to determine retry behavior.
-type Retryer interface {
- // Retry reports whether a request should be retriedand how long to pause before retrying
- // if the previous attempt returned with err. Invoke never calls Retry with nil error.
- Retry(err error) (pause time.Duration, shouldRetry bool)
-}
-
-type retryerOption func() Retryer
-
-func (o retryerOption) Resolve(s *CallSettings) {
- s.Retry = o
-}
+type Retryer = v2.Retryer
 
 // WithRetry sets CallSettings.Retry to fn.
 func WithRetry(fn func() Retryer) CallOption {
- return retryerOption(fn)
+ return v2.WithRetry(fn)
 }
 
 // OnCodes returns a Retryer that retries if and only if
@@ -69,89 +53,17 @@ func WithRetry(fn func() Retryer) CallOption {
 //
 // bo is only used for its parameters; each Retryer has its own copy.
 func OnCodes(cc []codes.Code, bo Backoff) Retryer {
- return &boRetryer{
- backoff: bo,
- codes: append([]codes.Code(nil), cc...),
- }
-}
-
-type boRetryer struct {
- backoff Backoff
- codes []codes.Code
-}
-
-func (r *boRetryer) Retry(err error) (time.Duration, bool) {
- st, ok := status.FromError(err)
- if !ok {
- return 0, false
- }
- c := st.Code()
- for _, rc := range r.codes {
- if c == rc {
- return r.backoff.Pause(), true
- }
- }
- return 0, false
+ return v2.OnCodes(cc, bo)
 }
 
 // Backoff implements exponential backoff.
 // The wait time between retries is a random value between 0 and the "retry envelope".
 // The envelope starts at Initial and increases by the factor of Multiplier every retry,
 // but is capped at Max.
-type Backoff struct {
- // Initial is the initial value of the retry envelope, defaults to 1 second.
- Initial time.Duration
-
- // Max is the maximum value of the retry envelope, defaults to 30 seconds.
- Max time.Duration
-
- // Multiplier is the factor by which the retry envelope increases.
- // It should be greater than 1 and defaults to 2.
- Multiplier float64
-
- // cur is the current retry envelope
- cur time.Duration
-}
-
-func (bo *Backoff) Pause() time.Duration {
- if bo.Initial == 0 {
- bo.Initial = time.Second
- }
- if bo.cur == 0 {
- bo.cur = bo.Initial
- }
- if bo.Max == 0 {
- bo.Max = 30 * time.Second
- }
- if bo.Multiplier < 1 {
- bo.Multiplier = 2
- }
- // Select a duration between zero and the current max. It might seem counterintuitive to
- // have so much jitter, but https://www.awsarchitectureblog.com/2015/03/backoff.html
- // argues that that is the best strategy.
- d := time.Duration(rand.Int63n(int64(bo.cur)))
- bo.cur = time.Duration(float64(bo.cur) * bo.Multiplier)
- if bo.cur > bo.Max {
- bo.cur = bo.Max
- }
- return d
-}
-
-type grpcOpt []grpc.CallOption
-
-func (o grpcOpt) Resolve(s *CallSettings) {
- s.GRPC = o
-}
+type Backoff = v2.Backoff
 
 func WithGRPCOptions(opt ...grpc.CallOption) CallOption {
- return grpcOpt(append([]grpc.CallOption(nil), opt...))
+ return v2.WithGRPCOptions(opt...)
 }
 
-type CallSettings struct {
- // Retry returns a Retryer to be used to control retry logic of a method call.
- // If Retry is nil or the returned Retryer is nil, the call will not be retried.
- Retry func() Retryer
-
- // CallOptions to be forwarded to GRPC.
- GRPC []grpc.CallOption
-}
+type CallSettings = v2.CallSettings

gax.go

@@ -35,4 +35,4 @@
 // to simplify code generation and to provide more convenient and idiomatic API surfaces.
 package gax
 
-const Version = "2.0.0"
+const Version = "1.0.1"

header.go

@@ -1,24 +1,11 @@
 package gax
 
-import "bytes"
+import v2 "github.com/googleapis/gax-go/v2"
 
 // XGoogHeader is for use by the Google Cloud Libraries only.
 //
 // XGoogHeader formats key-value pairs.
 // The resulting string is suitable for x-goog-api-client header.
 func XGoogHeader(keyval ...string) string {
- if len(keyval) == 0 {
- return ""
- }
- if len(keyval)%2 != 0 {
- panic("gax.Header: odd argument count")
- }
- var buf bytes.Buffer
- for i := 0; i < len(keyval); i += 2 {
- buf.WriteByte(' ')
- buf.WriteString(keyval[i])
- buf.WriteByte('/')
- buf.WriteString(keyval[i+1])
- }
- return buf.String()[1:]
+ return v2.XGoogHeader(keyval...)
 }

invoke.go

@@ -32,58 +32,21 @@ package gax
 import (
  "context"
  "time"
+
+ v2 "github.com/googleapis/gax-go/v2"
 )
 
 // A user defined call stub.
-type APICall func(context.Context, CallSettings) error
+type APICall = v2.APICall
 
 // Invoke calls the given APICall,
 // performing retries as specified by opts, if any.
 func Invoke(ctx context.Context, call APICall, opts ...CallOption) error {
- var settings CallSettings
- for _, opt := range opts {
- opt.Resolve(&settings)
- }
- return invoke(ctx, call, settings, Sleep)
+ return v2.Invoke(ctx, call, opts...)
 }
 
 // Sleep is similar to time.Sleep, but it can be interrupted by ctx.Done() closing.
 // If interrupted, Sleep returns ctx.Err().
 func Sleep(ctx context.Context, d time.Duration) error {
- t := time.NewTimer(d)
- select {
- case <-ctx.Done():
- t.Stop()
- return ctx.Err()
- case <-t.C:
- return nil
- }
-}
-
-type sleeper func(ctx context.Context, d time.Duration) error
-
-// invoke implements Invoke, taking an additional sleeper argument for testing.
-func invoke(ctx context.Context, call APICall, settings CallSettings, sp sleeper) error {
- var retryer Retryer
- for {
- err := call(ctx, settings)
- if err == nil {
- return nil
- }
- if settings.Retry == nil {
- return err
- }
- if retryer == nil {
- if r := settings.Retry(); r != nil {
- retryer = r
- } else {
- return err
- }
- }
- if d, ok := retryer.Retry(err); !ok {
- return err
- } else if err = sp(ctx, d); err != nil {
- return err
- }
- }
-}
+ return v2.Sleep(ctx, d)
+}