Merge pull request #228 from qiniu/fix/customVars

xwen-winnie · web-flow · commit 90c317d0b501 · 2021-10-08T16:46:20.000+08:00
fix customVars on resumeable upload
diff --git a/.github/workflows/test-ci.yml b/.github/workflows/test-ci.yml
@@ -23,12 +23,12 @@ jobs:
 
       - name: Build
         run: dotnet build src/Qiniu/Qiniu.csproj
-      
+
       - name: Test
-        run: dotnet test src/QiniuTests/QiniuTests.csproj
-        
+        run: dotnet test -v n src/QiniuTests/QiniuTests.csproj
+
         env:
           QINIU_ACCESS_KEY: ${{ secrets.QINIU_ACCESS_KEY }}
           QINIU_SECRET_KEY: ${{ secrets.QINIU_SECRET_KEY }}
           QINIU_TEST_BUCKET: ${{ secrets.QINIU_TEST_BUCKET }}
-          QINIU_TEST_DOMAIN: ${{ secrets.QINIU_TEST_DOMAIN }}
+          QINIU_TEST_DOMAIN: ${{ secrets.QINIU_TEST_DOMAIN }}
diff --git a/src/Qiniu/Storage/PutExtra.cs b/src/Qiniu/Storage/PutExtra.cs
@@ -27,7 +27,7 @@ public class PutExtra
         /// 设置文件上传的状态控制器
         /// </summary>
         public UploadController UploadController { set; get; }
-        
+
         /// <summary>
         /// 最大重试次数
         /// </summary>
diff --git a/src/Qiniu/Storage/ResumableUploader.cs b/src/Qiniu/Storage/ResumableUploader.cs
@@ -10,7 +10,7 @@
 namespace Qiniu.Storage
 {
     /// <summary>
-    /// 分片上传/断点续上传，适合于以下"情形2~3":  
+    /// 分片上传/断点续上传，适合于以下"情形2~3":
     /// (1)网络较好并且待上传的文件体积较小时(比如100MB或更小一点)使用简单上传;
     /// (2)文件较大或者网络状况不理想时请使用分片上传;
     /// (3)文件较大并且需要支持断点续上传，请使用分片上传(断点续上传)
@@ -84,7 +84,7 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
             {
                 encodedObjectName = Base64.GetEncodedObjectName(key);
             }
-    
+
             //check put extra
             if (putExtra == null)
             {
@@ -142,15 +142,15 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
                                 ExpiredAt = 0,
                             };
                         }
-                        else
+                        else if (putExtra.Version == "v2")
                         {
                             HttpResult res = initReq(encodedObjectName, upToken);
                             Dictionary<string, string> responseBody = JsonConvert.DeserializeObject<Dictionary<string, string>>(res.Text);
                             if (res.Code != 200)
                             {
                                 return res;
                             }
-                            
+
                             resumeInfo = new ResumeInfo()
                             {
                                 FileSize = fileSize,
@@ -160,14 +160,15 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
                                 ExpiredAt = long.Parse(responseBody["expireAt"]),
                                 UploadId = responseBody["uploadId"]
                             };
+                        } else {
+                            throw new Exception("Invalid Version, only supports v1 / v2");
                         }
-                        
                     }
 
                     //calc upload progress
                     for (long blockIndex = 0; blockIndex < blockCount; blockIndex++)
                     {
-                        
+
                         if (putExtra.Version == "v1")
                         {
                             string context = resumeInfo.Contexts[blockIndex];
@@ -176,7 +177,7 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
                                 uploadedBytes += putExtra.PartSize;
                             }
                         }
-                        else
+                        else if (putExtra.Version == "v2")
                         {
                             Dictionary<string, object> etag = resumeInfo.Etags[blockIndex];
                             if (etag != null)
@@ -188,8 +189,10 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
                                 uploadedBytes += putExtra.PartSize;
                                 resumeInfo.Uploaded = uploadedBytes;
                             }
+                        } else {
+                            throw new Exception("Invalid Version, only supports v1 / v2");
                         }
-                        
+
                     }
 
                     //set upload progress
@@ -211,15 +214,17 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
                         {
                             context = resumeInfo.Contexts[blockIndex];
                         }
