// Establish Credentials with AWS IAM Credentials in Environmental variables
public async static Task Run()
{
AWSEnvironmentProvider provider = new AWSEnvironmentProvider();
MinioClient minioClient = new MinioClient()
.WithEndpoint("s3.amazonaws.com")
.WithSSL()
.WithCredentialsProvider(provider)
.Build();
try
{
StatObjectArgs statObjectArgs = new StatObjectArgs()
.WithBucket("my-bucket-name")
.WithObject("my-object-name");
ObjectStat result = await minioClient.StatObjectAsync(statObjectArgs);
Console.WriteLine("Object Stat: \n" + result.ToString());
}
catch (MinioException me)
{
Console.WriteLine($"[Bucket] IAMAWSProviderExample example case encountered Exception: {me}");
}
catch (Exception e)
{
Console.WriteLine($"[Bucket] IAMAWSProviderExample example case encountered Exception: {e}");
}
}
/// <summary>
///
/// </summary>
/// <param name="_minio"></param>
/// <param name="bucketName"></param>
/// <param name="objectName"></param>
/// <param name="contentType"></param>
/// <param name="fileName"></param>
/// <param name="metaData"></param>
/// <returns></returns>
public async static Task <ObjectStat> PutObject_Tester(MinioClient _minio, string bucketName, string objectName, string contentType, string fileName = null, Dictionary <string, string> metaData = null)
{
int count = 0;
IObservable <Item> observable = _minio.ListObjectsAsync(bucketName, "objectName", true);
IDisposable subscription = observable.Subscribe(
item =>
{
if (item.Key.StartsWith("device3"))
{
count += 1;
Console.WriteLine($"count: {count}");
}
},
ex => Console.WriteLine($"OnError: {ex}"),
() => Console.WriteLine($"Listed all objects in bucket {bucketName}\n"));
ObjectStat statObject = await _minio.StatObjectAsync(bucketName, "device3");
//await _minio.PutObjectAsync(bucketName,objectName,objectName,contentType);
Assert.IsNotNull(statObject);
Assert.AreEqual(statObject.ObjectName, objectName);
//Assert.AreEqual(statObject.Size, file_read_size);
if (contentType != null)
{
Assert.AreEqual(statObject.ContentType, contentType);
}
return(statObject);
}
public async static Task PutObject_Test1(MinioClient _minio, string bucketName, string objectName)
{
ObjectStat statObject = await _minio.StatObjectAsync(bucketName, objectName);
Assert.IsNotNull(statObject);
Assert.AreEqual(statObject.ObjectName, objectName);
}
// Establish Credentials with AWS Session token
public async static Task Run()
{
ChainedProvider provider = new ChainedProvider()
.AddProviders(new ClientProvider[] { new AWSEnvironmentProvider(), new MinioEnvironmentProvider() });
//Chained provider definition here.
MinioClient minioClient = new MinioClient()
.WithEndpoint("s3.amazonaws.com")
.WithSSL()
.WithCredentialsProvider(provider)
.Build();
try
{
StatObjectArgs statObjectArgs = new StatObjectArgs()
.WithBucket("my-bucket-name")
.WithObject("my-object-name");
ObjectStat result = await minioClient.StatObjectAsync(statObjectArgs);
}
catch (MinioException me)
{
Console.WriteLine($"[Bucket] ChainedCredentialProvider example case encountered Exception: {me}");
}
catch (Exception e)
{
Console.WriteLine($"[Bucket] ChainedCredentialProvider example case encountered Exception: {e}");
}
}
public async Task <ItemMeta> GetObjectMetadataAsync(string bucketName
, string objectName
, string versionID = null
, string matchEtag = null
, DateTime?modifiedSince = null)
{
if (string.IsNullOrEmpty(bucketName))
{
throw new ArgumentNullException(nameof(bucketName));
}
objectName = FormatObjectName(objectName);
StatObjectArgs args = new StatObjectArgs()
.WithBucket(bucketName)
.WithObject(objectName)
.WithVersionId(versionID)
.WithMatchETag(matchEtag);
if (modifiedSince.HasValue)
{
args = args.WithModifiedSince(modifiedSince.Value);
}
ObjectStat statObject = await _client.StatObjectAsync(args);
return(new ItemMeta()
{
ObjectName = statObject.ObjectName,
Size = statObject.Size,
LastModified = statObject.LastModified,
ETag = statObject.ETag,
ContentType = statObject.ContentType,
IsEnableHttps = Options.IsEnableHttps,
MetaData = statObject.MetaData
});
}
// Get stats on a object
public async static Task Run(MinioClient minio,
string bucketName = "my-bucket-name",
string bucketObject = "my-object-name",
string versionID = null,
string matchEtag = null,
DateTime modifiedSince = default(DateTime))
{
try
{
Console.WriteLine("Running example for API: StatObjectAsync [with ObjectQuery]");
StatObjectArgs args = new StatObjectArgs()
.WithBucket(bucketName)
.WithObject(bucketObject)
.WithVersionId(versionID)
.WithMatchETag(matchEtag)
.WithModifiedSince(modifiedSince);
ObjectStat statObjectVersion = await minio.StatObjectAsync(args);
PrintStat(bucketObject, statObjectVersion);
}
catch (MinioException me)
{
string objectNameInfo = $"{bucketName}-{bucketObject}";
if (!string.IsNullOrEmpty(versionID))
{
objectNameInfo = objectNameInfo + $" (Version ID) {me.Response.VersionId} (Marked DEL) {me.Response.DeleteMarker}";
}
Console.WriteLine($"[StatObject] {objectNameInfo} Exception: {me}");
}
catch (Exception e)
{
Console.WriteLine($"[StatObject] Exception: {e}");
}
}
private async static Task PresignedPutObject_Test1(MinioClient minio)
{
Console.Out.WriteLine("Test1: PresignedPutObjectAsync");
string bucketName = GetRandomName(15);
string objectName = GetRandomName(10);
string fileName = CreateFile(1 * MB);
await Setup_Test(minio, bucketName);
// Upload with presigned url
string presigned_url = await minio.PresignedPutObjectAsync(bucketName, objectName, 1000);
await UploadObjectAsync(presigned_url, fileName);
// Get stats for object from server
ObjectStat stats = await minio.StatObjectAsync(bucketName, objectName);
// Compare with file used for upload
FileInfo writtenInfo = new FileInfo(fileName);
long file_written_size = writtenInfo.Length;
Assert.AreEqual(file_written_size, stats.Size);
await minio.RemoveObjectAsync(bucketName, objectName);
await TearDown(minio, bucketName);
File.Delete(fileName);
Console.Out.WriteLine("Test1: PresignedPutObjectAsync Complete");
}
internal StatObjectResponse(HttpStatusCode statusCode, string responseContent,
Dictionary <string, string> responseHeaders, StatObjectArgs args)
: base(statusCode, responseContent)
{
// StatObjectResponse object is populated with available stats from the response.
ObjectInfo = ObjectStat.FromResponseHeaders(args.ObjectName, responseHeaders);
}
public async Task <IStorageObject> GetObject(string bucketName, string objectName, CancellationToken token = default)
{
ObjectStat stats = await StatObject(bucketName, objectName, token);
if (stats is null)
{
return(null);
}
var stream = new MemoryStream();
await _client.GetObjectAsync(bucketName, objectName, input =>
{
input.CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
input.Dispose();
}, cancellationToken : token);
return(new StorageObject
{
ContentType = stats.ContentType,
Data = stream,
Metadata = StripPrefixes(stats.MetaData),
Name = stats.ObjectName,
Size = stats.Size,
LastModified = stats.LastModified
});
}
/// <summary>
/// private helper method to remove list of objects from bucket
/// </summary>
/// <param name="args">GetObjectArgs Arguments Object encapsulates information like - bucket name, object name etc </param>
/// <param name="objectStat">
/// ObjectStat object encapsulates information like - object name, size, etag etc, represents
/// Object Information
/// </param>
/// <param name="cb"> Action object of type Stream, callback to send Object contents, if assigned </param>
/// <param name="cancellationToken">Optional cancellation token to cancel the operation</param>
private async Task getObjectStreamAsync(GetObjectArgs args, ObjectStat objectStat, Action <Stream> cb,
CancellationToken cancellationToken = default)
{
var requestMessageBuilder = await CreateRequest(args).ConfigureAwait(false);
using var response = await ExecuteTaskAsync(NoErrorHandlers, requestMessageBuilder, cancellationToken)
.ConfigureAwait(false);
}
public MinioObjectStatModel(ObjectStat ojectStat)
{
ObjectName = ojectStat.ObjectName;
Size = ojectStat.Size;
LastModified = ojectStat.LastModified;
ETag = ojectStat.ETag;
ContentType = ojectStat.ContentType;
MetaData = ojectStat.MetaData;
}
private async static Task PutObject_Tester(MinioClient minio, string bucketName, string objectName, string fileName = null, string contentType = "application/octet-stream", long size = 0)
{
try
{
byte[] bs = File.ReadAllBytes(fileName);
System.IO.MemoryStream filestream = new System.IO.MemoryStream(bs);
long file_write_size = filestream.Length;
long file_read_size = 0;
string tempFileName = "tempfiletosavestream";
if (size == 0)
{
size = filestream.Length;
}
if (filestream.Length < (5 * MB))
{
Console.Out.WriteLine("Test1: PutobjectAsync: PutObjectAsync with Stream");
}
else
{
Console.Out.WriteLine("Test1: PutobjectAsync: PutObjectAsync with Stream and MultiPartUpload");
}
await minio.PutObjectAsync(bucketName,
objectName,
filestream,
size,
contentType);
await minio.GetObjectAsync(bucketName, objectName,
(stream) =>
{
var fileStream = File.Create(tempFileName);
stream.CopyTo(fileStream);
fileStream.Dispose();
FileInfo writtenInfo = new FileInfo(tempFileName);
file_read_size = writtenInfo.Length;
Assert.AreEqual(file_read_size, file_write_size);
File.Delete(tempFileName);
});
ObjectStat statObject = await minio.StatObjectAsync(bucketName, objectName);
Assert.IsNotNull(statObject);
Assert.AreEqual(statObject.ObjectName, objectName);
Assert.AreEqual(statObject.Size, file_read_size);
Assert.AreEqual(statObject.ContentType, contentType);
await minio.RemoveObjectAsync(bucketName, objectName);
}
catch (Exception e)
{
Console.WriteLine("[Bucket] Exception: {0}", e);
Assert.Fail();
}
}
public static void PrintStat(string bucketObject, ObjectStat statObject)
{
var currentColor = Console.ForegroundColor;
Console.WriteLine($"Details of the object {bucketObject} are");
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.WriteLine($"{statObject}");
Console.ForegroundColor = currentColor;
Console.WriteLine();
}
public ObjectInfo(ObjectStat stat)
{
ObjectName = stat.ObjectName;
Size = stat.Size;
LastModified = stat.LastModified;
ETag = stat.ETag;
ContentType = stat.ContentType;
MetaData = stat.MetaData;
// Not existent values.
Expires = DateTime.MaxValue;
}
private async static Task CopyObject_Test3(MinioClient minio)
{
Console.Out.WriteLine("Test3: CopyObjectsAsync");
// Test CopyConditions where matching ETag is found
string bucketName = GetRandomName(15);
string objectName = GetRandomName(10);
string destBucketName = GetRandomName(15);
string destObjectName = GetRandomName(10);
string fileName = CreateFile(1 * MB);
await Setup_Test(minio, bucketName);
await Setup_Test(minio, destBucketName);
await minio.PutObjectAsync(bucketName,
objectName,
fileName);
ObjectStat stats = await minio.StatObjectAsync(bucketName, objectName);
CopyConditions conditions = new CopyConditions();
conditions.SetMatchETag(stats.ETag);
try
{
await minio.CopyObjectAsync(bucketName, objectName, destBucketName, destObjectName, conditions);
}
catch (MinioException)
{
Assert.Fail();
}
string outFileName = "outFileName";
ObjectStat dstats = await minio.StatObjectAsync(destBucketName, destObjectName);
Assert.IsNotNull(dstats);
Assert.AreEqual(dstats.ETag, stats.ETag);
Assert.AreEqual(dstats.ObjectName, destObjectName);
await minio.GetObjectAsync(destBucketName, destObjectName, outFileName);
File.Delete(outFileName);
await minio.RemoveObjectAsync(bucketName, objectName);
await minio.RemoveObjectAsync(destBucketName, destObjectName);
await TearDown(minio, bucketName);
await TearDown(minio, destBucketName);
File.Delete(fileName);
Console.Out.WriteLine("Test3: CopyObjectsAsync Complete");
}
// Get stats on a object
public async static Task Run(Minio.MinioClient minio,
string bucketName = "my-bucket-name",
string bucketObject="my-object-name")
{
try
{
Console.Out.WriteLine("Running example for API: StatObjectAsync");
ObjectStat statObject = await minio.StatObjectAsync(bucketName, bucketObject);
Console.Out.WriteLine("Details of the object " + bucketObject + " are " + statObject);
Console.Out.WriteLine();
}
catch (Exception e)
{
Console.WriteLine("[StatObject] {0}-{1} Exception: {2}",bucketName, bucketObject, e);
}
}
public void Properties()
{
var stat = new ObjectStat
{
BlockSize = 1,
CumulativeSize = 2,
DataSize = 3,
LinkCount = 4,
LinkSize = 5
};
Assert.AreEqual(1, stat.BlockSize);
Assert.AreEqual(2, stat.CumulativeSize);
Assert.AreEqual(3, stat.DataSize);
Assert.AreEqual(4, stat.LinkCount);
Assert.AreEqual(5, stat.LinkSize);
}
private static async Task Run(MinioClient minio, string userBucketName, string uploadFilePath, string saveFileName)
{
var bucketName = userBucketName; //桶名
var location = "us-east-1"; //地址
var filePath = uploadFilePath; //上传文件路径
//var objectName = "device1/"+"20210107/"+saveFileName;//保存文件名
//var objectName = "device3" + "/" +levelTwo + "/" + saveFileName;
var objectName = "LK500" + "/" + DateTime.Now.ToShortDateString().ToString() + "/" + saveFileName;
var contentType = ContentTypeHelper.GetContentType(saveFileName.Substring(saveFileName.LastIndexOf('.') + 1));
var file = new FileInfo(uploadFilePath);
try
{
var found = await minio.BucketExistsAsync(bucketName);//判断是否存在桶名
if (!found)
{
await minio.MakeBucketAsync(bucketName, location);
}
_minioClient.SetTraceOn(new LogHelper());//我们在上传开始的时候，打开日志，通过日志抛出的块编号来计算出当前进度
ViewModelLocator.FileUploadViewModel.FileSize = file.Length;
ViewModelLocator.FileUploadViewModel.TotalParts = file.Length / App.MinimumPartSize + 1;//计算出文件总块数
//20210109 插入内容，如果不存在二级、三级内容及内容，直接创建并插入，如果存在二级、三级及对应内容则不插入，并返回标识
ObjectStat statObject = await PutObject_Tester(minio, bucketName, objectName, filePath, contentType);
Assert.IsTrue(statObject != null);
Assert.IsTrue(statObject.MetaData != null);
//await minio.PutObjectAsync(bucketName, objectName, filePath, contentType);//上传文件
//await minio.PutObjectAsync();//上传文件
Debug.WriteLine("Successfully uploaded " + objectName);
}
catch (MinioException e)
{
App.NewNLog.Error($"File Upload Error: {e}");
Debug.WriteLine($"File Upload Error: {e.Message}");
}
finally
{
_minioClient.SetTraceOff();
}
}
// Get stats on a object
public async static Task Run(MinioClient minio,
string bucketName = "my-bucket-name",
string bucketObject = "my-object-name")
{
try
{
Console.WriteLine("Running example for API: StatObjectAsync");
ObjectStat statObject = await minio.StatObjectAsync(bucketName, bucketObject);
Console.WriteLine($"Details of the object {bucketObject} are {statObject}");
Console.WriteLine();
}
catch (Exception e)
{
Console.WriteLine($"[StatObject] {bucketName}-{bucketObject} Exception: {e}");
}
}
private async static Task CopyObject_Test5(MinioClient minio)
{
// Test if multi-part copy upload for large files works as expected.
Console.Out.WriteLine("Test5: CopyObjectsAsync");
string bucketName = GetRandomName(15);
string objectName = GetRandomName(10);
string destBucketName = GetRandomName(15);
string fileName = CreateFile(7 * MB);
await Setup_Test(minio, bucketName);
await Setup_Test(minio, destBucketName);
await minio.PutObjectAsync(bucketName,
objectName,
fileName);
CopyConditions conditions = new CopyConditions();
conditions.SetByteRange(1024, 6291456);
// omit dest object name.
await minio.CopyObjectAsync(bucketName, objectName, destBucketName, copyConditions : conditions);
string outFileName = "outFileName";
await minio.GetObjectAsync(bucketName, objectName, outFileName);
File.Delete(outFileName);
ObjectStat stats = await minio.StatObjectAsync(destBucketName, objectName);
Assert.IsNotNull(stats);
Assert.AreEqual(stats.ObjectName, objectName);
Assert.AreEqual(stats.Size, 6291456 - 1024 + 1);
await minio.RemoveObjectAsync(bucketName, objectName);
await minio.RemoveObjectAsync(destBucketName, objectName);
await TearDown(minio, bucketName);
await TearDown(minio, destBucketName);
File.Delete(fileName);
Console.Out.WriteLine("Test4: CopyObjectsAsync Complete");
}
private async static Task StatObject_Test1(MinioClient minio)
{
Console.Out.WriteLine("Test1: StatObjectAsync");
string bucketName = GetRandomName(15);
string objectName = GetRandomName(10);
string fileName = CreateFile(1 * MB);
string contentType = "gzip";
await Setup_Test(minio, bucketName);
try
{
byte[] bs = File.ReadAllBytes(fileName);
System.IO.MemoryStream filestream = new System.IO.MemoryStream(bs);
long file_write_size = filestream.Length;
await minio.PutObjectAsync(bucketName,
objectName,
filestream,
filestream.Length,
contentType);
ObjectStat statObject = await minio.StatObjectAsync(bucketName, objectName);
Assert.IsNotNull(statObject);
Assert.AreEqual(statObject.ObjectName, objectName);
Assert.AreEqual(statObject.Size, file_write_size);
Assert.AreEqual(statObject.ContentType, contentType);
await minio.RemoveObjectAsync(bucketName, objectName);
}
catch (Exception e)
{
Console.WriteLine("[Bucket] Exception: {0}", e);
Assert.Fail();
}
await TearDown(minio, bucketName);
File.Delete(fileName);
Console.Out.WriteLine("Test1: StatObjectAsync Complete");
}
private async static Task CopyObject_Test4(MinioClient minio)
{
// Test if objectName is defaulted to source objectName
Console.Out.WriteLine("Test4: CopyObjectsAsync");
string bucketName = GetRandomName(15);
string objectName = GetRandomName(10);
string destBucketName = GetRandomName(15);
string fileName = CreateFile(1 * MB);
await Setup_Test(minio, bucketName);
await Setup_Test(minio, destBucketName);
await minio.PutObjectAsync(bucketName,
objectName,
fileName);
CopyConditions conditions = new CopyConditions();
conditions.SetMatchETag("TestETag");
// omit dest bucket name.
await minio.CopyObjectAsync(bucketName, objectName, destBucketName);
string outFileName = "outFileName";
await minio.GetObjectAsync(bucketName, objectName, outFileName);
File.Delete(outFileName);
ObjectStat stats = await minio.StatObjectAsync(destBucketName, objectName);
Assert.IsNotNull(stats);
Assert.AreEqual(stats.ObjectName, objectName);
await minio.RemoveObjectAsync(bucketName, objectName);
await minio.RemoveObjectAsync(destBucketName, objectName);
await TearDown(minio, bucketName);
await TearDown(minio, destBucketName);
File.Delete(fileName);
Console.Out.WriteLine("Test4: CopyObjectsAsync Complete");
}
/// <summary>
/// private helper method return the specified object from the bucket
/// </summary>
/// <param name="args">GetObjectArgs Arguments Object encapsulates information like - bucket name, object name etc </param>
/// <param name="objectStat"> ObjectStat object encapsulates information like - object name, size, etag etc </param>
/// <param name="cancellationToken">Optional cancellation token to cancel the operation</param>
private Task getObjectFileAsync(GetObjectArgs args, ObjectStat objectStat,
CancellationToken cancellationToken = default)
{
var length = objectStat.Size;
var etag = objectStat.ETag;
long tempFileSize = 0;
var tempFileName = $"{args.FileName}.{etag}.part.minio";
if (!string.IsNullOrEmpty(args.VersionId))
{
tempFileName = $"{args.FileName}.{etag}.{args.VersionId}.part.minio";
}
if (File.Exists(args.FileName))
{
File.Delete(args.FileName);
}
utils.ValidateFile(tempFileName);
if (File.Exists(tempFileName))
{
File.Delete(tempFileName);
}
args = args.WithCallbackStream(stream =>
{
var fileStream = File.Create(tempFileName);
stream.CopyTo(fileStream);
fileStream.Dispose();
var writtenInfo = new FileInfo(tempFileName);
var writtenSize = writtenInfo.Length;
if (writtenSize != length - tempFileSize)
{
throw new IOException(tempFileName +
": Unexpected data written. Expected = "
+ (length - tempFileSize)
+ ", written = " + writtenSize);
}
utils.MoveWithReplace(tempFileName, args.FileName);
});
return(getObjectStreamAsync(args, objectStat, null, cancellationToken));
}
// Get stats on a object
public async static Task Run(MinioClient minio,
string bucketName = "my-bucket-name",
string bucketObject = "my-object-name",
string versionID = null)
{
try
{
Console.WriteLine("Running example for API: StatObjectAsync");
if (string.IsNullOrEmpty(versionID))
{
StatObjectArgs objectStatArgs = new StatObjectArgs()
.WithBucket(bucketName)
.WithObject(bucketObject);
ObjectStat statObject = await minio.StatObjectAsync(objectStatArgs);
PrintStat(bucketObject, statObject);
PrintMetaData(statObject.MetaData);
return;
}
StatObjectArgs args = new StatObjectArgs()
.WithBucket(bucketName)
.WithObject(bucketObject)
.WithVersionId(versionID);
ObjectStat statObjectVersion = await minio.StatObjectAsync(args);
PrintStat(bucketObject, statObjectVersion);
PrintMetaData(statObjectVersion.MetaData);
}
catch (MinioException me)
{
string objectNameInfo = $"{bucketName}-{bucketObject}";
if (!string.IsNullOrEmpty(versionID))
{
objectNameInfo = objectNameInfo + $" (Version ID) {me.Response.VersionId} (Delete Marker) {me.Response.DeleteMarker}";
}
Console.WriteLine($"[StatObject] {objectNameInfo} Exception: {me}");
}
catch (Exception e)
{
Console.WriteLine($"[StatObject] {bucketName}-{bucketObject} Exception: {e}");
}
}
private async static Task PresignedGetObject_Test1(MinioClient minio)
{
Console.Out.WriteLine("Test1: PresignedGetObjectAsync");
string bucketName = GetRandomName(15);
string objectName = GetRandomName(10);
string fileName = CreateFile(1 * MB);
string downloadFile = "downloadFileName";
await Setup_Test(minio, bucketName);
await minio.PutObjectAsync(bucketName,
objectName,
fileName);
ObjectStat stats = await minio.StatObjectAsync(bucketName, objectName);
string presigned_url = await minio.PresignedGetObjectAsync(bucketName, objectName, 1000);
WebRequest httpRequest = WebRequest.Create(presigned_url);
var response = (HttpWebResponse)(await Task <WebResponse> .Factory.FromAsync(httpRequest.BeginGetResponse, httpRequest.EndGetResponse, null));
Stream stream = response.GetResponseStream();
var fileStream = File.Create(downloadFile);
stream.CopyTo(fileStream);
fileStream.Dispose();
FileInfo writtenInfo = new FileInfo(downloadFile);
long file_read_size = writtenInfo.Length;
// Compare size of file downloaded with presigned curl request and actual object size on server
Assert.AreEqual(file_read_size, stats.Size);
await minio.RemoveObjectAsync(bucketName, objectName);
await TearDown(minio, bucketName);
File.Delete(fileName);
File.Delete(downloadFile);
Console.Out.WriteLine("Test1: PresignedGetObjectAsync Complete");
}
public async Task <GetImageStatusResult> GetImageStatusAsync(ImageLocationParam param)
{
try
{
ObjectStat os = await _minio.StatObjectAsync(param.BucketName, param.ImageName);
return(new GetImageStatusResult()
{
ImageName = os.ObjectName,
Size = os.Size,
LastModified = os.LastModified,
ETag = os.ETag,
ContentType = os.ContentType,
MetaData = os.MetaData
});
}
catch (Exception exception)
{
//SentrySdk.CaptureException(exception);
throw;
}
}
public static ObjectStat FromResponseHeaders(string objectName, Dictionary <string, string> responseHeaders)
{
if (string.IsNullOrEmpty(objectName))
{
throw new ArgumentNullException("Name of an object cannot be empty");
}
var objInfo = new ObjectStat();
objInfo.ObjectName = objectName;
foreach (var paramName in responseHeaders.Keys)
{
var paramValue = responseHeaders[paramName];
switch (paramName.ToLower())
{
case "content-length":
objInfo.Size = long.Parse(paramValue);
break;
case "last-modified":
objInfo.LastModified = DateTime.Parse(paramValue, CultureInfo.InvariantCulture);
break;
case "etag":
objInfo.ETag = paramValue.Replace("\"", string.Empty);
break;
case "content-type":
objInfo.ContentType = paramValue;
objInfo.MetaData["Content-Type"] = objInfo.ContentType;
break;
case "x-amz-version-id":
objInfo.VersionId = paramValue;
break;
case "x-amz-delete-marker":
objInfo.DeleteMarker = paramValue.Equals("true");
break;
case "x-amz-archive-status":
objInfo.ArchiveStatus = paramValue;
break;
case "x-amz-tagging-count":
if (int.TryParse(paramValue, out var tagCount) && tagCount >= 0)
{
objInfo.TaggingCount = (uint)tagCount;
}
break;
case "x-amz-expiration":
// x-amz-expiration header includes the expiration date and the corresponding rule id.
var expirationResponse = paramValue.Trim();
var expiryDatePattern =
@"(Sun|Mon|Tue|Wed|Thu|Fri|Sat), \d{2} (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} [A-Z]+";
var expiryMatch = Regex.Match(expirationResponse, expiryDatePattern);
if (expiryMatch.Success)
{
objInfo.Expires = DateTime.SpecifyKind(
DateTime.Parse(expiryMatch.Value),
DateTimeKind.Utc);
}
break;
case "x-amz-object-lock-mode":
if (!string.IsNullOrWhiteSpace(paramValue))
{
objInfo.ObjectLockMode = paramValue.ToLower().Equals("governance")
? RetentionMode.GOVERNANCE
: RetentionMode.COMPLIANCE;
}
break;
case "x-amz-object-lock-retain-until-date":
var lockUntilDate = paramValue;
if (!string.IsNullOrWhiteSpace(lockUntilDate))
{
objInfo.ObjectLockRetainUntilDate = DateTime.SpecifyKind(
DateTime.Parse(lockUntilDate),
DateTimeKind.Utc);
;
}
break;
case "x-amz-object-lock-legal-hold":
var legalHoldON = paramValue.Trim();
if (!string.IsNullOrWhiteSpace(legalHoldON))
{
objInfo.LegalHoldEnabled = legalHoldON.ToLower().Equals("on");
}
break;
default:
if (OperationsUtil.IsSupportedHeader(paramName))
{
objInfo.MetaData[paramName] = paramValue;
}
else if (paramName.StartsWith("x-amz-meta-", StringComparison.OrdinalIgnoreCase))
{
objInfo.MetaData[paramName.Substring("x-amz-meta-".Length)] = paramValue;
}
else
{
objInfo.ExtraHeaders[paramName] = paramValue;
}
break;
}
}
return(objInfo);
}
