public void CopyObjectBasicTest()
{
var targetObjectKey = OssTestUtils.GetObjectKey(_className);
//construct metadata
var metadata = new ObjectMetadata();
const string userMetaKey = "myKey";
const string userMetaValue = "myValue";
metadata.UserMetadata.Add(userMetaKey, userMetaValue);
metadata.CacheControl = "No-Cache";
var coRequest = new CopyObjectRequest(_bucketName, _sourceObjectKey, _bucketName, targetObjectKey)
{
NewObjectMetadata = metadata
};
//copy object
_ossClient.CopyObject(coRequest);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, targetObjectKey));
var resMetadata = _ossClient.GetObjectMetadata(_bucketName, targetObjectKey);
Assert.AreEqual(userMetaValue, resMetadata.UserMetadata[userMetaKey]);
_ossClient.DeleteObject(_bucketName, targetObjectKey);
}
public void CreateAndDeleteIABucketTest()
{
//get a random bucketName
var bucketName = OssTestUtils.GetBucketName(_className);
//assert bucket does not exist
Assert.IsFalse(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should not exist before creation", bucketName));
//create a new bucket
_ossClient.CreateBucket(bucketName, StorageClass.IA);
OssTestUtils.WaitForCacheExpire();
Assert.IsTrue(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should exist after creation", bucketName));
var objectName = bucketName + "firstobject";
_ossClient.PutObject(bucketName, objectName, new MemoryStream());
var objMeta = _ossClient.GetObjectMetadata(bucketName, objectName);
Assert.AreEqual(objMeta.HttpMetadata["x-oss-storage-class"], StorageClass.IA.ToString());
_ossClient.DeleteObject(bucketName, objectName);
//delete the new created bucket
_ossClient.DeleteBucket(bucketName);
OssTestUtils.WaitForCacheExpire();
Assert.IsFalse(OssTestUtils.BucketExists(_ossClient, bucketName),
string.Format("Bucket {0} should not exist after deletion", bucketName));
}
public void ImageProcessTest()
{
try
{
// put example image
_ossClient.PutObject(_bucketName, _keyName, _localImageFile);
// get processed image
GetObjectRequest request = new GetObjectRequest(_bucketName, _keyName, _process);
OssObject ossObject = _ossClient.GetObject(request);
// put processed image
Stream seekableStream = ConvertStreamToSeekable(ossObject.Content);
_ossClient.PutObject(_bucketName, _processedKey, seekableStream);
// get info of processed image
var imgInfo = GetOssImageObjectInfo(_bucketName, _processedKey);
// check processed result
Assert.AreEqual(imgInfo, _imageInfo);
}
finally
{
_ossClient.DeleteObject(_bucketName, _keyName);
_ossClient.DeleteObject(_bucketName, _processedKey);
}
}
public void PutObjectProgressTest()
{
// put object
using (var inputStream = File.Open(Config.MultiUploadTestFile, FileMode.Open))
{
var putObjectRequest = new PutObjectRequest(_bucketName, _objectKey, inputStream);
putObjectRequest.Metadata = new ObjectMetadata();
putObjectRequest.StreamTransferProgress += uploadProgressCallback;
_ossClient.PutObject(putObjectRequest);
inputStream.Close();
}
// get object
var getObjectRequest = new GetObjectRequest(_bucketName, _objectKey);
getObjectRequest.StreamTransferProgress += uploadProgressCallback;
var ossObject = _ossClient.GetObject(getObjectRequest);
using (var requestStream = ossObject.Content)
{
using (var localfile = File.Open(_tmpLocalFile, FileMode.OpenOrCreate))
{
OssTestUtils.WriteTo(requestStream, localfile);
}
}
// check md5
var expectedHashDigest = FileUtils.ComputeContentMd5(Config.MultiUploadTestFile);
var actualHashDigest = FileUtils.ComputeContentMd5(_tmpLocalFile);
Assert.AreEqual(expectedHashDigest, actualHashDigest);
_ossClient.DeleteObject(_bucketName, _objectKey);
File.Delete(_tmpLocalFile);
}
public void PutObjectDisableMD5CheckTest()
{
// put object
_ossClientDisableMD5.PutObject(_bucketName, _objectKey, Config.UploadTestFile);
// get object
var ossObject = _ossClientDisableMD5.GetObject(_bucketName, _objectKey);
using (var requestStream = ossObject.Content)
{
using (var localfile = File.Open(_tmpLocalFile, FileMode.OpenOrCreate))
{
OssTestUtils.WriteTo(requestStream, localfile);
}
}
// check md5
var expectedHashDigest = FileUtils.ComputeContentMd5(Config.UploadTestFile);
var actualHashDigest = FileUtils.ComputeContentMd5(_tmpLocalFile);
Assert.AreEqual(expectedHashDigest, actualHashDigest);
_ossClientDisableMD5.DeleteObject(_bucketName, _objectKey);
File.Delete(_tmpLocalFile);
}
public void SetObjectAclApiTest()
{
try
{
_ossClient.PutObject(_bucketName, _keyName, Config.UploadTestFile);
// default
var acl = _ossClient.GetObjectAcl(_bucketName, _keyName);
Assert.AreEqual(acl.ACL, CannedAccessControlList.Default);
// public read
_ossClient.SetObjectAcl(_bucketName, _keyName, CannedAccessControlList.PublicRead);
OssTestUtils.WaitForCacheExpire();
acl = _ossClient.GetObjectAcl(_bucketName, _keyName);
Assert.AreEqual(acl.ACL, CannedAccessControlList.PublicRead);
// public read and write
_ossClient.SetObjectAcl(_bucketName, _keyName, CannedAccessControlList.PublicReadWrite);
OssTestUtils.WaitForCacheExpire();
acl = _ossClient.GetObjectAcl(_bucketName, _keyName);
Assert.AreEqual(acl.ACL, CannedAccessControlList.PublicReadWrite);
// private
_ossClient.SetObjectAcl(_bucketName, _keyName, CannedAccessControlList.Private);
OssTestUtils.WaitForCacheExpire();
acl = _ossClient.GetObjectAcl(_bucketName, _keyName);
Assert.AreEqual(acl.ACL, CannedAccessControlList.Private);
}
finally
{
_ossClient.DeleteObject(_bucketName, _keyName);
}
}
public static void CleanBucket(IOss oss, string bucketName)
{
if (!BucketExists(oss, bucketName))
{
return;
}
//abort in progress multipart uploading
var multipartListing = oss.ListMultipartUploads(new ListMultipartUploadsRequest(bucketName));
foreach (var upload in multipartListing.MultipartUploads)
{
var abortRequest = new AbortMultipartUploadRequest(bucketName, upload.Key, upload.UploadId);
oss.AbortMultipartUpload(abortRequest);
}
// Clean up objects
var objects = oss.ListObjects(bucketName);
foreach (var obj in objects.ObjectSummaries)
{
oss.DeleteObject(bucketName, obj.Key);
}
// Delete the bucket.
oss.DeleteBucket(bucketName);
}
public void ProxyAuthTest()
{
var key = OssTestUtils.GetObjectKey(_className);
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
try {
//put object
_ossClient.PutObject(_bucketName, key, Config.UploadTestFile);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, key));
//get object
OssTestUtils.DownloadObject(_ossClient, _bucketName, key, targetFile);
var expectedETag = _ossClient.GetObjectMetadata(_bucketName, key).ETag;
var downloadedFileETag = FileUtils.ComputeContentMd5(targetFile);
Assert.AreEqual(expectedETag.ToLowerInvariant(), downloadedFileETag.ToLowerInvariant());
//list object
var allObjects = _ossClient.ListObjects(_bucketName, key);
var allObjectsSumm = OssTestUtils.ToArray <OssObjectSummary>(allObjects.ObjectSummaries);
Assert.AreEqual(1, allObjectsSumm.Count);
}
catch (Exception e)
{
Assert.IsTrue(false, e.Message);
}
finally
{
_ossClient.DeleteObject(_bucketName, key);
try
{
FileUtils.DeleteFile(targetFile);
}
catch (Exception e)
{
LogUtility.LogWarning("Delete file {0} failed with Exception {1}", targetFile, e.Message);
}
}
}
private static void PutAndGetObject(IOss ossClient, string originalFile, int i)
{
//prepare the object key
var key = OssTestUtils.GetObjectKey(_className);
key = string.Format("{0}_{1}", key, i);
//prepare the file for download (GET)
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = string.Format("{0}_{1}", targetFile, i);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
try
{
LogUtility.LogMessage("Thread {0}--Begin to put object", i);
var sWatch = new Stopwatch();
sWatch.Start();
OssTestUtils.UploadObject(ossClient, _bucketName, key, originalFile);
sWatch.Stop();
var duration = sWatch.Elapsed;
LogUtility.LogMessage("Thread {0}--Put Duration is {1:00}:{2:00}:{3:00}",
i, duration.Hours, duration.Minutes, duration.Seconds);
LogUtility.LogMessage("Finish to put object");
Assert.IsTrue(OssTestUtils.ObjectExists(ossClient, _bucketName, key));
LogUtility.LogMessage("Thread {0}--Begin to get object", i);
sWatch = new Stopwatch();
sWatch.Start();
OssTestUtils.DownloadObject(ossClient, _bucketName, key, targetFile);
sWatch.Stop();
duration = sWatch.Elapsed;
LogUtility.LogMessage("Thread {0}--Get Duration is {1:00}:{2:00}:{3:00}",
i, duration.Hours, duration.Minutes, duration.Seconds);
LogUtility.LogMessage("Thread {0}--Finish to get object", i);
}
finally
{
FileUtils.DeleteFile(originalFile);
FileUtils.DeleteFile(targetFile);
if (OssTestUtils.ObjectExists(ossClient, _bucketName, key))
{
ossClient.DeleteObject(_bucketName, key);
}
}
}
public static void CleanBucket(IOss oss, string bucketName)
{
if (!BucketExists(oss, bucketName))
return;
//abort in progress multipart uploading
var multipartListing = oss.ListMultipartUploads(new ListMultipartUploadsRequest(bucketName));
foreach (var upload in multipartListing.MultipartUploads)
{
var abortRequest = new AbortMultipartUploadRequest(bucketName, upload.Key, upload.UploadId);
oss.AbortMultipartUpload(abortRequest);
}
// Clean up objects
var objects = oss.ListObjects(bucketName);
foreach(var obj in objects.ObjectSummaries)
{
oss.DeleteObject(bucketName, obj.Key);
}
// Delete the bucket.
oss.DeleteBucket(bucketName);
}
public void DeleteObjectWithHiddenCharacters()
{
char[] buffer = new char[2];
buffer[0] = Convert.ToChar(0x1c);
buffer[1] = Convert.ToChar(0x1a);
var newKey = _keyName + (new string(buffer)) + ".1.cd";
try
{
_ossClient.PutObject(_bucketName, newKey, Config.UploadTestFile);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, newKey));
_ossClient.DeleteObject(_bucketName, newKey);
Assert.IsFalse(OssTestUtils.ObjectExists(_ossClient, _bucketName, newKey));
}
finally
{
_ossClient.DeleteObject(_bucketName, newKey);
}
}
public void UploadObjectBasicSettingsTest()
{
var key = OssTestUtils.GetObjectKey(_className);
try
{
//upload the object
OssTestUtils.UploadObject(_ossClient, _bucketName, key,
Config.UploadSampleFile, new ObjectMetadata());
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, key));
}
finally
{
if (OssTestUtils.ObjectExists(_ossClient, _bucketName, key))
{
_ossClient.DeleteObject(_bucketName, key);
}
}
}
public void CompleteMultipartUploadWithListParts()
{
var sourceFile = Config.MultiUploadTestFile;
//get target object name
var targetObjectKey = OssTestUtils.GetObjectKey(_className);
var initRequest = new InitiateMultipartUploadRequest(_bucketName, targetObjectKey);
var initResult = _ossClient.InitiateMultipartUpload(initRequest);
// Set the part size
const int partSize = 1024 * 1024 * 1;
var partFile = new FileInfo(sourceFile);
// Calculate the part count
var partCount = OssTestUtils.CalculatePartCount(partFile.Length, partSize);
LogUtility.LogMessage("File {0} is splitted to {1} parts for multipart upload",
sourceFile, partCount);
//upload the file
using (var fs = new FileStream(partFile.FullName, FileMode.Open))
{
for (var i = 0; i < partCount; i++)
{
// Skip to the start position
long skipBytes = partSize * i;
fs.Position = skipBytes;
// calculate the part size
var size = partSize < partFile.Length - skipBytes
? partSize
: partFile.Length - skipBytes;
// Create a UploadPartRequest, uploading parts
var uploadPartRequest = new UploadPartRequest(_bucketName, targetObjectKey, initResult.UploadId)
{
InputStream = fs,
PartSize = size,
PartNumber = (i + 1)
};
_ossClient.UploadPart(uploadPartRequest);
}
}
var lmuRequest = new ListMultipartUploadsRequest(_bucketName);
var lmuListing = _ossClient.ListMultipartUploads(lmuRequest);
string mpUpload = null;
foreach (var t in lmuListing.MultipartUploads)
{
if (t.UploadId == initResult.UploadId)
{
mpUpload = t.UploadId;
}
}
Assert.IsNotNull(mpUpload, "The multipart uploading should be in progress");
PartListing partList = _ossClient.ListParts(new ListPartsRequest(_bucketName, targetObjectKey, mpUpload));
var completeRequest = new CompleteMultipartUploadRequest(_bucketName, targetObjectKey, initResult.UploadId);
foreach (var part in partList.Parts)
{
completeRequest.PartETags.Add(part.PartETag);
}
_ossClient.CompleteMultipartUpload(completeRequest);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, targetObjectKey));
//delete the object
_ossClient.DeleteObject(_bucketName, targetObjectKey);
}
public void PutObjectCallbackTest()
{
string callbackHeaderBuilder = new CallbackHeaderBuilder(_callbackUrl, _callbackBody).Build();
var metadata = new ObjectMetadata();
metadata.AddHeader(HttpHeaders.Callback, callbackHeaderBuilder);
var putObjectResult = _ossClient.PutObject(_bucketName, _objectKey, Config.UploadTestFile, metadata);
Assert.IsTrue(putObjectResult.IsSetResponseStream());
Assert.AreEqual(_callbackOkResponse, GetCallbackResponse(putObjectResult));
Assert.AreEqual(putObjectResult.HttpStatusCode, HttpStatusCode.OK);
Assert.AreEqual(putObjectResult.ContentLength, _callbackOkResponse.Length);
Assert.AreEqual(putObjectResult.RequestId.Length, "58DB0ACB686D42D5B4163D75".Length);
Assert.AreEqual(putObjectResult.ResponseMetadata[HttpHeaders.ContentType], "application/json");
Assert.AreEqual(putObjectResult.ResponseMetadata[HttpHeaders.ETag], putObjectResult.ETag);
Assert.AreEqual(putObjectResult.ResponseMetadata[HttpHeaders.ContentMd5].Length, "7GoU4OYaYroKXsbsG1f/lw==".Length);
Assert.IsTrue(putObjectResult.ResponseMetadata[HttpHeaders.HashCrc64Ecma].Length > 0);
Assert.IsTrue(putObjectResult.ResponseMetadata[HttpHeaders.ServerElapsedTime].Length > 0);
Assert.AreEqual(putObjectResult.ResponseMetadata[HttpHeaders.Date].Length, "Wed, 29 Mar 2017 01:15:58 GMT".Length);
_ossClient.DeleteObject(_bucketName, _objectKey);
}
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);
}
}
}
private static void PutAndGetObject(IOss ossClient, string originalFile, int i)
{
//prepare the object key
var key = OssTestUtils.GetObjectKey(_className);
key = string.Format("{0}_{1}", key, i);
//prepare the file for download (GET)
var targetFile = OssTestUtils.GetTargetFileName(_className);
targetFile = string.Format("{0}_{1}", targetFile, i);
targetFile = Path.Combine(Config.DownloadFolder, targetFile);
try
{
LogUtility.LogMessage("Thread {0}--Begin to put object", i);
var sWatch = new Stopwatch();
sWatch.Start();
OssTestUtils.UploadObject(ossClient, _bucketName, key, originalFile);
sWatch.Stop();
var duration = sWatch.Elapsed;
LogUtility.LogMessage("Thread {0}--Put Duration is {1:00}:{2:00}:{3:00}",
i, duration.Hours, duration.Minutes, duration.Seconds);
LogUtility.LogMessage("Finish to put object");
Assert.IsTrue(OssTestUtils.ObjectExists(ossClient, _bucketName, key));
LogUtility.LogMessage("Thread {0}--Begin to get object", i);
sWatch = new Stopwatch();
sWatch.Start();
OssTestUtils.DownloadObject(ossClient, _bucketName, key, targetFile);
sWatch.Stop();
duration = sWatch.Elapsed;
LogUtility.LogMessage("Thread {0}--Get Duration is {1:00}:{2:00}:{3:00}",
i, duration.Hours, duration.Minutes, duration.Seconds);
LogUtility.LogMessage("Thread {0}--Finish to get object", i);
}
finally
{
FileUtils.DeleteFile(originalFile);
FileUtils.DeleteFile(targetFile);
if (OssTestUtils.ObjectExists(ossClient, _bucketName, key))
{
ossClient.DeleteObject(_bucketName, key);
}
}
}
public void ResumableUploadObjectTest()
{
var key = OssTestUtils.GetObjectKey(_className);
try
{
var result = _ossClient.ResumableUploadObject(_bucketName, key, Config.MultiUploadTestFile, null,
Config.DownloadFolder);
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 MultipartUploadComplexStepTest()
{
var sourceFile = Config.MultiUploadTestFile;
//get target object name
var targetObjectKey = OssTestUtils.GetObjectKey(_className);
var initRequest = new InitiateMultipartUploadRequest(_bucketName, targetObjectKey);
var initResult = _ossClient.InitiateMultipartUpload(initRequest);
// 设置每块为 1M
const int partSize = 1024 * 1024 * 1;
var partFile = new FileInfo(sourceFile);
// 计算分块数目
var partCount = OssTestUtils.CalculatePartCount(partFile.Length, partSize);
LogUtility.LogMessage("File {0} is splitted to {1} parts for multipart upload",
sourceFile, partCount);
// 新建一个List保存每个分块上传后的ETag和PartNumber
var partETags = new List <PartETag>();
//upload the file
using (var fs = new FileStream(partFile.FullName, FileMode.Open))
{
for (var i = 0; i < partCount; i++)
{
// 跳到每个分块的开头
long skipBytes = partSize * i;
fs.Position = skipBytes;
// 计算每个分块的大小
var size = partSize < partFile.Length - skipBytes
? partSize
: partFile.Length - skipBytes;
// 创建UploadPartRequest，上传分块
var uploadPartRequest = new UploadPartRequest(_bucketName, targetObjectKey, initResult.UploadId)
{
InputStream = fs,
PartSize = size,
PartNumber = (i + 1)
};
var uploadPartResult = _ossClient.UploadPart(uploadPartRequest);
// 将返回的PartETag保存到List中。
partETags.Add(uploadPartResult.PartETag);
}
}
var lmuRequest = new ListMultipartUploadsRequest(_bucketName);
var lmuListing = _ossClient.ListMultipartUploads(lmuRequest);
string mpUpload = null;
foreach (var t in lmuListing.MultipartUploads)
{
if (t.UploadId == initResult.UploadId)
{
mpUpload = t.UploadId;
}
}
Assert.IsNotNull(mpUpload, "The multipart uploading should be in progress");
var completeRequest = new CompleteMultipartUploadRequest(_bucketName, targetObjectKey, initResult.UploadId);
foreach (var partETag in partETags)
{
completeRequest.PartETags.Add(partETag);
}
_ossClient.CompleteMultipartUpload(completeRequest);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, targetObjectKey));
//delete the object
_ossClient.DeleteObject(_bucketName, targetObjectKey);
}
public void CSVSelectObjectNormalTest()
{
const string key = "SqlObjectWithCsvData";
try
{
byte[] binaryData = Encoding.ASCII.GetBytes(_sqlMessage);
var stream = new MemoryStream(binaryData);
_ossClient.PutObject(_bucketName, key, stream);
var request = new SelectObjectRequest(_bucketName, key);
request.Expression = "select * from ossobject";
var inputFormat = new SelectObjectCSVInputFormat();
inputFormat.FileHeaderInfo = FileHeaderInfo.Use;
inputFormat.RecordDelimiter = "\r\n";
inputFormat.FieldDelimiter = ",";
inputFormat.QuoteCharacter = "\"";
inputFormat.CommentCharacter = "#";
inputFormat.CompressionType = CompressionType.None;
request.InputFormat = inputFormat;
var outputFormat = new SelectObjectCSVOutputFormat();
outputFormat.EnablePayloadCrc = true;
outputFormat.OutputRawData = false;
outputFormat.KeepAllColumns = false;
outputFormat.OutputHeader = false;
outputFormat.FieldDelimiter = ",";
outputFormat.RecordDelimiter = "\n";
request.OutputFormat = outputFormat;
var result = _ossClient.SelectObject(request);
string expect = "Lora Francis,School A,Staples Inc,27\n" +
"Eleanor Little,School B,\"Conectiv, Inc\",43\n" +
"Rosie Hughes,School C,Western Gas Resources Inc,44\n" +
"Lawrence Ross,School D,MetLife Inc.,24\n";
var buf = new byte[256];
int offset = 0;
for (int i = 1; i < 30; i++)
{
int got = result.Content.Read(buf, offset, i);
offset += got;
}
Assert.AreEqual(expect.Length, offset);
string str = Encoding.Default.GetString(buf, 0, offset);
Assert.AreEqual(expect, str);
}
finally
{
_ossClient.DeleteObject(_bucketName, key);
}
}
public void ObjectBasicTest()
{
//Get Case
var key = OssTestUtils.GetObjectKey(_className);
_ossClient.PutObject(_bucketName, key, new MemoryStream(Encoding.ASCII.GetBytes("hello world")));
var getRequest = new GetObjectRequest(_bucketName, key);
Assert.AreEqual(getRequest.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.GetObject(getRequest);
Assert.Fail("should not here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
getRequest.RequestPayer = RequestPayer.Requester;
var getResult = _ossPayerClient.GetObject(getRequest);
Assert.AreEqual(getResult.ContentLength, 11);
_ossClient.DeleteObject(_bucketName, key);
//Put Case
key = OssTestUtils.GetObjectKey(_className);
var content = new MemoryStream(Encoding.ASCII.GetBytes("hello world"));
var putRequest = new PutObjectRequest(_bucketName, key, content);
Assert.AreEqual(putRequest.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.PutObject(putRequest);
Assert.Fail("should not here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
content = new MemoryStream(Encoding.ASCII.GetBytes("hello world"));
putRequest = new PutObjectRequest(_bucketName, key, content);
putRequest.RequestPayer = RequestPayer.Requester;
var putResult = _ossPayerClient.PutObject(putRequest);
Assert.AreEqual(putResult.HttpStatusCode, HttpStatusCode.OK);
//head object
var headRequest = new GetObjectMetadataRequest(_bucketName, key);
Assert.AreEqual(headRequest.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.GetObjectMetadata(headRequest);
Assert.Fail("should not here.");
}
catch (Exception e)
{
Assert.IsTrue(true, e.Message);
}
headRequest.RequestPayer = RequestPayer.Requester;
var headResult = _ossPayerClient.GetObjectMetadata(headRequest);
Assert.AreEqual(headResult.ContentLength, 11);
//Delete Case
Assert.IsTrue(_ossClient.DoesObjectExist(_bucketName, key));
var delReqeust = new DeleteObjectRequest(_bucketName, key);
Assert.AreEqual(delReqeust.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.DeleteObject(delReqeust);
Assert.Fail("should not here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
delReqeust = new DeleteObjectRequest(_bucketName, key);
delReqeust.RequestPayer = RequestPayer.Requester;
_ossPayerClient.DeleteObject(delReqeust);
Assert.IsFalse(_ossClient.DoesObjectExist(_bucketName, key));
//delete objects
var keys = new List <string>();
keys.Add(key);
var delsReqeust = new DeleteObjectsRequest(_bucketName, keys);
Assert.AreEqual(delsReqeust.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.DeleteObjects(delsReqeust);
Assert.Fail("should not here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
delsReqeust.RequestPayer = RequestPayer.Requester;
_ossPayerClient.DeleteObjects(delsReqeust);
//delete object versions
var objects = new List <ObjectIdentifier>();
objects.Add(new ObjectIdentifier(key));
var delvsReqeust = new DeleteObjectVersionsRequest(_bucketName, objects);
Assert.AreEqual(delvsReqeust.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.DeleteObjectVersions(delvsReqeust);
Assert.Fail("should not here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
delvsReqeust.RequestPayer = RequestPayer.Requester;
_ossPayerClient.DeleteObjectVersions(delvsReqeust);
//list objets
var lsRequest = new ListObjectsRequest(_bucketName);
Assert.AreEqual(lsRequest.RequestPayer, RequestPayer.BucketOwner);
try
{
_ossPayerClient.ListObjects(lsRequest);
Assert.Fail("should not here.");
}
catch (OssException e)
{
Assert.AreEqual(e.ErrorCode, "AccessDenied");
}
lsRequest.RequestPayer = RequestPayer.Requester;
_ossPayerClient.ListObjects(lsRequest);
}
private void MultipartUploadComplexStepTest(IOss ossClient, bool overrideCrc = false)
{
var sourceFile = Config.MultiUploadTestFile;
//get target object name
var targetObjectKey = OssTestUtils.GetObjectKey(_className);
var initRequest = new InitiateMultipartUploadRequest(_bucketName, targetObjectKey);
var initResult = ossClient.InitiateMultipartUpload(initRequest);
// Set the part size
const int partSize = 1024 * 1024 * 1;
var partFile = new FileInfo(sourceFile);
// Calculate the part count
var partCount = OssTestUtils.CalculatePartCount(partFile.Length, partSize);
LogUtility.LogMessage("File {0} is splitted to {1} parts for multipart upload",
sourceFile, partCount);
// Create a list to save result
var partETags = new List <PartETag>();
//upload the file
using (var fs = new FileStream(partFile.FullName, FileMode.Open))
{
for (var i = 0; i < partCount; i++)
{
// Skip to the start position
long skipBytes = partSize * i;
fs.Position = skipBytes;
// calculate the part size
var size = partSize < partFile.Length - skipBytes
? partSize
: partFile.Length - skipBytes;
// Create a UploadPartRequest, uploading parts
var uploadPartRequest = new UploadPartRequest(_bucketName, targetObjectKey, initResult.UploadId)
{
InputStream = fs,
PartSize = size,
PartNumber = (i + 1)
};
var uploadPartResult = ossClient.UploadPart(uploadPartRequest);
// Save the result
partETags.Add(uploadPartResult.PartETag);
Assert.AreNotEqual(uploadPartResult.Crc64, 0);
Assert.AreNotEqual(uploadPartResult.Length, 0);
}
}
var lmuRequest = new ListMultipartUploadsRequest(_bucketName);
var lmuListing = ossClient.ListMultipartUploads(lmuRequest);
string mpUpload = null;
string mpUploadInfo = null;
foreach (var t in lmuListing.MultipartUploads)
{
if (t.UploadId == initResult.UploadId)
{
mpUpload = t.UploadId;
mpUploadInfo = t.ToString();
}
}
Assert.IsNotNull(mpUpload, "The multipart uploading should be in progress");
Assert.IsTrue(mpUploadInfo.Contains(mpUpload));
var completeRequest = new CompleteMultipartUploadRequest(_bucketName, targetObjectKey, initResult.UploadId);
foreach (var partETag in partETags)
{
if (overrideCrc)
{
partETag.Crc64 = "0";
}
completeRequest.PartETags.Add(partETag);
}
ossClient.CompleteMultipartUpload(completeRequest);
Assert.IsTrue(OssTestUtils.ObjectExists(_ossClient, _bucketName, targetObjectKey));
//delete the object
ossClient.DeleteObject(_bucketName, targetObjectKey);
}