-                        else 
+                        else if (putExtra.Version == "v2")
                         {
                             Dictionary<string, object> etag = resumeInfo.Etags[blockIndex];
                             if (etag != null && etag.Count > 0)
                             {
                                 context = "~";
                             }
+                        } else {
+                            throw new Exception("Invalid Version, only supports v1 / v2");
                         }
-                       
+
                         if (string.IsNullOrEmpty(context))
                         {
                             //check upload controller action before each chunk
@@ -258,7 +263,7 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
 
                             if (blockDataDict.Count == putExtra.BlockUploadThreads)
                             {
-                    
+
                                 processMakeBlocks(blockDataDict, upToken, putExtra, resumeInfo, blockMakeResults, uploadedBytesDict, fileSize,
                                                   encodedObjectName);
                                 //check mkblk results
@@ -312,11 +317,13 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt
                         {
                             hr = MakeFile(key, fileSize, key, upToken, putExtra, resumeInfo.Contexts);
                         }
-                        else 
+                        else if (putExtra.Version == "v2")
                         {
                             hr = completeParts(key, resumeInfo, key, upToken, putExtra, encodedObjectName);
+                        } else {
+                            throw new Exception("Invalid Version, only supports v1 / v2");
                         }
-                        
+
                         if (hr.Code != (int)HttpCode.OK)
                         {
                             result.Shadow(hr);
@@ -462,12 +469,14 @@ private void MakeBlock(object resumeBlockerObj)
                 {
                     url = string.Format("{0}/mkblk/{1}", uploadHost, blockSize);
                 }
-                else
+                else if (putExtra.Version == "v2")
                 {
                     url = string.Format("{0}/buckets/{1}/objects/{2}/uploads/{3}/{4}", uploadHost, bucket, resumeBlocker.encodedObjectName,
                                         resumeInfo.UploadId, blockIndex+1);
+                } else {
+                    throw new Exception("Invalid Version, only supports v1 / v2");
                 }
-                
+
                 string upTokenStr = string.Format("UpToken {0}", upToken);
                 using (MemoryStream ms = new MemoryStream(blockBuffer, 0, blockSize))
                 {
@@ -476,17 +485,19 @@ private void MakeBlock(object resumeBlockerObj)
                     {
                         result = httpManager.PostData(url, data, upTokenStr);
                     }
-                    else
+                    else if (putExtra.Version == "v2")
                     {
                         Dictionary<string, string> headers = new Dictionary<string, string>();
                         headers.Add("Authorization", upTokenStr);
                         // data to md5
                         string md5 = LabMD5.GenerateMD5(blockBuffer);
                         headers.Add("Content-MD5", md5);
                         result = httpManager.PutDataWithHeaders(url, data, headers);
+                    } else {
+                        throw new Exception("Invalid Version, only supports v1 / v2");
                     }
-                    
-                    
+
+
                     if (result.Code == (int)HttpCode.OK)
                     {
                         if (putExtra.Version == "v1")
@@ -514,14 +525,16 @@ private void MakeBlock(object resumeBlockerObj)
                                     putExtra.ProgressHandler(uploadedBytesDict["UploadProgress"], fileSize);
                                 }
                             }
-                            else
+                            else if (putExtra.Version == "v2")
                             {
                                 result.RefText += string.Format("[{0}] JSON Decode Error: text = {1}",
                                     DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff"), result.Text);
                                 result.RefCode = (int)HttpCode.USER_NEED_RETRY;
+                            } else {
+                                throw new Exception("Invalid Version, only supports v1 / v2");
                             }
                         }
-                        else
+                        else if (putExtra.Version == "v2")
                         {
                             Dictionary<string, string> rc = JsonConvert.DeserializeObject<Dictionary<string, string>>(result.Text);
                             string md5 = LabMD5.GenerateMD5(blockBuffer);
@@ -543,6 +556,8 @@ private void MakeBlock(object resumeBlockerObj)
                                     }
                                     putExtra.ProgressHandler(uploadedBytesDict["UploadProgress"], fileSize);
                             }
+                        } else {
+                            throw new Exception("Invalid Version, only supports v1 / v2");
                         }
 
                     }
