cds支持rclone挂载

sdks/storage/bucket.go

@@ -15,18 +15,53 @@ func (c *Client) Bucket() *BucketService {
 	return &BucketService{c}
 }
 
+const BucketGetByNamePath = "/bucket/getByName"
+
+type BucketGetByName struct {
+	UserID UserID `json:"userID" form:"userID" binding:"required"`
+	Name   string `json:"name" form:"name" binding:"required"`
+}
+type BucketGetByNameResp struct {
+	Bucket Bucket `json:"bucket"`
+}
+
+func (c *BucketService) GetByName(req BucketGetByName) (*BucketGetByNameResp, error) {
+	url, err := url.JoinPath(c.baseURL, BucketGetByNamePath)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := myhttp.GetForm(url, myhttp.RequestParam{
+		Query: req,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	codeResp, err := ParseJSONResponse[response[BucketGetByNameResp]](resp)
+	if err != nil {
+		return nil, err
+	}
+
+	if codeResp.Code == errorcode.OK {
+		return &codeResp.Data, nil
+	}
+
+	return nil, codeResp.ToError()
+}
+
 const BucketCreatePath = "/bucket/create"
 
-type BucketCreateReq struct {
+type BucketCreate struct {
 	UserID UserID `json:"userID" binding:"required"`
 	Name   string `json:"name" binding:"required"`
 }
 
 type BucketCreateResp struct {
-	BucketID BucketID `json:"bucketID"`
+	Bucket Bucket `json:"bucket"`
 }
 
-func (c *BucketService) Create(req BucketCreateReq) (*BucketCreateResp, error) {
+func (c *BucketService) Create(req BucketCreate) (*BucketCreateResp, error) {
 	url, err := url.JoinPath(c.baseURL, BucketCreatePath)
 	if err != nil {
 		return nil, err
@@ -39,7 +74,7 @@ func (c *BucketService) Create(req BucketCreateReq) (*BucketCreateResp, error) {
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[BucketCreateResp]](resp)
+	codeResp, err := ParseJSONResponse[response[BucketCreateResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -53,36 +88,36 @@ func (c *BucketService) Create(req BucketCreateReq) (*BucketCreateResp, error) {
 
 const BucketDeletePath = "/bucket/delete"
 
-type BucketDeleteReq struct {
+type BucketDelete struct {
 	UserID   UserID   `json:"userID" binding:"required"`
 	BucketID BucketID `json:"bucketID" binding:"required"`
 }
 
 type BucketDeleteResp struct{}
 
-func (c *BucketService) Delete(req BucketDeleteReq) (*BucketDeleteResp, error) {
+func (c *BucketService) Delete(req BucketDelete) error {
 	url, err := url.JoinPath(c.baseURL, BucketDeletePath)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	resp, err := myhttp.PostJSON(url, myhttp.RequestParam{
 		Body: req,
 	})
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[BucketDeleteResp]](resp)
+	codeResp, err := ParseJSONResponse[response[BucketDeleteResp]](resp)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	if codeResp.Code == errorcode.OK {
-		return &codeResp.Data, nil
+		return nil
 	}
 
-	return nil, codeResp.ToError()
+	return codeResp.ToError()
 }
 
 const BucketListUserBucketsPath = "/bucket/listUserBuckets"
@@ -108,7 +143,7 @@ func (c *BucketService) ListUserBuckets(req BucketListUserBucketsReq) (*BucketLi
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[BucketListUserBucketsResp]](resp)
+	codeResp, err := ParseJSONResponse[response[BucketListUserBucketsResp]](resp)
 	if err != nil {
 		return nil, err
 	}

sdks/storage/cache.go

@@ -29,7 +29,7 @@ func (c *Client) CacheMovePackage(req CacheMovePackageReq) (*CacheMovePackageRes
 		return nil, err
 	}
 
-	jsonResp, err := myhttp.ParseJSONResponse[response[CacheMovePackageResp]](resp)
+	jsonResp, err := ParseJSONResponse[response[CacheMovePackageResp]](resp)
 	if err != nil {
 		return nil, err
 	}

sdks/storage/models.go

@@ -10,7 +10,7 @@ import (
 )
 
 const (
-	ObjectPathSeperator = "/"
+	ObjectPathSeparator = "/"
 )
 
 type NodeID int64

sdks/storage/node.go

@@ -30,7 +30,7 @@ func (c *Client) NodeGetNodes(req NodeGetNodesReq) (*NodeGetNodesResp, error) {
 		return nil, err
 	}
 
-	jsonResp, err := myhttp.ParseJSONResponse[response[NodeGetNodesResp]](resp)
+	jsonResp, err := ParseJSONResponse[response[NodeGetNodesResp]](resp)
 	if err != nil {
 		return nil, err
 	}

sdks/storage/object.go

@@ -25,7 +25,7 @@ func (c *Client) Object() *ObjectService {
 
 const ObjectUploadPath = "/object/upload"
 
-type ObjectUploadReq struct {
+type ObjectUpload struct {
 	ObjectUploadInfo
 	Files UploadObjectIterator `json:"-"`
 }
@@ -43,9 +43,15 @@ type UploadingObject struct {
 
 type UploadObjectIterator = iterator.Iterator[*UploadingObject]
 
-type ObjectUploadResp struct{}
+type ObjectUploadResp struct {
+	Uploadeds []UploadedObject `json:"uploadeds"`
+}
+type UploadedObject struct {
+	Object *Object `json:"object"`
+	Error  string  `json:"error"`
+}
 
-func (c *ObjectService) Upload(req ObjectUploadReq) (*ObjectUploadResp, error) {
+func (c *ObjectService) Upload(req ObjectUpload) (*ObjectUploadResp, error) {
 	url, err := url.JoinPath(c.baseURL, ObjectUploadPath)
 	if err != nil {
 		return nil, err
@@ -72,8 +78,9 @@ func (c *ObjectService) Upload(req ObjectUploadReq) (*ObjectUploadResp, error) {
 
 	contType := resp.Header.Get("Content-Type")
 	if strings.Contains(contType, myhttp.ContentTypeJSON) {
+		var err error
 		var codeResp response[ObjectUploadResp]
-		if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
+		if codeResp, err = serder.JSONToObjectStreamEx[response[ObjectUploadResp]](resp.Body); err != nil {
 			return nil, fmt.Errorf("parsing response: %w", err)
 		}
 
@@ -90,7 +97,7 @@ func (c *ObjectService) Upload(req ObjectUploadReq) (*ObjectUploadResp, error) {
 
 const ObjectDownloadPath = "/object/download"
 
-type ObjectDownloadReq struct {
+type ObjectDownload struct {
 	UserID   UserID   `form:"userID" json:"userID" binding:"required"`
 	ObjectID ObjectID `form:"objectID" json:"objectID" binding:"required"`
 }
@@ -99,7 +106,7 @@ type DownloadingObject struct {
 	File io.ReadCloser
 }
 
-func (c *ObjectService) Download(req ObjectDownloadReq) (*DownloadingObject, error) {
+func (c *ObjectService) Download(req ObjectDownload) (*DownloadingObject, error) {
 	url, err := url.JoinPath(c.baseURL, ObjectDownloadPath)
 	if err != nil {
 		return nil, err
@@ -123,10 +130,6 @@ func (c *ObjectService) Download(req ObjectDownloadReq) (*DownloadingObject, err
 		return nil, codeResp.ToError()
 	}
 
-	if !strings.Contains(contType, myhttp.ContentTypeMultiPart) {
-		return nil, fmt.Errorf("unknow response content type: %s", contType)
-	}
-
 	_, files, err := myhttp.ParseMultiPartResponse(resp)
 	if err != nil {
 		return nil, err
@@ -157,7 +160,7 @@ func (u *UpdatingObject) ApplyTo(obj *Object) {
 	obj.UpdateTime = u.UpdateTime
 }
 
-type ObjectUpdateInfoReq struct {
+type ObjectUpdateInfo struct {
 	UserID    UserID           `json:"userID" binding:"required"`
 	Updatings []UpdatingObject `json:"updatings" binding:"required"`
 }
@@ -166,7 +169,7 @@ type ObjectUpdateInfoResp struct {
 	Successes []ObjectID `json:"successes"`
 }
 
-func (c *ObjectService) Update(req ObjectUpdateInfoReq) (*ObjectUpdateInfoResp, error) {
+func (c *ObjectService) UpdateInfo(req ObjectUpdateInfo) (*ObjectUpdateInfoResp, error) {
 	url, err := url.JoinPath(c.baseURL, ObjectUpdateInfoPath)
 	if err != nil {
 		return nil, err
@@ -179,7 +182,7 @@ func (c *ObjectService) Update(req ObjectUpdateInfoReq) (*ObjectUpdateInfoResp,
 		return nil, err
 	}
 
-	jsonResp, err := myhttp.ParseJSONResponse[response[ObjectUpdateInfoResp]](resp)
+	jsonResp, err := ParseJSONResponse[response[ObjectUpdateInfoResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -204,7 +207,7 @@ func (m *MovingObject) ApplyTo(obj *Object) {
 	obj.Path = m.Path
 }
 
-type ObjectMoveReq struct {
+type ObjectMove struct {
 	UserID  UserID         `json:"userID" binding:"required"`
 	Movings []MovingObject `json:"movings" binding:"required"`
 }
@@ -213,7 +216,7 @@ type ObjectMoveResp struct {
 	Successes []ObjectID `json:"successes"`
 }
 
-func (c *ObjectService) Move(req ObjectMoveReq) (*ObjectMoveResp, error) {
+func (c *ObjectService) Move(req ObjectMove) (*ObjectMoveResp, error) {
 	url, err := url.JoinPath(c.baseURL, ObjectMovePath)
 	if err != nil {
 		return nil, err
@@ -226,7 +229,7 @@ func (c *ObjectService) Move(req ObjectMoveReq) (*ObjectMoveResp, error) {
 		return nil, err
 	}
 
-	jsonResp, err := myhttp.ParseJSONResponse[response[ObjectMoveResp]](resp)
+	jsonResp, err := ParseJSONResponse[response[ObjectMoveResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -240,41 +243,41 @@ func (c *ObjectService) Move(req ObjectMoveReq) (*ObjectMoveResp, error) {
 
 const ObjectDeletePath = "/object/delete"
 
-type ObjectDeleteReq struct {
+type ObjectDelete struct {
 	UserID    UserID     `json:"userID" binding:"required"`
 	ObjectIDs []ObjectID `json:"objectIDs" binding:"required"`
 }
 
 type ObjectDeleteResp struct{}
 
-func (c *ObjectService) Delete(req ObjectDeleteReq) (*ObjectDeleteResp, error) {
+func (c *ObjectService) Delete(req ObjectDelete) error {
 	url, err := url.JoinPath(c.baseURL, ObjectDeletePath)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	resp, err := myhttp.PostJSON(url, myhttp.RequestParam{
 		Body: req,
 	})
 	if err != nil {
-		return nil, err
+		return err
 	}
 
-	jsonResp, err := myhttp.ParseJSONResponse[response[ObjectDeleteResp]](resp)
+	jsonResp, err := ParseJSONResponse[response[ObjectDeleteResp]](resp)
 	if err != nil {
-		return nil, err
+		return err
 	}
 
 	if jsonResp.Code == errorcode.OK {
-		return &jsonResp.Data, nil
+		return nil
 	}
 
-	return nil, jsonResp.ToError()
+	return jsonResp.ToError()
 }
 
 const ObjectGetPackageObjectsPath = "/object/getPackageObjects"
 
-type ObjectGetPackageObjectsReq struct {
+type ObjectGetPackageObjects struct {
 	UserID    UserID    `form:"userID" json:"userID" binding:"required"`
 	PackageID PackageID `form:"packageID" json:"packageID" binding:"required"`
 }
@@ -282,7 +285,7 @@ type ObjectGetPackageObjectsResp struct {
 	Objects []Object `json:"objects"`
 }
 
-func (c *ObjectService) GetPackageObjects(req ObjectGetPackageObjectsReq) (*ObjectGetPackageObjectsResp, error) {
+func (c *ObjectService) GetPackageObjects(req ObjectGetPackageObjects) (*ObjectGetPackageObjectsResp, error) {
 	url, err := url.JoinPath(c.baseURL, ObjectGetPackageObjectsPath)
 	if err != nil {
 		return nil, err
@@ -295,7 +298,7 @@ func (c *ObjectService) GetPackageObjects(req ObjectGetPackageObjectsReq) (*Obje
 		return nil, err
 	}
 
-	jsonResp, err := myhttp.ParseJSONResponse[response[ObjectGetPackageObjectsResp]](resp)
+	jsonResp, err := ParseJSONResponse[response[ObjectGetPackageObjectsResp]](resp)
 	if err != nil {
 		return nil, err
 	}

sdks/storage/package.go

@@ -41,7 +41,43 @@ func (c *PackageService) Get(req PackageGetReq) (*PackageGetResp, error) {
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[PackageGetResp]](resp)
+	codeResp, err := ParseJSONResponse[response[PackageGetResp]](resp)
+	if err != nil {
+		return nil, err
+	}
+
+	if codeResp.Code == errorcode.OK {
+		return &codeResp.Data, nil
+	}
+
+	return nil, codeResp.ToError()
+}
+
+const PackageGetByNamePath = "/package/getByName"
+
+type PackageGetByName struct {
+	UserID      UserID `form:"userID" json:"userID" binding:"required"`
+	BucketName  string `form:"bucketName" json:"bucketName" binding:"required"`
+	PackageName string `form:"packageName" json:"packageName" binding:"required"`
+}
+type PackageGetByNameResp struct {
+	Package Package `json:"package"`
+}
+
+func (c *PackageService) GetByName(req PackageGetByName) (*PackageGetByNameResp, error) {
+	url, err := url.JoinPath(c.baseURL, PackageGetByNamePath)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := myhttp.GetForm(url, myhttp.RequestParam{
+		Query: req,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	codeResp, err := ParseJSONResponse[response[PackageGetByNameResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -55,17 +91,17 @@ func (c *PackageService) Get(req PackageGetReq) (*PackageGetResp, error) {
 
 const PackageCreatePath = "/package/create"
 
-type PackageCreateReq struct {
+type PackageCreate struct {
 	UserID   UserID   `json:"userID"`
 	BucketID BucketID `json:"bucketID"`
 	Name     string   `json:"name"`
 }
 
 type PackageCreateResp struct {
-	PackageID PackageID `json:"packageID,string"`
+	Package Package `json:"package"`
 }
 
-func (s *PackageService) Create(req PackageCreateReq) (*PackageCreateResp, error) {
+func (s *PackageService) Create(req PackageCreate) (*PackageCreateResp, error) {
 	url, err := url.JoinPath(s.baseURL, PackageCreatePath)
 	if err != nil {
 		return nil, err
@@ -78,7 +114,7 @@ func (s *PackageService) Create(req PackageCreateReq) (*PackageCreateResp, error
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[PackageCreateResp]](resp)
+	codeResp, err := ParseJSONResponse[response[PackageCreateResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -92,12 +128,12 @@ func (s *PackageService) Create(req PackageCreateReq) (*PackageCreateResp, error
 
 const PackageDeletePath = "/package/delete"
 
-type PackageDeleteReq struct {
+type PackageDelete struct {
 	UserID    UserID    `json:"userID" binding:"required"`
 	PackageID PackageID `json:"packageID" binding:"required"`
 }
 
-func (c *PackageService) Delete(req PackageDeleteReq) error {
+func (c *PackageService) Delete(req PackageDelete) error {
 	url, err := url.JoinPath(c.baseURL, PackageDeletePath)
 	if err != nil {
 		return err
@@ -130,7 +166,7 @@ func (c *PackageService) Delete(req PackageDeleteReq) error {
 
 const PackageListBucketPackagesPath = "/package/listBucketPackages"
 
-type PackageListBucketPackagesReq struct {
+type PackageListBucketPackages struct {
 	UserID   UserID   `form:"userID" json:"userID" binding:"required"`
 	BucketID BucketID `form:"bucketID" json:"bucketID" binding:"required"`
 }
@@ -139,7 +175,7 @@ type PackageListBucketPackagesResp struct {
 	Packages []Package `json:"packages"`
 }
 
-func (c *PackageService) ListBucketPackages(req PackageListBucketPackagesReq) (*PackageListBucketPackagesResp, error) {
+func (c *PackageService) ListBucketPackages(req PackageListBucketPackages) (*PackageListBucketPackagesResp, error) {
 	url, err := url.JoinPath(c.baseURL, PackageListBucketPackagesPath)
 	if err != nil {
 		return nil, err
@@ -152,7 +188,7 @@ func (c *PackageService) ListBucketPackages(req PackageListBucketPackagesReq) (*
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[PackageListBucketPackagesResp]](resp)
+	codeResp, err := ParseJSONResponse[response[PackageListBucketPackagesResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -187,7 +223,7 @@ func (c *PackageService) GetCachedNodes(req PackageGetCachedNodesReq) (*PackageG
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[PackageGetCachedNodesResp]](resp)
+	codeResp, err := ParseJSONResponse[response[PackageGetCachedNodesResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -222,7 +258,7 @@ func (c *PackageService) GetLoadedNodes(req PackageGetLoadedNodesReq) (*PackageG
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[PackageGetLoadedNodesResp]](resp)
+	codeResp, err := ParseJSONResponse[response[PackageGetLoadedNodesResp]](resp)
 	if err != nil {
 		return nil, err
 	}

sdks/storage/storage.go

@@ -32,7 +32,7 @@ func (c *Client) StorageLoadPackage(req StorageLoadPackageReq) (*StorageLoadPack
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[StorageLoadPackageResp]](resp)
+	codeResp, err := ParseJSONResponse[response[StorageLoadPackageResp]](resp)
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +109,7 @@ func (c *Client) StorageGetInfo(req StorageGetInfoReq) (*StorageGetInfoResp, err
 		return nil, err
 	}
 
-	codeResp, err := myhttp.ParseJSONResponse[response[StorageGetInfoResp]](resp)
+	codeResp, err := ParseJSONResponse[response[StorageGetInfoResp]](resp)
 	if err != nil {
 		return nil, err
 	}

sdks/storage/storage_test.go

@@ -23,21 +23,21 @@ func Test_PackageGet(t *testing.T) {
 		}
 
 		pkgName := uuid.NewString()
-		createResp, err := cli.Package().Create(PackageCreateReq{
+		createResp, err := cli.Package().Create(PackageCreate{
 			UserID:   1,
 			BucketID: 1,
 			Name:     pkgName,
 		})
 		So(err, ShouldBeNil)
 
-		_, err = cli.Object().Upload(ObjectUploadReq{
+		_, err = cli.Object().Upload(ObjectUpload{
 			ObjectUploadInfo: ObjectUploadInfo{
 				UserID:    1,
-				PackageID: createResp.PackageID,
+				PackageID: createResp.Package.PackageID,
 			},
 			Files: iterator.Array(
 				&UploadingObject{
-					Path: "test",
+					Path: "abc/test",
 					File: io.NopCloser(bytes.NewBuffer(fileData)),
 				},
 				&UploadingObject{
@@ -50,16 +50,16 @@ func Test_PackageGet(t *testing.T) {
 
 		getResp, err := cli.Package().Get(PackageGetReq{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 		})
 		So(err, ShouldBeNil)
 
-		So(getResp.PackageID, ShouldEqual, createResp.PackageID)
+		So(getResp.PackageID, ShouldEqual, createResp.Package.PackageID)
 		So(getResp.Package.Name, ShouldEqual, pkgName)
 
-		err = cli.Package().Delete(PackageDeleteReq{
+		err = cli.Package().Delete(PackageDelete{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 		})
 		So(err, ShouldBeNil)
 	})
@@ -79,17 +79,17 @@ func Test_Object(t *testing.T) {
 		nodeAff := NodeID(2)
 
 		pkgName := uuid.NewString()
-		createResp, err := cli.Package().Create(PackageCreateReq{
+		createResp, err := cli.Package().Create(PackageCreate{
 			UserID:   1,
 			BucketID: 1,
 			Name:     pkgName,
 		})
 		So(err, ShouldBeNil)
 
-		_, err = cli.Object().Upload(ObjectUploadReq{
+		_, err = cli.Object().Upload(ObjectUpload{
 			ObjectUploadInfo: ObjectUploadInfo{
 				UserID:       1,
-				PackageID:    createResp.PackageID,
+				PackageID:    createResp.Package.PackageID,
 				NodeAffinity: &nodeAff,
 			},
 			Files: iterator.Array(
@@ -116,9 +116,9 @@ func Test_Object(t *testing.T) {
 		// So(downFileData, ShouldResemble, fileData)
 		// downFs.Close()
 
-		err = cli.Package().Delete(PackageDeleteReq{
+		err = cli.Package().Delete(PackageDelete{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 		})
 		So(err, ShouldBeNil)
 	})
@@ -136,17 +136,17 @@ func Test_Storage(t *testing.T) {
 		}
 
 		pkgName := uuid.NewString()
-		createResp, err := cli.Package().Create(PackageCreateReq{
+		createResp, err := cli.Package().Create(PackageCreate{
 			UserID:   1,
 			BucketID: 1,
 			Name:     pkgName,
 		})
 		So(err, ShouldBeNil)
 
-		_, err = cli.Object().Upload(ObjectUploadReq{
+		_, err = cli.Object().Upload(ObjectUpload{
 			ObjectUploadInfo: ObjectUploadInfo{
 				UserID:    1,
-				PackageID: createResp.PackageID,
+				PackageID: createResp.Package.PackageID,
 			},
 			Files: iterator.Array(
 				&UploadingObject{
@@ -163,14 +163,14 @@ func Test_Storage(t *testing.T) {
 
 		_, err = cli.StorageLoadPackage(StorageLoadPackageReq{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 			StorageID: 1,
 		})
 		So(err, ShouldBeNil)
 
-		err = cli.Package().Delete(PackageDeleteReq{
+		err = cli.Package().Delete(PackageDelete{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 		})
 		So(err, ShouldBeNil)
 	})
@@ -188,17 +188,17 @@ func Test_Cache(t *testing.T) {
 		}
 
 		pkgName := uuid.NewString()
-		createResp, err := cli.Package().Create(PackageCreateReq{
+		createResp, err := cli.Package().Create(PackageCreate{
 			UserID:   1,
 			BucketID: 1,
 			Name:     pkgName,
 		})
 		So(err, ShouldBeNil)
 
-		_, err = cli.Object().Upload(ObjectUploadReq{
+		_, err = cli.Object().Upload(ObjectUpload{
 			ObjectUploadInfo: ObjectUploadInfo{
 				UserID:    1,
-				PackageID: createResp.PackageID,
+				PackageID: createResp.Package.PackageID,
 			},
 			Files: iterator.Array(
 				&UploadingObject{
@@ -215,14 +215,14 @@ func Test_Cache(t *testing.T) {
 
 		_, err = cli.CacheMovePackage(CacheMovePackageReq{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 			NodeID:    1,
 		})
 		So(err, ShouldBeNil)
 
-		err = cli.Package().Delete(PackageDeleteReq{
+		err = cli.Package().Delete(PackageDelete{
 			UserID:    1,
-			PackageID: createResp.PackageID,
+			PackageID: createResp.Package.PackageID,
 		})
 		So(err, ShouldBeNil)
 	})

sdks/storage/utils.go

@@ -1,7 +1,38 @@
 package cdssdk
 
-import "path/filepath"
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	myhttp "gitlink.org.cn/cloudream/common/utils/http"
+	"gitlink.org.cn/cloudream/common/utils/math"
+	"gitlink.org.cn/cloudream/common/utils/serder"
+)
 
 func MakeIPFSFilePath(fileHash string) string {
 	return filepath.Join("ipfs", fileHash)
 }
+
+func ParseJSONResponse[TBody any](resp *http.Response) (TBody, error) {
+	var ret TBody
+	contType := resp.Header.Get("Content-Type")
+	if strings.Contains(contType, myhttp.ContentTypeJSON) {
+		var err error
+		if ret, err = serder.JSONToObjectStreamEx[TBody](resp.Body); err != nil {
+			return ret, fmt.Errorf("parsing response: %w", err)
+		}
+
+		return ret, nil
+	}
+
+	cont, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return ret, fmt.Errorf("unknow response content type: %s, status: %d", contType, resp.StatusCode)
+	}
+	strCont := string(cont)
+
+	return ret, fmt.Errorf("unknow response content type: %s, status: %d, body(prefix): %s", contType, resp.StatusCode, strCont[:math.Min(len(strCont), 200)])
+}

utils/http/http.go

@@ -133,8 +133,9 @@ func ParseJSONResponse[TBody any](resp *http.Response) (TBody, error) {
 }
 
 type MultiPartFile struct {
-	FileName string
-	File     io.ReadCloser
+	FieldName string
+	FileName  string
+	File      io.ReadCloser
 }
 
 type multiPartFileIterator struct {
@@ -146,9 +147,16 @@ func (m *multiPartFileIterator) MoveNext() (*MultiPartFile, error) {
 	if m.firstFile != nil {
 		f := m.firstFile
 		m.firstFile = nil
+
+		fileName, err := ul.PathUnescape(f.FileName())
+		if err != nil {
+			return nil, fmt.Errorf("unescape file name: %w", err)
+		}
+
 		return &MultiPartFile{
-			FileName: f.FileName(),
-			File:     f,
+			FieldName: f.FormName(),
+			FileName:  fileName,
+			File:      f,
 		}, nil
 	}
 
@@ -161,10 +169,16 @@ func (m *multiPartFileIterator) MoveNext() (*MultiPartFile, error) {
 			return nil, err
 		}
 
+		fileName, err := ul.PathUnescape(part.FileName())
+		if err != nil {
+			return nil, fmt.Errorf("unescape file name: %w", err)
+		}
+
 		if part.FileName() != "" {
 			return &MultiPartFile{
-				FileName: part.FileName(),
-				File:     part,
+				FieldName: part.FormName(),
+				FileName:  fileName,
+				File:      part,
 			}, nil
 		}
 	}
@@ -292,7 +306,7 @@ func PostMultiPart(url string, param MultiPartRequestParam) (*http.Response, err
 				err = func() error {
 					defer file.File.Close()
 
-					w, err := muWriter.CreateFormFile(file.FieldName, file.FileName)
+					w, err := muWriter.CreateFormFile(file.FieldName, ul.PathEscape(file.FileName))
 					if err != nil {
 						return fmt.Errorf("create form file failed, err: %w", err)
 					}

utils/serder/serder.go

@@ -53,6 +53,18 @@ func JSONToObjectEx[T any](data []byte) (T, error) {
 	return ret, nil
 }
 
+// 将JSON字符串转为对象。支持TypeUnion。
+func JSONToObjectStreamEx[T any](stream io.Reader) (T, error) {
+	var ret T
+	dec := defaultAPI.NewDecoder(stream)
+	err := dec.Decode(&ret)
+	if err != nil {
+		return ret, err
+	}
+
+	return ret, nil
+}
+
 // 将对象转为JSON字符串。如果需要支持解析TypeUnion类型，则使用"Ex"结尾的同名函数。
 func ObjectToJSON(obj any) ([]byte, error) {
 	return json.Marshal(obj)