feat(jdcloud): add bucket check

Author: 404tk

pkg/providers/jdcloud/jdcloud.go

@@ -21,9 +21,10 @@ import (
 )
 
 type Provider struct {
-	region    string
-	accessKey string
-	apiClient *_api.Client
+	credential _auth.Credential
+	region     string
+	accessKey  string
+	apiClient  *_api.Client
 }
 
 // New creates a new provider client for JDCloud API.
@@ -53,9 +54,10 @@ func New(options schema.Options) (*Provider, error) {
 	}
 
 	return &Provider{
-		region:    region,
-		accessKey: credential.AccessKey,
-		apiClient: apiClient,
+		credential: credential,
+		region:     region,
+		accessKey:  credential.AccessKey,
+		apiClient:  apiClient,
 	}, nil
 }
 
@@ -96,7 +98,7 @@ func (p *Provider) Resources(ctx context.Context) (schema.Resources, error) {
 			list.AddError("account", err)
 		case "database":
 		case "bucket":
-			d := &oss.Driver{Client: p.apiClient}
+			d := p.newOSSDriver(p.region)
 			storages, err := d.ListBuckets(ctx)
 			schema.AppendAssets(&list, storages)
 			list.AddError("bucket", err)
@@ -129,6 +131,28 @@ func (p *Provider) UserManagement(action, username, password string) {
 	}
 }
 
+func (p *Provider) BucketDump(ctx context.Context, action, bucketName string) {
+	driver := p.newOSSDriver(p.region)
+	switch action {
+	case "list":
+		infos, err := p.bucketInfos(context.Background(), driver, bucketName)
+		if err != nil {
+			logger.Error("List buckets failed:", err)
+			return
+		}
+		driver.ListObjects(ctx, infos)
+	case "total":
+		infos, err := p.bucketInfos(context.Background(), driver, bucketName)
+		if err != nil {
+			logger.Error("List buckets failed:", err)
+			return
+		}
+		driver.TotalObjects(ctx, infos)
+	default:
+		logger.Error("`list all` or `total all`.")
+	}
+}
+
 // ExecuteCloudVMCommand routes through JDCloud Cloud Assistant (assistant.jdcloud-api.com).
 // Region must be a real VM region (cn-north-1 / cn-east-2 / ...); we resolve it
 // from the host cache populated by `cloudlist` so `shell <instance-id>` works
@@ -163,3 +187,50 @@ func (p *Provider) lookupHost(instanceID string) (schema.Host, bool) {
 	}
 	return schema.Host{}, false
 }
+
+func (p *Provider) newOSSDriver(region string) *oss.Driver {
+	return &oss.Driver{
+		Client:     p.apiClient,
+		Credential: p.credential,
+		Region:     region,
+	}
+}
+
+func (p *Provider) bucketInfos(ctx context.Context, driver *oss.Driver, bucketName string) (map[string]string, error) {
+	infos := make(map[string]string)
+	bucketName = strings.TrimSpace(bucketName)
+	region := strings.TrimSpace(p.region)
+	switch {
+	case bucketName == "":
+		return nil, fmt.Errorf("empty bucket name")
+	case bucketName == "all":
+		buckets, err := driver.ListBuckets(ctx)
+		if err != nil {
+			return nil, err
+		}
+		for _, bucket := range buckets {
+			bucketRegion := strings.TrimSpace(bucket.Region)
+			if bucketRegion == "" {
+				bucketRegion, err = driver.ResolveBucketRegion(ctx, bucket.BucketName)
+				if err != nil {
+					return nil, err
+				}
+			}
+			infos[bucket.BucketName] = bucketRegion
+		}
+		if len(infos) == 0 {
+			return nil, fmt.Errorf("no buckets found")
+		}
+		return infos, nil
+	case region != "" && !strings.EqualFold(region, "all"):
+		infos[bucketName] = region
+		return infos, nil
+	default:
+		resolved, err := driver.ResolveBucketRegion(ctx, bucketName)
+		if err != nil {
+			return nil, fmt.Errorf("bucket %s region not found; set region explicitly or use `list all` first", bucketName)
+		}
+		infos[bucketName] = resolved
+		return infos, nil
+	}
+}

pkg/providers/jdcloud/oss/bucket.go

@@ -3,14 +3,31 @@ package oss
 import (
 	"context"
 	"errors"
+	"fmt"
+	"net/http"
+	"strings"
 
 	"github.com/404tk/cloudtoolkit/pkg/providers/jdcloud/api"
+	jdauth "github.com/404tk/cloudtoolkit/pkg/providers/jdcloud/auth"
 	"github.com/404tk/cloudtoolkit/pkg/schema"
 	"github.com/404tk/cloudtoolkit/utils/logger"
 )
 
