public void ResumableUploadObjectTestWithSingleThread()
{
var key = OssTestUtils.GetObjectKey(_className);
try
{
var fileInfo = new FileInfo(Config.MultiUploadTestFile);
var fileSize = fileInfo.Length;
var config = new ClientConfiguration();
var client = OssClientFactory.CreateOssClient(config);
UploadObjectRequest request = new UploadObjectRequest(_bucketName, key, Config.MultiUploadTestFile);
request.Metadata = new ObjectMetadata();
request.CheckpointDir = Config.DownloadFolder;
request.PartSize = fileSize / 3;
request.ParallelThreadCount = 1;
var result = client.ResumableUploadObject(request);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, key));
Assert.IsTrue(result.ETag.Length > 0);
}
finally
{
if (OssTestUtils.ObjectExists(_ossClient, _bucketName, key))
{
_ossClient.DeleteObject(_bucketName, key);
}
}
}
/// <summary>
/// 根据文件流上传
/// </summary>
/// <param name="param"></param>
/// <param name="isResume">是否允许续传</param>
/// <returns></returns>
public UploadResultDto UploadStream(UploadByStreamParam param, bool isResume = false)
{
return(ToolCommon.GetResponse(() =>
{
var zone = Core.Tools.GetZone(_aLiYunConfig, param.UploadPersistentOps.Zone,
() => ZoneEnum.HangZhou);
var client = _aLiYunConfig.GetClient(zone);
return Upload(isResume, (bucket, newPersistentOps, objectMetadata) =>
{
PutObjectResult ret;
if (isResume)
{
var request = new UploadObjectRequest(bucket, param.Key, param.Stream)
{
PartSize = Core.Tools.GetPartSize(
Core.Tools.GetChunkUnit(_aLiYunConfig, newPersistentOps.ChunkUnit,
() => ChunkUnit.U2048K)),
Metadata = objectMetadata
};
ret = client.ResumableUploadObject(request);
}
else
{
ret = client.PutObject(bucket, param.Key, param.Stream, objectMetadata);
}
return ret;
}, param.UploadPersistentOps);
}, (message, ex) => new UploadResultDto(false, ex, message)));
}
public static void ResumableUploadObject(string bucketName)
{
const string key = "ResumableUploadObject";
string checkpointDir = Config.DirToDownload;
try
{
UploadObjectRequest request = new UploadObjectRequest(bucketName, key, fileToUpload)
{
PartSize = 8 * 1024 * 1024,
ParallelThreadCount = 3,
CheckpointDir = checkpointDir,
};
client.ResumableUploadObject(request);
Console.WriteLine("Resumable upload object:{0} succeeded", key);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
}
public void ResumableUploadObjectWithRetry(int threadCount)
{
var key = OssTestUtils.GetObjectKey(_className);
int failedCount = 0;
UploadObjectRequest request = new UploadObjectRequest(_bucketName, key, Config.MultiUploadTestFile);
request.CheckpointDir = Config.DownloadFolder;
request.PartSize = 200 * 1024;
request.StreamTransferProgress = (sender, e) => {
if (failedCount < 2)
{
failedCount++;
throw new Exception("injection failure");
}
};
request.ParallelThreadCount = threadCount;
try
{
var result = _ossClient.ResumableUploadObject(request);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, key));
Assert.IsTrue(result.ETag.Length > 0);
}
finally
{
if (OssTestUtils.ObjectExists(_ossClient, _bucketName, key))
{
_ossClient.DeleteObject(_bucketName, key);
}
}
}
public void ResumableUploadNegativeTest()
{
var key = OssTestUtils.GetObjectKey(_className);
// < Default PartSize Case
var request = new UploadObjectRequest(_bucketName, key, Config.UploadTestFile);
Assert.AreEqual(request.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.ResumableUploadObject(request);
Assert.Fail("should not be here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
// > Default PartSize Case
request = new UploadObjectRequest(_bucketName, key, Config.MultiUploadTestFile);
Assert.AreEqual(request.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.ResumableUploadObject(request);
Assert.Fail("should not be here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
}
public void ResumableUploadPositiveTest()
{
var fileName = Config.UploadTestFile;
var fileInfo = new FileInfo(fileName);
var fileSize = fileInfo.Length;
// < PartSize
var key = OssTestUtils.GetObjectKey(_className);
var request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = fileSize + 1,
RequestPayer = RequestPayer.Requester
};
var result = _ossPayerClient.ResumableUploadObject(request);
Assert.IsTrue(result.ETag.Length > 0);
var headResult = _ossClient.GetObjectMetadata(_bucketName, key);
Assert.AreEqual(headResult.ContentLength, fileSize);
// > PartSize with multi thread
key = OssTestUtils.GetObjectKey(_className);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = 100 * 1024,
RequestPayer = RequestPayer.Requester
};
result = _ossPayerClient.ResumableUploadObject(request);
Assert.IsTrue(result.ETag.Length > 0);
headResult = _ossClient.GetObjectMetadata(_bucketName, key);
Assert.AreEqual(headResult.ContentLength, fileSize);
// > PartSize with single thread
key = OssTestUtils.GetObjectKey(_className);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = 100 * 1024,
RequestPayer = RequestPayer.Requester,
ParallelThreadCount = 1
};
result = _ossPayerClient.ResumableUploadObject(request);
Assert.IsTrue(result.ETag.Length > 0);
headResult = _ossClient.GetObjectMetadata(_bucketName, key);
Assert.AreEqual(headResult.ContentLength, fileSize);
}
private static string BackUp(string backupFilePath)
{
if (!Directory.Exists(backupFilePath))
{
Console.WriteLine("backupFilePath do not exists");
}
var dir = new DirectoryInfo(backupFilePath);
var zipName = $"{dir.Name}_{DateTime.Now.ToString("yyyyMMddHHmmss")}.zip";
var localFilename = Path.Combine(directoryPath, zipName);
if (!Directory.Exists(directoryPath))
{
Directory.CreateDirectory(directoryPath);
}
if (File.Exists(localFilename))
{
File.Delete(localFilename);
}
ZipFile.CreateFromDirectory(backupFilePath, localFilename);
var objectName = $"{BaseObjectName.TrimEnd('/')}/{zipName}";
var client = new OssClient(Endpoint, AccessKeyId, AccessKeySecret);
try
{
UploadObjectRequest request = new UploadObjectRequest(BucketName, objectName, localFilename)
{
PartSize = 8 * 1024 * 1024,
ParallelThreadCount = 3,
CheckpointDir = directoryPath,
};
client.ResumableUploadObject(request);
Console.WriteLine("Resumable upload object:{0} succeeded", objectName);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
return(localFilename);
}
/// <summary>
/// 私有方法，实际实现断点续传方法
/// </summary>
/// <param name="objectName"></param>
/// <param name="localFilename"></param>
/// <param name="checkpointDir"></param>
/// <param name="bucketName"></param>
private static FileData FilePonit(string objectName, string localFilename, string checkpointDir, string bucketName)
{
FileData file = new FileData();
file.OssKey = objectName;
file.LocalFilePath = localFilename;
try
{
// 通过UploadFileRequest设置多个参数。
UploadObjectRequest request = new UploadObjectRequest(bucketName, objectName, localFilename)
{
// 指定上传的分片大小。
PartSize = 1024, //byte 8 * 1024 * 1024,
// 指定并发线程数。
ParallelThreadCount = 3,
// checkpointDir保存断点续传的中间状态，用于失败后继续上传。如果checkpointDir为null，断点续传功能不会生效，每次失败后都会重新上传。
CheckpointDir = checkpointDir,
StreamTransferProgress = streamProgressCallback
};
OssClient client = new OssClient(AppConfig.GetSection("AliyunOSS:Endpoint"), AppConfig.GetSection("AliyunOSS:AccessKeyId"), AppConfig.GetSection("AliyunOSS:AccessKeySecret"));
// 断点续传上传。
client.ResumableUploadObject(request);
//返回上传到oss的地址
file.Url = AppConfig.GetSection("AliyunOSS:Endpoint").Insert(8, bucketName + ".") + "/" + objectName;
file.IsSuccess = true;
}
catch (OssException ex)
{
file.IsSuccess = false;
//记录日志
}
catch (Exception ex)
{
//记录日志
file.IsSuccess = false;
}
return(file);
}
public void ResumableUploadDownloadTest()
{
var filePath = OssTestUtils.GetTargetFileName(_className);
filePath = Path.Combine(Config.DownloadFolder, filePath);
FileUtils.PrepareSampleFile(filePath, 800);
var fileName = filePath;
var fileInfo = new FileInfo(fileName);
var fileSize = fileInfo.Length;
// < PartSize
var key = OssTestUtils.GetObjectKey(_className);
var request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = fileSize + 1,
};
Assert.AreEqual(request.TrafficLimit, 0);
DateTime beforDT = System.DateTime.Now;
var result = _ossClient.ResumableUploadObject(request);
DateTime afterDT = System.DateTime.Now;
TimeSpan ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds < 2);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = fileSize + 1,
TrafficLimit = 100 * 1024 * 8
};
Assert.AreEqual(request.TrafficLimit, 819200);
beforDT = System.DateTime.Now;
result = _ossClient.ResumableUploadObject(request);
afterDT = System.DateTime.Now;
ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds > 6);
// > PartSize with single thread
key = OssTestUtils.GetObjectKey(_className);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = 400 * 1024,
ParallelThreadCount = 1
};
Assert.AreEqual(request.TrafficLimit, 0);
beforDT = DateTime.Now;
result = _ossClient.ResumableUploadObject(request);
afterDT = DateTime.Now;
ts = afterDT.Subtract(beforDT).Duration();
Assert.IsTrue(ts.TotalSeconds < 3);
key = OssTestUtils.GetObjectKey(_className);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = 400 * 1024,
ParallelThreadCount = 1,
TrafficLimit = 100 * 1024 * 8
};
Assert.AreEqual(request.TrafficLimit, 819200);
beforDT = System.DateTime.Now;
result = _ossClient.ResumableUploadObject(request);
afterDT = System.DateTime.Now;
ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds > 6);
// > PartSize with 2 thread
key = OssTestUtils.GetObjectKey(_className);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = 200 * 1024,
ParallelThreadCount = 2
};
Assert.AreEqual(request.TrafficLimit, 0);
beforDT = DateTime.Now;
result = _ossClient.ResumableUploadObject(request);
afterDT = DateTime.Now;
ts = afterDT.Subtract(beforDT).Duration();
Assert.IsTrue(ts.TotalSeconds < 2);
key = OssTestUtils.GetObjectKey(_className);
request = new UploadObjectRequest(_bucketName, key, fileName)
{
PartSize = 200 * 1024,
ParallelThreadCount = 2,
TrafficLimit = 100 * 1024 * 8
};
Assert.AreEqual(request.TrafficLimit, 819200);
beforDT = System.DateTime.Now;
result = _ossClient.ResumableUploadObject(request);
afterDT = System.DateTime.Now;
ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds > 6);
//download
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
// < PartSize
var dRequest = new DownloadObjectRequest(_bucketName, key, targetFile)
{
PartSize = fileSize + 1,
};
Assert.AreEqual(dRequest.TrafficLimit, 0);
beforDT = System.DateTime.Now;
var metadata = _ossClient.ResumableDownloadObject(dRequest);
afterDT = System.DateTime.Now;
ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds < 2);
FileUtils.DeleteFile(targetFile);
// > PartSize with multi thread
dRequest = new DownloadObjectRequest(_bucketName, key, targetFile)
{
PartSize = 200 * 1024,
ParallelThreadCount = 2,
TrafficLimit = 100 * 1024 * 8
};
Assert.AreEqual(dRequest.TrafficLimit, 819200);
afterDT = System.DateTime.Now;
metadata = _ossClient.ResumableDownloadObject(dRequest);
afterDT = System.DateTime.Now;
ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds > 4);
FileUtils.DeleteFile(targetFile);
// > PartSize with single thread
dRequest = new DownloadObjectRequest(_bucketName, key, targetFile)
{
PartSize = 200 * 1024,
ParallelThreadCount = 1,
TrafficLimit = 100 * 1024 * 8
};
Assert.AreEqual(dRequest.TrafficLimit, 819200);
afterDT = System.DateTime.Now;
metadata = _ossClient.ResumableDownloadObject(dRequest);
afterDT = System.DateTime.Now;
ts = afterDT.Subtract(beforDT);
Assert.IsTrue(ts.TotalSeconds > 6);
FileUtils.DeleteFile(targetFile);
//FileUtils.DeleteFile(filePath);
}
