public void MarshalResponse(SimpleS3Config config, ListBucketsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("ListAllMyBucketsResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "Owner":
response.Owner = ParserHelper.ParseOwner(xmlReader);
break;
case "Buckets":
ReadBuckets(response, xmlReader);
break;
}
}
}
}
public Stream?MarshalRequest(CreateBucketRequest request, SimpleS3Config config)
{
//We only enable object locking on creation. We can't disable it, so there is no "false" option
if (request.EnableObjectLocking.HasValue && request.EnableObjectLocking.Value)
{
request.SetHeader(AmzHeaders.XAmzBucketObjectLockEnabled, "TRUE");
}
//Hard-code the LocationConstraint to the region from the config
if (config.ProviderName != "BackBlazeB2")
{
FastXmlWriter writer = new FastXmlWriter(128);
writer.WriteStartElement("CreateBucketConfiguration");
writer.WriteElement("LocationConstraint", config.RegionCode);
writer.WriteEndElement("CreateBucketConfiguration");
return(new MemoryStream(writer.GetBytes()));
}
return(null);
}
public void MarshalResponse(SimpleS3Config config, CopyObjectResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.NewVersionId = headers.GetOptionalValue(AmzHeaders.XAmzCopySourceVersionId);
if (ParserHelper.TryParseExpiration(headers, out (DateTimeOffset expiresOn, string ruleId)data))
{
response.LifeCycleExpiresOn = data.expiresOn;
response.LifeCycleRuleId = data.ruleId;
}
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
response.SseAlgorithm = headers.GetHeaderEnum <SseAlgorithm>(AmzHeaders.XAmzSse);
response.SseKmsKeyId = headers.GetOptionalValue(AmzHeaders.XAmzSseAwsKmsKeyId);
response.SseContext = headers.GetOptionalValue(AmzHeaders.XAmzSseContext);
response.SseCustomerAlgorithm = headers.GetHeaderEnum <SseCustomerAlgorithm>(AmzHeaders.XAmzSseCustomerAlgorithm);
response.SseCustomerKeyMd5 = headers.GetHeaderByteArray(AmzHeaders.XAmzSseCustomerKeyMd5, BinaryEncoding.Base64);
response.VersionId = headers.GetOptionalValue(AmzHeaders.XAmzVersionId);
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("CopyObjectResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "ETag":
response.ETag = xmlReader.ReadString();
break;
case "LastModified":
response.LastModified = ValueHelper.ParseDate(xmlReader.ReadString(), DateTimeFormat.Iso8601DateTimeExt);
break;
}
}
}
}
public void MarshalResponse(SimpleS3Config config, GetBucketTaggingResponse response, IDictionary <string, string> headers, Stream responseStream)
{
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("TagSet");
while (xmlReader.Read())
{
if (!xmlReader.IsStartElement() || xmlReader.Name != "Tag")
{
continue;
}
//Read the next token
xmlReader.Read();
string key = xmlReader.ReadElementContentAsString();
string value = xmlReader.ReadElementContentAsString();
response.Tags.Add(key, value);
}
}
}
public void MarshalResponse(SimpleS3Config config, DeleteObjectsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("DeleteResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "Deleted":
ParseDeleted(response, xmlReader);
break;
case "Error":
ParseError(response, xmlReader);
break;
}
}
}
}
public void MarshalResponse(SimpleS3Config config, GetObjectAclResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("AccessControlPolicy");
foreach (string name in XmlHelper.ReadElements(xmlReader, "AccessControlPolicy"))
{
switch (name)
{
case "Owner":
response.Owner = ParserHelper.ParseOwner(xmlReader);
break;
case "AccessControlList":
ParseAcl(response, xmlReader);
break;
}
}
}
}
public ChunkedSignatureTests()
{
ServiceCollection services = new ServiceCollection();
services.AddLogging();
SimpleS3CoreServices.AddSimpleS3Core(services).UseAmazonS3(x =>
{
x.Credentials = new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY");
x.Region = AmazonS3Region.UsEast1;
//The tests here have signatures built using path style
x.NamingMode = NamingMode.PathStyle;
});
ServiceProvider?provider = services.BuildServiceProvider();
_scopeBuilder = (ScopeBuilder)provider.GetRequiredService <IScopeBuilder>();
_sigBuilder = (SignatureBuilder)provider.GetRequiredService <ISignatureBuilder>();
_chunkedSigBuilder = (ChunkedSignatureBuilder)provider.GetRequiredService <IChunkedSignatureBuilder>();
_authBuilder = provider.GetRequiredService <HeaderAuthorizationBuilder>();
_config = provider.GetRequiredService <IOptions <SimpleS3Config> >().Value;
}
public SignedUrlTests()
{
//See https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
ServiceCollection services = new ServiceCollection();
services.AddLogging();
SimpleS3CoreServices.AddSimpleS3Core(services).UseAmazonS3(x =>
{
x.Credentials = new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY");
x.Region = AmazonS3Region.UsEast1;
//The tests here have signatures built using path style
x.NamingMode = NamingMode.PathStyle;
});
ServiceProvider provider = services.BuildServiceProvider();
_scopeBuilder = (ScopeBuilder)provider.GetRequiredService <IScopeBuilder>();
_sigBuilder = (SignatureBuilder)provider.GetRequiredService <ISignatureBuilder>();
_options = provider.GetRequiredService <IOptions <SimpleS3Config> >().Value;
}
public Stream?MarshalRequest(CompleteMultipartUploadRequest request, SimpleS3Config config)
{
//build the XML required to describe each part
FastXmlWriter xml = new FastXmlWriter(512);
xml.WriteStartElement("CompleteMultipartUpload");
foreach (S3PartInfo partInfo in request.UploadParts)
{
xml.WriteStartElement("Part");
if (partInfo.ETag != null)
{
xml.WriteElement("ETag", partInfo.ETag.Trim('"'));
}
xml.WriteElement("PartNumber", partInfo.PartNumber.ToString(NumberFormatInfo.InvariantInfo));
xml.WriteEndElement("Part");
}
xml.WriteEndElement("CompleteMultipartUpload");
return(new MemoryStream(xml.GetBytes()));
}
public Stream? MarshalRequest(DeleteObjectsRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.Delete, string.Empty);
FastXmlWriter xml = new FastXmlWriter(512);
xml.WriteStartElement("Delete");
if (request.Quiet)
xml.WriteElement("Quiet", true);
foreach (S3DeleteInfo info in request.Objects)
{
xml.WriteStartElement("Object");
xml.WriteElement("Key", info.ObjectKey);
if (info.VersionId != null)
xml.WriteElement("VersionId", info.VersionId);
xml.WriteEndElement("Object");
}
xml.WriteEndElement("Delete");
return new MemoryStream(xml.GetBytes());
}
public void MarshalResponse(SimpleS3Config config, RestoreObjectResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
response.RestoreOutputPath = headers.GetOptionalValue(AmzHeaders.XAmzRestoreOutputPath);
}
public Stream?MarshalRequest(GetBucketAccelerateConfigurationRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.Accelerate, string.Empty);
return(null);
}
public ScopeBuilder(IOptions <SimpleS3Config> options)
{
_options = options.Value;
}
public Stream?MarshalRequest(GetBucketTaggingRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.Tagging, string.Empty);
return(null);
}
public Stream?MarshalRequest(CreateMultipartUploadRequest request, SimpleS3Config config)
{
//This is required for multipart uploads
request.SetQueryParameter(AmzParameters.Uploads, string.Empty);
return(null);
}
public Stream?MarshalRequest(GetObjectLegalHoldRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.LegalHold, string.Empty);
return(null);
}
public void MarshalResponse(SimpleS3Config config, DeleteObjectResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.IsDeleteMarker = headers.GetHeaderBool(AmzHeaders.XAmzDeleteMarker);
response.VersionId = headers.GetOptionalValue(AmzHeaders.XAmzVersionId);
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
}
protected virtual void ConfigureConfig(SimpleS3Config config)
{
}
public void MarshalResponse(SimpleS3Config config, ListObjectVersionsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
//To support Google's lack of versions which is identical to S3 ListObjectVersions, but not quite
//xmlReader.ReadToDescendant("ListVersionsResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "IsTruncated":
response.IsTruncated = ValueHelper.ParseBool(xmlReader.ReadString());
break;
case "EncodingType":
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(xmlReader.ReadString());
break;
case "KeyMarker":
response.KeyMarker = xmlReader.ReadString();
break;
case "VersionIdMarker":
response.VersionIdMarker = xmlReader.ReadString();
break;
case "NextKeyMarker":
response.NextKeyMarker = xmlReader.ReadString();
break;
case "NextVersionIdMarker":
response.NextVersionIdMarker = xmlReader.ReadString();
break;
case "Name":
response.BucketName = xmlReader.ReadString();
break;
case "Prefix":
response.Prefix = xmlReader.ReadString();
break;
case "Delimiter":
response.Delimiter = xmlReader.ReadString();
break;
case "MaxKeys":
response.MaxKeys = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "Version":
response.Versions.Add(ParseVersion(xmlReader));
break;
case "DeleteMarker":
response.DeleteMarkers.Add(ParseDeleteMarker(xmlReader));
break;
case "CommonPrefixes":
response.CommonPrefixes.Add(ParseCommonPrefixes(xmlReader));
break;
}
}
}
if (config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url)
{
response.KeyMarker = WebUtility.UrlDecode(response.KeyMarker);
response.NextKeyMarker = WebUtility.UrlDecode(response.NextKeyMarker);
response.Prefix = WebUtility.UrlDecode(response.Prefix);
response.Delimiter = WebUtility.UrlDecode(response.Delimiter);
foreach (S3Version version in response.Versions)
{
version.ObjectKey = WebUtility.UrlDecode(version.ObjectKey);
}
foreach (S3DeleteMarker marker in response.DeleteMarkers)
{
marker.ObjectKey = WebUtility.UrlDecode(marker.ObjectKey);
}
}
}
public static void UseDefaultProfile(this SimpleS3Config config, IProfileManager profileManager)
{
UseProfile(config, profileManager, ProfileManager.DefaultProfile);
}
public void MarshalResponse(SimpleS3Config config, AbortMultipartUploadResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
}
public void MarshalResponse(SimpleS3Config config, ListMultipartUploadsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("ListMultipartUploadsResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "Bucket":
response.Bucket = xmlReader.ReadString();
break;
case "KeyMarker":
response.KeyMarker = xmlReader.ReadString();
break;
case "UploadIdMarker":
response.UploadIdMarker = xmlReader.ReadString();
break;
case "NextKeyMarker":
response.NextKeyMarker = xmlReader.ReadString();
break;
case "NextUploadIdMarker":
response.NextUploadIdMarker = xmlReader.ReadString();
break;
case "MaxUploads":
response.MaxUploads = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "EncodingType":
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(xmlReader.ReadString());
break;
case "IsTruncated":
response.IsTruncated = ValueHelper.ParseBool(xmlReader.ReadString());
break;
case "Upload":
ParseUpload(response, xmlReader);
break;
}
}
}
if (config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url)
{
response.Delimiter = WebUtility.UrlDecode(response.Delimiter);
response.KeyMarker = WebUtility.UrlDecode(response.KeyMarker);
response.Prefix = WebUtility.UrlDecode(response.Prefix);
response.NextKeyMarker = WebUtility.UrlDecode(response.NextKeyMarker);
foreach (S3Upload upload in response.Uploads)
{
upload.ObjectKey = WebUtility.UrlDecode(upload.ObjectKey);
}
}
}
public Stream?MarshalRequest(RestoreObjectRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.Restore, string.Empty);
FastXmlWriter xml = new FastXmlWriter(512);
xml.WriteStartElement("RestoreRequest", "http://s3.amazonaws.com/doc/2006-03-01/");
if (request.Days > 0)
{
xml.WriteElement("Days", request.Days);
}
if (request.RequestType != RestoreRequestType.Unknown)
{
xml.WriteElement("Type", ValueHelper.EnumToString(request.RequestType));
}
if (request.RequestTier != RetrievalTier.Unknown)
{
xml.WriteElement("Tier", ValueHelper.EnumToString(request.RequestTier));
}
if (request.GlacierTier != RetrievalTier.Unknown)
{
xml.WriteStartElement("GlacierJobParameters");
xml.WriteElement("Tier", ValueHelper.EnumToString(request.GlacierTier));
xml.WriteEndElement("GlacierJobParameters");
}
if (request.Description != null)
{
xml.WriteElement("Description", request.Description);
}
if (request.SelectParameters != null)
{
xml.WriteStartElement("SelectParameters");
if (request.SelectParameters.InputFormat != null)
{
xml.WriteStartElement("InputSerialization");
if (request.SelectParameters.InputFormat.CompressionType != CompressionType.Unknown)
{
xml.WriteElement("CompressionType", ValueHelper.EnumToString(request.SelectParameters.InputFormat.CompressionType));
}
switch (request.SelectParameters.InputFormat)
{
case S3CsvInputFormat csvInput:
{
xml.WriteStartElement("CSV");
if (csvInput.HeaderUsage != HeaderUsage.Unknown)
{
xml.WriteElement("FileHeaderInfo", ValueHelper.EnumToString(csvInput.HeaderUsage));
}
if (csvInput.CommentCharacter != null)
{
xml.WriteElement("Comments", ConvertChar(csvInput.CommentCharacter));
}
if (csvInput.QuoteEscapeCharacter != null)
{
xml.WriteElement("QuoteEscapeCharacter", ConvertChar(csvInput.QuoteEscapeCharacter));
}
if (csvInput.RecordDelimiter != null)
{
xml.WriteElement("RecordDelimiter", ConvertChar(csvInput.RecordDelimiter));
}
if (csvInput.FieldDelimiter != null)
{
xml.WriteElement("FieldDelimiter", ConvertChar(csvInput.FieldDelimiter));
}
if (csvInput.QuoteCharacter != null)
{
xml.WriteElement("QuoteCharacter", ConvertChar(csvInput.QuoteCharacter));
}
if (csvInput.AllowQuotedRecordDelimiter != null)
{
xml.WriteElement("AllowQuotedRecordDelimiter", csvInput.AllowQuotedRecordDelimiter);
}
xml.WriteEndElement("CSV");
break;
}
case S3JsonInputFormat jsonInput:
{
xml.WriteStartElement("JSON");
if (jsonInput.JsonType != JsonType.Unknown)
{
xml.WriteElement("Type", ValueHelper.EnumToString(jsonInput.JsonType));
}
xml.WriteEndElement("JSON");
break;
}
case S3ParquetInputFormat _:
xml.WriteElement("Parquet", string.Empty);
break;
}
xml.WriteEndElement("InputSerialization");
}
if (request.SelectParameters.ExpressionType != ExpressionType.Unknown)
{
xml.WriteElement("ExpressionType", ValueHelper.EnumToString(request.SelectParameters.ExpressionType));
}
xml.WriteElement("Expression", request.SelectParameters.Expression);
xml.WriteStartElement("OutputSerialization");
switch (request.SelectParameters.OutputFormat)
{
case S3CsvOutputFormat csvOutput:
xml.WriteStartElement("CSV");
if (csvOutput.FieldDelimiter != null)
{
xml.WriteElement("FieldDelimiter", ConvertChar(csvOutput.FieldDelimiter));
}
if (csvOutput.QuoteCharacter != null)
{
xml.WriteElement("QuoteCharacter", ConvertChar(csvOutput.QuoteCharacter));
}
if (csvOutput.QuoteEscapeCharacter != null)
{
xml.WriteElement("QuoteEscapeCharacter", ConvertChar(csvOutput.QuoteEscapeCharacter));
}
if (csvOutput.QuoteFields != QuoteField.Unknown)
{
xml.WriteElement("QuoteFields", ValueHelper.EnumToString(csvOutput.QuoteFields));
}
if (csvOutput.RecordDelimiter != null)
{
xml.WriteElement("RecordDelimiter", ConvertChar(csvOutput.RecordDelimiter));
}
xml.WriteEndElement("CSV");
break;
case S3JsonOutputFormat jsonOutput:
xml.WriteElement("RecordDelimiter", jsonOutput.RecordDelimiter);
break;
}
xml.WriteEndElement("OutputSerialization");
xml.WriteEndElement("SelectParameters");
}
if (request.OutputLocation != null)
{
xml.WriteStartElement("OutputLocation");
xml.WriteStartElement("S3");
//These two are required, so we don't check for null
xml.WriteElement("BucketName", request.OutputLocation.BucketName);
if (request.OutputLocation.Prefix != null)
{
xml.WriteElement("Prefix", request.OutputLocation.Prefix);
}
if (request.OutputLocation.StorageClass != StorageClass.Unknown)
{
xml.WriteElement("StorageClass", ValueHelper.EnumToString(request.OutputLocation.StorageClass));
}
if (request.OutputLocation.Acl != ObjectCannedAcl.Unknown)
{
xml.WriteElement("CannedACL", ValueHelper.EnumToString(request.OutputLocation.Acl));
}
//TODO: AccessControlList support
if (request.OutputLocation.SseAlgorithm != SseAlgorithm.Unknown)
{
xml.WriteStartElement("Encryption");
xml.WriteElement("EncryptionType", ValueHelper.EnumToString(request.OutputLocation.SseAlgorithm));
string?context = request.OutputLocation.SseContext.Build();
if (context != null)
{
xml.WriteElement("KMSContext", context);
}
if (request.OutputLocation.SseKmsKeyId != null)
{
xml.WriteElement("KMSKeyId", request.OutputLocation.SseKmsKeyId);
}
xml.WriteEndElement("Encryption");
}
List <KeyValuePair <string, string> > tags = request.OutputLocation.Tags.ToList();
if (tags.Count > 0)
{
xml.WriteStartElement("Tagging");
xml.WriteStartElement("TagSet");
foreach (KeyValuePair <string, string> tag in tags)
{
xml.WriteStartElement("Tag");
xml.WriteElement("Key", tag.Key);
xml.WriteElement("Value", tag.Value);
xml.WriteEndElement("Tag");
}
xml.WriteEndElement("TagSet");
xml.WriteEndElement("Tagging");
}
List <KeyValuePair <string, string> > metadata = request.OutputLocation.Metadata.ToList();
if (metadata.Count > 0)
{
xml.WriteStartElement("UserMetadata");
foreach (KeyValuePair <string, string> meta in metadata)
{
xml.WriteStartElement("MetadataEntry");
xml.WriteElement("Name", meta.Key);
xml.WriteElement("Value", meta.Value);
xml.WriteEndElement("MetadataEntry");
}
xml.WriteEndElement("UserMetadata");
}
xml.WriteEndElement("S3");
xml.WriteEndElement("OutputLocation");
}
xml.WriteEndElement("RestoreRequest");
return(new MemoryStream(xml.GetBytes()));
}
public void MarshalResponse(SimpleS3Config config, ListObjectsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("ListBucketResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "Name":
response.BucketName = xmlReader.ReadString();
break;
case "Prefix":
response.Prefix = xmlReader.ReadString();
break;
case "KeyCount":
response.KeyCount = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "MaxKeys":
response.MaxKeys = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "IsTruncated":
response.IsTruncated = ValueHelper.ParseBool(xmlReader.ReadString());
break;
case "EncodingType":
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(xmlReader.ReadString());
break;
case "Delimiter":
response.Delimiter = xmlReader.ReadString();
break;
case "StartAfter":
response.StartAfter = xmlReader.ReadString();
break;
case "NextContinuationToken":
response.NextContinuationToken = xmlReader.ReadString();
break;
case "ContinuationToken":
response.ContinuationToken = xmlReader.ReadString();
break;
case "Contents":
ReadContents(response, xmlReader);
break;
case "CommonPrefixes":
ReadCommonPrefixes(response, xmlReader);
break;
}
}
}
if (config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url)
{
response.Delimiter = WebUtility.UrlDecode(response.Delimiter);
response.Prefix = WebUtility.UrlDecode(response.Prefix);
response.StartAfter = WebUtility.UrlDecode(response.StartAfter);
foreach (S3Object obj in response.Objects)
{
obj.ObjectKey = WebUtility.UrlDecode(obj.ObjectKey);
}
}
}
public void MarshalResponse(SimpleS3Config config, ListPartsResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.AbortsOn = headers.GetHeaderDate(AmzHeaders.XAmzAbortDate, DateTimeFormat.Iso8601DateTimeExt);
response.AbortRuleId = headers.GetOptionalValue(AmzHeaders.XAmzAbortRuleId);
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
using (XmlTextReader xmlReader = new XmlTextReader(responseStream))
{
xmlReader.ReadToDescendant("ListPartsResult");
foreach (string name in XmlHelper.ReadElements(xmlReader))
{
switch (name)
{
case "Key":
response.ObjectKey = xmlReader.ReadString();
break;
case "Bucket":
response.BucketName = xmlReader.ReadString();
break;
case "UploadId":
response.UploadId = xmlReader.ReadString();
break;
case "EncodingType":
response.EncodingType = ValueHelper.ParseEnum <EncodingType>(xmlReader.ReadString());
break;
case "StorageClass":
response.StorageClass = ValueHelper.ParseEnum <StorageClass>(xmlReader.ReadString());
break;
case "PartNumberMarker":
response.PartNumberMarker = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "NextPartNumberMarker":
response.NextPartNumberMarker = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "MaxParts":
response.MaxParts = ValueHelper.ParseInt(xmlReader.ReadString());
break;
case "IsTruncated":
response.IsTruncated = ValueHelper.ParseBool(xmlReader.ReadString());
break;
case "Owner":
response.Owner = ParserHelper.ParseOwner(xmlReader);
break;
case "Initiator":
response.Initiator = ParserHelper.ParseOwner(xmlReader, "Initiator");
break;
case "Part":
ParsePart(response, xmlReader);
break;
}
}
}
//Bug: Docs at https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html does not list encoding type, but the response is XML, so I have implemented it anyway.
if (config.AutoUrlDecodeResponses && response.EncodingType == EncodingType.Url)
{
response.ObjectKey = WebUtility.UrlDecode(response.ObjectKey);
}
}
public Stream?MarshalRequest(PutBucketLifecycleConfigurationRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.Lifecycle, string.Empty);
FastXmlWriter writer = new FastXmlWriter(600);
writer.WriteStartElement("LifecycleConfiguration", "http://s3.amazonaws.com/doc/2006-03-01/");
foreach (S3Rule rule in request.Rules)
{
writer.WriteStartElement("Rule");
if (rule.AbortIncompleteMultipartUploadDays.HasValue)
{
writer.WriteStartElement("AbortIncompleteMultipartUpload");
writer.WriteElement("DaysAfterInitiation", rule.AbortIncompleteMultipartUploadDays.Value);
writer.WriteEndElement("AbortIncompleteMultipartUpload");
}
if (rule.Expiration != null)
{
writer.WriteStartElement("Expiration");
if (rule.Expiration.ExpireOnDate.HasValue)
{
writer.WriteElement("Date", ValueHelper.DateToString(rule.Expiration.ExpireOnDate.Value.UtcDateTime.Date, DateTimeFormat.Iso8601DateTimeExt));
}
if (rule.Expiration.ExpireAfterDays.HasValue)
{
writer.WriteElement("Days", rule.Expiration.ExpireAfterDays.Value);
}
if (rule.Expiration.ExpireObjectDeleteMarker.HasValue)
{
writer.WriteElement("ExpiredObjectDeleteMarker", rule.Expiration.ExpireObjectDeleteMarker.Value);
}
writer.WriteEndElement("Expiration");
}
if (rule.Filter != null)
{
writer.WriteStartElement("Filter");
if (rule.Filter.Prefix != null)
{
writer.WriteElement("Prefix", rule.Filter.Prefix);
}
if (rule.Filter.Tag != null)
{
writer.WriteStartElement("Tag");
writer.WriteElement("Key", rule.Filter.Tag.Value.Key);
writer.WriteElement("Value", rule.Filter.Tag.Value.Value);
writer.WriteEndElement("Tag");
}
S3AndCondition?andCondition = rule.Filter.AndConditions;
if (andCondition != null)
{
writer.WriteStartElement("And");
if (andCondition.Prefix != null)
{
writer.WriteElement("Prefix", andCondition.Prefix);
}
if (andCondition.Tags != null)
{
foreach (KeyValuePair <string, string> tag in andCondition.Tags)
{
writer.WriteStartElement("Tag");
writer.WriteElement("Key", tag.Key);
writer.WriteElement("Value", tag.Value);
writer.WriteEndElement("Tag");
}
}
writer.WriteEndElement("And");
}
writer.WriteEndElement("Filter");
}
writer.WriteElement("ID", rule.Id);
if (rule.NonCurrentVersionExpirationDays != null)
{
writer.WriteStartElement("NoncurrentVersionExpiration");
writer.WriteElement("NoncurrentDays", rule.NonCurrentVersionExpirationDays.Value);
writer.WriteEndElement("NoncurrentVersionExpiration");
}
foreach (S3NonCurrentVersionTransition transition in rule.NonCurrentVersionTransitions)
{
writer.WriteStartElement("NoncurrentVersionTransition");
writer.WriteElement("NoncurrentDays", transition.NonCurrentDays);
writer.WriteElement("StorageClass", ValueHelper.EnumToString(transition.StorageClass));
writer.WriteEndElement("NoncurrentVersionTransition");
}
writer.WriteElement("Status", rule.Enabled ? "Enabled" : "Disabled");
foreach (S3Transition transition in rule.Transitions)
{
writer.WriteStartElement("Transition");
if (transition.TransitionOnDate.HasValue)
{
writer.WriteElement("Date", ValueHelper.DateToString(transition.TransitionOnDate.Value, DateTimeFormat.Iso8601Date));
}
if (transition.TransitionAfterDays.HasValue)
{
writer.WriteElement("Days", transition.TransitionAfterDays.Value);
}
if (transition.StorageClass != StorageClass.Unknown)
{
writer.WriteElement("StorageClass", ValueHelper.EnumToString(transition.StorageClass));
}
writer.WriteEndElement("Transition");
}
writer.WriteEndElement("Rule");
}
writer.WriteEndElement("LifecycleConfiguration");
return(new MemoryStream(writer.GetBytes()));
}
public EndpointBuilder(IOptions <SimpleS3Config> config)
{
_config = config.Value;
}
public Stream?MarshalRequest(PutObjectAclRequest request, SimpleS3Config config)
{
request.SetQueryParameter(AmzParameters.Acl, string.Empty);
return(null);
}
public void MarshalResponse(SimpleS3Config config, PutBucketLockConfigurationResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
}
public void MarshalResponse(SimpleS3Config config, PutObjectLegalHoldResponse response, IDictionary <string, string> headers, Stream responseStream)
{
response.RequestCharged = headers.ContainsKey(AmzHeaders.XAmzRequestCharged);
}
