external store: use separate ctx for GCS clients

br/pkg/storage/gcs.go

@@ -110,8 +110,9 @@ type GCSStorage struct {
 	clientCnt int64
 	clientOps []option.ClientOption
 
-	handles []*storage.BucketHandle
-	clients []*storage.Client
+	handles      []*storage.BucketHandle
+	clients      []*storage.Client
+	clientCancel context.CancelFunc
 }
 
 // CopyFrom implements Copier.
@@ -366,6 +367,7 @@ func (s *GCSStorage) Rename(ctx context.Context, oldFileName, newFileName string
 
 // Close implements ExternalStorage interface.
 func (s *GCSStorage) Close() {
+	s.clientCancel()
 	for _, client := range s.clients {
 		if err := client.Close(); err != nil {
 			log.Warn("failed to close gcs client", zap.Error(err))
@@ -447,39 +449,73 @@ skipHandleCred:
 	return ret, nil
 }
 
-// Reset resets the GCS storage.
+// Reset resets the GCS storage. Reset should not be used concurrently with
+// Close.
 func (s *GCSStorage) Reset(ctx context.Context) error {
 	logutil.Logger(ctx).Info("resetting gcs storage")
 
-	for _, client := range s.clients {
-		_ = client.Close()
-	}
-
-	s.clients = make([]*storage.Client, gcsClientCnt)
-	eg, egCtx := util.NewErrorGroupWithRecoverWithCtx(ctx)
-	for i := range s.clients {
-		eg.Go(func() error {
-			client, err := storage.NewClient(egCtx, s.clientOps...)
+	s.cancelAndCloseGCSClients()
+
+	clientCtx, clientCancel := context.WithCancel(context.Background())
+	s.clients = make([]*storage.Client, 0, gcsClientCnt)
+	wg := util.WaitGroupWrapper{}
+	cliCh := make(chan *storage.Client)
+	wg.RunWithLog(func() {
+		for range gcsClientCnt {
+			select {
+			case cli := <-cliCh:
+				s.clients = append(s.clients, cli)
+			case <-ctx.Done():
+				clientCancel()
+				return
+			case <-clientCtx.Done():
+				return
+			}
+		}
+	})
+	firstErr := atomic.NewError(nil)
+	for range gcsClientCnt {
+		wg.RunWithLog(func() {
+			client, err := storage.NewClient(clientCtx, s.clientOps...)
 			if err != nil {
-				return errors.Trace(err)
+				firstErr.CompareAndSwap(nil, err)
+				clientCancel()
+				return
 			}
 			client.SetRetry(storage.WithErrorFunc(shouldRetry), storage.WithPolicy(storage.RetryAlways))
-			s.clients[i] = client
-			return nil
+			select {
+			case cliCh <- client:
+			case <-clientCtx.Done():
+			}
 		})
 	}
-	err := eg.Wait()
-	if err != nil {
+	wg.Wait()
+	if err := firstErr.Load(); err != nil {
+		s.cancelAndCloseGCSClients()
 		return errors.Trace(err)
 	}
 
+	s.clientCancel = clientCancel
 	s.handles = make([]*storage.BucketHandle, gcsClientCnt)
 	for i := range s.handles {
 		s.handles[i] = s.clients[i].Bucket(s.gcs.Bucket)
 	}
 	return nil
 }
 
+func (s *GCSStorage) cancelAndCloseGCSClients() {
+	if s.clientCancel != nil {
+		s.clientCancel()
+		s.clientCancel = nil
+	}
+
+	for _, client := range s.clients {
+		if client != nil {
+			_ = client.Close()
+		}
+	}
+}
+
 func shouldRetry(err error) bool {
 	if storage.ShouldRetry(err) {
 		return true

br/pkg/storage/gcs_test.go

@@ -10,6 +10,8 @@ import (
 	"flag"
 	"fmt"
 	"io"
+	"net/http"
+	"net/http/httptest"
 	"net/url"
 	"os"
 	"testing"
@@ -578,3 +580,30 @@ func TestGCSShouldRetry(t *testing.T) {
 	require.True(t, shouldRetry(&url.Error{Err: goerrors.New("http2: client connection lost"), Op: "Get", URL: "https://storage.googleapis.com/storage/v1/"}))
 	require.True(t, shouldRetry(&url.Error{Err: io.EOF, Op: "Get", URL: "https://storage.googleapis.com/storage/v1/"}))
 }
+
+func TestCtxUsage(t *testing.T) {
+	httpSvr := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
+	defer httpSvr.Close()
+
+	ctx := context.Background()
+	gcs := &backuppb.GCS{
+		Endpoint:      httpSvr.URL,
+		Bucket:        "test",
+		Prefix:        "prefix",
+		StorageClass:  "NEARLINE",
+		PredefinedAcl: "private",
+		CredentialsBlob: fmt.Sprintf(`
+{
+	"type":"external_account",
+	"audience":"//iam.googleapis.com/projects/1234567890123/locations/global/workloadIdentityPools/my-pool/providers/my-provider",
+	"subject_token_type":"urn:ietf:params:oauth:token-type:access_token",
+	"credential_source":{"url":"%s"}
+}`, httpSvr.URL),
+	}
+	stg, err := NewGCSStorage(ctx, gcs, &ExternalStorageOptions{})
+	require.NoError(t, err)
+
+	_, err = stg.FileExists(ctx, "key")
+	// before the fix, it's context canceled error
+	require.ErrorContains(t, err, "invalid_request")
+}