+const defaultBucketRegion = "cn-north-1"
+
+var knownJDCloudOSSRegions = []string{
+	"cn-north-1",
+	"cn-east-1",
+	"cn-east-2",
+	"cn-south-1",
+	"eu-west-1",
+}
+
 type Driver struct {
-	Client *api.Client
+	Client       *api.Client
+	Credential   jdauth.Credential
+	Region       string
+	ObjectClient *Client
 }
 
 func (d *Driver) ListBuckets(ctx context.Context) ([]schema.Storage, error) {
@@ -45,8 +62,78 @@ func (d *Driver) ListBuckets(ctx context.Context) ([]schema.Storage, error) {
 		_bucket := schema.Storage{
 			BucketName: bucket.Name,
 		}
+		if region, err := d.ResolveBucketRegion(ctx, bucket.Name); err == nil {
+			_bucket.Region = region
+		}
 		list = append(list, _bucket)
 	}
 
 	return list, nil
 }
+
+func (d *Driver) ResolveBucketRegion(ctx context.Context, bucket string) (string, error) {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	bucket = strings.TrimSpace(bucket)
+	if bucket == "" {
+		return "", fmt.Errorf("empty bucket name")
+	}
+	if d.Client == nil {
+		return "", errors.New("jdcloud oss: nil api client")
+	}
+
+	var lastErr error
+	for _, region := range d.probeRegions() {
+		err := d.headBucket(ctx, region, bucket)
+		if err == nil {
+			return region, nil
+		}
+		lastErr = err
+		var apiErr *api.APIError
+		if errors.As(err, &apiErr) && apiErr.IsAuthFailure() {
+			return "", err
+		}
+	}
+	if lastErr != nil {
+		return "", fmt.Errorf("bucket %s region not found", bucket)
+	}
+	return "", fmt.Errorf("bucket %s region not found", bucket)
+}
+
+func (d *Driver) objectClient() (*Client, error) {
+	if d.ObjectClient != nil {
+		return d.ObjectClient, nil
+	}
+	if err := d.Credential.Validate(); err != nil {
+		return nil, err
+	}
+	d.ObjectClient = NewClient(d.Credential)
+	return d.ObjectClient, nil
+}
+
+func (d *Driver) headBucket(ctx context.Context, region, bucket string) error {
+	return d.Client.DoJSON(ctx, api.Request{
+		Service: "oss",
+		Region:  region,
+		Method:  http.MethodHead,
+		Version: "v1",
+		Path:    "/regions/" + region + "/buckets/" + strings.TrimSpace(bucket),
+	}, nil)
+}
+
+func (d *Driver) probeRegions() []string {
+	explicit := strings.TrimSpace(d.Region)
+	if explicit == "" || strings.EqualFold(explicit, "all") {
+		return append([]string(nil), knownJDCloudOSSRegions...)
+	}
+
+	regions := []string{explicit}
+	for _, region := range knownJDCloudOSSRegions {
+		if strings.EqualFold(region, explicit) {
+			continue
+		}
+		regions = append(regions, region)
+	}
+	return regions
+}

pkg/providers/jdcloud/oss/bucket_test.go

@@ -2,21 +2,34 @@ package oss
 
 import (
 	"context"
+	"crypto/tls"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
+	"strings"
 	"testing"
 	"time"
 
+	awsapi "github.com/404tk/cloudtoolkit/pkg/providers/aws/api"
 	"github.com/404tk/cloudtoolkit/pkg/providers/jdcloud/api"
 	"github.com/404tk/cloudtoolkit/pkg/providers/jdcloud/auth"
 )
 
-func TestDriverListBucketsUsesFixedRegion(t *testing.T) {
+func TestDriverListBucketsUsesFixedRegionAndResolvesBucketRegions(t *testing.T) {
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/v1/regions/cn-north-1/buckets" {
-			t.Fatalf("unexpected path: %s", r.URL.Path)
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == "/v1/regions/cn-north-1/buckets":
+			_, _ = w.Write([]byte(`{"requestId":"req-oss","result":{"buckets":[{"name":"bucket-a"},{"name":"bucket-b"}]}}`))
+		case r.Method == http.MethodHead && r.URL.Path == "/v1/regions/cn-north-1/buckets/bucket-a":
+			w.WriteHeader(http.StatusNotFound)
+			_, _ = w.Write([]byte(`{"requestId":"req-miss-a","error":{"status":"404","code":404,"message":"bucket not found"}}`))
+		case r.Method == http.MethodHead && r.URL.Path == "/v1/regions/cn-east-1/buckets/bucket-a":
+			w.WriteHeader(http.StatusOK)
+		case r.Method == http.MethodHead && r.URL.Path == "/v1/regions/cn-north-1/buckets/bucket-b":
+			w.WriteHeader(http.StatusOK)
+		default:
+			t.Fatalf("unexpected request: %s %s", r.Method, r.URL.Path)
 		}
-		_, _ = w.Write([]byte(`{"requestId":"req-oss","result":{"buckets":[{"name":"bucket-a"},{"name":"bucket-b"}]}}`))
 	}))
 	defer server.Close()
 
