v2: Client unary interceptor timeout on v2 branch (#330)

* Client unary interceptor timeout on v2 branch

* change fmt.println with log.Println in example (linter fix)

* fix test

* Update interceptors/timeout/examples_test.go

Co-authored-by: Johan Brandhorst-Satzkorn <[email protected]>

* fixup example linter

* fix when context already has timeout

* fixup trailing period

* try increase timing

* delete deadline check

* update comment

* add readme timeout note

* fixup test

Co-authored-by: Johan Brandhorst-Satzkorn <[email protected]>

Author: instabledesign

README.md

@@ -70,6 +70,7 @@ myServer := grpc.NewServer(
 
 #### Client
    * [`retry`](interceptors/retry) - a generic gRPC response code retry mechanism, client-side middleware
+   * [`timeout`](interceptors/timeout) - a generic gRPC request timeout, client-side middleware
 
 #### Server
    * [`validator`](interceptors/validator) - codegen inbound message validation from `.proto` options

interceptors/timeout/doc.go

@@ -0,0 +1,8 @@
+/*
+`grpc_timeout` are interceptors that timeout for gRPC client calls.
+
+Client Side Timeout Middleware
+
+Please see examples for simple examples of use.
+*/
+package timeout

interceptors/timeout/examples_test.go

@@ -0,0 +1,35 @@
+package timeout_test
+
+import (
+	"context"
+	"log"
+	"time"
+
+	"github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/timeout"
+	"github.com/grpc-ecosystem/go-grpc-middleware/v2/testing/testpb"
+	"google.golang.org/grpc"
+)
+
+// Initialization shows an initialization sequence with a custom client request timeout.
+func Example_initialization() {
+	clientConn, err := grpc.Dial(
+		"ServerAddr",
+		grpc.WithUnaryInterceptor(
+			// Set your client request timeout.
+			timeout.TimeoutUnaryClientInterceptor(20*time.Millisecond),
+		),
+	)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Initialize your grpc service with connection.
+	testServiceClient := testpb.NewTestServiceClient(clientConn)
+	resp, err := testServiceClient.Ping(context.TODO(), &testpb.PingRequest{Value: "my_example_value"})
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Use grpc response value.
+	log.Println(resp.Value)
+}

interceptors/timeout/timeout.go

@@ -0,0 +1,17 @@
+package timeout
+
+import (
+	"context"
+	"time"
+
+	"google.golang.org/grpc"
+)
+
+// TimeoutUnaryClientInterceptor returns a new unary client interceptor that sets a timeout on the request context.
+func TimeoutUnaryClientInterceptor(timeout time.Duration) grpc.UnaryClientInterceptor {
+	return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
+		timedCtx, cancel := context.WithTimeout(ctx, timeout)
+		defer cancel()
+		return invoker(timedCtx, method, req, reply, cc, opts...)
+	}
+}

interceptors/timeout/timeout_test.go

@@ -0,0 +1,52 @@
+package timeout_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/grpc-ecosystem/go-grpc-middleware/v2/interceptors/timeout"
+	"github.com/grpc-ecosystem/go-grpc-middleware/v2/testing/testpb"
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/grpc"
+)
+
+type TimeoutTestServiceServer struct {
+	sleepTime time.Duration
+	testpb.TestPingService
+}
+
+func (t *TimeoutTestServiceServer) Ping(ctx context.Context, req *testpb.PingRequest) (*testpb.PingResponse, error) {
+	if t.sleepTime > 0 {
+		time.Sleep(t.sleepTime)
+	}
+	return t.TestPingService.Ping(ctx, req)
+}
+
+func TestTimeoutUnaryClientInterceptor(t *testing.T) {
+	server := &TimeoutTestServiceServer{}
+
+	its := &testpb.InterceptorTestSuite{
+		ClientOpts: []grpc.DialOption{
+			grpc.WithUnaryInterceptor(timeout.TimeoutUnaryClientInterceptor(100 * time.Millisecond)),
+		},
+		TestService: server,
+	}
+	its.Suite.SetT(t)
+	its.SetupSuite()
+	defer its.TearDownSuite()
+
+	// This call will take 0/100ms for respond, so the client timeout NOT exceed.
+	resp, err := its.Client.Ping(context.TODO(), &testpb.PingRequest{Value: "default_response_value"})
+	assert.NoError(t, err)
+	assert.NotNil(t, resp)
+	assert.Equal(t, "default_response_value", resp.Value)
+
+	// server will sleep 300ms before respond
+	server.sleepTime = 300 * time.Millisecond
+
+	// This call will take 300/100ms for respond, so the client timeout exceed.
+	resp2, err2 := its.Client.Ping(context.TODO(), &testpb.PingRequest{})
+	assert.Nil(t, resp2)
+	assert.EqualError(t, err2, "rpc error: code = DeadlineExceeded desc = context deadline exceeded")
+}