public void GenerateUriWithProcessTest()
{
try
{
// put example image
_ossClient.PutObject(_bucketName, _keyName, _localImageFile);
// generate uri
var req = new GeneratePresignedUriRequest(_bucketName, _keyName, SignHttpMethod.Get)
{
Expiration = DateTime.Now.AddHours(1),
Process = _process
};
var uri = _ossClient.GeneratePresignedUri(req);
// get processed image
OssObject ossObject = _ossClient.GetObject(uri);
// 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 GeneratePresignedUriCallbackTest()
{
string callbackHeaderBuilder = new CallbackHeaderBuilder(_callbackUrl, _callbackBody).Build();
string CallbackVariableHeaderBuilder = new CallbackVariableHeaderBuilder().
AddCallbackVariable("x:var1", "x:value1").AddCallbackVariable("x:var2", "x:value2").Build();
var gpuRequest = new GeneratePresignedUriRequest(_bucketName, _objectKey, SignHttpMethod.Put)
{
ContentType = "text/rtf",
Expiration = DateTime.Now.AddHours(1),
Callback = callbackHeaderBuilder,
CallbackVar = CallbackVariableHeaderBuilder
};
gpuRequest.UserMetadata.Add("Author", "Mingdi");
var uri = _ossClient.GeneratePresignedUri(gpuRequest);
var metadata = new ObjectMetadata();
metadata.ContentType = "text/rtf";
metadata.UserMetadata.Add("Author", "Mingdi");
metadata.AddHeader(HttpHeaders.Callback, callbackHeaderBuilder);
metadata.AddHeader(HttpHeaders.CallbackVar, CallbackVariableHeaderBuilder);
var putObjectResult = _ossClient.PutObject(uri, 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 SignedUrlTest()
{
var key = OssTestUtils.GetObjectKey(_className);
var content = new MemoryStream(Encoding.ASCII.GetBytes(_data_200KB));
_ossClient.PutObject(new PutObjectRequest(_bucketName, key, content));
var request = new GeneratePresignedUriRequest(_bucketName, key, SignHttpMethod.Get);
request.AddQueryParam("x-oss-traffic-limit", "819200");
var uri = _ossClient.GeneratePresignedUri(request);
Assert.AreNotEqual(uri.ToString().IndexOf("x-oss-traffic-limit=819200"), -1);
var result = _ossClient.GetObject(uri);
Assert.AreEqual(result.ResponseMetadata.ContainsKey(HttpHeaders.QosDelayTime), true);
}
public void GetPreSignedUriDefaultPositiveTest()
{
HttpWebRequest req = null;
HttpWebResponse res = null;
var now = DateTime.Now;
//set expiration time to 5 seconds later
var expireDate = now.AddSeconds(5);
var uri = _ossClient.GeneratePresignedUri(_bucketName, _objectKey, expireDate);
try
{
req = WebRequest.Create(uri) as HttpWebRequest;
req.Method = "GET";
res = req.GetResponse() as HttpWebResponse;
Assert.AreEqual(HttpStatusCode.OK, res.StatusCode, "response status code is not expected.");
using (var stream = res.GetResponseStream())
{
var actualETag = FileUtils.ComputeContentMd5(stream);
Assert.AreEqual(_objectETag.ToLowerInvariant(), actualETag.ToLowerInvariant());
}
}
catch (WebException)
{
//TODO:
}
finally
{
if (req != null)
{
req.Abort();
}
if (res != null)
{
res.Close();
}
}
}
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 static Task <Uri> GeneratePresignedUriAsync(this IOss client, string bucketName, string key, DateTime expiration, SignHttpMethod method)
{
return(Task.Factory.StartNew(() => client.GeneratePresignedUri(bucketName, key, expiration, method)));
}
public static Task <Uri> GeneratePresignedUriAsync(this IOss client, GeneratePresignedUriRequest generatePresignedUriRequest)
{
return(Task.Factory.StartNew(() => client.GeneratePresignedUri(generatePresignedUriRequest)));
}
public static Task <Uri> GeneratePresignedUriAsync(this IOss client, string bucketName, string key)
{
return(Task.Factory.StartNew(() => client.GeneratePresignedUri(bucketName, key)));
}
