private static async Task UploadFileAsync() { try { var fileTransferUtility = new TransferUtility(s3Client); // Option 2. Specify object key name explicitly. await fileTransferUtility.UploadAsync(filePath, bucketName, keyName); Console.WriteLine("Upload 2 completed"); } 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 <string> UploadFileAsync(byte[] inputData, string keyName) { try { Stream input = new MemoryStream(inputData); var fileTransferUtility = new TransferUtility(s3Client); await fileTransferUtility.UploadAsync(input, bucketName, keyName); return(null); } catch (AmazonS3Exception e) { logger.Log(LogLevel.Error, $"Error encountered on server. Message:'{e.Message}' when writing an object"); return(e.ToString()); } catch (Exception e) { logger.Log(LogLevel.Error, $"Unknown encountered on server. Message:'{e.Message}' when writing an object"); return(e.ToString()); } }
/// <summary> /// Saves the stream to S3 Object /// </summary> /// <param name="memoryStream"></param> /// <param name="folder"></param> /// <param name="fileName"></param> /// <returns></returns> public async Task <string> SaveStreamToFile(Stream memoryStream, string folder = null, string fileName = null) { try { var bucketName = _s3CsvDataFileConfiguration.DataFileLocation; var keyName = fileName ?? Guid.NewGuid() + ".txt"; var filePath = folder ?? _s3CsvDataFileConfiguration.OutputFileFolder; var fileTransferUtility = new TransferUtility(_amazonS3Client); memoryStream.Seek(0, SeekOrigin.Begin); await fileTransferUtility.UploadAsync(memoryStream, bucketName, filePath + "/" + keyName); return(filePath + "/" + keyName); } catch (AmazonS3Exception e) { _logger.LogError("GetStudentGradesFromCsvFile - Error occurred writing file to S3 - {Error}", e); throw; } }
public async Task <string> Upload(MemoryStream file, string fileName) { using var client = new AmazonS3Client(EnvironmentVariables.AwsAccessKeyId, EnvironmentVariables.AwsSecretAccessKey, RegionEndpoint.SAEast1); using var tinyClient = new TinyPngClient(EnvironmentVariables.TinyPngApiKey); var response = await tinyClient.Compress(file.ToArray()).Download().GetImageStreamData(); var uploadRequest = new TransferUtilityUploadRequest { InputStream = response, Key = $"uploads/{fileName}", BucketName = EnvironmentVariables.AwsBucketName, CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); return("https://s3-sa-east-1.amazonaws.com/traba.io/uploads/" + fileName); }
public static async Task UploadFileToS3(IFormFile file, string key) { using (var client = new AmazonS3Client("AKIAWOOZGGP3DE67XJ6O", "4SXKP3xXZ1F/X/YfNPQHbqg3NPntmrXOUIMUtpVL", RegionEndpoint.USEast1)) { using (var newMemoryStream = new MemoryStream()) { file.CopyTo(newMemoryStream); var uploadRequest = new TransferUtilityUploadRequest { InputStream = newMemoryStream, Key = key + file.FileName, BucketName = "contestplatformcontests", CannedACL = S3CannedACL.NoACL }; var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); } } }
/// <summary> /// Save file to amazon. /// </summary> /// <param name="fileStream">The file bytes.</param> /// <param name="filename">The fime name.</param> /// <param name="contentType">The content type.</param> /// <returns>The file url.</returns> private async Task <string> SaveFileToAmazon(byte[] fileStream, string filename, string contentType) { // Upload image to amazon aws s3 bucket using (var client = AWSClientFactory.CreateAmazonS3Client(AWSAccessKey, AWSSecretAccessKey, RegionEndpoint.USEast1)) { TransferUtility utility = new TransferUtility(client); TransferUtilityUploadRequest request = new TransferUtilityUploadRequest(); using (var stream = new MemoryStream(fileStream)) { request.BucketName = AWSBucketName; request.Key = filename; request.InputStream = stream; request.ContentType = contentType; await utility.UploadAsync(request); } utility.Dispose(); request.AutoCloseStream = true; } return(AWSUrl + filename); }
public async Task UploadFileToS3(IFormFile file) { using (var client = new AmazonS3Client("ASIAUMDIRDA44BKH3D5V", "HClz97bFcQk0Hza5bkaf1g7FhOpmFPEEQ4H25gvi", RegionEndpoint.USEast1)) { using (var newMemoryStream = new MemoryStream()) { file.CopyTo(newMemoryStream); var uploadRequest = new TransferUtilityUploadRequest { InputStream = newMemoryStream, Key = file.FileName, BucketName = "bukectmyportfolio", CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); } } }
private async Task <string> UploadFileToS3(IFormFile file) { var key = Guid.NewGuid().ToString() + separationString + GetValidFileName(file.FileName); TransferUtility fileTransferUtility; try { fileTransferUtility = new TransferUtility(s3Client); using (var fileToUpload = file.OpenReadStream()) { await fileTransferUtility.UploadAsync(fileToUpload, bucketName, key); } } catch (Exception) { throw new FileLoadException(); } fileTransferUtility.Dispose(); return(key); }
private static async Task UploadFileAsync(string filePath, string bucketName, string keyName) { try { var fileTransferUtility = new TransferUtility(s3Client); await fileTransferUtility.UploadAsync(filePath, bucketName); Log.Information("Upload 2 completed"); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message); Log.Error("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); Log.Error("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } }
public async Task <string> UploadImage(IFormFile file) { var newMemoryStream = new MemoryStream(); await file.CopyToAsync(newMemoryStream); string uniqueName = Guid.NewGuid().ToString() + "_" + file.FileName; var uploadRequest = new TransferUtilityUploadRequest { InputStream = newMemoryStream, Key = uniqueName, ///Bucket name BucketName = "Bucket name", CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(s3Client); await fileTransferUtility.UploadAsync(uploadRequest); //Returns the files url when it gets uploaded to s3 bucket return(filePath + uploadRequest.Key); }
/// <summary> /// S3 doesnt support this natively and will cache everything in MemoryStream until disposed. /// </summary> public Task <Stream> OpenWriteAsync(string fullPath, bool append = false, CancellationToken cancellationToken = default) { if (append) { throw new NotSupportedException(); } GenericValidation.CheckBlobFullPath(fullPath); fullPath = StoragePath.Normalize(fullPath, false); //http://docs.aws.amazon.com/AmazonS3/latest/dev/HLuploadFileDotNet.html var callbackStream = new FixedStream(new MemoryStream(), null, async(fx) => { var ms = (MemoryStream)fx.Parent; ms.Position = 0; await _fileTransferUtility.UploadAsync(ms, _bucketName, fullPath, cancellationToken).ConfigureAwait(false); }); return(Task.FromResult <Stream>(callbackStream)); }
public async Task UploadFileToS3(IFormFile file) { using (var client = new AmazonS3Client(BucketInfo.AWSKey, BucketInfo.AWSSKey, RegionEndpoint.USEast2)) { using (var newMemoryStream = new MemoryStream()) { file.CopyTo(newMemoryStream); var uploadRequest = new TransferUtilityUploadRequest { InputStream = newMemoryStream, Key = file.FileName, BucketName = BucketInfo.Bucket, CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); } } }
public async Task <IActionResult> CovertDoc(List <IFormFile> files) { if (!files.Any()) { return(View()); } var doc = files[0]; var key = doc.FileName;//key is full folder path on S3 var utility = new TransferUtility(_s3Client); await utility.UploadAsync(doc.OpenReadStream(), _bucket, key); var req = new InvokeRequest { FunctionName = "your_lambda_funtion_name", Payload = JsonSerializer.Serialize(new { key, bucket = _bucket }), }; var res = await _lambdaClient.InvokeAsync(req); using var sr = new StreamReader(res.Payload); var resString = await sr.ReadToEndAsync(); var pdfKey = JsonSerializer.Deserialize <string>(resString);// my lambda return converted pdf S3 key var preSignedUrlRequest = new GetPreSignedUrlRequest { BucketName = _bucket, Key = pdfKey, Expires = DateTime.Now.AddDays(1), ResponseHeaderOverrides = new ResponseHeaderOverrides() { ContentType = "application/force-download", ContentDisposition = "attachment;filename=" + "download_file_name" } }; var preSignedUrl = _s3Client.GetPreSignedURL(preSignedUrlRequest);//downloadable S3 file url ViewBag.pdfUrl = preSignedUrl; return(View("Convert-Pdf")); }
private void Bw_DoWork(object sender, DoWorkEventArgs e) { var file = new FileInfo(FileName); FileSize = Tools.SizeToHuman(file.Length); Status = "Uploading"; using (var fileTransferUtility = new TransferUtility(_client)) { var uploadRequest = new TransferUtilityUploadRequest { BucketName = _awsbucket, FilePath = file.FullName, Key = $"{_prefix}/{file.Name}", CannedACL = S3CannedACL.Private, ContentType = MimeMapping.GetMimeMapping(file.Name), StorageClass = S3StorageClass.Standard, AutoCloseStream = true, TagSet = new List <Tag>() { new Tag() { Key = "MachineName", Value = Environment.MachineName }, new Tag() { Key = "UserName", Value = Environment.UserName } } }; uploadRequest.UploadProgressEvent += uploadRequest_UploadPartProgressEvent; fileTransferUtility.UploadAsync(uploadRequest, _tokenSource.Token); } }
public async Task <APIGatewayProxyResponse> CreateProfileAsync(APIGatewayProxyRequest request, ILambdaContext context) { WriteVariables(context); string requestBody = request.Body; context.Logger.LogLine($"Request Body\n {requestBody}"); AddProfileModel addProfileModel = JsonConvert.DeserializeObject <AddProfileModel>(requestBody); context.Logger.LogLine($"Decoding Base64 image"); var bytes = Convert.FromBase64String(addProfileModel.ProfilePicBase64); var fileTransferUtility = new TransferUtility(_awsS3Client); using (var ms = new MemoryStream(bytes)) { context.Logger.LogLine($"Uploading {addProfileModel.ProfilePicName} to {BucketName}"); await fileTransferUtility.UploadAsync(ms, BucketName, addProfileModel.ProfilePicName); } context.Logger.LogLine($"Adding profile to DynamoDb"); await _awsDynamoDbClient.PutItemAsync(TableName, new Dictionary <string, AttributeValue>() { { nameof(AddProfileModel.Id), new AttributeValue(addProfileModel.Id) }, { nameof(AddProfileModel.Name), new AttributeValue(addProfileModel.Name) }, { nameof(AddProfileModel.Email), new AttributeValue(addProfileModel.Email) }, { nameof(AddProfileModel.ProfilePicName), new AttributeValue(addProfileModel.ProfilePicName) } }); var response = new APIGatewayProxyResponse { StatusCode = (int)HttpStatusCode.OK, Body = "Created", Headers = new Dictionary <string, string> { { "Content-Type", "text/plain" } } }; return(response); }
public async Task UploadFileAsync(string emailId) { try { var uploadRequest = new TransferUtilityUploadRequest { FilePath = filePath, BucketName = bucketName, Key = keyName, CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(s3Client); await Task.Run(() => { Task upld = fileTransferUtility.UploadAsync(uploadRequest); while (!upld.IsCompleted) { upld.Wait(25); if (upld.IsFaulted || upld.IsCanceled) { return; } } Trace.WriteLine(String.Format("Upload status: {0} \n Upload Complete: {1}", upld.Status, upld.IsCompleted)); AWSConnectionService.getInstance().ListPDFFilesforUser(emailId); Console.WriteLine("File Upload completed.. Check bucket via console"); Application.Current.Dispatcher.Invoke((Action) delegate { new Welcome(emailId).Show(); }); }); } catch (AmazonS3Exception e) { Trace.WriteLine(String.Format("Error encountered on server. Message: '{0}' when writing an object", e.Message)); } catch (Exception e) { Trace.WriteLine(String.Format("Unknown encountered on server. Message: '{0}' when writing an object", e.Message)); } }
public async Task Deliver(Uri destination, MsgNThenMessage message) { //https://s3.us-east-2.amazonaws.com/my-bucket-name/filename //s3://john.doe@my-bucket-name/filename[ //s3://<credentialName>@<bucketname>/filename var credentials = GetCredentials(destination); var bucketName = destination.Host; var pathAndQuery = Uri.UnescapeDataString(destination.PathAndQuery).TrimStart('/'); var messageId = message.Headers[HeaderConstants.MessageId]; var messageGroupId = message.Headers[HeaderConstants.MessageGroupId]; var correlationId = message.Headers[HeaderConstants.CorrelationId]; var fileKey = string.Format(pathAndQuery, messageId, messageGroupId, correlationId); var queryDictionary = QueryHelpers.ParseQuery(destination.Query); if (message.Body.CanSeek) { message.Body.Position = 0; } using (var client = new AmazonS3Client(credentials.awsAccessKeyId, credentials.awsSecretAccessKey, RegionEndpoint.USEast1)) { var uploadRequest = new TransferUtilityUploadRequest { InputStream = message.Body, Key = fileKey, BucketName = bucketName, CannedACL = S3CannedACL.BucketOwnerFullControl }; if (queryDictionary.TryGetValue(QueryConstants.S3CannedACL, out var val)) { var cannedAcl = S3CannedACL.FindValue(val); if (cannedAcl != null) { uploadRequest.CannedACL = cannedAcl; } } var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); } }
public static async Task UploadFileAsync( IAmazonS3 client, string bucketName, string key, string contentType, string contentEncoding, Stream reader, ServerSideEncryptionMethod serverSideEncryptionMethod, CancellationToken token) { var transferUtility = new TransferUtility(client); var request = new TransferUtilityUploadRequest { BucketName = bucketName, Key = key, InputStream = reader, AutoCloseStream = false, AutoResetStreamPosition = false, Headers = { CacheControl = "no-store" } }; if (serverSideEncryptionMethod != ServerSideEncryptionMethod.None) { request.ServerSideEncryptionMethod = serverSideEncryptionMethod; } if (contentType != null) { request.ContentType = contentType; request.Headers.ContentType = contentType; } if (contentEncoding != null) { request.Headers.ContentEncoding = contentEncoding; } using (transferUtility) await transferUtility.UploadAsync(request, token).ConfigureAwait(false); }
public async Task <bool> UploadFileAsync(Stream fileStream, string fileName, string directory = null) { try { var fileTransferUtility = new TransferUtility(_s3Client); var bucketPath = !string.IsNullOrWhiteSpace(directory) ? _s3BucketOptions.BucketName + @"/" + directory : _s3BucketOptions.BucketName; var fileUploadRequest = new TransferUtilityUploadRequest() { CannedACL = S3CannedACL.PublicRead, BucketName = bucketPath, Key = fileName, //PartSize = 26214400, InputStream = fileStream }; fileUploadRequest.UploadProgressEvent += (sender, args) => _logger.LogInformation($"{args.FilePath} upload complete : {args.PercentDone}%"); await fileTransferUtility.UploadAsync(fileUploadRequest); _logger.LogInformation($"successfully uploaded {fileName} to {bucketPath} on {DateTime.UtcNow:O}"); return(true); } catch (AmazonS3Exception amazonS3Exception) { if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity"))) { _logger.LogError("Please check the provided AWS Credentials."); } else { _logger.LogError( $"An error occurred with the message '{amazonS3Exception.Message}' when uploading {fileName}"); } return(false); } }
private async Task <IActionResult> UploadByteAsync(string keyName) { try { string path = Path.Combine(this.hostingEnvironment.ContentRootPath, keyName); FileStream fs = new FileStream(path, FileMode.Open); var fileTransferUtility = new TransferUtility(this.s3Client); var fileTransferUtilityRequest = new TransferUtilityUploadRequest { BucketName = bucketName, InputStream = fs, StorageClass = S3StorageClass.Standard, Key = keyName, CannedACL = S3CannedACL.PublicRead }; await fileTransferUtility.UploadAsync(fileTransferUtilityRequest); fs.Close(); System.IO.File.Delete(path); return(Ok(new ServiceResponse { Status = "success", Message = $"https://s3.ap-south-1.amazonaws.com/{bucketName}/{keyName}" })); } catch (AmazonS3Exception e) { this.logger.Log("UploadByteAsync Amazon has Problem", e.Message, e.InnerException?.Message); Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { this.logger.Log("UploadByteAsync has Problem", e.Message, e.InnerException?.Message); Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } return(Ok(new ServiceResponse { Status = "error", Message = "Something Went Wrong When Uploading The File" })); }
private async void UploadFile(string bucketName) { OpenFileDialog choofdlog = new OpenFileDialog(); choofdlog.Filter = "All Files (*.*)|*.*"; choofdlog.FilterIndex = 1; choofdlog.Multiselect = false; if (choofdlog.ShowDialog() == DialogResult.OK) { try { var fileTransferUtility = new TransferUtility(client); TransferUtilityUploadRequest request = new TransferUtilityUploadRequest() { BucketName = bucketName, FilePath = choofdlog.FileName, Key = choofdlog.SafeFileName }; request.UploadProgressEvent += new EventHandler <UploadProgressArgs> (uploadRequest_UploadPartProgressEvent); EnableProgressBar(); await fileTransferUtility.UploadAsync(request); MessageBox.Show("Upload Completed"); ResetProgressBar(); } catch (AmazonS3Exception e) { MessageBox.Show($"Error encountered on server. Message:'{e.Message}' when writing an object"); } catch (Exception e) { MessageBox.Show($"Unknown encountered on server. Message:'{e.Message}' when writing an object"); } } }
private static readonly IAmazonS3 S3Client = new AmazonS3Client(BucketRegion); // Instantiating S3 Client public static async Task <int> UploadingFileAsync() // Method to upload files to S3 bucket { try { var fileTransferUtility = new TransferUtility(S3Client); await fileTransferUtility.UploadAsync(FilePath, bucketName); return(0); } catch (AmazonS3Exception exception) { Console.Error.WriteLine("Error encountered on server. Message:'{0}' when writing an object", exception.Message); return(-1); } catch (Exception exception) { Console.Error.WriteLine("Unknown error encountered on server. Message:'{0}' when writing an object", exception.Message); return(-1); } }
public async Task <string> SafePhoto(string photo) { var bytes = Convert.FromBase64String(photo.Split(',')[1]); var photoName = GetHashedName(bytes) + "." + Regex.Match(photo, @"data:.*?/(?<ext>.*?);base64").Groups["ext"].Value; using (var stream = new MemoryStream(bytes)) { using (var fileTransferUtility = new TransferUtility(_client)) { var awsRequest = new TransferUtilityUploadRequest() { BucketName = BucketName, Key = photoName, InputStream = stream }; awsRequest.CannedACL = "public-read"; await fileTransferUtility.UploadAsync(awsRequest); } } return(photoName); }
public async Task <String> SaveToBlobAsync(string bucketDestino, MemoryStream filePath, string contentType) { try { TransferUtility fileTransferUtility = new TransferUtility(new AmazonS3Client(ConfigurationManager.AppSettings["awsAccessKeyId"].ToString(), ConfigurationManager.AppSettings["awsSecretAccessKey"].ToString(), Amazon.RegionEndpoint.SAEast1) ); string nomeArquivo = Guid.NewGuid().ToString(); nomeArquivo = nomeArquivo + "." + contentType; await fileTransferUtility.UploadAsync(filePath, bucketDestino, nomeArquivo); string url = @"https://s3-sa-east-1.amazonaws.com/"; url += bucketDestino + "/" + nomeArquivo; return(url); } catch (AmazonS3Exception s3Exception) { var x = s3Exception.Message; return("Error" + x); } }
protected override async Task <bool> DoSaveAsync(string path, Stream file, CancellationToken?cancellationToken = null) { await CreateBucketAsync(Options.Bucket, cancellationToken); using var fileTransferUtility = new TransferUtility(_s3Client); try { var request = new TransferUtilityUploadRequest { InputStream = file, Key = path, BucketName = Options.Bucket }; await fileTransferUtility.UploadAsync(request, cancellationToken ?? CancellationToken.None); return(true); } catch (Exception e) { Logger.LogError(e, "Error uploading file {File}: {ErrorText}", path, e.ToString()); throw; } }
public async Task UploadFile(Stream fileStream, string key, string mimeType) { TransferUtility fileTransferUtility = new TransferUtility(this.amazonS3); TransferUtilityUploadRequest uploadRequest = new TransferUtilityUploadRequest() { InputStream = fileStream, BucketName = this.configuration.GetSection("AWS") .GetSection("S3") .GetSection("Bucket") .GetValue <string>("Name"), Key = key, ContentType = mimeType, AutoCloseStream = true }; this.logger.LogInformation("Starting file upload to AWS S3 storage bucket: " + key + " (" + mimeType + ")"); await fileTransferUtility.UploadAsync(uploadRequest); this.logger.LogInformation("File uploaded to AWS S3 storage bucket: " + key + " (" + mimeType + ")"); }
public async Task <IActionResult> OnPostAsync() { try { // 1. upload video to s3 // TODO check stream processing await using var memoryStream = new MemoryStream(); FileUpload.CopyTo(memoryStream); var uploadRequest = new TransferUtilityUploadRequest { InputStream = memoryStream, Key = Title, BucketName = BucketName, CannedACL = S3CannedACL.PublicRead }; var ftu = new TransferUtility(_amazonS3); await ftu.UploadAsync(uploadRequest); // 2. save s3 link in db var curUser = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value; var video = new Video { S3Url = $"{Constants.VideoUploadS3BaseUrl}/{Title}", Title = this.Title, UserId = curUser }; _context.Add(video); await _context.SaveChangesAsync(); return(new RedirectToPageResult("/Index")); } catch (Exception e) { // idk handle later throw; } }
public async Task UploadObjectDataAsyncAWSS3(string filename, byte[] bytea, EbFileCategory cat) { try { var fileTransferUtility = new TransferUtility(s3Client); var ms = new System.IO.MemoryStream(); ms.Write(bytea, 0, bytea.Length); ms.Position = 0; await fileTransferUtility.UploadAsync(ms, bucketName, filename); Console.WriteLine("Upload 4 completed"); } 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 <string> UploadFileAsync(string fileName, Stream file) { var filestream = new MemoryStream(); await file.CopyToAsync(filestream); var s3FileName = $"{DateTime.Now.Ticks}-{fileName}"; var transferRequest = new TransferUtilityUploadRequest() { ContentType = "application/octet-stream", InputStream = filestream, BucketName = _bucket, Key = s3FileName }; transferRequest.Metadata.Add("x-amz-meta-title", fileName); var fileTransferUtility = new TransferUtility(_client); await fileTransferUtility.UploadAsync(transferRequest); return(s3FileName); }
/// <summary> /// Adds the image to the cache in an asynchronous manner. /// </summary> /// <param name="stream"> /// The stream containing the image data. /// </param> /// <param name="contentType"> /// The content type of the image. /// </param> /// <returns> /// The <see cref="Task"/> representing an asynchronous operation. /// </returns> public override async Task AddImageToCacheAsync(Stream stream, string contentType) { TransferUtility transferUtility = new TransferUtility(this.amazonS3ClientCache); string path = this.GetFolderStructureForAmazon(this.CachedPath); string filename = Path.GetFileName(this.CachedPath); string key = this.GetKey(path, filename); TransferUtilityUploadRequest transferUtilityUploadRequest = new TransferUtilityUploadRequest { BucketName = this.awsBucketName, InputStream = stream, Key = key, CannedACL = S3CannedACL.PublicRead }; transferUtilityUploadRequest.Headers.CacheControl = string.Format("public, max-age={0}", this.MaxDays * 86400); transferUtilityUploadRequest.Headers.ContentType = contentType; transferUtilityUploadRequest.Metadata.Add("x-amz-meta-ImageProcessedBy", "ImageProcessor.Web/" + AssemblyVersion); await transferUtility.UploadAsync(transferUtilityUploadRequest); }