public static UploadPartCommand Create(IServiceClient client, Uri endpoint, ExecutionContext context,
UploadPartRequest uploadPartRequest)
{
OssUtils.CheckBucketName(uploadPartRequest.BucketName);
OssUtils.CheckObjectKey(uploadPartRequest.Key);
if (string.IsNullOrEmpty(uploadPartRequest.UploadId))
{
throw new ArgumentException("uploadId should be specified");
}
if (!uploadPartRequest.PartNumber.HasValue)
{
throw new ArgumentException("partNumber should be specified");
}
if (!uploadPartRequest.PartSize.HasValue)
{
throw new ArgumentException("partSize should be specified");
}
if (uploadPartRequest.InputStream == null)
{
throw new ArgumentException("inputStream should be specified");
}
if (uploadPartRequest.PartSize < 0 || uploadPartRequest.PartSize > OssUtils.MaxFileSize)
{
throw new ArgumentException("partSize not live in valid range");
}
if (!OssUtils.IsPartNumberInRange(uploadPartRequest.PartNumber))
{
throw new ArgumentException("partNumber not live in valid range");
}
var conf = OssUtils.GetClientConfiguration(client);
var originalStream = uploadPartRequest.InputStream;
var streamLength = uploadPartRequest.PartSize.Value;
// wrap input stream in PartialWrapperStream
originalStream = new PartialWrapperStream(originalStream, streamLength);
// setup progress
var callback = uploadPartRequest.StreamTransferProgress;
if (callback != null)
{
originalStream = OssUtils.SetupProgressListeners(originalStream, conf.ProgressUpdateInterval, client, callback);
uploadPartRequest.InputStream = originalStream;
}
// wrap input stream in MD5Stream
if (conf.EnalbeMD5Check)
{
var hashStream = new MD5Stream(originalStream, null, streamLength);
uploadPartRequest.InputStream = hashStream;
context.ResponseHandlers.Add(new MD5DigestCheckHandler(hashStream));
}
return(new UploadPartCommand(client, endpoint, context,
DeserializerFactory.GetFactory().CreateUploadPartResultDeserializer(uploadPartRequest.PartNumber.Value),
uploadPartRequest));
}
/// <summary>
/// Compute the MD5 on the input stream with the given size.
/// </summary>
/// <param name="input">The input stream</param>
/// <param name="partSize">the part size---it could be less than the stream size</param>
/// <returns>MD5 digest value</returns>
public static string ComputeContentMd5(Stream input, long partSize)
{
using (var md5Calculator = MD5.Create())
{
long position = input.Position;
var partialStream = new PartialWrapperStream(input, partSize);
var md5Value = md5Calculator.ComputeHash(partialStream);
input.Seek(position, SeekOrigin.Begin);
return(Convert.ToBase64String(md5Value));
}
}
static List <byte[]> computePartHashs(Stream stream)
{
long initialPosition = stream.Position;
List <byte[]> hashes = new List <byte[]>();
while (stream.Position < stream.Length)
{
Stream wrapper = new PartialWrapperStream(stream, MB);
byte[] currentHash = CryptoUtilFactory.CryptoInstance.ComputeSHA256Hash(wrapper);
hashes.Add(currentHash);
}
stream.Seek(initialPosition, SeekOrigin.Begin);
return(hashes);
}
public static async Task PutObjectWithMd5(string bucketName)
{
const string key = "PutObjectWithMd5";
try
{
string md5;
using (var fs = File.Open(fileToUpload, FileMode.Open))
{
using (var md5Calculator = MD5.Create())
{
long position = fs.Position;
var partialStream = new PartialWrapperStream(fs, fs.Length);
var md5Value = md5Calculator.ComputeHash(partialStream);
fs.Seek(position, SeekOrigin.Begin);
md5 = Convert.ToBase64String(md5Value);
}
}
var req = new PutObjectRequest
{
BucketName = bucketName,
Key = key,
FilePath = fileToUpload,
MD5Digest = md5
};
await Sample.Client.PutObjectAsync(req);
Console.WriteLine("Put object:{0} succeeded", key);
}
catch (AmazonServiceException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}",
ex.ErrorCode, ex.Message, ex.RequestId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
}
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.MarshallerVersion = 2;
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 = uploadPartRequest.UseChunkEncoding;
}
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);
}
internal override void Execute()
{
FileInfo fileInfo = new FileInfo(filePath);
FileStream fileStream = File.OpenRead(filePath);
string uploadId = null;
try
{
this.currentUploadProgressArgs = new StreamTransferProgressArgs(0, 0, fileInfo.Length);
long partSize = CalculatePartSize(fileInfo.Length);
InitiateMultipartUploadRequest initiateRequest = new InitiateMultipartUploadRequest()
{
AccountId = this.options.AccountId,
ArchiveDescription = archiveDescription,
VaultName = vaultName,
PartSize = partSize
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)initiateRequest).AddBeforeRequestHandler(new ArchiveTransferManager.UserAgentPostFix("MultiUpload").UserAgentRequestEventHandlerSync);
InitiateMultipartUploadResponse initiateResponse = this.manager.GlacierClient.InitiateMultipartUpload(initiateRequest);
uploadId = initiateResponse.UploadId;
List <string> partTreeHashs = new List <string>();
long currentPosition = 0;
while (currentPosition < fileInfo.Length)
{
long length = partSize;
if (currentPosition + partSize > fileInfo.Length)
{
length = fileInfo.Length - currentPosition;
}
Stream partStream = new PartialWrapperStream(fileStream, length);
string checksum = TreeHashGenerator.CalculateTreeHash(partStream);
partTreeHashs.Add(checksum);
UploadMultipartPartRequest uploadRequest = new UploadMultipartPartRequest()
{
AccountId = this.options.AccountId,
Checksum = checksum,
Range = "bytes " + currentPosition + "-" + (currentPosition + length - 1) + "/*",
UploadId = uploadId,
VaultName = vaultName,
Body = partStream
};
uploadRequest.StreamTransferProgress += this.ProgressCallback;
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)uploadRequest).AddBeforeRequestHandler(new ArchiveTransferManager.UserAgentPostFix("MultiUpload").UserAgentRequestEventHandlerSync);
this.manager.GlacierClient.UploadMultipartPart(uploadRequest);
currentPosition += partSize;
}
string totalFileChecksum = TreeHashGenerator.CalculateTreeHash(partTreeHashs);
string archiveSize = fileInfo.Length.ToString(CultureInfo.InvariantCulture);
CompleteMultipartUploadRequest compRequest = new CompleteMultipartUploadRequest()
{
AccountId = this.options.AccountId,
ArchiveSize = archiveSize,
VaultName = vaultName,
Checksum = totalFileChecksum,
UploadId = uploadId
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)compRequest).AddBeforeRequestHandler(new ArchiveTransferManager.UserAgentPostFix("MultiUpload").UserAgentRequestEventHandlerSync);
CompleteMultipartUploadResponse completeMultipartUploadResponse = this.manager.GlacierClient.CompleteMultipartUpload(compRequest);
string archiveId = completeMultipartUploadResponse.ArchiveId;
this.UploadResult = new UploadResult(archiveId, totalFileChecksum);
}
catch (Exception)
{
// If we got an unrecoverable then abort the upload.
if (!string.IsNullOrEmpty(uploadId))
{
AbortMultipartUploadRequest abortRequest = new AbortMultipartUploadRequest()
{
AccountId = this.options.AccountId,
VaultName = this.vaultName,
UploadId = uploadId
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)abortRequest).AddBeforeRequestHandler(new ArchiveTransferManager.UserAgentPostFix("MultiUpload").UserAgentRequestEventHandlerSync);
this.manager.GlacierClient.AbortMultipartUpload(abortRequest);
}
throw;
}
finally
{
try { fileStream.Close(); }
catch (Exception) { }
}
}
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["Content-MD5"] = uploadPartRequest.MD5Digest;
}
var uriResourcePath = string.Format(CultureInfo.InvariantCulture, "/{0}/{1}",
S3Transforms.ToStringValue(uploadPartRequest.BucketName),
S3Transforms.ToStringValue(uploadPartRequest.Key));
if (uploadPartRequest.IsSetPartNumber())
{
request.Parameters.Add("partNumber", S3Transforms.ToStringValue(uploadPartRequest.PartNumber));
}
if (uploadPartRequest.IsSetUploadId())
{
request.Parameters.Add("uploadId", S3Transforms.ToStringValue(uploadPartRequest.UploadId));
}
request.CanonicalResource = S3Transforms.GetCanonicalResource(uriResourcePath, request.Parameters);
request.ResourcePath = S3Transforms.FormatResourcePath(uriResourcePath, request.Parameters);
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("Content-Length"))
{
request.Headers.Add("Content-Length", 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("Content-Type"))
{
request.Headers.Add("Content-Type", "text/plain");
}
if (!request.UseQueryString)
{
var queryString = AWSSDKUtils.GetParametersAsString(request.Parameters);
if (!string.IsNullOrEmpty(queryString))
{
request.ResourcePath = string.Concat(request.ResourcePath, request.ResourcePath.Contains("?") ? "&" : "?", queryString);
}
}
return(request);
}
public IRequest Marshall(UploadPartRequest uploadPartRequest)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0166: Expected O, but got Unknown
//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
//IL_01ba: Expected O, but got Unknown
IRequest val = new DefaultRequest(uploadPartRequest, "AmazonS3");
val.set_HttpMethod("PUT");
if (uploadPartRequest.IsSetMD5Digest())
{
val.get_Headers()["Content-MD5"] = uploadPartRequest.MD5Digest;
}
if (uploadPartRequest.IsSetServerSideEncryptionCustomerMethod())
{
val.get_Headers().Add("x-amz-server-side-encryption-customer-algorithm", ConstantClass.op_Implicit(uploadPartRequest.ServerSideEncryptionCustomerMethod));
}
if (uploadPartRequest.IsSetServerSideEncryptionCustomerProvidedKey())
{
val.get_Headers().Add("x-amz-server-side-encryption-customer-key", uploadPartRequest.ServerSideEncryptionCustomerProvidedKey);
if (uploadPartRequest.IsSetServerSideEncryptionCustomerProvidedKeyMD5())
{
val.get_Headers().Add("x-amz-server-side-encryption-customer-key-MD5", uploadPartRequest.ServerSideEncryptionCustomerProvidedKeyMD5);
}
else
{
val.get_Headers().Add("x-amz-server-side-encryption-customer-key-MD5", AmazonS3Util.ComputeEncodedMD5FromEncodedString(uploadPartRequest.ServerSideEncryptionCustomerProvidedKey));
}
}
if (uploadPartRequest.IsSetRequestPayer())
{
val.get_Headers().Add(S3Constants.AmzHeaderRequestPayer, S3Transforms.ToStringValue(((object)uploadPartRequest.RequestPayer).ToString()));
}
val.set_ResourcePath(string.Format(CultureInfo.InvariantCulture, "/{0}/{1}", S3Transforms.ToStringValue(uploadPartRequest.BucketName), S3Transforms.ToStringValue(uploadPartRequest.Key)));
if (uploadPartRequest.IsSetPartNumber())
{
val.AddSubResource("partNumber", S3Transforms.ToStringValue(uploadPartRequest.PartNumber));
}
if (uploadPartRequest.IsSetUploadId())
{
val.AddSubResource("uploadId", S3Transforms.ToStringValue(uploadPartRequest.UploadId));
}
if (uploadPartRequest.InputStream != null)
{
PartialWrapperStream val2 = new PartialWrapperStream(uploadPartRequest.InputStream, uploadPartRequest.PartSize);
if (((Stream)val2).Length > 0)
{
val.set_UseChunkEncoding(true);
}
if (!val.get_Headers().ContainsKey("Content-Length"))
{
val.get_Headers().Add("Content-Length", ((Stream)val2).Length.ToString(CultureInfo.InvariantCulture));
}
MD5Stream val3 = uploadPartRequest.InputStream = (Stream) new MD5Stream((Stream)val2, (byte[])null, ((Stream)val2).Length);
}
val.set_ContentStream(uploadPartRequest.InputStream);
if (!val.get_Headers().ContainsKey("Content-Type"))
{
val.get_Headers().Add("Content-Type", "text/plain");
}
return(val);
}
public IRequest Marshall(UploadPartRequest uploadPartRequest)
{
IRequest request = new DefaultRequest(uploadPartRequest, "AmazonS3");
request.HttpMethod = "PUT";
if (uploadPartRequest.IsSetChecksumAlgorithm())
{
request.Headers.Add(S3Constants.AmzHeaderSdkChecksumAlgorithm, S3Transforms.ToStringValue(uploadPartRequest.ChecksumAlgorithm));
}
if (uploadPartRequest.IsSetChecksumCRC32())
{
request.Headers["x-amz-checksum-crc32"] = S3Transforms.ToStringValue(uploadPartRequest.ChecksumCRC32);
}
if (uploadPartRequest.IsSetChecksumCRC32C())
{
request.Headers["x-amz-checksum-crc32c"] = S3Transforms.ToStringValue(uploadPartRequest.ChecksumCRC32C);
}
if (uploadPartRequest.IsSetChecksumSHA1())
{
request.Headers["x-amz-checksum-sha1"] = S3Transforms.ToStringValue(uploadPartRequest.ChecksumSHA1);
}
if (uploadPartRequest.IsSetChecksumSHA256())
{
request.Headers["x-amz-checksum-sha256"] = S3Transforms.ToStringValue(uploadPartRequest.ChecksumSHA256);
}
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;
// Calculate Content-MD5 if not already set
if (!uploadPartRequest.IsSetMD5Digest() && uploadPartRequest.CalculateContentMD5Header)
{
string md5 = AmazonS3Util.GenerateMD5ChecksumForStream(partialStream);
if (!string.IsNullOrEmpty(md5))
{
request.Headers[HeaderKeys.ContentMD5Header] = md5;
}
}
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;
ChecksumUtils.SetRequestChecksum(request, uploadPartRequest.ChecksumAlgorithm, fallbackToMD5: false);
if (!request.Headers.ContainsKey(HeaderKeys.ContentTypeHeader))
{
request.Headers.Add(HeaderKeys.ContentTypeHeader, "text/plain");
}
return(request);
}