@@ -28,6 +41,79 @@ func TestDriverListBucketsUsesFixedRegion(t *testing.T) {
 	if len(got) != 2 || got[0].BucketName != "bucket-a" || got[1].BucketName != "bucket-b" {
 		t.Fatalf("unexpected buckets: %+v", got)
 	}
+	if got[0].Region != "cn-east-1" || got[1].Region != "cn-north-1" {
+		t.Fatalf("unexpected bucket regions: %+v", got)
+	}
+}
+
+func TestDriverResolveBucketRegionUsesExplicitRegionFirst(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/v1/regions/cn-south-1/buckets/demo-bucket":
+			w.WriteHeader(http.StatusOK)
+		default:
+			t.Fatalf("unexpected path: %s", r.URL.Path)
+		}
+	}))
+	defer server.Close()
+
+	driver := &Driver{
+		Client: newTestClient(server.URL),
+		Region: "cn-south-1",
+	}
+	got, err := driver.ResolveBucketRegion(context.Background(), "demo-bucket")
+	if err != nil {
+		t.Fatalf("ResolveBucketRegion() error = %v", err)
+	}
+	if got != "cn-south-1" {
+		t.Fatalf("ResolveBucketRegion() = %q, want cn-south-1", got)
+	}
+}
+
+func TestClientListObjectsV2UsesServiceHostAndContinuationToken(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Host != "s3.cn-north-1.jdcloud-oss.com" {
+			t.Fatalf("unexpected host: %s", r.Host)
+		}
+		if r.URL.Path != "/demo-bucket" {
+			t.Fatalf("unexpected path: %s", r.URL.Path)
+		}
+		if got := r.URL.Query().Get("list-type"); got != "2" {
+			t.Fatalf("unexpected list-type: %s", got)
+		}
+		if got := r.URL.Query().Get("continuation-token"); got != "page-2" {
+			t.Fatalf("unexpected continuation-token: %s", got)
+		}
+		if got := r.URL.Query().Get("max-keys"); got != "100" {
+			t.Fatalf("unexpected max-keys: %s", got)
+		}
+		if authz := r.Header.Get("Authorization"); !strings.HasPrefix(authz, "AWS4-HMAC-SHA256 Credential=AKID/20260419/cn-north-1/s3/aws4_request, SignedHeaders=") {
+			t.Fatalf("unexpected authorization: %s", authz)
+		}
+		_, _ = w.Write([]byte(`<ListBucketResult><IsTruncated>true</IsTruncated><NextContinuationToken>page-3</NextContinuationToken><Contents><Key>logs/a.txt</Key><Size>12</Size></Contents></ListBucketResult>`))
+	}))
+	defer server.Close()
+
+	client := NewClient(
+		auth.New("AKID", "SECRET", ""),
+		awsapi.WithHTTPClient(rewriteHostClient(server.URL)),
+		awsapi.WithClock(func() time.Time { return time.Date(2026, 4, 19, 12, 0, 0, 0, time.UTC) }),
+		awsapi.WithRetryPolicy(awsapi.RetryPolicy{
+			MaxAttempts: 1,
+			Sleep:       func(context.Context, time.Duration) error { return nil },
+		}),
+	)
+
+	got, err := client.ListObjectsV2(context.Background(), "demo-bucket", "cn-north-1", "page-2", 100)
+	if err != nil {
+		t.Fatalf("ListObjectsV2() error = %v", err)
+	}
+	if !got.IsTruncated || got.NextContinuationToken != "page-3" {
+		t.Fatalf("unexpected pagination: %+v", got)
+	}
+	if len(got.Objects) != 1 || got.Objects[0].Key != "logs/a.txt" || got.Objects[0].Size != 12 {
+		t.Fatalf("unexpected objects: %+v", got)
+	}
 }
 
 func newTestClient(baseURL string) *api.Client {
@@ -42,3 +128,32 @@ func newTestClient(baseURL string) *api.Client {
 		}),
 	)
 }
+
+func rewriteHostClient(rawURL string) *http.Client {
+	target, err := url.Parse(rawURL)
+	if err != nil {
+		panic(err)
+	}
+	return &http.Client{
+		Transport: &rewriteHostTransport{
+			target: target,
+			base: &http.Transport{
+				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+			},
+		},
+	}
+}
+
+type rewriteHostTransport struct {
+	target *url.URL
+	base   http.RoundTripper
+}
+
+func (t *rewriteHostTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	clone := req.Clone(req.Context())
+	urlCopy := *clone.URL
+	urlCopy.Scheme = t.target.Scheme
+	urlCopy.Host = t.target.Host
+	clone.URL = &urlCopy
+	return t.base.RoundTrip(clone)
+}