fix: form upload, host not effective (#166)

YangSen-qn · YangSen-qn · web-flow · commit 26000cca704b · 2025-06-06T10:41:11.000+08:00
* fix: form upload, Specified domain name not effective

* fix: form upload, Specified domain name not effective

---------

Co-authored-by: YangSen-qn &lt;yangsen@qiniu.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,4 +1,10 @@
 # Changelog
+## 7.25.4
+
+* 修复
+  * 处理表单上传指定域名不生效问题
+
+
 ## 7.25.3
 
 * 修复
diff --git a/storage/form_upload_test.go b/storage/form_upload_test.go
@@ -51,6 +51,45 @@ func TestFormUploadPutFileWithoutExtra(t *testing.T) {
 	t.Logf("Key: %s, Hash:%s", putRet.Key, putRet.Hash)
 }
 
+func TestFormUploaderWithInvalidUpHost(t *testing.T) {
+	var putRet PutRet
+	ctx := context.TODO()
+	putPolicy := PutPolicy{
+		Scope:           testBucket,
+		DeleteAfterDays: 7,
+	}
+
+	// prepare file for test uploading
+	testLocalFile, err := ioutil.TempFile("", "TestFormUploadPutFile")
+	if err != nil {
+		t.Fatalf("ioutil.TempFile file failed, err: %v", err)
+	}
+	defer os.Remove(testLocalFile.Name())
+
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	_, err = io.CopyN(testLocalFile, r, 1024)
+	if err != nil {
+		t.Fatalf("ioutil.TempFile file write failed, err: %v", err)
+	}
+	_, err = testLocalFile.Seek(0, io.SeekCurrent)
+	if err != nil {
+		t.Fatalf("ioutil.TempFile file seek failed, err: %v", err)
+	}
+
+	upToken := putPolicy.UploadToken(mac)
+	testKey := fmt.Sprintf("testPutFileWithoutExtra_%d", r.Int())
+
+	err = formUploader.PutFile(ctx, &putRet, upToken, testKey, testLocalFile.Name(), &PutExtra{
+		UpHost: "mock.upload.io",
+	})
+	if err == nil {
+		t.Fatalf("TestFormUploaderWithInvalidUpHost should error, %s", err)
+	}
+	if !strings.Contains(err.Error(), "lookup mock.upload.io: no such host") {
+		t.Fatalf("TestFormUploaderWithInvalidUpHost should use mock host, %s", err)
+	}
+}
+
 func TestFormUploadPutFile(t *testing.T) {
 	var putRet PutRet
 	ctx := context.TODO()
diff --git a/storage/resume_uploader_test.go b/storage/resume_uploader_test.go
@@ -47,6 +47,35 @@ func TestResumeUploadPutFile(t *testing.T) {
 	t.Logf("Key: %s, Hash:%s", putRet.Key, putRet.Hash)
 }
 
+func TestResumeUploadWithInvalidUpHost(t *testing.T) {
+	var putRet PutRet
+	ctx := context.TODO()
+	putPolicy := PutPolicy{
+		Scope:           testBucket,
+		DeleteAfterDays: 7,
+	}
+	upToken := putPolicy.UploadToken(mac)
+	r := rand.New(rand.NewSource(time.Now().UnixNano()))
+	testKey := fmt.Sprintf("testRPutFileKey_%d", r.Int())
+
+	// prepare file for test uploading
+	testLocalFile, err := ioutil.TempFile("", "TestResumeUploadPutFile")
+	if err != nil {
+		t.Fatalf("ioutil.TempFile file failed, err: %v", err)
+	}
+	defer os.Remove(testLocalFile.Name())
+
+	err = resumeUploader.PutFile(ctx, &putRet, upToken, testKey, testLocalFile.Name(), &RputExtra{
+		UpHost: "mock.upload.io",
+	})
+	if err == nil {
+		t.Fatalf("TestFormUploaderWithInvalidUpHost should error, %s", err)
+	}
+	if !strings.Contains(err.Error(), "lookup mock.upload.io: no such host") {
+		t.Fatalf("TestFormUploaderWithInvalidUpHost should use mock host, %s", err)
+	}
+}
+
 func TestPutWithoutSize(t *testing.T) {
 	var putRet PutRet
 	putPolicy := PutPolicy{
diff --git a/storagev2/http_client/http_client.go b/storagev2/http_client/http_client.go
@@ -146,12 +146,14 @@ type (
 		Method string
 
 		// 请求服务名
+		// 注：应该是考虑同一个 API 有多个服务提供
 		ServiceNames []region.ServiceName
 
 		// 服务地址提供者
 		Endpoints region.EndpointsProvider
 
 		// 区域提供者
+		// 注：如果有多个只会使用第一个
 		Region region.RegionsProvider
 
 		// 请求路径
diff --git a/storagev2/region/region.go b/storagev2/region/region.go
@@ -122,56 +122,56 @@ func makeHost(domain string, useHttps bool) string {
 	}
 }
 
-func (region *Region) GetRegions(context.Context) ([]*Region, error) {
-	return []*Region{region}, nil
+func (r *Region) GetRegions(context.Context) ([]*Region, error) {
+	return []*Region{r}, nil
 }
 
-func (region *Region) Endpoints(serviceNames []ServiceName) (Endpoints, error) {
+func (r *Region) Endpoints(serviceNames []ServiceName) (Endpoints, error) {
 	var endpoint Endpoints
 	for _, serviceName := range serviceNames {
 		switch serviceName {
 		case ServiceUp:
-			endpoint = endpoint.Join(region.Up)
+			endpoint = endpoint.Join(r.Up)
 		case ServiceIo:
-			endpoint = endpoint.Join(region.Io)
+			endpoint = endpoint.Join(r.Io)
 		case ServiceIoSrc:
-			endpoint = endpoint.Join(region.IoSrc)
+			endpoint = endpoint.Join(r.IoSrc)
 		case ServiceRs:
-			endpoint = endpoint.Join(region.Rs)
+			endpoint = endpoint.Join(r.Rs)
 		case ServiceRsf:
-			endpoint = endpoint.Join(region.Rsf)
+			endpoint = endpoint.Join(r.Rsf)
 		case ServiceApi:
-			endpoint = endpoint.Join(region.Api)
+			endpoint = endpoint.Join(r.Api)
 		case ServiceBucket:
-			endpoint = endpoint.Join(region.Bucket)
+			endpoint = endpoint.Join(r.Bucket)
 		default:
 			return endpoint, ErrUnrecognizedServiceName
 		}
 	}
 	return endpoint, nil
 }
 
-func (region *Region) EndpointsIter(serviceNames []ServiceName) (*EndpointsIter, error) {
-	endpoints, err := region.Endpoints(serviceNames)
+func (r *Region) EndpointsIter(serviceNames []ServiceName) (*EndpointsIter, error) {
+	endpoints, err := r.Endpoints(serviceNames)
 	if err != nil {
 		return nil, err
 	}
 	return endpoints.Iter(), nil
 }
 
-func (left *Region) IsEqual(right *Region) bool {
-	return left.RegionID == right.RegionID &&
-		left.Up.IsEqual(right.Up) &&
-		left.Io.IsEqual(right.Io) &&
-		left.IoSrc.IsEqual(right.IoSrc) &&
-		left.Rs.IsEqual(right.Rs) &&
-		left.Rsf.IsEqual(right.Rsf) &&
-		left.Api.IsEqual(right.Api) &&
-		left.Bucket.IsEqual(right.Bucket)
+func (r *Region) IsEqual(right *Region) bool {
+	return r.RegionID == right.RegionID &&
+		r.Up.IsEqual(right.Up) &&
+		r.Io.IsEqual(right.Io) &&
+		r.IoSrc.IsEqual(right.IoSrc) &&
+		r.Rs.IsEqual(right.Rs) &&
+		r.Rsf.IsEqual(right.Rsf) &&
+		r.Api.IsEqual(right.Api) &&
+		r.Bucket.IsEqual(right.Bucket)
 }
 
-func (left Endpoints) Join(rights ...Endpoints) Endpoints {
-	newEndpoint := left
+func (ep Endpoints) Join(rights ...Endpoints) Endpoints {
+	newEndpoint := ep
 	for _, right := range rights {
 		newEndpoint.Accelerated = append(newEndpoint.Accelerated, right.Accelerated...)
 		newEndpoint.Preferred = append(newEndpoint.Preferred, right.Preferred...)
@@ -181,68 +181,68 @@ func (left Endpoints) Join(rights ...Endpoints) Endpoints {
 	return newEndpoint
 }
 
-func (left Endpoints) IsEqual(right Endpoints) bool {
-	return reflect.DeepEqual(left.Accelerated, right.Accelerated) &&
-		reflect.DeepEqual(left.Preferred, right.Preferred) &&
-		reflect.DeepEqual(left.Alternative, right.Alternative)
+func (ep Endpoints) IsEqual(right Endpoints) bool {
+	return reflect.DeepEqual(ep.Accelerated, right.Accelerated) &&
+		reflect.DeepEqual(ep.Preferred, right.Preferred) &&
+		reflect.DeepEqual(ep.Alternative, right.Alternative)
 
 }
 
-func (hosts Endpoints) Iter() *EndpointsIter {
-	return &EndpointsIter{endpoints: hosts}
+func (ep Endpoints) Iter() *EndpointsIter {
+	return &EndpointsIter{endpoints: ep}
 }
 
-func (endpoints Endpoints) HostsLength() int {
-	return len(endpoints.Accelerated) + len(endpoints.Preferred) + len(endpoints.Alternative)
+func (ep Endpoints) HostsLength() int {
+	return len(ep.Accelerated) + len(ep.Preferred) + len(ep.Alternative)
 }
 
-func (endpoints Endpoints) IsEmpty() bool {
-	return len(endpoints.Accelerated) == 0 && len(endpoints.Preferred) == 0 && len(endpoints.Alternative) == 0
+func (ep Endpoints) IsEmpty() bool {
+	return len(ep.Accelerated) == 0 && len(ep.Preferred) == 0 && len(ep.Alternative) == 0
 }
 
-func (endpoints Endpoints) firstUrl(useHttps bool) string {
-	for _, accelerated := range endpoints.Accelerated {
+func (ep Endpoints) firstUrl(useHttps bool) string {
+	for _, accelerated := range ep.Accelerated {
 		return makeUrlFromHost(accelerated, useHttps)
 	}
-	for _, preferred := range endpoints.Preferred {
+	for _, preferred := range ep.Preferred {
 		return makeUrlFromHost(preferred, useHttps)
 	}
-	for _, alternative := range endpoints.Alternative {
+	for _, alternative := range ep.Alternative {
 		return makeUrlFromHost(alternative, useHttps)
 	}
 	return ""
 }
 
-func (endpoints Endpoints) GetEndpoints(context.Context) (Endpoints, error) {
-	return endpoints, nil
+func (ep Endpoints) GetEndpoints(context.Context) (Endpoints, error) {
+	return ep, nil
 }
 
-func (endpoints Endpoints) allUrls(useHttps bool) []string {
-	allHosts := make([]string, 0, len(endpoints.Accelerated)+len(endpoints.Preferred)+len(endpoints.Alternative))
-	for _, accelerated := range endpoints.Accelerated {
+func (ep Endpoints) allUrls(useHttps bool) []string {
+	allHosts := make([]string, 0, len(ep.Accelerated)+len(ep.Preferred)+len(ep.Alternative))
+	for _, accelerated := range ep.Accelerated {
 		allHosts = append(allHosts, makeUrlFromHost(accelerated, useHttps))
 	}
-	for _, preferred := range endpoints.Preferred {
+	for _, preferred := range ep.Preferred {
 		allHosts = append(allHosts, makeUrlFromHost(preferred, useHttps))
 	}
-	for _, alternative := range endpoints.Alternative {
+	for _, alternative := range ep.Alternative {
 		allHosts = append(allHosts, makeUrlFromHost(alternative, useHttps))
 	}
 	return allHosts
 }
 
-func (endpoints Endpoints) ToHostProvider() hostprovider.HostProvider {
+func (ep Endpoints) ToHostProvider() hostprovider.HostProvider {
 	return &endpointsHostProvider{
-		iter:    endpoints.Iter(),
+		iter:    ep.Iter(),
 		freezer: freezer.New(),
 	}
 }
 
-func (endpoints Endpoints) Clone() Endpoints {
+func (ep Endpoints) Clone() Endpoints {
 	return Endpoints{
-		Preferred:   append([]string{}, endpoints.Preferred...),
-		Alternative: append([]string{}, endpoints.Alternative...),
-		Accelerated: append([]string{}, endpoints.Accelerated...),
+		Preferred:   append([]string{}, ep.Preferred...),
+		Alternative: append([]string{}, ep.Alternative...),
+		Accelerated: append([]string{}, ep.Accelerated...),
 	}
 }
 
diff --git a/storagev2/uploader/upload_manager.go b/storagev2/uploader/upload_manager.go
@@ -101,7 +101,11 @@ func NewUploadManager(options *UploadManagerOptions) *UploadManager {
 func (uploadManager *UploadManager) UploadDirectory(ctx context.Context, directoryPath string, directoryOptions *DirectoryOptions) error {
 	if directoryOptions == nil {
 		directoryOptions = &DirectoryOptions{}
+	} else {
+		tmp := *directoryOptions
+		directoryOptions = &tmp
 	}
+
 	objectConcurrency := directoryOptions.ObjectConcurrency
 	if objectConcurrency == 0 {
 		objectConcurrency = 4
@@ -191,6 +195,9 @@ func (uploadManager *UploadManager) UploadDirectory(ctx context.Context, directo
 func (uploadManager *UploadManager) UploadFile(ctx context.Context, path string, objectOptions *ObjectOptions, returnValue interface{}) error {
 	if objectOptions == nil {
 		objectOptions = &ObjectOptions{}
+	} else {
+		tmp := *objectOptions
+		objectOptions = &tmp
 	}
 
 	fileInfo, err := os.Stat(path)
@@ -214,6 +221,9 @@ func (uploadManager *UploadManager) UploadReader(ctx context.Context, reader io.
 
 	if objectOptions == nil {
 		objectOptions = &ObjectOptions{}
+	} else {
+		tmp := *objectOptions
+		objectOptions = &tmp
 	}
 
 	if rscs, ok := reader.(io.ReadSeeker); ok && canSeekReally(rscs) {
diff --git a/storagev2/uploader/uploaders.go b/storagev2/uploader/uploaders.go
