public IRequest Marshall(PutObjectRequest putObjectRequest)
{
IRequest request = new DefaultRequest(putObjectRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (putObjectRequest.IsSetCannedACL())
{
request.Headers.Add(HeaderKeys.XAmzAclHeader, S3Transforms.ToStringValue(putObjectRequest.CannedACL));
}
var headers = putObjectRequest.Headers;
foreach (var key in headers.Keys)
{
request.Headers[key] = headers[key];
}
if (putObjectRequest.IsSetMD5Digest())
{
request.Headers[HeaderKeys.ContentMD5Header] = putObjectRequest.MD5Digest;
}
HeaderACLRequestMarshaller.Marshall(request, putObjectRequest);
if (putObjectRequest.IsSetServerSideEncryptionMethod())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionHeader, S3Transforms.ToStringValue(putObjectRequest.ServerSideEncryptionMethod));
}
if (putObjectRequest.IsSetStorageClass())
{
request.Headers.Add(HeaderKeys.XAmzStorageClassHeader, S3Transforms.ToStringValue(putObjectRequest.StorageClass));
}
if (putObjectRequest.IsSetWebsiteRedirectLocation())
{
request.Headers.Add(HeaderKeys.XAmzWebsiteRedirectLocationHeader, S3Transforms.ToStringValue(putObjectRequest.WebsiteRedirectLocation));
}
if (putObjectRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, putObjectRequest.ServerSideEncryptionCustomerMethod);
}
if (putObjectRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, putObjectRequest.ServerSideEncryptionCustomerProvidedKey);
if (putObjectRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, putObjectRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(putObjectRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
AmazonS3Util.SetMetadataHeaders(request, putObjectRequest.Metadata);
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(putObjectRequest.BucketName),
S3Transforms.ToStringValue(putObjectRequest.Key));
if (putObjectRequest.InputStream != null)
{
// Wrap the stream in a stream that has a length
var streamWithLength = GetStreamWithLength(putObjectRequest.InputStream, putObjectRequest.Headers.ContentLength);
if (streamWithLength.Length > 0)
{
request.UseChunkEncoding = true;
}
var length = streamWithLength.Length - streamWithLength.Position;
if (!request.Headers.ContainsKey(HeaderKeys.ContentLengthHeader))
{
request.Headers.Add(HeaderKeys.ContentLengthHeader, length.ToString(CultureInfo.InvariantCulture));
}
// Wrap input stream in MD5Stream
var hashStream = new MD5Stream(streamWithLength, null, length);
putObjectRequest.InputStream = hashStream;
}
request.ContentStream = putObjectRequest.InputStream;
if (!request.Headers.ContainsKey(HeaderKeys.ContentTypeHeader))
{
request.Headers.Add(HeaderKeys.ContentTypeHeader, "text/plain");
}
return(request);
}
public IRequest Marshall(CopyObjectRequest copyObjectRequest)
{
IRequest request = new DefaultRequest(copyObjectRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (copyObjectRequest.IsSetCannedACL())
{
request.Headers.Add(HeaderKeys.XAmzAclHeader, S3Transforms.ToStringValue(copyObjectRequest.CannedACL));
}
var headers = copyObjectRequest.Headers;
foreach (var key in headers.Keys)
{
request.Headers[key] = headers[key];
}
HeaderACLRequestMarshaller.Marshall(request, copyObjectRequest);
if (copyObjectRequest.IsSetSourceBucket())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceHeader, ConstructCopySourceHeaderValue(copyObjectRequest.SourceBucket, copyObjectRequest.SourceKey, copyObjectRequest.SourceVersionId));
}
if (copyObjectRequest.IsSetETagToMatch())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfMatchHeader, S3Transforms.ToStringValue(copyObjectRequest.ETagToMatch));
}
if (copyObjectRequest.IsSetModifiedSinceDate())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfModifiedSinceHeader, S3Transforms.ToStringValue(copyObjectRequest.ModifiedSinceDate));
}
if (copyObjectRequest.IsSetETagToNotMatch())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfNoneMatchHeader, S3Transforms.ToStringValue(copyObjectRequest.ETagToNotMatch));
}
if (copyObjectRequest.IsSetUnmodifiedSinceDate())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfUnmodifiedSinceHeader, S3Transforms.ToStringValue(copyObjectRequest.UnmodifiedSinceDate));
}
request.Headers.Add(HeaderKeys.XAmzMetadataDirectiveHeader, S3Transforms.ToStringValue(copyObjectRequest.MetadataDirective.ToString()));
if (copyObjectRequest.IsSetServerSideEncryptionMethod())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionHeader, S3Transforms.ToStringValue(copyObjectRequest.ServerSideEncryptionMethod));
}
if (copyObjectRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, copyObjectRequest.ServerSideEncryptionCustomerMethod);
}
if (copyObjectRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, copyObjectRequest.ServerSideEncryptionCustomerProvidedKey);
if (copyObjectRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, copyObjectRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(copyObjectRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (copyObjectRequest.IsSetCopySourceServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerAlgorithmHeader, copyObjectRequest.CopySourceServerSideEncryptionCustomerMethod);
}
if (copyObjectRequest.IsSetCopySourceServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerKeyHeader, copyObjectRequest.CopySourceServerSideEncryptionCustomerProvidedKey);
if (copyObjectRequest.IsSetCopySourceServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerKeyMD5Header, copyObjectRequest.CopySourceServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(copyObjectRequest.CopySourceServerSideEncryptionCustomerProvidedKey));
}
}
if (copyObjectRequest.IsSetServerSideEncryptionKeyManagementServiceKeyId())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader, copyObjectRequest.ServerSideEncryptionKeyManagementServiceKeyId);
}
if (copyObjectRequest.IsSetStorageClass())
{
request.Headers.Add(HeaderKeys.XAmzStorageClassHeader, S3Transforms.ToStringValue(copyObjectRequest.StorageClass));
}
if (copyObjectRequest.IsSetWebsiteRedirectLocation())
{
request.Headers.Add(HeaderKeys.XAmzWebsiteRedirectLocationHeader, S3Transforms.ToStringValue(copyObjectRequest.WebsiteRedirectLocation));
}
AmazonS3Util.SetMetadataHeaders(request, copyObjectRequest.Metadata);
var destinationKey = copyObjectRequest.DestinationKey.StartsWith("/", StringComparison.Ordinal)
? copyObjectRequest.DestinationKey.Substring(1)
: copyObjectRequest.DestinationKey;
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(copyObjectRequest.DestinationBucket),
S3Transforms.ToStringValue(destinationKey));
request.UseQueryString = true;
return(request);
}
public static void ClassCleanup()
{
AmazonS3Util.DeleteS3BucketWithObjects(Client, bucketName);
BaseClean();
}
public void TestCleanup()
{
AmazonS3Util.DeleteS3BucketWithObjects(Client, eastBucketName);
AmazonS3Util.DeleteS3BucketWithObjects(Client, westBucketName);
BaseClean();
}
public IRequest Marshall(SelectObjectContentRequest selectObjectContentRequest)
{
// Required Parameters
// Bucket
if (string.IsNullOrEmpty(selectObjectContentRequest.Bucket))
{
throw ConstructExceptionArgumentRequired(nameof(selectObjectContentRequest.Bucket));
}
// Key
if (string.IsNullOrEmpty(selectObjectContentRequest.Key))
{
throw ConstructExceptionArgumentRequired(nameof(selectObjectContentRequest.Key));
}
// Expression
if (string.IsNullOrEmpty(selectObjectContentRequest.Expression))
{
throw ConstructExceptionArgumentRequired(nameof(selectObjectContentRequest.Expression));
}
// ExpressionType
if (!selectObjectContentRequest.IsSetExpressionType())
{
throw ConstructExceptionArgumentRequired(nameof(selectObjectContentRequest.ExpressionType));
}
// InputSerialization
if (!selectObjectContentRequest.IsSetInputSerialization())
{
throw ConstructExceptionArgumentRequired(nameof(selectObjectContentRequest.InputSerialization));
}
// OutputSerialization
if (!selectObjectContentRequest.IsSetOutputSerialization())
{
throw ConstructExceptionArgumentRequired(nameof(selectObjectContentRequest.OutputSerialization));
}
var request = new DefaultRequest(selectObjectContentRequest, "AmazonS3")
{
HttpMethod = "POST",
ResourcePath =
string.Format(CultureInfo.InvariantCulture, "/{0}/{1}", S3Transforms.ToStringValue(selectObjectContentRequest.Bucket), S3Transforms.ToStringValue(selectObjectContentRequest.Key)),
UseQueryString = true,
};
// Headers
if (selectObjectContentRequest.IsSetServerSideCustomerEncryptionMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader,
selectObjectContentRequest.ServerSideCustomerEncryptionMethod);
}
if (selectObjectContentRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader,
selectObjectContentRequest.ServerSideEncryptionCustomerProvidedKey);
if (selectObjectContentRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header,
selectObjectContentRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header,
AmazonS3Util.ComputeEncodedMD5FromEncodedString(selectObjectContentRequest
.ServerSideEncryptionCustomerProvidedKey));
}
}
if (selectObjectContentRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner,
S3Transforms.ToStringValue(selectObjectContentRequest.ExpectedBucketOwner));
}
// Subresources
request.AddSubResource("select");
request.AddSubResource("select-type", "2");
// Parameters
using (var stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
var xmlWriterSettings = new XmlWriterSettings()
{
Encoding = Encoding.UTF8,
OmitXmlDeclaration = true,
NewLineHandling = NewLineHandling.None
};
using (var xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSettings))
{
xmlWriter.WriteStartElement("SelectRequest");
xmlWriter.WriteElementString("Expression",
S3Transforms.ToXmlStringValue(selectObjectContentRequest.Expression));
xmlWriter.WriteElementString("ExpressionType",
S3Transforms.ToXmlStringValue(selectObjectContentRequest.ExpressionType.Value));
selectObjectContentRequest.InputSerialization.Marshall("InputSerialization", xmlWriter);
selectObjectContentRequest.OutputSerialization.Marshall("OutputSerialization", xmlWriter);
xmlWriter.WriteStartElement("RequestProgress");
xmlWriter.WriteElementString("Enabled",
selectObjectContentRequest.RequestProgress.GetValueOrDefault(false).ToString()
.ToUpperInvariant());
if (selectObjectContentRequest.IsSetScanRange())
{
selectObjectContentRequest.ScanRange.Marshall("ScanRange", xmlWriter);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
var checksum = AWSSDKUtils.GenerateChecksumForContent(content, true);
request.Headers[HeaderKeys.ContentMD5Header] = checksum;
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
}
return(request);
}
protected override void ProcessPreRequestHandlers(AmazonWebServiceRequest request)
{
base.ProcessPreRequestHandlers(request);
var putObjectRequest = request as PutObjectRequest;
if (putObjectRequest != null)
{
if (putObjectRequest.InputStream != null && !string.IsNullOrEmpty(putObjectRequest.FilePath))
{
throw new ArgumentException("Please specify one of either an InputStream or a FilePath to be PUT as an S3 object.");
}
if (!string.IsNullOrEmpty(putObjectRequest.ContentBody) && !string.IsNullOrEmpty(putObjectRequest.FilePath))
{
throw new ArgumentException("Please specify one of either a FilePath or the ContentBody to be PUT as an S3 object.");
}
if (putObjectRequest.InputStream != null && !string.IsNullOrEmpty(putObjectRequest.ContentBody))
{
throw new ArgumentException("Please specify one of either an InputStream or the ContentBody to be PUT as an S3 object.");
}
if (!putObjectRequest.Headers.IsSetContentType())
{
// Get the extension of the file from the path.
// Try the key as well.
string ext = null;
if (!string.IsNullOrEmpty(putObjectRequest.FilePath))
{
ext = Path.GetExtension(putObjectRequest.FilePath);
}
#if WIN_RT || WINDOWS_PHONE
if (putObjectRequest.StorageFile != null)
{
ext = Path.GetExtension(putObjectRequest.StorageFile.Path);
}
#endif
if (String.IsNullOrEmpty(ext) && putObjectRequest.IsSetKey())
{
ext = Path.GetExtension(putObjectRequest.Key);
}
// Use the extension to get the mime-type
if (!String.IsNullOrEmpty(ext))
{
putObjectRequest.Headers.ContentType = AmazonS3Util.MimeTypeFromExtension(ext);
}
}
if (putObjectRequest.InputStream != null)
{
if (putObjectRequest.AutoResetStreamPosition && putObjectRequest.InputStream.CanSeek)
{
putObjectRequest.InputStream.Seek(0, SeekOrigin.Begin);
}
}
if (!string.IsNullOrEmpty(putObjectRequest.FilePath))
{
putObjectRequest.SetupForFilePath();
}
#if WIN_RT || WINDOWS_PHONE
else if (putObjectRequest.StorageFile != null)
{
putObjectRequest.InputStream = Task.Run(() =>
putObjectRequest.StorageFile.OpenAsync(Windows.Storage.FileAccessMode.Read).AsTask())
.Result.AsStreamForRead();
if (string.IsNullOrEmpty(putObjectRequest.Key))
{
putObjectRequest.Key = Path.GetFileName(putObjectRequest.StorageFile.Name);
}
}
#endif
else if (null == putObjectRequest.InputStream)
{
if (string.IsNullOrEmpty(putObjectRequest.Headers.ContentType))
{
putObjectRequest.Headers.ContentType = "text/plain";
}
var payload = Encoding.UTF8.GetBytes(putObjectRequest.ContentBody ?? "");
//putObjectRequest.Headers[AWS4Signer.XAmzContentSha256]
// = AWSSDKUtils.ToHex(AWS4Signer.ComputeHash(payload), true);
putObjectRequest.InputStream = new MemoryStream(payload);
}
}
var putBucketRequest = request as PutBucketRequest;
if (putBucketRequest != null)
{
// UseClientRegion only applies if neither BucketRegionName and BucketRegion are set.
if (putBucketRequest.UseClientRegion &&
!(putBucketRequest.IsSetBucketRegionName() || putBucketRequest.IsSetBucketRegion()))
{
var regionCode = Amazon.Util.AWSSDKUtils.DetermineRegion(this.Config.DetermineServiceURL());
if (regionCode == S3Constants.REGION_US_EAST_1)
{
regionCode = null;
}
else if (regionCode == S3Constants.REGION_EU_WEST_1)
{
regionCode = "EU";
}
putBucketRequest.BucketRegion = regionCode;
}
}
var deleteBucketRequest = request as DeleteBucketRequest;
if (deleteBucketRequest != null)
{
if (deleteBucketRequest.UseClientRegion && !deleteBucketRequest.IsSetBucketRegion())
{
var regionCode = Amazon.Util.AWSSDKUtils.DetermineRegion(this.Config.DetermineServiceURL());
if (regionCode == S3Constants.REGION_US_EAST_1)
{
regionCode = null;
}
//else if (regionCode == S3Constants.REGION_EU_WEST_1)
// regionCode = "EU";
if (regionCode != null)
{
deleteBucketRequest.BucketRegion = regionCode;
}
}
}
var uploadPartRequest = request as UploadPartRequest;
if (uploadPartRequest != null)
{
if (uploadPartRequest.InputStream != null && !string.IsNullOrEmpty(uploadPartRequest.FilePath))
{
throw new ArgumentException("Please specify one of either a InputStream or a FilePath to be PUT as an S3 object.");
}
if (uploadPartRequest.IsSetFilePath())
{
uploadPartRequest.SetupForFilePath();
}
#if WIN_RT || WINDOWS_PHONE
else if (uploadPartRequest.StorageFile != null)
{
uploadPartRequest.InputStream = Task.Run(() =>
uploadPartRequest.StorageFile.OpenAsync(Windows.Storage.FileAccessMode.Read).AsTask())
.Result.AsStreamForRead();
uploadPartRequest.InputStream.Position = uploadPartRequest.FilePosition;
}
#endif
}
var initMultipartRequest = request as InitiateMultipartUploadRequest;
if (initMultipartRequest != null)
{
if (!initMultipartRequest.Headers.IsSetContentType())
{
// Get the extension of the object key.
string ext = Path.GetExtension(initMultipartRequest.Key);
// Use the extension to get the mime-type
if (!String.IsNullOrEmpty(ext))
{
initMultipartRequest.Headers.ContentType = AmazonS3Util.MimeTypeFromExtension(ext);
}
}
}
}
private static void UnmarshallResult(XmlUnmarshallerContext context, GetObjectResponse response)
{
response.ResponseStream = context.Stream;
IWebResponseData responseData = context.ResponseData;
if (responseData.IsHeaderPresent("x-amz-delete-marker"))
{
response.DeleteMarker = S3Transforms.ToString(responseData.GetHeaderValue("x-amz-delete-marker"));
}
if (responseData.IsHeaderPresent("accept-ranges"))
{
response.AcceptRanges = S3Transforms.ToString(responseData.GetHeaderValue("accept-ranges"));
}
if (responseData.IsHeaderPresent("x-amz-expiration"))
{
response.Expiration = new Expiration(responseData.GetHeaderValue("x-amz-expiration"));
}
if (responseData.IsHeaderPresent("x-amz-restore"))
{
bool restoreInProgress;
DateTime?restoreExpiration;
AmazonS3Util.ParseAmzRestoreHeader(responseData.GetHeaderValue("x-amz-restore"), out restoreInProgress, out restoreExpiration);
response.RestoreInProgress = restoreInProgress;
response.RestoreExpiration = restoreExpiration;
}
if (responseData.IsHeaderPresent("Last-Modified"))
{
response.LastModified = S3Transforms.ToDateTime(responseData.GetHeaderValue("Last-Modified"));
}
if (responseData.IsHeaderPresent("ETag"))
{
response.ETag = S3Transforms.ToString(responseData.GetHeaderValue("ETag"));
}
if (responseData.IsHeaderPresent("x-amz-missing-meta"))
{
response.MissingMeta = S3Transforms.ToInt(responseData.GetHeaderValue("x-amz-missing-meta"));
}
if (responseData.IsHeaderPresent("x-amz-version-id"))
{
response.VersionId = S3Transforms.ToString(responseData.GetHeaderValue("x-amz-version-id"));
}
if (responseData.IsHeaderPresent("Cache-Control"))
{
response.Headers.CacheControl = S3Transforms.ToString(responseData.GetHeaderValue("Cache-Control"));
}
if (responseData.IsHeaderPresent("Content-Disposition"))
{
response.Headers.ContentDisposition = S3Transforms.ToString(responseData.GetHeaderValue("Content-Disposition"));
}
if (responseData.IsHeaderPresent("Content-Encoding"))
{
response.Headers.ContentEncoding = S3Transforms.ToString(responseData.GetHeaderValue("Content-Encoding"));
}
if (responseData.IsHeaderPresent("Content-Length"))
{
response.Headers.ContentLength = long.Parse(responseData.GetHeaderValue("Content-Length"), CultureInfo.InvariantCulture);
}
if (responseData.IsHeaderPresent("Content-Type"))
{
response.Headers.ContentType = S3Transforms.ToString(responseData.GetHeaderValue("Content-Type"));
}
if (responseData.IsHeaderPresent("Expires"))
{
response.Expires = S3Transforms.ToDateTime(responseData.GetHeaderValue("Expires"));
}
if (responseData.IsHeaderPresent("x-amz-website-redirect-location"))
{
response.WebsiteRedirectLocation = S3Transforms.ToString(responseData.GetHeaderValue("x-amz-website-redirect-location"));
}
if (responseData.IsHeaderPresent("x-amz-server-side-encryption"))
{
response.ServerSideEncryptionMethod = S3Transforms.ToString(responseData.GetHeaderValue("x-amz-server-side-encryption"));
}
if (responseData.IsHeaderPresent("x-amz-server-side-encryption-customer-algorithm"))
{
response.ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.FindValue(responseData.GetHeaderValue("x-amz-server-side-encryption-customer-algorithm"));
}
if (responseData.IsHeaderPresent(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader))
{
response.ServerSideEncryptionKeyManagementServiceKeyId = S3Transforms.ToString(responseData.GetHeaderValue(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader));
}
if (responseData.IsHeaderPresent("x-amz-replication-status"))
{
response.ReplicationStatus = S3Transforms.ToString(responseData.GetHeaderValue("x-amz-replication-status"));
}
foreach (var name in responseData.GetHeaderNames())
{
if (name.StartsWith("x-amz-meta-", StringComparison.OrdinalIgnoreCase))
{
response.Metadata[name] = responseData.GetHeaderValue(name);
}
}
return;
}
public IRequest Marshall(DeleteObjectsRequest deleteObjectsRequest)
{
IRequest request = new DefaultRequest(deleteObjectsRequest, "AmazonS3");
request.HttpMethod = "POST";
if (deleteObjectsRequest.IsSetMfaCodes())
{
request.Headers.Add(HeaderKeys.XAmzMfaHeader, deleteObjectsRequest.MfaCodes.FormattedMfaCodes);
}
request.ResourcePath = string.Concat("/", S3Transforms.ToStringValue(deleteObjectsRequest.BucketName));
request.AddSubResource("delete");
var stringWriter = new StringWriter(CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = Encoding.UTF8, OmitXmlDeclaration = true
}))
{
xmlWriter.WriteStartElement("Delete", "");
var deleteDeleteobjectsList = deleteObjectsRequest.Objects;
if (deleteDeleteobjectsList != null && deleteDeleteobjectsList.Count > 0)
{
foreach (var deleteDeleteobjectsListValue in deleteDeleteobjectsList)
{
xmlWriter.WriteStartElement("Object", "");
if (deleteDeleteobjectsListValue.IsSetKey())
{
xmlWriter.WriteElementString("Key", "", S3Transforms.ToXmlStringValue(deleteDeleteobjectsListValue.Key));
}
if (deleteDeleteobjectsListValue.IsSetVersionId())
{
xmlWriter.WriteElementString("VersionId", "", S3Transforms.ToXmlStringValue(deleteDeleteobjectsListValue.VersionId));
}
xmlWriter.WriteEndElement();
}
}
if (deleteObjectsRequest.IsSetQuiet())
{
xmlWriter.WriteElementString("Quiet", "", deleteObjectsRequest.Quiet.ToString().ToLowerInvariant());
}
xmlWriter.WriteEndElement();
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
var checksum = AmazonS3Util.GenerateChecksumForContent(content, true);
request.Headers[HeaderKeys.ContentMD5Header] = checksum;
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
public IRequest Marshall(PutBucketRequest putBucketRequest)
{
IRequest request = new DefaultRequest(putBucketRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (putBucketRequest.IsSetCannedACL())
{
request.Headers.Add(HeaderKeys.XAmzAclHeader, putBucketRequest.CannedACL.Value);
}
else if (putBucketRequest.Grants != null && putBucketRequest.Grants.Count > 0)
{
ConvertPutWithACLRequest(putBucketRequest, request);
}
var uriResourcePath = string.Concat("/", S3Transforms.ToStringValue(putBucketRequest.BucketName));
request.ResourcePath = uriResourcePath;
var stringWriter = new StringWriter(CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = Encoding.UTF8, OmitXmlDeclaration = true
}))
{
string regionCode = null;
var region = putBucketRequest.BucketRegion;
if (region != null && !string.IsNullOrEmpty(region.Value))
{
regionCode = region.Value;
}
else if (!string.IsNullOrEmpty(putBucketRequest.BucketRegionName))
{
if (putBucketRequest.BucketRegionName == "eu-west-1")
{
regionCode = "EU";
}
else if (putBucketRequest.BucketRegionName != "us-east-1")
{
regionCode = putBucketRequest.BucketRegionName;
}
}
if (regionCode != null)
{
xmlWriter.WriteStartElement("PutBucketConfiguration", "");
xmlWriter.WriteElementString("LocationConstraint", "", regionCode);
xmlWriter.WriteEndElement();
}
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
var checksum = AmazonS3Util.GenerateChecksumForContent(content, true);
request.Headers[HeaderKeys.ContentMD5Header] = checksum;
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
public IRequest Marshall(PutCORSConfigurationRequest putCORSConfigurationRequest)
{
IRequest request = new DefaultRequest(putCORSConfigurationRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (putCORSConfigurationRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner, S3Transforms.ToStringValue(putCORSConfigurationRequest.ExpectedBucketOwner));
}
if (string.IsNullOrEmpty(putCORSConfigurationRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "PutCORSConfigurationRequest.BucketName");
}
request.MarshallerVersion = 2;
request.ResourcePath = string.Concat("/", S3Transforms.ToStringValue(putCORSConfigurationRequest.BucketName));
request.AddSubResource("cors");
var stringWriter = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = Encoding.UTF8, OmitXmlDeclaration = true
}))
{
var configuration = putCORSConfigurationRequest.Configuration;
if (configuration != null)
{
xmlWriter.WriteStartElement("CORSConfiguration", "");
if (configuration != null)
{
var cORSConfigurationCORSConfigurationcORSRulesList = configuration.Rules;
if (cORSConfigurationCORSConfigurationcORSRulesList != null && cORSConfigurationCORSConfigurationcORSRulesList.Count > 0)
{
foreach (var cORSConfigurationCORSConfigurationcORSRulesListValue in cORSConfigurationCORSConfigurationcORSRulesList)
{
xmlWriter.WriteStartElement("CORSRule", "");
if (cORSConfigurationCORSConfigurationcORSRulesListValue != null)
{
var cORSRuleMemberallowedMethodsList = cORSConfigurationCORSConfigurationcORSRulesListValue.AllowedMethods;
if (cORSRuleMemberallowedMethodsList != null && cORSRuleMemberallowedMethodsList.Count > 0)
{
foreach (string cORSRuleMemberallowedMethodsListValue in cORSRuleMemberallowedMethodsList)
{
xmlWriter.WriteStartElement("AllowedMethod", "");
xmlWriter.WriteValue(cORSRuleMemberallowedMethodsListValue);
xmlWriter.WriteEndElement();
}
}
}
if (cORSConfigurationCORSConfigurationcORSRulesListValue != null)
{
var cORSRuleMemberallowedOriginsList = cORSConfigurationCORSConfigurationcORSRulesListValue.AllowedOrigins;
if (cORSRuleMemberallowedOriginsList != null && cORSRuleMemberallowedOriginsList.Count > 0)
{
foreach (string cORSRuleMemberallowedOriginsListValue in cORSRuleMemberallowedOriginsList)
{
xmlWriter.WriteStartElement("AllowedOrigin", "");
xmlWriter.WriteValue(cORSRuleMemberallowedOriginsListValue);
xmlWriter.WriteEndElement();
}
}
}
if (cORSConfigurationCORSConfigurationcORSRulesListValue != null)
{
var cORSRuleMemberexposeHeadersList = cORSConfigurationCORSConfigurationcORSRulesListValue.ExposeHeaders;
if (cORSRuleMemberexposeHeadersList != null && cORSRuleMemberexposeHeadersList.Count > 0)
{
foreach (string cORSRuleMemberexposeHeadersListValue in cORSRuleMemberexposeHeadersList)
{
xmlWriter.WriteStartElement("ExposeHeader", "");
xmlWriter.WriteValue(cORSRuleMemberexposeHeadersListValue);
xmlWriter.WriteEndElement();
}
}
}
if (cORSConfigurationCORSConfigurationcORSRulesListValue != null)
{
var cORSRuleMemberallowedHeadersList = cORSConfigurationCORSConfigurationcORSRulesListValue.AllowedHeaders;
if (cORSRuleMemberallowedHeadersList != null && cORSRuleMemberallowedHeadersList.Count > 0)
{
foreach (string cORSRuleMemberallowedHeadersListValue in cORSRuleMemberallowedHeadersList)
{
xmlWriter.WriteStartElement("AllowedHeader", "");
xmlWriter.WriteValue(cORSRuleMemberallowedHeadersListValue);
xmlWriter.WriteEndElement();
}
}
}
if (cORSConfigurationCORSConfigurationcORSRulesListValue.IsSetMaxAgeSeconds())
{
xmlWriter.WriteElementString("MaxAgeSeconds", "", S3Transforms.ToXmlStringValue(cORSConfigurationCORSConfigurationcORSRulesListValue.MaxAgeSeconds));
}
if (cORSConfigurationCORSConfigurationcORSRulesListValue.IsSetId())
{
xmlWriter.WriteElementString("ID", "", S3Transforms.ToXmlStringValue(cORSConfigurationCORSConfigurationcORSRulesListValue.Id));
}
xmlWriter.WriteEndElement();
}
}
}
xmlWriter.WriteEndElement();
}
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
var checksum = AmazonS3Util.GenerateChecksumForContent(content, true);
request.Headers[HeaderKeys.ContentMD5Header] = checksum;
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
public IRequest Marshall(InitiateMultipartUploadRequest initiateMultipartUploadRequest)
{
IRequest request = new DefaultRequest(initiateMultipartUploadRequest, "AmazonS3");
request.HttpMethod = "POST";
if (initiateMultipartUploadRequest.IsSetCannedACL())
{
request.Headers.Add(HeaderKeys.XAmzAclHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.CannedACL));
}
var headers = initiateMultipartUploadRequest.Headers;
foreach (var key in headers.Keys)
{
request.Headers.Add(key, headers[key]);
}
HeaderACLRequestMarshaller.Marshall(request, initiateMultipartUploadRequest);
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionMethod())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.ServerSideEncryptionMethod));
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, initiateMultipartUploadRequest.ServerSideEncryptionCustomerMethod);
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, initiateMultipartUploadRequest.ServerSideEncryptionCustomerProvidedKey);
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, initiateMultipartUploadRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(initiateMultipartUploadRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionKeyManagementServiceKeyId())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader, initiateMultipartUploadRequest.ServerSideEncryptionKeyManagementServiceKeyId);
}
if (initiateMultipartUploadRequest.IsSetStorageClass())
{
request.Headers.Add(HeaderKeys.XAmzStorageClassHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.StorageClass));
}
if (initiateMultipartUploadRequest.IsSetWebsiteRedirectLocation())
{
request.Headers.Add(HeaderKeys.XAmzWebsiteRedirectLocationHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.WebsiteRedirectLocation));
}
AmazonS3Util.SetMetadataHeaders(request, initiateMultipartUploadRequest.Metadata);
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(initiateMultipartUploadRequest.BucketName),
S3Transforms.ToStringValue(initiateMultipartUploadRequest.Key));
request.AddSubResource("uploads");
request.UseQueryString = true;
return(request);
}
public IRequest Marshall(InitiateMultipartUploadRequest initiateMultipartUploadRequest)
{
IRequest request = new DefaultRequest(initiateMultipartUploadRequest, "AmazonS3");
request.HttpMethod = "POST";
if (initiateMultipartUploadRequest.IsSetCannedACL())
{
request.Headers.Add(HeaderKeys.XAmzAclHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.CannedACL));
}
if (initiateMultipartUploadRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner, S3Transforms.ToStringValue(initiateMultipartUploadRequest.ExpectedBucketOwner));
}
var headers = initiateMultipartUploadRequest.Headers;
foreach (var key in headers.Keys)
{
request.Headers.Add(key, headers[key]);
}
HeaderACLRequestMarshaller.Marshall(request, initiateMultipartUploadRequest);
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionMethod())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.ServerSideEncryptionMethod));
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, initiateMultipartUploadRequest.ServerSideEncryptionCustomerMethod);
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, initiateMultipartUploadRequest.ServerSideEncryptionCustomerProvidedKey);
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, initiateMultipartUploadRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(initiateMultipartUploadRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionKeyManagementServiceKeyId())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader, initiateMultipartUploadRequest.ServerSideEncryptionKeyManagementServiceKeyId);
}
if (initiateMultipartUploadRequest.IsSetServerSideEncryptionKeyManagementServiceEncryptionContext())
{
request.Headers.Add("x-amz-server-side-encryption-context", initiateMultipartUploadRequest.ServerSideEncryptionKeyManagementServiceEncryptionContext);
}
if (initiateMultipartUploadRequest.IsSetStorageClass())
{
request.Headers.Add(HeaderKeys.XAmzStorageClassHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.StorageClass));
}
if (initiateMultipartUploadRequest.IsSetWebsiteRedirectLocation())
{
request.Headers.Add(HeaderKeys.XAmzWebsiteRedirectLocationHeader, S3Transforms.ToStringValue(initiateMultipartUploadRequest.WebsiteRedirectLocation));
}
if (initiateMultipartUploadRequest.IsSetRequestPayer())
{
request.Headers.Add(S3Constants.AmzHeaderRequestPayer, S3Transforms.ToStringValue(initiateMultipartUploadRequest.RequestPayer.ToString()));
}
if (initiateMultipartUploadRequest.IsSetObjectLockLegalHoldStatus())
{
request.Headers.Add("x-amz-object-lock-legal-hold", S3Transforms.ToStringValue(initiateMultipartUploadRequest.ObjectLockLegalHoldStatus));
}
if (initiateMultipartUploadRequest.IsSetObjectLockMode())
{
request.Headers.Add("x-amz-object-lock-mode", S3Transforms.ToStringValue(initiateMultipartUploadRequest.ObjectLockMode));
}
if (initiateMultipartUploadRequest.IsSetObjectLockRetainUntilDate())
{
request.Headers.Add("x-amz-object-lock-retain-until-date", S3Transforms.ToStringValue(initiateMultipartUploadRequest.ObjectLockRetainUntilDate, AWSSDKUtils.ISO8601DateFormat));
}
if (initiateMultipartUploadRequest.IsSetTagSet())
{
request.Headers.Add(S3Constants.AmzHeaderTagging, AmazonS3Util.TagSetToQueryString(initiateMultipartUploadRequest.TagSet));
}
AmazonS3Util.SetMetadataHeaders(request, initiateMultipartUploadRequest.Metadata);
if (string.IsNullOrEmpty(initiateMultipartUploadRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "InitiateMultipartUploadRequest.BucketName");
}
if (string.IsNullOrEmpty(initiateMultipartUploadRequest.Key))
{
throw new System.ArgumentException("Key is a required property and must be set before making this call.", "InitiateMultipartUploadRequest.Key");
}
request.MarshallerVersion = 2;
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(initiateMultipartUploadRequest.BucketName),
S3Transforms.ToStringValue(initiateMultipartUploadRequest.Key));
request.AddSubResource("uploads");
request.UseQueryString = true;
return(request);
}
public IRequest Marshall(CopyPartRequest copyPartRequest)
{
IRequest request = new DefaultRequest(copyPartRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (copyPartRequest.IsSetSourceBucket())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceHeader, ConstructCopySourceHeaderValue(copyPartRequest.SourceBucket, copyPartRequest.SourceKey, copyPartRequest.SourceVersionId));
}
if (copyPartRequest.IsSetETagToMatch())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfMatchHeader, AWSSDKUtils.Join(copyPartRequest.ETagToMatch));
}
if (copyPartRequest.IsSetETagToNotMatch())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfNoneMatchHeader, AWSSDKUtils.Join(copyPartRequest.ETagsToNotMatch));
}
if (copyPartRequest.IsSetModifiedSinceDate())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfModifiedSinceHeader, copyPartRequest.ModifiedSinceDate.ToUniversalTime().ToString(AWSSDKUtils.GMTDateFormat, CultureInfo.InvariantCulture));
}
if (copyPartRequest.IsSetUnmodifiedSinceDate())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceIfUnmodifiedSinceHeader, copyPartRequest.UnmodifiedSinceDate.ToUniversalTime().ToString(AWSSDKUtils.GMTDateFormat, CultureInfo.InvariantCulture));
}
if (copyPartRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, copyPartRequest.ServerSideEncryptionCustomerMethod);
}
if (copyPartRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, copyPartRequest.ServerSideEncryptionCustomerProvidedKey);
if (copyPartRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, copyPartRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(copyPartRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (copyPartRequest.IsSetCopySourceServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerAlgorithmHeader, copyPartRequest.CopySourceServerSideEncryptionCustomerMethod);
}
if (copyPartRequest.IsSetCopySourceServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerKeyHeader, copyPartRequest.CopySourceServerSideEncryptionCustomerProvidedKey);
if (copyPartRequest.IsSetCopySourceServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerKeyMD5Header, copyPartRequest.CopySourceServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzCopySourceSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(copyPartRequest.CopySourceServerSideEncryptionCustomerProvidedKey));
}
}
if (copyPartRequest.IsSetServerSideEncryptionKeyManagementServiceKeyId())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader, copyPartRequest.ServerSideEncryptionKeyManagementServiceKeyId);
}
request.Headers.Add(HeaderKeys.XAmzCopySourceRangeHeader, ConstructCopySourceRangeHeader(copyPartRequest.FirstByte, copyPartRequest.LastByte));
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(copyPartRequest.DestinationBucket),
S3Transforms.ToStringValue(copyPartRequest.DestinationKey));
request.AddSubResource("partNumber", S3Transforms.ToStringValue(copyPartRequest.PartNumber));
request.AddSubResource("uploadId", S3Transforms.ToStringValue(copyPartRequest.UploadId));
request.UseQueryString = true;
return(request);
}
static string ConstructCopySourceHeaderValue(string bucket, string key, string version)
{
string source;
if (!String.IsNullOrEmpty(key))
{
source = AmazonS3Util.UrlEncode(String.Concat("/", bucket, "/", key), true);
if (!String.IsNullOrEmpty(version))
{
source = string.Format(CultureInfo.InvariantCulture, "{0}?versionId={1}", source, AmazonS3Util.UrlEncode(version, true));
}
}
else
{
source = AmazonS3Util.UrlEncode(bucket, true);
}
return(source);
}
/// <summary>
/// Create a signed URL allowing access to a resource that would
/// usually require authentication.
/// </summary>
/// <remarks>
/// <para>
/// When using query string authentication you create a query,
/// specify an expiration time for the query, sign it with your
/// signature, place the data in an HTTP request, and distribute
/// the request to a user or embed the request in a web page.
/// </para>
/// <para>
/// A PreSigned URL can be generated for GET, PUT, DELETE and HEAD
/// operations on your bucketName, keys, and versions.
/// </para>
/// </remarks>
/// <param name="request">The GetPreSignedUrlRequest that defines the
/// parameters of the operation.</param>
/// <param name="useSigV2Fallback">determines if signing will fall back to SigV2 if the
/// signing region is us-east-1</param>
/// <returns>A string that is the signed http request.</returns>
/// <exception cref="T:System.ArgumentException" />
/// <exception cref="T:System.ArgumentNullException" />
internal string GetPreSignedURLInternal(GetPreSignedUrlRequest request, bool useSigV2Fallback = true)
{
if (Credentials == null)
{
throw new AmazonS3Exception("Credentials must be specified, cannot call method anonymously");
}
if (request == null)
{
throw new ArgumentNullException("request", "The PreSignedUrlRequest specified is null!");
}
if (!request.IsSetExpires())
{
throw new InvalidOperationException("The Expires specified is null!");
}
var signatureVersionToUse = AWSConfigsS3.UseSignatureVersion4 ? SignatureVersion.SigV4 : SignatureVersion.SigV2;
Arn arn;
string accessPoint;
if (Arn.TryParse(request.BucketName, out arn) &&
(arn.TryParseAccessPoint(out accessPoint) || arn.IsOutpostArn()))
{
signatureVersionToUse = SignatureVersion.SigV4;
if (arn.IsMRAPArn())
{
signatureVersionToUse = SignatureVersion.SigV4a;
}
}
else
{
var region = AWS4Signer.DetermineSigningRegion(Config, "s3", alternateEndpoint: null, request: null);
if (signatureVersionToUse == SignatureVersion.SigV4 && string.IsNullOrEmpty(region))
{
throw new InvalidOperationException("To use AWS4 signing, a region must be specified in the client configuration using the AuthenticationRegion or Region properties, or be determinable from the service URL.");
}
RegionEndpoint endpoint = RegionEndpoint.GetBySystemName(region);
var s3SignatureVersionOverride = endpoint.GetEndpointForService("s3", Config.ToGetEndpointForServiceOptions()).SignatureVersionOverride;
if (s3SignatureVersionOverride == "4" || s3SignatureVersionOverride == null)
{
signatureVersionToUse = SignatureVersion.SigV4;
}
var fallbackToSigV2 = useSigV2Fallback && !AWSConfigsS3.UseSigV4SetExplicitly;
if (endpoint?.SystemName == RegionEndpoint.USEast1.SystemName && fallbackToSigV2)
{
signatureVersionToUse = SignatureVersion.SigV2;
}
// If the expiration is longer than SigV4 will allow then automatically use SigV2 instead.
// But only if the region we're signing for allows SigV2.
if (signatureVersionToUse == SignatureVersion.SigV4)
{
var secondsUntilExpiration = GetSecondsUntilExpiration(this.Config, request, signatureVersionToUse);
if (secondsUntilExpiration > AWS4PreSignedUrlSigner.MaxAWS4PreSignedUrlExpiry &&
s3SignatureVersionOverride == "2")
{
signatureVersionToUse = SignatureVersion.SigV2;
}
}
}
var immutableCredentials = Credentials.GetCredentials();
var irequest = Marshall(this.Config, request, immutableCredentials.AccessKey, immutableCredentials.Token, signatureVersionToUse);
irequest.Endpoint = EndpointResolver.DetermineEndpoint(this.Config, irequest);
var context = new Amazon.Runtime.Internal.ExecutionContext(new Amazon.Runtime.Internal.RequestContext(true, new NullSigner())
{
Request = irequest, ClientConfig = this.Config
}, null);
AmazonS3PostMarshallHandler.ProcessRequestHandlers(context);
var metrics = new RequestMetrics();
string result;
string authorization;
switch (signatureVersionToUse)
{
case SignatureVersion.SigV4a:
var aws4aSigner = new AWS4aSignerCRTWrapper();
var signingResult4a = aws4aSigner.Presign4a(irequest,
Config,
metrics,
immutableCredentials,
"s3",
arn.IsMRAPArn() ? "*" : "");
result = signingResult4a.PresignedUri;
break;
case SignatureVersion.SigV4:
var aws4Signer = new AWS4PreSignedUrlSigner();
var signingResult4 = aws4Signer.SignRequest(irequest,
Config,
metrics,
immutableCredentials.AccessKey,
immutableCredentials.SecretKey);
authorization = "&" + signingResult4.ForQueryParameters;
result = ComposeUrl(irequest).AbsoluteUri + authorization;
break;
default: // SigV2
Amazon.S3.Internal.S3Signer.SignRequest(irequest, metrics, immutableCredentials.AccessKey, immutableCredentials.SecretKey);
authorization = irequest.Headers[HeaderKeys.AuthorizationHeader];
authorization = authorization.Substring(authorization.IndexOf(":", StringComparison.Ordinal) + 1);
authorization = "&Signature=" + AmazonS3Util.UrlEncode(authorization, false);
result = ComposeUrl(irequest).AbsoluteUri + authorization;
break;
}
Protocol protocol = DetermineProtocol();
if (request.Protocol != protocol)
{
switch (protocol)
{
case Protocol.HTTP:
result = result.Replace("http://", "https://");
break;
case Protocol.HTTPS:
result = result.Replace("https://", "http://");
break;
}
}
return(result);
}
public static void ClassCleanup()
{
AmazonS3Util.DeleteS3BucketWithObjects(Client, bucketName);
BaseClean();
Directory.Delete(basePath, true);
}
public IRequest Marshall(PutBucketLoggingRequest putBucketLoggingRequest)
{
IRequest request = new DefaultRequest(putBucketLoggingRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (string.IsNullOrEmpty(putBucketLoggingRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "PutBucketLoggingRequest.BucketName");
}
request.ResourcePath = string.Concat("/", S3Transforms.ToStringValue(putBucketLoggingRequest.BucketName));
request.AddSubResource("logging");
var stringWriter = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = System.Text.Encoding.UTF8, OmitXmlDeclaration = true
}))
{
xmlWriter.WriteStartElement("BucketLoggingStatus", "");
var bucketLoggingStatusBucketLoggingStatus = putBucketLoggingRequest.LoggingConfig;
if (bucketLoggingStatusBucketLoggingStatus != null)
{
if (bucketLoggingStatusBucketLoggingStatus != null)
{
var loggingEnabledLoggingEnabled = bucketLoggingStatusBucketLoggingStatus;
if (loggingEnabledLoggingEnabled != null && loggingEnabledLoggingEnabled.IsSetTargetBucket())
{
xmlWriter.WriteStartElement("LoggingEnabled", "");
xmlWriter.WriteElementString("TargetBucket", "", S3Transforms.ToXmlStringValue(loggingEnabledLoggingEnabled.TargetBucketName));
var loggingEnabledLoggingEnabledtargetGrantsList = loggingEnabledLoggingEnabled.Grants;
if (loggingEnabledLoggingEnabledtargetGrantsList != null && loggingEnabledLoggingEnabledtargetGrantsList.Count > 0)
{
xmlWriter.WriteStartElement("TargetGrants", "");
foreach (var loggingEnabledLoggingEnabledtargetGrantsListValue in loggingEnabledLoggingEnabledtargetGrantsList)
{
xmlWriter.WriteStartElement("Grant", "");
if (loggingEnabledLoggingEnabledtargetGrantsListValue != null)
{
var granteeGrantee = loggingEnabledLoggingEnabledtargetGrantsListValue.Grantee;
if (granteeGrantee != null)
{
xmlWriter.WriteStartElement("Grantee", "");
if (granteeGrantee.IsSetType())
{
xmlWriter.WriteAttributeString("xsi", "type", "http://www.w3.org/2001/XMLSchema-instance", granteeGrantee.Type.ToString());
}
if (granteeGrantee.IsSetDisplayName())
{
xmlWriter.WriteElementString("DisplayName", "", S3Transforms.ToXmlStringValue(granteeGrantee.DisplayName));
}
if (granteeGrantee.IsSetEmailAddress())
{
xmlWriter.WriteElementString("EmailAddress", "", S3Transforms.ToXmlStringValue(granteeGrantee.EmailAddress));
}
if (granteeGrantee.IsSetCanonicalUser())
{
xmlWriter.WriteElementString("ID", "", S3Transforms.ToXmlStringValue(granteeGrantee.CanonicalUser));
}
if (granteeGrantee.IsSetURI())
{
xmlWriter.WriteElementString("URI", "", S3Transforms.ToXmlStringValue(granteeGrantee.URI));
}
xmlWriter.WriteEndElement();
}
if (loggingEnabledLoggingEnabledtargetGrantsListValue.IsSetPermission())
{
xmlWriter.WriteElementString("Permission", "", S3Transforms.ToXmlStringValue(loggingEnabledLoggingEnabledtargetGrantsListValue.Permission));
}
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
if (loggingEnabledLoggingEnabled.IsSetTargetPrefix())
{
xmlWriter.WriteElementString("TargetPrefix", "", S3Transforms.ToXmlStringValue(loggingEnabledLoggingEnabled.TargetPrefix));
}
else
{
xmlWriter.WriteStartElement("TargetPrefix");
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
}
}
xmlWriter.WriteEndElement();
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
var checksum = AmazonS3Util.GenerateChecksumForContent(content, true);
request.Headers[HeaderKeys.ContentMD5Header] = checksum;
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
async Task <(bool x, bool y)> Run(string[] args)
{
Initialized();
//バケットリストを表示する
ListBucketsResponse res1 = await m_client.ListBucketsAsync();
foreach (S3Bucket bucket in res1.Buckets)
{
Console.WriteLine("{0}", bucket.BucketName);
}
//バケットを作成する
var bucketName = @"bucket03";
bool isExisted = await AmazonS3Util.DoesS3BucketExistV2Async(m_client, bucketName);
if (isExisted == false)
{
PutBucketRequest req2 = new PutBucketRequest {
BucketName = bucketName, UseClientRegion = true
};
PutBucketResponse res2 = await m_client.PutBucketAsync(req2);
if (res2 != null)
{
Console.Write($"バケットの作成に失敗しました。{bucketName}");
}
}
else
{
Console.Write($"既にバケットはある。BucketName={bucketName}");
}
//ファイルをアップロードする
//二度目は更新されます。
var req3 = new PutObjectRequest
{
BucketName = "bucket01",
Key = "TextFile.txt",
FilePath = @"TextFile.txt",
};
var res3 = await m_client.PutObjectAsync(req3);
if (res3?.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
Console.WriteLine($"ファイルのアップロードは成功した。BucketName={bucketName}");
}
//ファイルをダウンロードする
//https://dev.classmethod.jp/articles/use-dot-net-core-and-aws-sdk-for-dot-net/
var req4 = new GetObjectRequest {
BucketName = "bucket01", Key = "abe.txt"
};
using (var res4 = await m_client.GetObjectAsync(req4))
using (var streamReader = new StreamReader(res4.ResponseStream))
{
if (res4.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
Console.WriteLine($"ファイルのダウンロードに成功した。");
}
Console.WriteLine(streamReader.ReadToEnd());
}
return(x : true, y : true);
}
/// <summary>
/// Create a signed URL allowing access to a resource that would
/// usually require authentication.
/// </summary>
/// <remarks>
/// <para>
/// When using query string authentication you create a query,
/// specify an expiration time for the query, sign it with your
/// signature, place the data in an HTTP request, and distribute
/// the request to a user or embed the request in a web page.
/// </para>
/// <para>
/// A PreSigned URL can be generated for GET, PUT, DELETE and HEAD
/// operations on your bucketName, keys, and versions.
/// </para>
/// </remarks>
/// <param name="request">The GetPreSignedUrlRequest that defines the
/// parameters of the operation.</param>
/// <returns>A string that is the signed http request.</returns>
/// <exception cref="T:System.ArgumentException" />
/// <exception cref="T:System.ArgumentNullException" />
public string GetPreSignedURL(GetPreSignedUrlRequest request)
{
if (Credentials == null)
{
throw new AmazonS3Exception("Credentials must be specified, cannot call method anonymously");
}
if (request == null)
{
throw new ArgumentNullException("request", "The PreSignedUrlRequest specified is null!");
}
if (!request.IsSetExpires())
{
throw new InvalidOperationException("The Expires specified is null!");
}
var aws4Signing = AWSConfigs.S3UseSignatureVersion4;
var region = AWS4Signer.DetermineRegion(Config);
if (aws4Signing && string.IsNullOrEmpty(region))
{
throw new InvalidOperationException("To use AWS4 signing, a region must be specified in the client configuration using the AuthenticationRegion or Region properties, or be determinable from the service URL.");
}
if (region.Equals(RegionEndpoint.CNNorth1.SystemName, StringComparison.OrdinalIgnoreCase))
{
aws4Signing = true;
}
var immutableCredentials = Credentials.GetCredentials();
var irequest = Marshall(request, immutableCredentials.AccessKey, immutableCredentials.Token, aws4Signing);
irequest.Endpoint = DetermineEndpoint(irequest);
ProcessRequestHandlers(irequest);
var metrics = new RequestMetrics();
string authorization;
if (aws4Signing)
{
var aws4Signer = new AWS4PreSignedUrlSigner();
var signingResult = aws4Signer.SignRequest(irequest,
this.Config,
metrics,
immutableCredentials.AccessKey,
immutableCredentials.SecretKey);
authorization = "&" + signingResult.ForQueryParameters;
}
else
{
signer.SignRequest(irequest, metrics, immutableCredentials.AccessKey, immutableCredentials.SecretKey);
authorization = irequest.Headers[S3QueryParameter.Authorization.ToString()];
authorization = authorization.Substring(authorization.IndexOf(":", StringComparison.Ordinal) + 1);
authorization = "&Signature=" + AmazonS3Util.UrlEncode(authorization, false);
}
Uri url = ComposeUrl(irequest, irequest.Endpoint);
string result = url.AbsoluteUri + authorization;
Protocol protocol = DetermineProtocol();
if (request.Protocol != protocol)
{
switch (protocol)
{
case Protocol.HTTP:
result = result.Replace("http://", "https://");
break;
case Protocol.HTTPS:
result = result.Replace("https://", "http://");
break;
}
}
return(result);
}
public IRequest Marshall(UploadPartRequest uploadPartRequest)
{
IRequest request = new DefaultRequest(uploadPartRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (uploadPartRequest.IsSetMD5Digest())
{
request.Headers[HeaderKeys.ContentMD5Header] = uploadPartRequest.MD5Digest;
}
if (uploadPartRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, uploadPartRequest.ServerSideEncryptionCustomerMethod);
}
if (uploadPartRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, uploadPartRequest.ServerSideEncryptionCustomerProvidedKey);
if (uploadPartRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, uploadPartRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(uploadPartRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(uploadPartRequest.BucketName),
S3Transforms.ToStringValue(uploadPartRequest.Key));
if (uploadPartRequest.IsSetPartNumber())
{
request.AddSubResource("partNumber", S3Transforms.ToStringValue(uploadPartRequest.PartNumber));
}
if (uploadPartRequest.IsSetUploadId())
{
request.AddSubResource("uploadId", S3Transforms.ToStringValue(uploadPartRequest.UploadId));
}
if (uploadPartRequest.InputStream != null)
{
// Wrap input stream in partial wrapper (to upload only part of the stream)
var partialStream = new PartialWrapperStream(uploadPartRequest.InputStream, uploadPartRequest.PartSize);
if (partialStream.Length > 0)
{
request.UseChunkEncoding = true;
}
if (!request.Headers.ContainsKey(HeaderKeys.ContentLengthHeader))
{
request.Headers.Add(HeaderKeys.ContentLengthHeader, partialStream.Length.ToString(CultureInfo.InvariantCulture));
}
// Wrap input stream in MD5Stream; after this we can no longer seek or position the stream
var hashStream = new MD5Stream(partialStream, null, partialStream.Length);
uploadPartRequest.InputStream = hashStream;
}
request.ContentStream = uploadPartRequest.InputStream;
if (!request.Headers.ContainsKey(HeaderKeys.ContentTypeHeader))
{
request.Headers.Add(HeaderKeys.ContentTypeHeader, "text/plain");
}
return(request);
}
public IRequest Marshall(UploadPartRequest uploadPartRequest)
{
IRequest request = new DefaultRequest(uploadPartRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (uploadPartRequest.IsSetMD5Digest())
{
request.Headers[HeaderKeys.ContentMD5Header] = uploadPartRequest.MD5Digest;
}
if (uploadPartRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, uploadPartRequest.ServerSideEncryptionCustomerMethod);
}
if (uploadPartRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, uploadPartRequest.ServerSideEncryptionCustomerProvidedKey);
if (uploadPartRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, uploadPartRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(uploadPartRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (uploadPartRequest.IsSetRequestPayer())
{
request.Headers.Add(S3Constants.AmzHeaderRequestPayer, S3Transforms.ToStringValue(uploadPartRequest.RequestPayer.ToString()));
}
if (uploadPartRequest.IsSetExpectedBucketOwner())
{
request.Headers.Add(S3Constants.AmzHeaderExpectedBucketOwner, S3Transforms.ToStringValue(uploadPartRequest.ExpectedBucketOwner));
}
if (string.IsNullOrEmpty(uploadPartRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "UploadPartRequest.BucketName");
}
if (string.IsNullOrEmpty(uploadPartRequest.Key))
{
throw new System.ArgumentException("Key is a required property and must be set before making this call.", "UploadPartRequest.Key");
}
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(uploadPartRequest.BucketName),
S3Transforms.ToStringValue(uploadPartRequest.Key));
if (uploadPartRequest.IsSetPartNumber())
{
request.AddSubResource("partNumber", S3Transforms.ToStringValue(uploadPartRequest.PartNumber));
}
if (uploadPartRequest.IsSetUploadId())
{
request.AddSubResource("uploadId", S3Transforms.ToStringValue(uploadPartRequest.UploadId));
}
if (uploadPartRequest.InputStream != null)
{
// Wrap input stream in partial wrapper (to upload only part of the stream)
var partialStream = new PartialWrapperStream(uploadPartRequest.InputStream, uploadPartRequest.PartSize);
if (partialStream.Length > 0 && !(uploadPartRequest.DisablePayloadSigning ?? false))
{
request.UseChunkEncoding = uploadPartRequest.UseChunkEncoding;
}
if (!request.Headers.ContainsKey(HeaderKeys.ContentLengthHeader))
{
request.Headers.Add(HeaderKeys.ContentLengthHeader, partialStream.Length.ToString(CultureInfo.InvariantCulture));
}
request.DisablePayloadSigning = uploadPartRequest.DisablePayloadSigning;
if (!(uploadPartRequest.DisableMD5Stream ?? AWSConfigsS3.DisableMD5Stream))
{
// Wrap input stream in MD5Stream; after this we can no longer seek or position the stream
var hashStream = new MD5Stream(partialStream, null, partialStream.Length);
uploadPartRequest.InputStream = hashStream;
}
else
{
uploadPartRequest.InputStream = partialStream;
}
}
request.ContentStream = uploadPartRequest.InputStream;
if (!request.Headers.ContainsKey(HeaderKeys.ContentTypeHeader))
{
request.Headers.Add(HeaderKeys.ContentTypeHeader, "text/plain");
}
return(request);
}
public void CreateBucketAsyncTest()
{
bool isOk = AmazonS3Util.DoesS3BucketExistAsync(s3Client, _bucketName).Result;
Assert.IsTrue(isOk);
}
public IRequest Marshall(PutLifecycleConfigurationRequest putLifecycleConfigurationRequest)
{
IRequest request = new DefaultRequest(putLifecycleConfigurationRequest, "AmazonS3");
request.HttpMethod = "PUT";
request.ResourcePath = string.Concat("/", S3Transforms.ToStringValue(putLifecycleConfigurationRequest.BucketName));
request.AddSubResource("lifecycle");
var stringWriter = new StringWriter(System.Globalization.CultureInfo.InvariantCulture);
using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Encoding = Encoding.UTF8, OmitXmlDeclaration = true
}))
{
var lifecycleConfigurationLifecycleConfiguration = putLifecycleConfigurationRequest.Configuration;
if (lifecycleConfigurationLifecycleConfiguration != null)
{
xmlWriter.WriteStartElement("LifecycleConfiguration", "");
if (lifecycleConfigurationLifecycleConfiguration != null)
{
var lifecycleConfigurationLifecycleConfigurationrulesList = lifecycleConfigurationLifecycleConfiguration.Rules;
if (lifecycleConfigurationLifecycleConfigurationrulesList != null && lifecycleConfigurationLifecycleConfigurationrulesList.Count > 0)
{
foreach (var lifecycleConfigurationLifecycleConfigurationrulesListValue in lifecycleConfigurationLifecycleConfigurationrulesList)
{
xmlWriter.WriteStartElement("Rule", "");
if (lifecycleConfigurationLifecycleConfigurationrulesListValue != null)
{
var expiration = lifecycleConfigurationLifecycleConfigurationrulesListValue.Expiration;
if (expiration != null)
{
xmlWriter.WriteStartElement("Expiration", "");
if (expiration.IsSetDate())
{
xmlWriter.WriteElementString("Date", "", S3Transforms.ToXmlStringValue(expiration.Date));
}
if (expiration.IsSetDays())
{
xmlWriter.WriteElementString("Days", "", S3Transforms.ToXmlStringValue(expiration.Days));
}
xmlWriter.WriteEndElement();
}
var transitions = lifecycleConfigurationLifecycleConfigurationrulesListValue.Transitions;
if (transitions != null && transitions.Count > 0)
{
foreach (var transition in transitions)
{
if (transition != null)
{
xmlWriter.WriteStartElement("Transition", "");
if (transition.IsSetDate())
{
xmlWriter.WriteElementString("Date", "", S3Transforms.ToXmlStringValue(transition.Date));
}
if (transition.IsSetDays())
{
xmlWriter.WriteElementString("Days", "", S3Transforms.ToXmlStringValue(transition.Days));
}
if (transition.IsSetStorageClass())
{
xmlWriter.WriteElementString("StorageClass", "", S3Transforms.ToXmlStringValue(transition.StorageClass));
}
xmlWriter.WriteEndElement();
}
}
}
var noncurrentVersionExpiration = lifecycleConfigurationLifecycleConfigurationrulesListValue.NoncurrentVersionExpiration;
if (noncurrentVersionExpiration != null)
{
xmlWriter.WriteStartElement("NoncurrentVersionExpiration", "");
if (noncurrentVersionExpiration.IsSetNoncurrentDays())
{
xmlWriter.WriteElementString("NoncurrentDays", "", S3Transforms.ToXmlStringValue(noncurrentVersionExpiration.NoncurrentDays));
}
xmlWriter.WriteEndElement();
}
var noncurrentVersionTransitions = lifecycleConfigurationLifecycleConfigurationrulesListValue.NoncurrentVersionTransitions;
if (noncurrentVersionTransitions != null && noncurrentVersionTransitions.Count > 0)
{
foreach (var noncurrentVersionTransition in noncurrentVersionTransitions)
{
if (noncurrentVersionTransition != null)
{
xmlWriter.WriteStartElement("NoncurrentVersionTransition", "");
if (noncurrentVersionTransition.IsSetNoncurrentDays())
{
xmlWriter.WriteElementString("NoncurrentDays", "", S3Transforms.ToXmlStringValue(noncurrentVersionTransition.NoncurrentDays));
}
if (noncurrentVersionTransition.IsSetStorageClass())
{
xmlWriter.WriteElementString("StorageClass", "", S3Transforms.ToXmlStringValue(noncurrentVersionTransition.StorageClass));
}
xmlWriter.WriteEndElement();
}
}
}
}
if (lifecycleConfigurationLifecycleConfigurationrulesListValue.IsSetId())
{
xmlWriter.WriteElementString("ID", "", S3Transforms.ToXmlStringValue(lifecycleConfigurationLifecycleConfigurationrulesListValue.Id));
}
if (lifecycleConfigurationLifecycleConfigurationrulesListValue.IsSetPrefix())
{
xmlWriter.WriteElementString("Prefix", "", S3Transforms.ToXmlStringValue(lifecycleConfigurationLifecycleConfigurationrulesListValue.Prefix));
}
if (lifecycleConfigurationLifecycleConfigurationrulesListValue.IsSetStatus())
{
xmlWriter.WriteElementString("Status", "", S3Transforms.ToXmlStringValue(lifecycleConfigurationLifecycleConfigurationrulesListValue.Status));
}
else
{
xmlWriter.WriteElementString("Status", "", "Disabled");
}
xmlWriter.WriteEndElement();
}
}
}
xmlWriter.WriteEndElement();
}
}
try
{
var content = stringWriter.ToString();
request.Content = Encoding.UTF8.GetBytes(content);
request.Headers[HeaderKeys.ContentTypeHeader] = "application/xml";
var checksum = AmazonS3Util.GenerateChecksumForContent(content, true);
request.Headers[HeaderKeys.ContentMD5Header] = checksum;
}
catch (EncoderFallbackException e)
{
throw new AmazonServiceException("Unable to marshall request to XML", e);
}
return(request);
}
public async Task TestS3EventLambdaFunction()
{
var accessKey = Configuration["AWS:AccessKeyId"];
var secretKey = Configuration["AWS:SecretKey"];
IAmazonS3 s3Client = new AmazonS3Client(new BasicAWSCredentials(accessKey, secretKey), RegionEndpoint.APSoutheast2);
var bucketName = "lambda-LambdaS3test-".ToLower() + DateTime.Now.Ticks;
var key = "abcd1234";
var contextMock = new Mock <ILambdaContext>();
contextMock.Setup(x => x.Logger).Returns(new TestLambdaLogger());
// Create a bucket an object to setup a test data.
await s3Client.PutBucketAsync(bucketName);
try
{
var imageData = new Models.ObjectModel();
imageData.ImageData = await ReadImageBase64("TestData\\borders.jpg");
await s3Client.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = JsonConvert.SerializeObject(imageData)
});
// Setup the S3 event object that S3 notifications would create with the fields used by the Lambda function.
var s3Event = new S3Event
{
Records = new List <S3EventNotification.S3EventNotificationRecord>
{
new S3EventNotification.S3EventNotificationRecord
{
S3 = new S3EventNotification.S3Entity
{
Bucket = new S3EventNotification.S3BucketEntity {
Name = bucketName
},
Object = new S3EventNotification.S3ObjectEntity {
Key = key
}
},
EventName = EventType.ObjectCreatedPut
}
}
};
// Invoke the lambda function and confirm the content type was returned.
var function = new Function(s3Client);
var contentType = await function.FunctionHandler(s3Event, contextMock.Object);
Assert.Equal(null, contentType);
Assert.True(true, "Succeeded");
}
catch (Exception e)
{
Assert.True(false, "Not succeeded");
}
finally
{
// Clean up the test data
await AmazonS3Util.DeleteS3BucketWithObjectsAsync(s3Client, bucketName);
}
}
static string ConstructCopySourceHeaderValue(string bucket, string key, string version)
{
string source;
if (!String.IsNullOrEmpty(key))
{
var sourceKey = key.StartsWith("/", StringComparison.Ordinal)
? key.Substring(1)
: key;
source = AmazonS3Util.UrlEncode(String.Concat("/", bucket, "/", sourceKey), true);
if (!String.IsNullOrEmpty(version))
{
source = string.Format(CultureInfo.InvariantCulture, "{0}?versionId={1}", source, AmazonS3Util.UrlEncode(version, true));
}
}
else
{
source = AmazonS3Util.UrlEncode(bucket, true);
}
return(source);
}
public IRequest Marshall(PutObjectRequest putObjectRequest)
{
IRequest request = new DefaultRequest(putObjectRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (putObjectRequest.IsSetCannedACL())
{
request.Headers.Add(HeaderKeys.XAmzAclHeader, S3Transforms.ToStringValue(putObjectRequest.CannedACL));
}
var headers = putObjectRequest.Headers;
foreach (var key in headers.Keys)
{
request.Headers[key] = headers[key];
}
if (putObjectRequest.IsSetMD5Digest())
{
request.Headers[HeaderKeys.ContentMD5Header] = putObjectRequest.MD5Digest;
}
HeaderACLRequestMarshaller.Marshall(request, putObjectRequest);
if (putObjectRequest.IsSetServerSideEncryptionMethod())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionHeader, S3Transforms.ToStringValue(putObjectRequest.ServerSideEncryptionMethod));
}
if (putObjectRequest.IsSetStorageClass())
{
request.Headers.Add(HeaderKeys.XAmzStorageClassHeader, S3Transforms.ToStringValue(putObjectRequest.StorageClass));
}
if (putObjectRequest.IsSetWebsiteRedirectLocation())
{
request.Headers.Add(HeaderKeys.XAmzWebsiteRedirectLocationHeader, S3Transforms.ToStringValue(putObjectRequest.WebsiteRedirectLocation));
}
if (putObjectRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, putObjectRequest.ServerSideEncryptionCustomerMethod);
}
if (putObjectRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyHeader, putObjectRequest.ServerSideEncryptionCustomerProvidedKey);
if (putObjectRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, putObjectRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerKeyMD5Header, AmazonS3Util.ComputeEncodedMD5FromEncodedString(putObjectRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (putObjectRequest.IsSetServerSideEncryptionKeyManagementServiceKeyId())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader, putObjectRequest.ServerSideEncryptionKeyManagementServiceKeyId);
}
if (putObjectRequest.IsSetObjectLockLegalHoldStatus())
{
request.Headers.Add("x-amz-object-lock-legal-hold", S3Transforms.ToStringValue(putObjectRequest.ObjectLockLegalHoldStatus));
}
if (putObjectRequest.IsSetObjectLockMode())
{
request.Headers.Add("x-amz-object-lock-mode", S3Transforms.ToStringValue(putObjectRequest.ObjectLockMode));
}
if (putObjectRequest.IsSetObjectLockRetainUntilDate())
{
request.Headers.Add("x-amz-object-lock-retain-until-date", S3Transforms.ToStringValue(putObjectRequest.ObjectLockRetainUntilDate, AWSSDKUtils.ISO8601DateFormat));
}
if (putObjectRequest.IsSetRequestPayer())
{
request.Headers.Add(S3Constants.AmzHeaderRequestPayer, S3Transforms.ToStringValue(putObjectRequest.RequestPayer.ToString()));
}
if (putObjectRequest.IsSetTagSet())
{
request.Headers.Add(S3Constants.AmzHeaderTagging, AmazonS3Util.TagSetToQueryString(putObjectRequest.TagSet));
}
AmazonS3Util.SetMetadataHeaders(request, putObjectRequest.Metadata);
if (string.IsNullOrEmpty(putObjectRequest.BucketName))
{
throw new System.ArgumentException("BucketName is a required property and must be set before making this call.", "PutObjectRequest.BucketName");
}
if (string.IsNullOrEmpty(putObjectRequest.Key))
{
throw new System.ArgumentException("Key is a required property and must be set before making this call.", "PutObjectRequest.Key");
}
request.ResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(putObjectRequest.BucketName),
S3Transforms.ToStringValue(putObjectRequest.Key));
if (putObjectRequest.InputStream != null)
{
// Wrap the stream in a stream that has a length
var streamWithLength = GetStreamWithLength(putObjectRequest.InputStream, putObjectRequest.Headers.ContentLength);
if (streamWithLength.Length > 0)
{
request.UseChunkEncoding = putObjectRequest.UseChunkEncoding;
}
var length = streamWithLength.Length - streamWithLength.Position;
if (!request.Headers.ContainsKey(HeaderKeys.ContentLengthHeader))
{
request.Headers.Add(HeaderKeys.ContentLengthHeader, length.ToString(CultureInfo.InvariantCulture));
}
// Wrap input stream in MD5Stream
var hashStream = new MD5Stream(streamWithLength, null, length);
putObjectRequest.InputStream = hashStream;
}
request.ContentStream = putObjectRequest.InputStream;
if (!request.Headers.ContainsKey(HeaderKeys.ContentTypeHeader))
{
request.Headers.Add(HeaderKeys.ContentTypeHeader, "text/plain");
}
return(request);
}
public void ServerSideEncryptionBYOKPutAndGet()
{
var bucketName = S3TestUtils.CreateBucket(Client);
try
{
Aes aesEncryption = Aes.Create();
aesEncryption.KeySize = 256;
aesEncryption.GenerateKey();
string base64Key = Convert.ToBase64String(aesEncryption.Key);
string base64KeyMd5 = ComputeEncodedMD5FromEncodedString(base64Key);
PutObjectRequest putRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = "The Data To Encrypt in S3",
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
ServerSideEncryptionCustomerProvidedKeyMD5 = base64KeyMd5
};
Client.PutObject(putRequest);
GetObjectMetadataRequest getObjectMetadataRequest = new GetObjectMetadataRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
ServerSideEncryptionCustomerProvidedKeyMD5 = base64KeyMd5
};
GetObjectMetadataResponse getObjectMetadataResponse = Client.GetObjectMetadata(getObjectMetadataRequest);
Assert.AreEqual(ServerSideEncryptionCustomerMethod.AES256, getObjectMetadataResponse.ServerSideEncryptionCustomerMethod);
GetObjectRequest getObjectRequest = new GetObjectRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = base64Key,
ServerSideEncryptionCustomerProvidedKeyMD5 = base64KeyMd5
};
using (GetObjectResponse getResponse = Client.GetObject(getObjectRequest))
using (StreamReader reader = new StreamReader(getResponse.ResponseStream))
{
string content = reader.ReadToEnd();
Assert.AreEqual(putRequest.ContentBody, content);
Assert.AreEqual(ServerSideEncryptionCustomerMethod.AES256, getResponse.ServerSideEncryptionCustomerMethod);
}
GetPreSignedUrlRequest getPresignedUrlRequest = new GetPreSignedUrlRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
Expires = DateTime.Now.AddMinutes(5)
};
var url = Client.GetPreSignedURL(getPresignedUrlRequest);
var webRequest = HttpWebRequest.Create(url);
webRequest.Headers.Add("x-amz-server-side-encryption-customer-algorithm", "AES256");
webRequest.Headers.Add("x-amz-server-side-encryption-customer-key", base64Key);
webRequest.Headers.Add("x-amz-server-side-encryption-customer-key-MD5", base64KeyMd5);
using (var response = webRequest.GetResponse())
using (var reader = new StreamReader(response.GetResponseStream()))
{
var contents = reader.ReadToEnd();
Assert.AreEqual(putRequest.ContentBody, contents);
}
aesEncryption.GenerateKey();
string copyBase64Key = Convert.ToBase64String(aesEncryption.Key);
CopyObjectRequest copyRequest = new CopyObjectRequest
{
SourceBucket = bucketName,
SourceKey = key,
DestinationBucket = bucketName,
DestinationKey = "EncryptedObject_Copy",
CopySourceServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
CopySourceServerSideEncryptionCustomerProvidedKey = base64Key,
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = copyBase64Key
};
Client.CopyObject(copyRequest);
getObjectMetadataRequest = new GetObjectMetadataRequest
{
BucketName = bucketName,
Key = "EncryptedObject_Copy",
ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256,
ServerSideEncryptionCustomerProvidedKey = copyBase64Key
};
getObjectMetadataResponse = Client.GetObjectMetadata(getObjectMetadataRequest);
Assert.AreEqual(ServerSideEncryptionCustomerMethod.AES256, getObjectMetadataResponse.ServerSideEncryptionCustomerMethod);
// Test calls against HTTP client, some should fail on the client
using (var httpClient = CreateHttpClient())
{
getObjectMetadataRequest.ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.None;
getObjectMetadataRequest.ServerSideEncryptionCustomerProvidedKey = null;
AssertExtensions.ExpectException(() =>
httpClient.GetObjectMetadata(getObjectMetadataRequest), typeof(AmazonS3Exception));
getObjectMetadataRequest.ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256;
AssertExtensions.ExpectException(() =>
httpClient.GetObjectMetadata(getObjectMetadataRequest), typeof(AmazonS3Exception));
getObjectMetadataRequest.ServerSideEncryptionCustomerProvidedKey = copyBase64Key;
AssertExtensions.ExpectException(() =>
httpClient.GetObjectMetadata(getObjectMetadataRequest), typeof(Amazon.Runtime.AmazonClientException));
url = httpClient.GetPreSignedURL(getPresignedUrlRequest);
Assert.IsFalse(string.IsNullOrEmpty(url));
}
}
finally
{
AmazonS3Util.DeleteS3BucketWithObjects(Client, bucketName);
}
}
/// <summary>
/// Marshalls the parameters for a presigned url for a preferred signing protocol.
/// </summary>
/// <param name="config">service client configuration</param>
/// <param name="getPreSignedUrlRequest"></param>
/// <param name="accessKey"></param>
/// <param name="token"></param>
/// <param name="signatureVersion">Signature version to use.
/// If AWS4 signing will be used and if the expiry period in the request exceeds the
/// maximum allowed for AWS4 (one week), an ArgumentException is thrown.
/// </param>
/// <returns>Internal request</returns>
private static IRequest Marshall(IClientConfig config,
GetPreSignedUrlRequest getPreSignedUrlRequest,
string accessKey,
string token,
SignatureVersion signatureVersion)
{
IRequest request = new DefaultRequest(getPreSignedUrlRequest, "AmazonS3");
request.HttpMethod = getPreSignedUrlRequest.Verb.ToString();
var headers = getPreSignedUrlRequest.Headers;
foreach (var key in headers.Keys)
{
request.Headers[key] = headers[key];
}
AmazonS3Util.SetMetadataHeaders(request, getPreSignedUrlRequest.Metadata);
if (getPreSignedUrlRequest.ServerSideEncryptionMethod != null && getPreSignedUrlRequest.ServerSideEncryptionMethod != ServerSideEncryptionMethod.None)
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionHeader, S3Transforms.ToStringValue(getPreSignedUrlRequest.ServerSideEncryptionMethod));
}
if (getPreSignedUrlRequest.IsSetServerSideEncryptionCustomerMethod())
{
request.Headers.Add(HeaderKeys.XAmzSSECustomerAlgorithmHeader, getPreSignedUrlRequest.ServerSideEncryptionCustomerMethod);
}
if (getPreSignedUrlRequest.IsSetServerSideEncryptionKeyManagementServiceKeyId())
{
request.Headers.Add(HeaderKeys.XAmzServerSideEncryptionAwsKmsKeyIdHeader, getPreSignedUrlRequest.ServerSideEncryptionKeyManagementServiceKeyId);
}
if (getPreSignedUrlRequest.IsSetRequestPayer() && getPreSignedUrlRequest.RequestPayer == RequestPayer.Requester)
{
request.Parameters.Add("x-amz-request-payer", RequestPayer.Requester.Value);
}
var queryParameters = request.Parameters;
var uriResourcePath = new StringBuilder("/");
if (!string.IsNullOrEmpty(getPreSignedUrlRequest.BucketName))
{
uriResourcePath.Append(S3Transforms.ToStringValue(getPreSignedUrlRequest.BucketName));
}
if (!string.IsNullOrEmpty(getPreSignedUrlRequest.Key))
{
if (uriResourcePath.Length > 1)
{
uriResourcePath.Append("/");
}
uriResourcePath.Append(S3Transforms.ToStringValue(getPreSignedUrlRequest.Key));
}
var expires = GetSecondsUntilExpiration(config, getPreSignedUrlRequest, signatureVersion);
if ((signatureVersion == SignatureVersion.SigV4 || signatureVersion == SignatureVersion.SigV4a) &&
expires > AWS4PreSignedUrlSigner.MaxAWS4PreSignedUrlExpiry)
{
var msg = string.Format(CultureInfo.InvariantCulture, "The maximum expiry period for a presigned url using AWS4 signing is {0} seconds",
AWS4PreSignedUrlSigner.MaxAWS4PreSignedUrlExpiry);
throw new ArgumentException(msg);
}
if (signatureVersion == SignatureVersion.SigV2)
{
queryParameters.Add("Expires", expires.ToString(CultureInfo.InvariantCulture));
queryParameters.Add("AWSAccessKeyId", accessKey);
if (!string.IsNullOrEmpty(token))
{
queryParameters.Add("x-amz-security-token", token);
}
}
else // SigV4 or SigV4a
{
queryParameters.Add(HeaderKeys.XAmzExpires, expires.ToString(CultureInfo.InvariantCulture));
if (!string.IsNullOrEmpty(token))
{
queryParameters.Add("X-Amz-Security-Token", token);
}
}
if (getPreSignedUrlRequest.IsSetVersionId())
{
request.AddSubResource("versionId", S3Transforms.ToStringValue(getPreSignedUrlRequest.VersionId));
}
if (getPreSignedUrlRequest.IsSetUploadId())
{
request.AddSubResource("uploadId", S3Transforms.ToStringValue(getPreSignedUrlRequest.UploadId));
}
if (getPreSignedUrlRequest.IsSetPartNumber())
{
request.AddSubResource("partNumber", S3Transforms.ToStringValue(getPreSignedUrlRequest.PartNumber));
}
var responseHeaderOverrides = getPreSignedUrlRequest.ResponseHeaderOverrides;
if (!string.IsNullOrEmpty(responseHeaderOverrides.CacheControl))
{
queryParameters.Add("response-cache-control", responseHeaderOverrides.CacheControl);
}
if (!string.IsNullOrEmpty(responseHeaderOverrides.ContentType))
{
queryParameters.Add("response-content-type", responseHeaderOverrides.ContentType);
}
if (!string.IsNullOrEmpty(responseHeaderOverrides.ContentLanguage))
{
queryParameters.Add("response-content-language", responseHeaderOverrides.ContentLanguage);
}
if (!string.IsNullOrEmpty(responseHeaderOverrides.Expires))
{
queryParameters.Add("response-expires", responseHeaderOverrides.Expires);
}
if (!string.IsNullOrEmpty(responseHeaderOverrides.ContentDisposition))
{
queryParameters.Add("response-content-disposition", responseHeaderOverrides.ContentDisposition);
}
if (!string.IsNullOrEmpty(responseHeaderOverrides.ContentEncoding))
{
queryParameters.Add("response-content-encoding", responseHeaderOverrides.ContentEncoding);
}
// Add custom parameters to be included and signed
foreach (string k in getPreSignedUrlRequest.Parameters.Keys)
{
queryParameters.Add(k, getPreSignedUrlRequest.Parameters[k]);
}
request.ResourcePath = uriResourcePath.ToString();
request.UseQueryString = true;
return(request);
}
private void TestSseKms(string keyId)
{
var bucketName = S3TestUtils.CreateBucket(Client);
try
{
var putObjectRequest = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = testContents,
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS
};
putObjectRequest.ServerSideEncryptionKeyManagementServiceKeyId = keyId;
var putObjectResponse = Client.PutObject(putObjectRequest);
Assert.IsNotNull(putObjectResponse.ServerSideEncryptionKeyManagementServiceKeyId);
var usedKeyId = putObjectResponse.ServerSideEncryptionKeyManagementServiceKeyId;
VerifyKeyId(keyId, usedKeyId);
VerifyObject(bucketName, key, usedKeyId);
VerifyObjectWithTransferUtility(bucketName);
TestCopyPart(bucketName, key, keyId);
var key2 = key + "Copy";
var copyResponse = Client.CopyObject(new CopyObjectRequest
{
SourceBucket = bucketName,
SourceKey = key,
DestinationBucket = bucketName,
DestinationKey = key2,
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
ServerSideEncryptionKeyManagementServiceKeyId = keyId
});
Assert.IsNotNull(copyResponse);
usedKeyId = copyResponse.ServerSideEncryptionKeyManagementServiceKeyId;
VerifyKeyId(keyId, usedKeyId);
VerifyObject(bucketName, key2, usedKeyId);
TransferUtility utility = new TransferUtility(Client);
var smallUploadRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
ServerSideEncryptionKeyManagementServiceKeyId = keyId,
InputStream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(testContents))
};
utility.Upload(smallUploadRequest);
VerifyObject(bucketName, key, keyId);
var largeUploadRequest = new TransferUtilityUploadRequest
{
BucketName = bucketName,
Key = key,
ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS,
ServerSideEncryptionKeyManagementServiceKeyId = keyId,
InputStream = new MemoryStream(UTF8Encoding.UTF8.GetBytes(largeTestContents))
};
utility.Upload(largeUploadRequest);
VerifyObject(bucketName, key, keyId);
TestUploadDirectory(bucketName, keyId);
}
finally
{
AmazonS3Util.DeleteS3BucketWithObjects(Client, bucketName);
}
}
public static void ClassCleanup()
{
DeleteBucketObjectsIncludingLocked(Client, bucketName);
AmazonS3Util.DeleteS3BucketWithObjects(Client, bucketName);
BaseClean();
}