@@ -632,7 +647,7 @@ private HttpResult MakeFile(string fileName, long size, string key, string upTok
                         string v = kvp.Value;
                         if (k.StartsWith("x:") && !string.IsNullOrEmpty(v))
                         {
-                            sb.AppendFormat("/{0}/{1}", k, v);
+                            sb.AppendFormat("/{0}/{1}", k, Base64.UrlSafeBase64Encode(v));
                         }
                     }
 
@@ -694,7 +709,7 @@ private HttpResult MakeFile(string fileName, long size, string key, string upTok
         private HttpResult initReq(string encodedObjectName, string upToken)
         {
             HttpResult result = new HttpResult();
-            
+
             try
             {
                 string ak = UpToken.GetAccessKeyFromUpToken(upToken);
@@ -751,25 +766,20 @@ private HttpResult initReq(string encodedObjectName, string upToken)
         private HttpResult completeParts(string fileName, ResumeInfo resumeInfo, string key, string upToken, PutExtra putExtra, string encodedObjectName)
         {
             HttpResult result = new HttpResult();
-            
+
             try
             {
-                string paramStr = "{}";
                 if (string.IsNullOrEmpty(fileName)) {
                     fileName = "fname";
                 }
-                if (string.IsNullOrEmpty(putExtra.MimeType)) 
+                if (string.IsNullOrEmpty(putExtra.MimeType))
                 {
                     putExtra.MimeType = "";
                 }
                 if (string.IsNullOrEmpty(key))
                 {
                     key = "";
                 }
-                if (putExtra.Params != null)
-                {
-                    paramStr = JsonConvert.SerializeObject(putExtra.Params);
-                }
                 //get upload host
                 string ak = UpToken.GetAccessKeyFromUpToken(upToken);
                 string bucket = UpToken.GetBucketFromUpToken(upToken);
@@ -784,7 +794,7 @@ private HttpResult completeParts(string fileName, ResumeInfo resumeInfo, string
                 Dictionary<string, object> body = new Dictionary<string, object>();
                 body.Add("fname", fileName);
                 body.Add("mimeType", putExtra.MimeType);
-                body.Add("customVars", null);
+                body.Add("customVars", putExtra.Params);
                 body.Add("parts", resumeInfo.Etags);
                 string url = string.Format("{0}/buckets/{1}/objects/{2}/uploads/{3}", uploadHost, bucket, encodedObjectName, resumeInfo.UploadId);
                 string bodyStr = JsonConvert.SerializeObject(body);
diff --git a/src/QiniuTests/Storage/FormUploaderTests.cs b/src/QiniuTests/Storage/FormUploaderTests.cs
@@ -17,9 +17,9 @@ public void UploadFileTest()
             string key = string.Format("UploadFileTest_{0}.dat", rand.Next());
 
             string tempPath = System.IO.Path.GetTempPath();
-            int rnd = new Random().Next(1, 100000); 
+            int rnd = new Random().Next(1, 100000);
             string filePath = tempPath + "resumeFile" + rnd.ToString();
-            char[] testBody = new char[4 * 1024 * 1024]; 
+            char[] testBody = new char[4 * 1024 * 1024];
             System.IO.FileStream stream = new System.IO.FileStream(filePath, System.IO.FileMode.Create);
             System.IO.StreamWriter sw = new System.IO.StreamWriter(stream, System.Text.Encoding.Default);
             sw.Write(testBody);
@@ -51,9 +51,9 @@ public void UploadFileV2Test()
             string key = string.Format("UploadFileTest_{0}.dat", rand.Next());
 
             string tempPath = System.IO.Path.GetTempPath();
-            int rnd = new Random().Next(1, 100000); 
+            int rnd = new Random().Next(1, 100000);
             string filePath = tempPath + "resumeFile" + rnd.ToString();
-            char[] testBody = new char[4 * 1024 * 1024]; 
+            char[] testBody = new char[4 * 1024 * 1024];
             System.IO.FileStream stream = new System.IO.FileStream(filePath, System.IO.FileMode.Create);
             System.IO.StreamWriter sw = new System.IO.StreamWriter(stream, System.Text.Encoding.Default);
             sw.Write(testBody);
@@ -81,4 +81,4 @@ public void UploadFileV2Test()
         }
 
     }
-}
+}
diff --git a/src/QiniuTests/Storage/ResumableUploaderTests.cs b/src/QiniuTests/Storage/ResumableUploaderTests.cs

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`	`namespace Qiniu.Storage`
`11`	`11`	`{`
`12`	`12`	`/// <summary>`
`13`		`- /// 分片上传/断点续上传，适合于以下"情形2~3":`
	`13`	`+ /// 分片上传/断点续上传，适合于以下"情形2~3":`
`14`	`14`	`/// (1)网络较好并且待上传的文件体积较小时(比如100MB或更小一点)使用简单上传;`
`15`	`15`	`/// (2)文件较大或者网络状况不理想时请使用分片上传;`
`16`	`16`	`/// (3)文件较大并且需要支持断点续上传，请使用分片上传(断点续上传)`
`@@ -84,7 +84,7 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`84`	`84`	`{`
`85`	`85`	`encodedObjectName = Base64.GetEncodedObjectName(key);`
`86`	`86`	`}`
`87`		`-`
	`87`	`+`
`88`	`88`	`//check put extra`
`89`	`89`	`if (putExtra == null)`
`90`	`90`	`{`
`@@ -142,15 +142,15 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`142`	`142`	`ExpiredAt = 0,`
`143`	`143`	`};`
`144`	`144`	`}`
`145`		`- else`
	`145`	`+ else if (putExtra.Version == "v2")`
`146`	`146`	`{`
`147`	`147`	`HttpResult res = initReq(encodedObjectName, upToken);`
`148`	`148`	`Dictionary<string, string> responseBody = JsonConvert.DeserializeObject<Dictionary<string, string>>(res.Text);`
`149`	`149`	`if (res.Code != 200)`
`150`	`150`	`{`
`151`	`151`	`return res;`
`152`	`152`	`}`
`153`		`-`
	`153`	`+`
`154`	`154`	`resumeInfo = new ResumeInfo()`
`155`	`155`	`{`
`156`	`156`	`FileSize = fileSize,`
`@@ -160,14 +160,15 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`160`	`160`	`ExpiredAt = long.Parse(responseBody["expireAt"]),`
`161`	`161`	`UploadId = responseBody["uploadId"]`
`162`	`162`	`};`
	`163`	`+ } else {`
	`164`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`163`	`165`	`}`
`164`		`-`
`165`	`166`	`}`
`166`	`167`
`167`	`168`	`//calc upload progress`
`168`	`169`	`for (long blockIndex = 0; blockIndex < blockCount; blockIndex++)`
`169`	`170`	`{`
`170`		`-`
	`171`	`+`
`171`	`172`	`if (putExtra.Version == "v1")`
`172`	`173`	`{`
`173`	`174`	`string context = resumeInfo.Contexts[blockIndex];`
`@@ -176,7 +177,7 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`176`	`177`	`uploadedBytes += putExtra.PartSize;`
`177`	`178`	`}`
`178`	`179`	`}`
`179`		`- else`
	`180`	`+ else if (putExtra.Version == "v2")`
`180`	`181`	`{`
`181`	`182`	`Dictionary<string, object> etag = resumeInfo.Etags[blockIndex];`
`182`	`183`	`if (etag != null)`
`@@ -188,8 +189,10 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`188`	`189`	`uploadedBytes += putExtra.PartSize;`
`189`	`190`	`resumeInfo.Uploaded = uploadedBytes;`
`190`	`191`	`}`
	`192`	`+ } else {`
	`193`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`191`	`194`	`}`
`192`		`-`
	`195`	`+`
`193`	`196`	`}`
`194`	`197`
`195`	`198`	`//set upload progress`
`@@ -211,15 +214,17 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`211`	`214`	`{`
`212`	`215`	`context = resumeInfo.Contexts[blockIndex];`
`213`	`216`	`}`
`214`		`- else`
	`217`	`+ else if (putExtra.Version == "v2")`
`215`	`218`	`{`
`216`	`219`	`Dictionary<string, object> etag = resumeInfo.Etags[blockIndex];`
`217`	`220`	`if (etag != null && etag.Count > 0)`
`218`	`221`	`{`
`219`	`222`	`context = "~";`
`220`	`223`	`}`
	`224`	`+ } else {`
	`225`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`221`	`226`	`}`
`222`		`-`
	`227`	`+`
`223`	`228`	`if (string.IsNullOrEmpty(context))`
`224`	`229`	`{`
`225`	`230`	`//check upload controller action before each chunk`
`@@ -258,7 +263,7 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`258`	`263`
`259`	`264`	`if (blockDataDict.Count == putExtra.BlockUploadThreads)`
`260`	`265`	`{`
`261`		`-`
	`266`	`+`
`262`	`267`	`processMakeBlocks(blockDataDict, upToken, putExtra, resumeInfo, blockMakeResults, uploadedBytesDict, fileSize,`
`263`	`268`	`encodedObjectName);`
`264`	`269`	`//check mkblk results`
`@@ -312,11 +317,13 @@ public HttpResult UploadStream(Stream stream, string key, string upToken, PutExt`
`312`	`317`	`{`
`313`	`318`	`hr = MakeFile(key, fileSize, key, upToken, putExtra, resumeInfo.Contexts);`
`314`	`319`	`}`
`315`		`- else`
	`320`	`+ else if (putExtra.Version == "v2")`
`316`	`321`	`{`
`317`	`322`	`hr = completeParts(key, resumeInfo, key, upToken, putExtra, encodedObjectName);`
	`323`	`+ } else {`
	`324`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`318`	`325`	`}`
`319`		`-`
	`326`	`+`
`320`	`327`	`if (hr.Code != (int)HttpCode.OK)`
`321`	`328`	`{`
`322`	`329`	`result.Shadow(hr);`
`@@ -462,12 +469,14 @@ private void MakeBlock(object resumeBlockerObj)`
`462`	`469`	`{`
`463`	`470`	`url = string.Format("{0}/mkblk/{1}", uploadHost, blockSize);`
`464`	`471`	`}`
`465`		`- else`
	`472`	`+ else if (putExtra.Version == "v2")`
`466`	`473`	`{`
`467`	`474`	`url = string.Format("{0}/buckets/{1}/objects/{2}/uploads/{3}/{4}", uploadHost, bucket, resumeBlocker.encodedObjectName,`
`468`	`475`	`resumeInfo.UploadId, blockIndex+1);`
	`476`	`+ } else {`
	`477`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`469`	`478`	`}`
`470`		`-`
	`479`	`+`
`471`	`480`	`string upTokenStr = string.Format("UpToken {0}", upToken);`
`472`	`481`	`using (MemoryStream ms = new MemoryStream(blockBuffer, 0, blockSize))`
`473`	`482`	`{`
`@@ -476,17 +485,19 @@ private void MakeBlock(object resumeBlockerObj)`
`476`	`485`	`{`
`477`	`486`	`result = httpManager.PostData(url, data, upTokenStr);`
`478`	`487`	`}`
`479`		`- else`
	`488`	`+ else if (putExtra.Version == "v2")`
`480`	`489`	`{`
`481`	`490`	`Dictionary<string, string> headers = new Dictionary<string, string>();`
`482`	`491`	`headers.Add("Authorization", upTokenStr);`
`483`	`492`	`// data to md5`
`484`	`493`	`string md5 = LabMD5.GenerateMD5(blockBuffer);`
`485`	`494`	`headers.Add("Content-MD5", md5);`
`486`	`495`	`result = httpManager.PutDataWithHeaders(url, data, headers);`
	`496`	`+ } else {`
	`497`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`487`	`498`	`}`
`488`		`-`
`489`		`-`
	`499`	`+`
	`500`	`+`
`490`	`501`	`if (result.Code == (int)HttpCode.OK)`
`491`	`502`	`{`
`492`	`503`	`if (putExtra.Version == "v1")`
`@@ -514,14 +525,16 @@ private void MakeBlock(object resumeBlockerObj)`
`514`	`525`	`putExtra.ProgressHandler(uploadedBytesDict["UploadProgress"], fileSize);`
`515`	`526`	`}`
`516`	`527`	`}`
`517`		`- else`
	`528`	`+ else if (putExtra.Version == "v2")`
`518`	`529`	`{`
`519`	`530`	`result.RefText += string.Format("[{0}] JSON Decode Error: text = {1}",`
`520`	`531`	`DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff"), result.Text);`
`521`	`532`	`result.RefCode = (int)HttpCode.USER_NEED_RETRY;`
	`533`	`+ } else {`
	`534`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`522`	`535`	`}`
`523`	`536`	`}`
`524`		`- else`
	`537`	`+ else if (putExtra.Version == "v2")`
`525`	`538`	`{`
`526`	`539`	`Dictionary<string, string> rc = JsonConvert.DeserializeObject<Dictionary<string, string>>(result.Text);`
`527`	`540`	`string md5 = LabMD5.GenerateMD5(blockBuffer);`
`@@ -543,6 +556,8 @@ private void MakeBlock(object resumeBlockerObj)`
`543`	`556`	`}`
`544`	`557`	`putExtra.ProgressHandler(uploadedBytesDict["UploadProgress"], fileSize);`
`545`	`558`	`}`
	`559`	`+ } else {`
	`560`	`+ throw new Exception("Invalid Version, only supports v1 / v2");`
`546`	`561`	`}`
`547`	`562`
`548`	`563`	`}`
`@@ -632,7 +647,7 @@ private HttpResult MakeFile(string fileName, long size, string key, string upTok`
`632`	`647`	`string v = kvp.Value;`
`633`	`648`	`if (k.StartsWith("x:") && !string.IsNullOrEmpty(v))`
`634`	`649`	`{`
`635`		`- sb.AppendFormat("/{0}/{1}", k, v);`
	`650`	`+ sb.AppendFormat("/{0}/{1}", k, Base64.UrlSafeBase64Encode(v));`
`636`	`651`	`}`
`637`	`652`	`}`
`638`	`653`
`@@ -694,7 +709,7 @@ private HttpResult MakeFile(string fileName, long size, string key, string upTok`
`694`	`709`	`private HttpResult initReq(string encodedObjectName, string upToken)`
`695`	`710`	`{`
`696`	`711`	`HttpResult result = new HttpResult();`
`697`		`-`
	`712`	`+`
`698`	`713`	`try`
`699`	`714`	`{`
`700`	`715`	`string ak = UpToken.GetAccessKeyFromUpToken(upToken);`
`@@ -751,25 +766,20 @@ private HttpResult initReq(string encodedObjectName, string upToken)`
`751`	`766`	`private HttpResult completeParts(string fileName, ResumeInfo resumeInfo, string key, string upToken, PutExtra putExtra, string encodedObjectName)`
`752`	`767`	`{`
`753`	`768`	`HttpResult result = new HttpResult();`
`754`		`-`
	`769`	`+`
`755`	`770`	`try`
`756`	`771`	`{`
`757`		`- string paramStr = "{}";`
`758`	`772`	`if (string.IsNullOrEmpty(fileName)) {`
`759`	`773`	`fileName = "fname";`
`760`	`774`	`}`
`761`		`- if (string.IsNullOrEmpty(putExtra.MimeType))`
	`775`	`+ if (string.IsNullOrEmpty(putExtra.MimeType))`
`762`	`776`	`{`
`763`	`777`	`putExtra.MimeType = "";`
`764`	`778`	`}`
`765`	`779`	`if (string.IsNullOrEmpty(key))`
`766`	`780`	`{`
`767`	`781`	`key = "";`
`768`	`782`	`}`
`769`		`- if (putExtra.Params != null)`
`770`		`- {`
`771`		`- paramStr = JsonConvert.SerializeObject(putExtra.Params);`
`772`		`- }`
`773`	`783`	`//get upload host`
`774`	`784`	`string ak = UpToken.GetAccessKeyFromUpToken(upToken);`
`775`	`785`	`string bucket = UpToken.GetBucketFromUpToken(upToken);`
`@@ -784,7 +794,7 @@ private HttpResult completeParts(string fileName, ResumeInfo resumeInfo, string`
`784`	`794`	`Dictionary<string, object> body = new Dictionary<string, object>();`
`785`	`795`	`body.Add("fname", fileName);`
`786`	`796`	`body.Add("mimeType", putExtra.MimeType);`
`787`		`- body.Add("customVars", null);`
	`797`	`+ body.Add("customVars", putExtra.Params);`
`788`	`798`	`body.Add("parts", resumeInfo.Etags);`
`789`	`799`	`string url = string.Format("{0}/buckets/{1}/objects/{2}/uploads/{3}", uploadHost, bucket, encodedObjectName, resumeInfo.UploadId);`
`790`	`800`	`string bodyStr = JsonConvert.SerializeObject(body);`