public void UpdateBlobProperties(string containerName, string blobName, BlobProperties properties) { var updateRequest = new CopyObjectRequest() { SourceBucket = _bucket, SourceKey = GenerateKeyName(containerName, blobName), DestinationBucket = _bucket, DestinationKey = GenerateKeyName(containerName, blobName), ContentType = properties?.ContentType, CannedACL = GetCannedACL(properties), MetadataDirective = S3MetadataDirective.REPLACE }; try { AsyncHelpers.RunSync(() => _s3Client.CopyObjectAsync(updateRequest)); } catch (AmazonS3Exception asex) { if (IsInvalidAccessException(asex)) { throw new StorageException(1000.ToStorageError(), asex); } else { throw new StorageException(1001.ToStorageError(), asex); } } }
public async Task <bool> ResetDataFilesAsync() { var request = new ListObjectsRequest(); request.BucketName = DataFileLocation; do { var response = await _amazonS3Client.ListObjectsAsync(request, CancellationToken.None); foreach (var file in response.S3Objects.Where(s => s.Key.StartsWith("DataFiles/") && s.Key != "DataFiles/")) { var deleteObjectRequest = new DeleteObjectRequest { BucketName = request.BucketName, Key = file.Key }; await _amazonS3Client.DeleteObjectAsync(deleteObjectRequest); } if (response.IsTruncated) { request.Marker = response.NextMarker; } else { request = null; } } while (request != null); var copyRequest = new CopyObjectRequest { SourceBucket = DataFileLocation, SourceKey = "MasterFiles/ClassA.csv", DestinationBucket = DataFileLocation, DestinationKey = "DataFiles/ClassA.csv" }; var result = await _amazonS3Client.CopyObjectAsync(copyRequest); copyRequest = new CopyObjectRequest { SourceBucket = DataFileLocation, SourceKey = "MasterFiles/ClassB.csv", DestinationBucket = DataFileLocation, DestinationKey = "DataFiles/ClassB.csv" }; result = await _amazonS3Client.CopyObjectAsync(copyRequest); copyRequest = new CopyObjectRequest { SourceBucket = DataFileLocation, SourceKey = "MasterFiles/ClassC.csv", DestinationBucket = DataFileLocation, DestinationKey = "DataFiles/ClassC.csv" }; result = await _amazonS3Client.CopyObjectAsync(copyRequest); return(true); }
public async Task ArchiveAsync(IFileEntry fileEntry, CancellationToken cancellationToken = default) { var copy = new CopyObjectRequest { SourceBucket = _options.BucketName, SourceKey = GetKey(fileEntry), DestinationBucket = _options.BucketName, DestinationKey = GetKey(fileEntry), StorageClass = S3StorageClass.StandardInfrequentAccess, }; await _client.CopyObjectAsync(copy, cancellationToken); }
// -------------------- S3 Specific Methods ------------------------------ /// <summary> /// Moves an image from the transfer bucket to the storage bucket with the appropriate key. /// </summary> /// <param name="tempTransferKey">The S3 object key of the image in the transfer bucket (provided by the client).</param> /// <param name="cloudStorageKey">The permanent object key</param> /// <returns>HttpStatusCode</returns> public async Task <HttpStatusCode> MoveImageFromTransferBucketToStorageBucket(string tempTransferKey, string cloudStorageKey) { try { var copyOjectResponse = await _s3Client.CopyObjectAsync(_config["AWSS3:TransferBucketName"], tempTransferKey, _config["AWSS3:StorageBucketName"], cloudStorageKey); if (copyOjectResponse.HttpStatusCode == HttpStatusCode.OK) { var deleteObjectResponse = await _s3Client.DeleteObjectAsync(_config["AWSS3:TransferBucketName"], tempTransferKey); if (deleteObjectResponse != null) { return(HttpStatusCode.OK); } else { throw new Exception($"Transfer image '{tempTransferKey}' was not deleted from the transfer bucket. Response code '{deleteObjectResponse.HttpStatusCode}'"); } } else { throw new Exception($"Image '{cloudStorageKey}' was not copied to the storage bucket. Response code '{copyOjectResponse.HttpStatusCode}'"); } } catch (AmazonS3Exception e) { throw new AmazonS3Exception($"S3 Specific Message: {e.Message}"); } catch (Exception e) { throw new Exception($"Generic ASP.NET Message: {e.Message}"); } }
public static bool CopyFileFormFolder(string sourceKey, string destinationKey) { try { using (IAmazonS3 client = AwsAuthentication()) { CopyObjectRequest request = new CopyObjectRequest(); request.SourceBucket = AwsBuketName; request.SourceKey = AwsFolderName + "/" + sourceKey; request.DestinationBucket = AwsBuketName; request.DestinationKey = AwsFolderName + "/" + destinationKey; request.CannedACL = S3CannedACL.PublicReadWrite; request.StorageClass = S3StorageClass.Standard; Task <CopyObjectResponse> response = client.CopyObjectAsync(request); if (response.Result.HttpStatusCode == System.Net.HttpStatusCode.OK) { return(true); } } } catch (Amazon.S3.AmazonS3Exception ex) { if (ex.StatusCode == System.Net.HttpStatusCode.NotFound) { return(false); } } catch (Exception) { return(false); } return(false); }
/// <summary> /// This method calls the AWS SDK for .NET to copy an /// object from one Amazon S3 bucket to another. /// </summary> /// <param name="client">The Amazon S3 client object.</param> /// <param name="sourceKey">The name of the object to be copied.</param> /// <param name="destinationKey">The name under which to save the copy.</param> /// <param name="sourceBucketName">The name of the Amazon S3 bucket /// where the file is located now.</param> /// <param name="destinationBucketName">The name of the Amazon S3 /// bucket where the copy should be saved.</param> /// <returns>Returns a CopyObjectResponse object with the results from /// the async call.</returns> public static async Task <CopyObjectResponse> CopyingObjectAsync( IAmazonS3 client, string sourceKey, string destinationKey, string sourceBucketName, string destinationBucketName) { var response = new CopyObjectResponse(); try { var request = new CopyObjectRequest { SourceBucket = sourceBucketName, SourceKey = sourceKey, DestinationBucket = destinationBucketName, DestinationKey = destinationKey, }; response = await client.CopyObjectAsync(request); } catch (AmazonS3Exception ex) { Console.WriteLine($"Error copying object: '{ex.Message}'"); } return(response); }
private async Task CopyBlobAsync(string sourceBucket, string sourceBlobName, string targetBucket, string?targetBlobName = null, CancellationToken cancellationToken = default) { var newTargetKey = targetBlobName ?? sourceBlobName; try { var request = new CopyObjectRequest { SourceBucket = sourceBucket, SourceKey = sourceBlobName, DestinationBucket = targetBucket, DestinationKey = newTargetKey, }; var response = await _client.CopyObjectAsync(request, cancellationToken); if (response.HttpStatusCode != HttpStatusCode.OK) { throw new StorageException("Copy object failed."); } } catch (AmazonS3Exception ex) { throw new StorageException(ex.Message, ex); } }
public async Task CopyAsync(string sourceFileName, string targetFileName, CancellationToken ct = default) { var sourceKey = GetKey(sourceFileName, nameof(sourceFileName)); var targetKey = GetKey(targetFileName, nameof(targetFileName)); try { await EnsureNotExistsAsync(targetKey, targetFileName, ct); var request = new CopyObjectRequest { SourceBucket = options.Bucket, SourceKey = sourceKey, DestinationBucket = options.Bucket, DestinationKey = targetKey }; await s3Client.CopyObjectAsync(request, ct); } catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.NotFound) { throw new AssetNotFoundException(sourceFileName, ex); } catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.PreconditionFailed) { throw new AssetAlreadyExistsException(targetFileName); } }
/// <summary> /// Copies an encrypted object from one Amazon S3 bucket to another. /// </summary> /// <param name="client">The initialized Amazon S3 client object used to call /// CopyObjectAsync.</param> /// <param name="bucketName">The Amazon S3 bucket containing the object /// to copy.</param> /// <param name="keyName">The name of the object to copy.</param> /// <param name="copyTargetKeyName">The Amazon S3 bucket to which the object /// will be copied.</param> /// <param name="aesEncryption">The encryption type to use.</param> /// <param name="base64Key">The encryption key to use.</param> public static async Task CopyObjectAsync( IAmazonS3 client, string bucketName, string keyName, string copyTargetKeyName, Aes aesEncryption, string base64Key) { aesEncryption.GenerateKey(); string copyBase64Key = Convert.ToBase64String(aesEncryption.Key); CopyObjectRequest copyRequest = new CopyObjectRequest { SourceBucket = bucketName, SourceKey = keyName, DestinationBucket = bucketName, DestinationKey = copyTargetKeyName, // Information about the source object's encryption. CopySourceServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256, CopySourceServerSideEncryptionCustomerProvidedKey = base64Key, // Information about the target object's encryption. ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256, ServerSideEncryptionCustomerProvidedKey = copyBase64Key, }; await client.CopyObjectAsync(copyRequest); }
// snippet-end:[S3.dotnetv3.S3_Basics-DownloadObject] // snippet-start:[S3.dotnetv3.S3_Basics-CopyObject] /// <summary> /// Copies an object in an Amazon S3 bucket to a folder within the /// same bucket. /// </summary> /// <param name="client">An initialized Amazon S3 client object.</param> /// <param name="bucketName">The name of the Amazon S3 bucket where the /// object to copy is located.</param> /// <param name="objectName">The object to be copied.</param> /// <param name="folderName">The folder to which the object will /// be copied.</param> /// <returns>A boolean value that indicates the success or failure of /// the copy operation.</returns> public static async Task <bool> CopyObjectInBucketAsync( IAmazonS3 client, string bucketName, string objectName, string folderName) { try { var request = new CopyObjectRequest { SourceBucket = bucketName, SourceKey = objectName, DestinationBucket = bucketName, DestinationKey = $"{folderName}\\{objectName}", }; var response = await client.CopyObjectAsync(request); return(response.HttpStatusCode == System.Net.HttpStatusCode.OK); } catch (AmazonS3Exception ex) { Console.WriteLine($"Error copying object: '{ex.Message}'"); return(false); } }
public async Task CopyBlobAsync(string sourceContainerName, string sourceBlobName, string destinationContainerName, string destinationBlobName = null) { if (string.IsNullOrEmpty(sourceContainerName)) { throw new StorageException(StorageErrorCode.InvalidName, $"Invalid {nameof(sourceContainerName)}"); } if (string.IsNullOrEmpty(sourceBlobName)) { throw new StorageException(StorageErrorCode.InvalidName, $"Invalid {nameof(sourceBlobName)}"); } if (string.IsNullOrEmpty(destinationContainerName)) { throw new StorageException(StorageErrorCode.InvalidName, $"Invalid {nameof(destinationContainerName)}"); } if (destinationBlobName == string.Empty) { throw new StorageException(StorageErrorCode.InvalidName, $"Invalid {nameof(destinationBlobName)}"); } var sourceKey = GenerateKeyName(sourceContainerName, sourceBlobName); var destinationKey = GenerateKeyName(destinationContainerName, destinationBlobName ?? sourceBlobName); try { var request = new CopyObjectRequest { SourceBucket = _bucket, SourceKey = sourceKey, DestinationBucket = _bucket, DestinationKey = destinationKey, ServerSideEncryptionMethod = _serverSideEncryptionMethod }; var response = await _s3Client.CopyObjectAsync(request); if (response.HttpStatusCode != HttpStatusCode.OK) { throw new StorageException(StorageErrorCode.GenericException, "Copy failed."); } } catch (AmazonS3Exception asex) { throw asex.ToStorageException(); } }
public static void CopyS3(IAmazonS3 s3Client, string sourceKey, string destKey) { s3Client.CopyObjectAsync(new Amazon.S3.Model.CopyObjectRequest() { SourceBucket = CachedData.S3ContentBucket, CannedACL = S3CannedACL.PublicRead, SourceKey = sourceKey, DestinationBucket = CachedData.S3ContentBucket, DestinationKey = destKey });; }
public async void CopiarArquivo(string caminhoArquivo, string nomeBucket) { CopyObjectRequest request = new CopyObjectRequest { SourceBucket = nomeBucket, SourceKey = caminhoArquivo, DestinationKey = caminhoArquivo, DestinationBucket = "conteudo-oregon", }; var response = await _amazoS3Client.CopyObjectAsync(request); Console.WriteLine(response.ETag); }
public async Task CopyFileAsync(string srcPath, string dstPath) { if (srcPath == dstPath) { throw new ArgumentException($"The values for {nameof(srcPath)} and {nameof(dstPath)} must not be the same."); } try { await _amazonS3Client.GetObjectMetadataAsync(new GetObjectMetadataRequest { BucketName = _options.BucketName, Key = this.Combine(_basePrefix, srcPath) }); } catch (AmazonS3Exception) { throw new FileStoreException($"Cannot copy file '{srcPath}' because it does not exist."); } try { var listObjects = await _amazonS3Client.ListObjectsV2Async(new ListObjectsV2Request { BucketName = _options.BucketName, Prefix = this.Combine(_basePrefix, dstPath) }); if (listObjects.S3Objects.Any()) { throw new FileStoreException($"Cannot copy file '{srcPath}' because a file already exists in the new path '{dstPath}'."); } var copyObjectResponse = await _amazonS3Client.CopyObjectAsync(new CopyObjectRequest { SourceBucket = _options.BucketName, SourceKey = this.Combine(_basePrefix, srcPath), DestinationBucket = _options.BucketName, DestinationKey = this.Combine(_basePrefix, dstPath) }); if (copyObjectResponse.HttpStatusCode != HttpStatusCode.OK) { throw new FileStoreException($"Error while copying file '{srcPath}'"); } } catch (AmazonS3Exception) { throw new FileStoreException($"Error while copying file '{srcPath}'"); } }
public async Task CopyObjectInBucketAsyncTest() { IAmazonS3 client = CreateMockS3Client(); var request = new CopyObjectRequest { SourceBucket = newBucket, SourceKey = keyName, DestinationBucket = newBucket, DestinationKey = $"{destinationFolderName}\\{keyName}", }; var response = await client.CopyObjectAsync(request); Assert.True(response.HttpStatusCode == System.Net.HttpStatusCode.OK, $"Could not copy {keyName}."); }
public static void Copy() { using (client = new AmazonS3Client("AKIAI4YXWZLJGJQBSZ6Q", "FctcgO3mUeaTt+oXOj5WxQWXSzTkOWiuMav26dz5", Amazon.RegionEndpoint.APSoutheast1)) { var copyObjectRequest = new CopyObjectRequest { SourceBucket = bucketName + "/temp", SourceKey = "17d8d41345aa4185b591ba5f55ef53fc.png", DestinationBucket = bucketName + "/store", DestinationKey = "17d8d41345aa4185b591ba5f55ef53fc.png", }; client.CopyObjectAsync(copyObjectRequest).Wait(); Console.WriteLine("Copy successfull"); } }
private async Task UpdateReadTimeAsync(ObjectIdentity identity, IAmazonS3 s3Client) { var metadataCollection = await GetObjectMetadataAsync(s3Client, identity, false); metadataCollection[MetadataKeys.ReadTime] = RebusTime.Now.ToString("O"); var copyObjectRequest = new CopyObjectRequest { SourceBucket = _options.BucketName, DestinationBucket = _options.BucketName, SourceKey = identity.Key, DestinationKey = identity.Key, MetadataDirective = S3MetadataDirective.REPLACE }; metadataCollection.SaveTo(copyObjectRequest.Metadata); await s3Client.CopyObjectAsync(copyObjectRequest); }
/// <summary> /// moves file (object) between bucket folders /// </summary> /// <param name="fileName"></param> /// <param name="sourceDirectory"></param> /// <param name="destDirectory"></param> /// <returns></returns> public async Task <bool> MoveFileAsync(string fileName, string sourceDirectory, string destDirectory) { try { var copyRequest = new CopyObjectRequest { SourceBucket = _s3BucketOptions.BucketName + @"/" + sourceDirectory, SourceKey = fileName, DestinationBucket = _s3BucketOptions.BucketName + @"/" + destDirectory, DestinationKey = fileName }; var response = await _s3Client.CopyObjectAsync(copyRequest); if (response.HttpStatusCode == HttpStatusCode.OK) { var deleteRequest = new DeleteObjectRequest { BucketName = _s3BucketOptions.BucketName + @"/" + sourceDirectory, Key = fileName }; await _s3Client.DeleteObjectAsync(deleteRequest); return(true); } return(false); } catch (AmazonS3Exception amazonS3Exception) { if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity"))) { Console.WriteLine("Please check the provided AWS Credentials."); } else { _logger.LogError("An error occurred with the message '{0}' when moving object", amazonS3Exception.Message); } return(false); } }
private void MoveS3ImageForReview(IAmazonS3 s3Client, ClassificationModel model) { var reviewImageCopyResult = s3Client.CopyObjectAsync( Constants.IMAGES_BUCKET, model.S3Path, NationalGalleryOfArtIndexer.BUCKET_REVIEW, model.S3Path ).Result; if (reviewImageCopyResult.HttpStatusCode != HttpStatusCode.OK) { throw new Exception("Failed to copy image to review bucket"); } var imageOriginalDeleteResult = s3Client.DeleteObjectAsync(Constants.IMAGES_BUCKET, model.S3Path).Result; if (!string.Equals(imageOriginalDeleteResult.DeleteMarker, "true", StringComparison.OrdinalIgnoreCase)) { throw new Exception("Failed to delete image from primary bucket"); } }
private async Task UploadFileAsync(string bucketName, string sourceKey, string destinationKey) { try { CopyObjectRequest request = new CopyObjectRequest { SourceBucket = bucketName, SourceKey = sourceKey, DestinationBucket = bucketName, DestinationKey = destinationKey }; CopyObjectResponse response = await _s3Client.CopyObjectAsync(request); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } }
public void CopyObject(String bucketPath, String newBucketPath) { try { CopyObjectRequest request = new CopyObjectRequest { SourceBucket = _bucketName, SourceKey = bucketPath, DestinationBucket = _bucketName, DestinationKey = newBucketPath }; CopyObjectResponse response = _client.CopyObjectAsync(request).Result; } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when copying an object", e.Message); } catch (Exception e) { Console.WriteLine("Unknown encountered on server. Message:'{0}' when copying an object", e.Message); } }
public async Task <S3Response> CopyObjectAsync(string pathOrigem, string pathDestino, string bucketOrigem, string bucketDestino) { try { using (Amazon.S3.Transfer.TransferUtility transferUti = new Amazon.S3.Transfer.TransferUtility(_client)) { CopyObjectRequest request = new CopyObjectRequest { SourceBucket = bucketOrigem, SourceKey = pathOrigem, DestinationBucket = bucketDestino, DestinationKey = pathDestino }; await _client.CopyObjectAsync(request); return(new S3Response { Status = HttpStatusCode.OK, Message = "Enviado com sucesso." }); } } catch (AmazonS3Exception e) { return(new S3Response { Message = e.Message, Status = e.StatusCode }); } catch (Exception e) { return(new S3Response { Status = HttpStatusCode.InternalServerError, Message = e.Message }); } }
public async Task CopyObject(string srcBuctet, string srcKey, string destBucket, string destKey) { try { CopyObjectRequest request = new CopyObjectRequest { SourceBucket = srcBuctet, SourceKey = srcKey, DestinationBucket = destBucket, DestinationKey = destKey }; CopyObjectResponse response = await client.CopyObjectAsync(request); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when copying an object, keyname {1}", e.Message, srcKey); } catch (Exception e) { Console.WriteLine("Unknown encountered on server. Message:'{0}' when copying an object, keyname {1}", e.Message, srcKey); } }
private static async Task CopyingObjectAsync() { try { CopyObjectRequest request = new CopyObjectRequest { SourceBucket = sourceBucket, SourceKey = objectKey, DestinationBucket = destinationBucket, DestinationKey = destObjectKey }; CopyObjectResponse response = await s3Client.CopyObjectAsync(request); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } }
public async Task RenameAsync(string srcFile, string dstFile, AccessMode mode) { var srcKey = srcFile.CheckSystemFile().NormalizeLinux(); var dstKey = dstFile.CheckSystemFile().NormalizeLinux(); srcFile.CheckSystemFile(); dstFile.CheckSystemFile(); await myS3Client.CopyObjectAsync(new CopyObjectRequest { SourceBucket = myBucketName, SourceKey = srcKey, DestinationBucket = myBucketName, DestinationKey = dstKey, CannedACL = GetS3CannedAcl(mode, mySupportAcl) }); await myS3Client.DeleteObjectAsync(new DeleteObjectRequest { BucketName = myBucketName, Key = srcKey }); }
public async Task <S3Response> CopyingObjectAsync(string bucketName, string folderFile, string destinationfolder) { try { using (_client) { CopyObjectRequest request = new CopyObjectRequest(); request.SourceBucket = bucketName; request.SourceKey = folderFile.Replace(@"\", "/"); request.DestinationBucket = bucketName; request.DestinationKey = destinationfolder.Replace(@"\", "/"); CopyObjectResponse response = await _client.CopyObjectAsync(request); return(new S3Response { Message = response.ResponseMetadata.RequestId, Status = response.HttpStatusCode }); } } catch (AmazonS3Exception e) { return(new S3Response { Message = e.Message, Status = e.StatusCode }); } }
public async Task Copy(string key, int age, CancellationToken stoppingToken) { string archiveBucketName; if (age > 30) { archiveBucketName = "glacier-bucket"; } else { archiveBucketName = "normal-bucket"; } var copyRequest = new CopyObjectRequest() { SourceBucket = liveBucketName, SourceKey = key, DestinationBucket = archiveBucketName, DestinationKey = key, }; await s3.CopyObjectAsync(copyRequest, stoppingToken); }
public static CopyObjectResponse CopyObject(this IAmazonS3 client, CopyObjectRequest request) { return(client.CopyObjectAsync(request).GetResult()); }
/// <summary> /// Copy a file or key to another location /// </summary> /// <param name="sourceBucket">source bucket name</param> /// <param name="sourceKey">source key</param> /// <param name="targetBucket">target bucket name</param> /// <param name="targetKey">traget key</param> /// <returns>target key</returns> public async Task <string> CopyKey(string sourceBucket, string sourceKey, string targetBucket, string targetKey) { var copy = await _s3Client.CopyObjectAsync(sourceBucket, sourceKey, targetBucket, targetKey); return(targetKey); }
/// <summary> /// Provides the actual implementation to move or copy an S3 object /// </summary> /// <param name="client"></param> /// <param name="request"></param> /// <param name="partSize"></param> /// <param name="deleteSource"></param> /// <returns></returns> private static async Task <CopyObjectRequestResponse> CopyOrMoveObjectAsync(this IAmazonS3 client, CopyObjectRequest request, long partSize, bool deleteSource, Func <long, long, bool> useMulitpart) { /// Handle operation cancelled exceptions ExponentialBackoffAndRetryClient backoffClient = new ExponentialBackoffAndRetryClient(4, 100, 1000) { ExceptionHandlingLogic = (ex) => { if (ex is OperationCanceledException) { return(true); } else { return(false); } } }; try { ParameterTests.NonNull(request, "request"); ParameterTests.OutOfRange(partSize >= Constants.MINIMUM_MULTIPART_PART_SIZE, "partSize", $"The part size must be at least {Constants.MINIMUM_MULTIPART_PART_SIZE} bytes."); ParameterTests.OutOfRange(partSize <= Constants.MAXIMUM_MULTIPART_PART_SIZE, "partSize", $"The part size cannot exceed {Constants.MAXIMUM_MULTIPART_PART_SIZE} bytes."); if (request.SourceKey == request.DestinationKey && request.SourceBucket != null && request.SourceBucket.Equals(request.DestinationBucket, StringComparison.OrdinalIgnoreCase)) { throw new SourceDestinationSameException("The source and destination of the copy operation cannot be the same.", new CopyObjectRequest[] { request }); } // Get the size of the object. GetObjectMetadataRequest metadataRequest = new GetObjectMetadataRequest { BucketName = request.SourceBucket, Key = request.SourceKey }; long objectSize; GetObjectMetadataResponse metadataResponse; try { metadataResponse = await backoffClient.RunAsync(() => client.GetObjectMetadataAsync(metadataRequest)); objectSize = metadataResponse.ContentLength; // Length in bytes. } catch (Exception e) { throw e; } CopyObjectResponse response = null; if (UseMultipart(objectSize, partSize)) { // If it takes more than a 5 GiB part to make 10000 or less parts, than this operation // isn't supported for an object this size if (objectSize / partSize > Constants.MAXIMUM_PARTS) { throw new NotSupportedException($"The object size, {objectSize}, cannot be broken into fewer than {Constants.MAXIMUM_PARTS} parts using a part size of {partSize} bytes."); } List <Task <CopyPartResponse> > copyResponses = new List <Task <CopyPartResponse> >(); // This property has a nullable backing private field that when set to // anything non-null causes the x-amz-object-lock-retain-until-date // header to be sent which in turn results in an exception being thrown // that the Bucket is missing ObjectLockConfiguration InitiateMultipartUploadRequest initiateRequest = request.ConvertTo <InitiateMultipartUploadRequest>("ObjectLockRetainUntilDate"); initiateRequest.BucketName = request.DestinationBucket; initiateRequest.Key = request.DestinationKey; InitiateMultipartUploadResponse initiateResponse = await backoffClient.RunAsync(() => client.InitiateMultipartUploadAsync(initiateRequest)); try { long bytePosition = 0; int counter = 1; // Launch all of the copy parts while (bytePosition < objectSize) { CopyPartRequest copyRequest = request.ConvertTo <CopyPartRequest>("ObjectLockRetainUntilDate"); copyRequest.UploadId = initiateResponse.UploadId; copyRequest.FirstByte = bytePosition; // If we're on the last part, the last byte is the object size minus 1, otherwise the last byte is the part size minus one // added to the current byte position copyRequest.LastByte = ((bytePosition + partSize - 1) >= objectSize) ? objectSize - 1 : bytePosition + partSize - 1; copyRequest.PartNumber = counter++; copyResponses.Add(backoffClient.RunAsync(() => client.CopyPartAsync(copyRequest))); bytePosition += partSize; } IEnumerable <CopyPartResponse> responses = (await Task.WhenAll(copyResponses)).OrderBy(x => x.PartNumber); // Set up to complete the copy. CompleteMultipartUploadRequest completeRequest = new CompleteMultipartUploadRequest { BucketName = request.DestinationBucket, Key = request.DestinationKey, UploadId = initiateResponse.UploadId }; completeRequest.AddPartETags(responses); // Complete the copy. CompleteMultipartUploadResponse completeUploadResponse = await backoffClient.RunAsync(() => client.CompleteMultipartUploadAsync(completeRequest)); response = completeUploadResponse.CopyProperties <CopyObjectResponse>(); response.SourceVersionId = metadataResponse.VersionId; } catch (AmazonS3Exception e) { AbortMultipartUploadRequest abortRequest = new AbortMultipartUploadRequest() { BucketName = request.DestinationBucket, Key = request.DestinationKey, UploadId = initiateResponse.UploadId }; await backoffClient.RunAsync(() => client.AbortMultipartUploadAsync(abortRequest)); throw e; } } else { response = await backoffClient.RunAsync(() => client.CopyObjectAsync(request)); } if (response.HttpStatusCode != HttpStatusCode.OK) { throw new AmazonS3Exception($"Could not copy object from s3://{request.SourceBucket}/{request.SourceKey} to s3://{request.DestinationBucket}/{request.DestinationKey}. Received response : {(int)response.HttpStatusCode}"); } else { // We already checked to make sure the source and destination weren't the same // and it's safe to delete the source object if (deleteSource) { DeleteObjectRequest deleteRequest = new DeleteObjectRequest() { BucketName = request.SourceBucket, Key = request.SourceKey }; DeleteObjectResponse deleteResponse = await backoffClient.RunAsync(() => client.DeleteObjectAsync(deleteRequest)); if (deleteResponse.HttpStatusCode != HttpStatusCode.NoContent) { throw new AmazonS3Exception($"Could not delete s3://{request.SourceBucket}/{request.SourceKey}. Received response : {(int)deleteResponse.HttpStatusCode}"); } } return(new CopyObjectRequestResponse(request, response)); } } catch (Exception e) { return(null); } }