public void ResumableDownloadSmallFileWithMd5CheckTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var config = new ClientConfiguration();
config.EnalbeMD5Check = true;
var client = OssClientFactory.CreateOssClient(config);
try
{
DownloadObjectRequest request = new DownloadObjectRequest(_bucketName, _objectKey, targetFile);
var metadata = client.ResumableDownloadObject(request);
var expectedETag = metadata.ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
}
}
public void ResumableDownloadBigFileWithMultipartUploadWithMd5CheckTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var key = OssTestUtils.GetObjectKey(_className);
_ossClient.ResumableUploadObject(_bucketName, key, Config.MultiUploadTestFile, new ObjectMetadata(), Config.DownloadFolder, null);
try
{
var config = new ClientConfiguration();
config.EnalbeMD5Check = true;
var client = OssClientFactory.CreateOssClient(config);
DownloadObjectRequest request = new DownloadObjectRequest(_bucketName, key, targetFile);
var metadata = client.ResumableDownloadObject(request);
Assert.AreEqual(metadata.ContentLength, new FileInfo(targetFile).Length);
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
_ossClient.DeleteObject(_bucketName, key);
}
}
public void ResumableDownloadBigFileSingleThreadTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var key = OssTestUtils.GetObjectKey(_className);
_ossClient.PutObject(_bucketName, key, Config.MultiUploadTestFile);
var config = new ClientConfiguration();
var client = OssClientFactory.CreateOssClient(config);
try
{
DownloadObjectRequest request = new DownloadObjectRequest(_bucketName, key, targetFile);
request.CheckpointDir = Config.DownloadFolder;
request.ParallelThreadCount = 1;
var metadata = client.ResumableDownloadObject(request);
var expectedETag = metadata.ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
_ossClient.DeleteObject(_bucketName, key);
}
}
public static void ResumableDownloadObject(string bucketName)
{
const string key = "ResumableDownloadObject";
string fileToDownload = Config.DirToDownload + key;
string checkpointDir = Config.DirToDownload;
try
{
DownloadObjectRequest request = new DownloadObjectRequest(bucketName, key, fileToDownload)
{
PartSize = 8 * 1024 * 1024,
ParallelThreadCount = 3,
CheckpointDir = Config.DirToDownload,
};
client.ResumableDownloadObject(request);
Console.WriteLine("Resumable download 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 ResumableDownloadBigFileSingleThreadBreakAndResumeTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var key = OssTestUtils.GetObjectKey(_className);
_ossClient.PutObject(_bucketName, key, Config.MultiUploadTestFile);
bool progressUpdateCalled = false;
bool faultInjected = false;
try
{
DownloadObjectRequest request = new DownloadObjectRequest(_bucketName, key, targetFile);
request.PartSize = 100 * 1024;
request.CheckpointDir = Config.DownloadFolder;
request.StreamTransferProgress += (object sender, StreamTransferProgressArgs e) => {
if (!progressUpdateCalled)
{
progressUpdateCalled = true;
}
else
{
if (!faultInjected)
{
faultInjected = true;
throw new TimeoutException("Inject failure");
}
}
};
var config = new ClientConfiguration();
request.ParallelThreadCount = 1;
var client = OssClientFactory.CreateOssClient(config);
var metadata = client.ResumableDownloadObject(request);
var expectedETag = metadata.ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
Assert.AreEqual(progressUpdateCalled, true);
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
_ossClient.DeleteObject(_bucketName, key);
}
}
public void ResumableDownloadPositiveTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var key = OssTestUtils.GetObjectKey(_className);
var fileName = Config.UploadTestFile;
var fileInfo = new FileInfo(fileName);
var fileSize = fileInfo.Length;
_ossClient.PutObject(_bucketName, key, fileName);
// < PartSize
var request = new DownloadObjectRequest(_bucketName, key, targetFile)
{
PartSize = fileSize + 1,
RequestPayer = RequestPayer.Requester
};
var metadata = _ossPayerClient.ResumableDownloadObject(request);
var expectedETag = metadata.ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
FileUtils.DeleteFile(targetFile);
// > PartSize with multi thread
request = new DownloadObjectRequest(_bucketName, key, targetFile)
{
PartSize = 100 * 1024,
RequestPayer = RequestPayer.Requester
};
metadata = _ossPayerClient.ResumableDownloadObject(request);
expectedETag = metadata.ETag;
downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
FileUtils.DeleteFile(targetFile);
// > PartSize with single thread
request = new DownloadObjectRequest(_bucketName, key, targetFile)
{
PartSize = 100 * 1024,
RequestPayer = RequestPayer.Requester,
ParallelThreadCount = 1
};
metadata = _ossPayerClient.ResumableDownloadObject(request);
expectedETag = metadata.ETag;
downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
FileUtils.DeleteFile(targetFile);
}
public void ResumableDownloadBigFileSingleThreadWithProgressUpdateTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var key = OssTestUtils.GetObjectKey(_className);
_ossClient.PutObject(_bucketName, key, Config.MultiUploadTestFile);
bool progressUpdateCalled = false;
int percentDone = 0;
long totalBytesDownloaded = 0;
var config = new ClientConfiguration();
config.EnalbeMD5Check = true;
var client = OssClientFactory.CreateOssClient(config);
try
{
DownloadObjectRequest request = new DownloadObjectRequest(_bucketName, key, targetFile);
request.ParallelThreadCount = 1;
request.StreamTransferProgress += (object sender, StreamTransferProgressArgs e) => {
totalBytesDownloaded += e.TransferredBytes;
Console.WriteLine("TotalBytes:" + e.TotalBytes);
Console.WriteLine("TransferredBytes:" + e.TransferredBytes);
Console.WriteLine("PercentageDone:" + e.PercentDone);
progressUpdateCalled = true;
percentDone = e.PercentDone;
};
var metadata = client.ResumableDownloadObject(request);
var expectedETag = metadata.ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
Assert.AreEqual(progressUpdateCalled, true);
Assert.AreEqual(percentDone, 100);
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
_ossClient.DeleteObject(_bucketName, key);
}
}
public void ResumableDownloadNegativeTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var key = OssTestUtils.GetObjectKey(_className);
var request = new DownloadObjectRequest(_bucketName, key, targetFile);
Assert.AreEqual(request.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.ResumableDownloadObject(request);
Assert.Fail("should not be here.");
}
catch (Exception e)
{
Assert.IsTrue(true, e.Message);
}
}
public void ResumableDownloadSmallFileProgressUpdateTest()
{
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
bool progressUpdateCalled = false;
int percentDone = 0;
try
{
DownloadObjectRequest request = new DownloadObjectRequest(_bucketName, _objectKey, targetFile);
long totalBytesDownloaded = 0;
request.StreamTransferProgress += (object sender, StreamTransferProgressArgs e) => {
totalBytesDownloaded += e.TransferredBytes;
Console.WriteLine("TotalBytes:" + e.TotalBytes);
Console.WriteLine("TransferredBytes:" + e.TransferredBytes);
Console.WriteLine("PercentageDone:" + e.PercentDone);
progressUpdateCalled = true;
percentDone = e.PercentDone;
};
var metadata = _ossClient.ResumableDownloadObject(request);
var expectedETag = metadata.ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
Assert.IsTrue(progressUpdateCalled);
Assert.IsTrue(percentDone == 100);
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
}
}
async Task <ObjectMetadata> OssDownload()
{
string path = dir + Name;
if (File.Exists(path))
{
File.Delete(path);
}
var ossClient = new OssClient(Config.EndPoint, Config.AccessKeyId, Config.AccessKeySecret);
try
{
DownloadObjectRequest request = new DownloadObjectRequest(Config.Bucket, Name, path)
{
PartSize = 8 * 1024 * 1024,
ParallelThreadCount = 3,
CheckpointDir = dir
};
request.StreamTransferProgress += OssDown;
ObjectMetadata dat = await Task.Run(
() => {
try
{
return(ossClient.ResumableDownloadObject(request));
}
catch
{
return(null);
}
}
);
return(dat);
}
catch (OssException ex)
{
Debug.Log(ex.StackTrace);
return(null);
}
}
public void TestDisableCrc()
{
Common.ClientConfiguration config = new Common.ClientConfiguration();
config.EnableCrcCheck = false;
IOss ossClient = OssClientFactory.CreateOssClient(config);
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
var objectKeyName = "test-object-disable-crc";
try
{
// put & get
PutObjectResult putObjectResult = ossClient.PutObject(_bucketName, objectKeyName, Config.UploadTestFile);
var actualCrc = putObjectResult.ResponseMetadata[HttpHeaders.HashCrc64Ecma];
OssObject ossObject = ossClient.GetObject(_bucketName, objectKeyName);
var expectedCrc = OssUtils.ComputeContentCrc64(ossObject.Content, ossObject.ContentLength);
Assert.AreEqual(expectedCrc, actualCrc);
ossClient.DeleteObject(_bucketName, objectKeyName);
// put & get by uri
var testStr = FileUtils.GenerateOneKb();
var content = Encoding.ASCII.GetBytes(testStr);
var now = DateTime.Now;
var expireDate = now.AddSeconds(120);
var uri = _ossClient.GeneratePresignedUri(_bucketName, objectKeyName, expireDate, SignHttpMethod.Put);
var putResult = ossClient.PutObject(uri, new MemoryStream(content));
expectedCrc = putResult.ResponseMetadata[HttpHeaders.HashCrc64Ecma];
actualCrc = OssUtils.ComputeContentCrc64(new MemoryStream(content), content.Length);
Assert.AreEqual(expectedCrc, actualCrc);
uri = _ossClient.GeneratePresignedUri(_bucketName, objectKeyName, expireDate, SignHttpMethod.Get);
ossObject = ossClient.GetObject(uri);
expectedCrc = OssUtils.ComputeContentCrc64(ossObject.Content, ossObject.ContentLength);
Assert.AreEqual(expectedCrc, actualCrc);
ossClient.DeleteObject(_bucketName, objectKeyName);
// upload & download
var uploadObjectResult = ossClient.ResumableUploadObject(_bucketName, objectKeyName, Config.MultiUploadTestFile, null,
Config.DownloadFolder);
actualCrc = uploadObjectResult.ResponseMetadata[HttpHeaders.HashCrc64Ecma];
DownloadObjectRequest downloadObjectRequest = new DownloadObjectRequest(_bucketName, objectKeyName, targetFile);
var metadata = ossClient.ResumableDownloadObject(downloadObjectRequest);
Assert.AreEqual(metadata.Crc64, actualCrc);
ossClient.DeleteObject(_bucketName, objectKeyName);
// append
using (var fs = File.Open(Config.UploadTestFile, FileMode.Open))
{
var fileLength = fs.Length;
var appendObjectRequest = new AppendObjectRequest(_bucketName, objectKeyName)
{
Content = fs,
};
var appendObjectResult = _ossClient.AppendObject(appendObjectRequest);
fs.Seek(0, SeekOrigin.Begin);
actualCrc = OssUtils.ComputeContentCrc64(fs, fs.Length);
Assert.AreEqual(appendObjectResult.HashCrc64Ecma.ToString(), actualCrc);
ossClient.DeleteObject(_bucketName, objectKeyName);
}
}
finally
{
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
}
}
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);
}
