fix(storage): restore metadata operations timeout in gRPC (#14575)

cpriti-os · gemini-code-assist[bot] · web-flow · commit 275ff562aee8 · 2026-05-12T12:18:53.000+05:30
fixes: Issue #14417 --------- Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
diff --git a/storage/grpc_client.go b/storage/grpc_client.go
@@ -156,7 +156,7 @@ func newGRPCStorageClient(ctx context.Context, opts ...storageOption) (*grpcStor
 	s := initSettings(opts...)
 	s.clientOption = append(defaultGRPCOptions(), s.clientOption...)
 	// Disable all gax-level retries in favor of retry logic in the veneer client.
-	s.gax = append(s.gax, gax.WithRetry(nil), gax.WithTimeout(0))
+	s.gax = append(s.gax, gax.WithRetry(nil))
 
 	config := newStorageConfig(s.clientOption...)
 	if config.readAPIWasSet {
@@ -187,10 +187,23 @@ func newGRPCStorageClient(ctx context.Context, opts ...storageOption) (*grpcStor
 	if err != nil {
 		return nil, err
 	}
+	configureStreamingTimeouts(g)
 	c.raw = g
 	return c, nil
 }
 
+// configureStreamingTimeouts explicitly overrides default call timeouts to 0 (unbounded)
+// for all generated payload streaming RPCs. This guarantees that long-running data reads
+// and writes are not prematurely aborted by default transport deadlines, while allowing
+// all transactional and metadata/unary operations to retain their safety deadlines.
+func configureStreamingTimeouts(g *gapic.Client) {
+	g.CallOptions.ReadObject = append(g.CallOptions.ReadObject, gax.WithTimeout(0))
+	g.CallOptions.WriteObject = append(g.CallOptions.WriteObject, gax.WithTimeout(0))
+	g.CallOptions.BidiReadObject = append(g.CallOptions.BidiReadObject, gax.WithTimeout(0))
+	g.CallOptions.BidiWriteObject = append(g.CallOptions.BidiWriteObject, gax.WithTimeout(0))
+	g.CallOptions.CancelResumableWrite = append(g.CallOptions.CancelResumableWrite, gax.WithTimeout(0))
+}
+
 func (c *grpcStorageClient) routingInterceptors() (grpc.UnaryClientInterceptor, grpc.StreamClientInterceptor) {
 	unary := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
 		ctx, err := c.prepareDirectPathMetadata(ctx, cc.Target())
diff --git a/storage/grpc_client_test.go b/storage/grpc_client_test.go
@@ -21,14 +21,18 @@ import (
 	"fmt"
 	"hash/crc32"
 	"math/rand"
+	"reflect"
 	"strings"
 	"testing"
 	"time"
 
 	"cloud.google.com/go/storage/internal/apiv2/storagepb"
 	"github.com/google/go-cmp/cmp"
+	gax "github.com/googleapis/gax-go/v2"
+	"google.golang.org/api/option"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/mem"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
@@ -566,3 +570,60 @@ func TestPrepareDirectPathMetadata_FeatureTracking(t *testing.T) {
 		})
 	}
 }
+
+func TestNewGRPCStorageClient_NoGlobalTimeout(t *testing.T) {
+	ctx := context.Background()
+	client, err := newGRPCStorageClient(ctx,
+		withClientOptions(
+			option.WithoutAuthentication(),
+			option.WithGRPCDialOption(grpc.WithTransportCredentials(insecure.NewCredentials())),
+		),
+	)
+	if err != nil {
+		t.Fatalf("newGRPCStorageClient: %v", err)
+	}
+	defer client.Close()
+
+	// Verify that default/global settings do NOT contain any timeout override,
+	// preventing indefinite hangs on metadata operations.
+	for _, opt := range client.settings.gax {
+		if strings.Contains(fmt.Sprintf("%T", opt), "timeoutOpt") {
+			t.Errorf("expected default/global settings to not contain a timeout option, but found: %T (%v)", opt, opt)
+		}
+	}
+
+	// Helper to verify that a list of CallOptions has a timeout of 0s
+	verifyTimeoutIsZero := func(method string, opts []gax.CallOption) {
+		var cs gax.CallSettings
+		// Apply a dummy non-zero timeout first
+		gax.WithTimeout(1 * time.Hour).Resolve(&cs)
+
+		// Apply all options of interest
+		for _, opt := range opts {
+			opt.Resolve(&cs)
+		}
+
+		val := reflect.ValueOf(cs)
+		field := val.FieldByName("timeout")
+		if !field.IsValid() {
+			t.Errorf("method %q: gax.CallSettings structure changed, field 'timeout' not found", method)
+			return
+		}
+
+		timeout := time.Duration(field.Int())
+		if timeout == 1*time.Hour {
+			t.Errorf("method %q: expected explicit WithTimeout(0) to keep streams unbounded, but none was found", method)
+		} else if timeout != 0 {
+			t.Errorf("method %q: expected timeout of 0s, got %v", method, timeout)
+		}
+	}
+
+	// Verify that all generated streaming CallOptions explicitly contain WithTimeout(0)
+	// to keep payload streams (Reads/Writes) completely timeout-free.
+	opts := client.raw.CallOptions
+	verifyTimeoutIsZero("ReadObject", opts.ReadObject)
+	verifyTimeoutIsZero("WriteObject", opts.WriteObject)
+	verifyTimeoutIsZero("BidiReadObject", opts.BidiReadObject)
+	verifyTimeoutIsZero("BidiWriteObject", opts.BidiWriteObject)
+	verifyTimeoutIsZero("CancelResumableWrite", opts.CancelResumableWrite)
+}
