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 HttpResponseMessage UploadFile() { var httpPostedFile = HttpContext.Current.Request.Files[0]; string fileName = Path.GetFileNameWithoutExtension(httpPostedFile.FileName); string extension = Path.GetExtension(httpPostedFile.FileName); var newGuid = Guid.NewGuid().ToString(""); var newfileName = fileName + "_" + newGuid + extension; Stream st = httpPostedFile.InputStream; try { if (httpPostedFile != null) { TransferUtility utility = new TransferUtility(awsS3Client); TransferUtilityUploadRequest request = new TransferUtilityUploadRequest(); request.BucketName = bucketname; request.Key = newfileName; request.InputStream = st; utility.Upload(request); //File Streamed to AWS } if (ModelState.IsValid) { FileUploadService svc = new FileUploadService(); FileUploadAddRequest model = new FileUploadAddRequest(); model.FileTypeId = 1; model.UserFileName = fileName; model.SystemFileName = newfileName; model.Location = "https://sabio-training.s3.us-west-2.amazonaws.com/Test/" + newfileName; int?id = svc.Insert(model); ItemResponse <int?> resp = new ItemResponse <int?>(); resp.Item = id; return(Request.CreateResponse(HttpStatusCode.OK, resp)); } else { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState)); } } catch (Exception ex) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex)); } }
public async Task UploadFileAsync(string filePath) { try { var fileTransferUtility = new TransferUtility(_s3Client); // Option 1. Upload a file. The file name is used as the object key name. await fileTransferUtility.UploadAsync(filePath, BucketName); } 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); } }
// Upload local file to bucket // Returns true on success, false on error. public override bool UploadFile(String bucket, String file) { try { this.Exception = null; TransferUtility fileTransferUtility = new TransferUtility(new AmazonS3Client(this.AccessKey, this.SecretKey, this.RegionEndpoint)); fileTransferUtility.Upload(file, bucket); return(true); } catch (Exception ex) { this.Exception = ex; if (!this.HandleErrors) { throw ex; } return(false); } }
static void Main(string[] args) { try { TransferUtility fileTransferUtility = new TransferUtility(new AmazonS3Client(Amazon.RegionEndpoint.APSoutheast2)); // 1. Upload a file, file name is used as the object key name. fileTransferUtility.Upload(filePath, existingBucketName); Console.WriteLine("Upload 1 completed"); // 2. Specify object key name explicitly. fileTransferUtility.Upload(filePath, existingBucketName, keyName); Console.WriteLine("Upload 2 completed"); // 3. Upload data from a type of System.IO.Stream. using (FileStream fileToUpload = new FileStream(filePath, FileMode.Open, FileAccess.Read)) { fileTransferUtility.Upload(fileToUpload, existingBucketName, keyName); } Console.WriteLine("Upload 3 completed"); // 4.Specify advanced settings/options. TransferUtilityUploadRequest fileTransferUtilityRequest = new TransferUtilityUploadRequest { BucketName = existingBucketName, FilePath = filePath, StorageClass = S3StorageClass.ReducedRedundancy, PartSize = 6291456, // 6 MB. Key = keyName, CannedACL = S3CannedACL.PublicRead }; fileTransferUtilityRequest.Metadata.Add("param1", "Value1"); fileTransferUtilityRequest.Metadata.Add("param2", "Value2"); fileTransferUtility.Upload(fileTransferUtilityRequest); Console.WriteLine("Upload 4 completed"); Console.Read(); } catch (AmazonS3Exception s3Exception) { Console.WriteLine(s3Exception.Message, s3Exception.InnerException); } }
public static async Task <String> UploadS3File(string bucket, string region, string access, string secret, IFormFile file, string filename) { try { var credentials = new BasicAWSCredentials(access, secret); var config = new AmazonS3Config { RegionEndpoint = andys.function.S3Region.getAWSRegion(region) }; using var client = new AmazonS3Client(credentials, config); await using var newMemoryStream = new MemoryStream(); file.CopyTo(newMemoryStream); var uploadRequest = new TransferUtilityUploadRequest { InputStream = newMemoryStream, Key = filename, BucketName = bucket, CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); } catch (AmazonS3Exception amazonS3Exception) { if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity"))) { Console.WriteLine("Incorrect AWS Credentials."); return("Incorrect AWS Credentials."); } else { Console.WriteLine("Error: ", amazonS3Exception.ErrorCode, amazonS3Exception.Message); return(("Error: ", amazonS3Exception.ErrorCode, amazonS3Exception.Message).ToString()); } } return(filename); }
private void TestUploadDirectory(string bucketName, string keyId) { var directoryName = UtilityMethods.GenerateName("UploadDirectoryTest"); var directoryPath = Path.Combine(basePath, directoryName); for (int i = 0; i < 5; i++) { var filePath = Path.Combine(Path.Combine(directoryPath, i.ToString()), "file.txt"); UtilityMethods.WriteFile(filePath, fileContents); } var config = new TransferUtilityConfig { ConcurrentServiceRequests = 10, }; var transferUtility = new TransferUtility(Client, config); var request = new TransferUtilityUploadDirectoryRequest { BucketName = bucketName, Directory = directoryPath, KeyPrefix = directoryName, SearchPattern = "*", SearchOption = SearchOption.AllDirectories, ServerSideEncryptionMethod = ServerSideEncryptionMethod.AWSKMS, ServerSideEncryptionKeyManagementServiceKeyId = keyId }; HashSet <string> keys = new HashSet <string>(); request.UploadDirectoryFileRequestEvent += (s, e) => { keys.Add(e.UploadRequest.Key); }; transferUtility.UploadDirectory(request); Assert.AreEqual(5, keys.Count); foreach (var key in keys) { VerifyObject(bucketName, key, keyId); } }
public async Task <S3Response> UploadFileAsync(MemoryStream memoryStream, string BucketName, string FileKey) { if (memoryStream == null) { return new S3Response { Message = "memoryStream value null" } } ; try { var fileTransferUtility = new TransferUtility(_client); await fileTransferUtility.UploadAsync(memoryStream, BucketName, FileKey); //await fileTransferUtility.UploadAsync(File, BucketName, "Test"); return(new S3Response { Message = "Upload Successfull", UploadSuccessful = true }); } catch (AmazonS3Exception e) { return(new S3Response { Message = e.Message, Status = e.StatusCode, UploadSuccessful = false }); } catch (Exception e) { Console.WriteLine(e.ToString()); return(new S3Response { Message = e.Message, UploadSuccessful = false }); } } }
/// <summary> /// Get file from s3 bucket /// </summary> /// <param name="bucketName">bucket name</param> /// <param name="key">s3 key - path + file name</param> /// <returns><see cref="MemoryStream"/>Memory file object</returns> public async Task <MemoryStream> DownloadMemoryStreamAsync(string bucketName, string key) { var memory = new MemoryStream(); try { var streamRequest = new TransferUtilityOpenStreamRequest { BucketName = bucketName, Key = key }; var request = new GetObjectRequest() { BucketName = bucketName, Key = key }; using (var transferUtility = new TransferUtility(_s3Client)) { var objectResponse = await transferUtility.S3Client.GetObjectAsync(request); var stream = objectResponse.ResponseStream; await stream.CopyToAsync(memory); } memory.Position = 0; return(memory); } catch (AmazonS3Exception e) { Console.Write("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { Console.Write("Download fail", e.Message); } return(memory); }
/// <summary> /// send file to s3 /// </summary> /// <param name="localFilePath"></param> /// <param name="bucketName"></param> /// <param name="subDirectoryInBucket"></param> /// <param name="fileNameInS3"></param> /// <returns></returns> public bool sendMyFileToS3(string localFilePath, string bucketName, string subDirectoryInBucket, string fileNameInS3) { try { AmazonS3Config config = new AmazonS3Config { ServiceURL = endPoint, ForcePathStyle = true }; IAmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client(AWSAccessKey, AWSSecretKey, config); //IAmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client(RegionEndpoint.EUWest1); // create a TransferUtility instance passing it the IAmazonS3 created in the first step TransferUtility utility = new TransferUtility(client); // making a TransferUtilityUploadRequest instance TransferUtilityUploadRequest request = new TransferUtilityUploadRequest(); if (subDirectoryInBucket == "" || subDirectoryInBucket == null) { request.BucketName = bucketName; //no subdirectory just bucket name } else { // subdirectory and bucket name request.BucketName = bucketName + @"/" + subDirectoryInBucket; } request.Key = fileNameInS3; //file name up in S3 request.FilePath = localFilePath; //local file name request.CannedACL = S3CannedACL.PublicRead; request.StorageClass = S3StorageClass.ReducedRedundancy; utility.Upload(request); //commensing the transfer } catch (AmazonS3Exception ex) { //Console.Write(ex.ToString()); Ultils.AddToLogFile("ex" + ex.ToString()); ////Console.WriteLine(s3Exception.Message, // s3Exception.InnerException); return(false); } return(true); //indicate that the file was sent }
public async Task UploadImageToS3(ImageModel imageToUpload) { var imagesBucketName = $"helpet/{_environment.EnvironmentName}/images/{imageToUpload.Folder}"; var thumbnailsBucketName = $"helpet/{_environment.EnvironmentName}/images/{imageToUpload.Folder}/thumbnails"; var client = new AmazonS3Client(_generalSettings.S3AccessKey, _generalSettings.S3SecretKey, RegionEndpoint.USEast1); var fileTransferUtility = new TransferUtility(client); try { await fileTransferUtility.S3Client.PutBucketAsync(new PutBucketRequest() { BucketName = "helpet" }); } catch { } if (!string.IsNullOrWhiteSpace(imageToUpload.Path)) { fileTransferUtility.Upload(new TransferUtilityUploadRequest() { FilePath = imageToUpload.Path, BucketName = imagesBucketName, Key = $"{imageToUpload.Key ?? imageToUpload.Id}.{imageToUpload.Extension}" }); } if (!string.IsNullOrWhiteSpace(imageToUpload.ThumbnailPath)) { fileTransferUtility.Upload(new TransferUtilityUploadRequest() { FilePath = imageToUpload.ThumbnailPath, BucketName = thumbnailsBucketName, Key = $"{imageToUpload.Key ?? imageToUpload.Id}.{imageToUpload.Extension}" }); } fileTransferUtility.Dispose(); client.Dispose(); }
public async Task <AddFileResponse> UploadFile(string bucketName, string key, IFormFile file) { if (string.IsNullOrEmpty(key)) { key = file.FileName; } else if (!key.EndsWith(Path.GetExtension(file.FileName))) { key = string.Join("", key, Path.GetExtension(file.FileName)); } var response = new List <string>(); var uploadRequest = new TransferUtilityUploadRequest { InputStream = file.OpenReadStream(), Key = key, BucketName = bucketName, CannedACL = S3CannedACL.Private }; using (var fileTransferUtility = new TransferUtility(_s3Client)) { await fileTransferUtility.UploadAsync(uploadRequest); } var expiryUriRequest = new GetPreSignedUrlRequest { BucketName = bucketName, Key = key, Expires = DateTime.Now.AddDays(1) }; var url = _s3Client.GetPreSignedURL(expiryUriRequest); response.Add(url); return(new AddFileResponse { PreSignedUrl = response }); }
private bool GetRestorePoint(Amazon.S3.Util.S3EventNotification.S3Entity s3Event) { var attempt = 0; while (true) { try { attempt++; var msg = new StringBuilder(); var timer = new Stopwatch(); timer.Start(); using (var transferUtility = new TransferUtility(this.S3Client)) using (var responseStream = transferUtility.OpenStream(s3Event.Bucket.Name, s3Event.Object.Key)) using (var reader = new StreamReader(responseStream)) { string line; while ((line = reader.ReadLine()) != null) { var fileName = line.Split(':')[0]; var rowIndex = long.Parse(line.Split(':')[1]); _restorePoint.Add(fileName, rowIndex); msg.Append($"{fileName}:{rowIndex};"); } } timer.Stop(); Console.WriteLine("Restore point:" + msg + " | " + timer.ElapsedMilliseconds + "ms"); return(true); } catch (Exception e) { if (attempt > 5) { Console.WriteLine($"WARN_EXC - GetRestorePoint [{s3Event.Object.Key}]"); Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); throw; } } } }
public static async Task UploadFileToS3(string awskeyId, string awskey, string bucketname, string key, string info) { using (var client = string.IsNullOrEmpty(awskeyId) ? new AmazonS3Client(RegionEndpoint.USEast1) : new AmazonS3Client(awskeyId, awskey, RegionEndpoint.USEast1)) { using (var newMemoryStream = new MemoryStream()) { var uploadRequest = new TransferUtilityUploadRequest { InputStream = new MemoryStream(Encoding.UTF8.GetBytes(info)), Key = key, BucketName = bucketname, CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(client); await fileTransferUtility.UploadAsync(uploadRequest); } } }
/// <summary> /// Upload file to S3 bucket /// </summary> /// <param name="filePath"></param> /// <param name="keyName"></param> /// <param name="bucketName"></param> /// <param name="bucketRegion"></param> /// <returns></returns> public async Task Upload(string filePath, string keyName, string bucketName, RegionEndpoint bucketRegion) { var s3Client = new AmazonS3Client(bucketRegion); var fileTransferUtility = new TransferUtility(s3Client); var fileTransferUtilityRequest = new TransferUtilityUploadRequest { BucketName = bucketName, FilePath = filePath, StorageClass = S3StorageClass.StandardInfrequentAccess, PartSize = 6291456, // 6 MB. Key = keyName, CannedACL = S3CannedACL.PublicRead }; //Provide additional meta data fileTransferUtilityRequest.Metadata.Add("Source", "aws-textract-demo"); await fileTransferUtility.UploadAsync(fileTransferUtilityRequest); }
public async Task UploadFileAsync(string bucketName, string keyName, string filePath) { try { var fileTransferUtility = new TransferUtility(s3Client); await fileTransferUtility.UploadAsync(filePath, bucketName, keyName); Console.WriteLine("Upload 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 static async Task UploadingFileAsync() //Method to upload files to S3 bucket { try { Console.WriteLine("Sending image to server ..."); var fileTransferUtility = new TransferUtility(s3Client); await fileTransferUtility.UploadAsync(FilePath, bucketName); Console.WriteLine("Upload completed."); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { Console.WriteLine("Unknown error encountered on server. Message:'{0}' when writing an object", e.Message); } }
private string bucketName = "missions69"; //папка в интернете (корзина) //private string keyName = "mission69.xml"; // название файла в папке в инете //private string filePath = "App1.dmissions.xml"; //путь файла для отправления/загрузки //private string dfilePath = "App1.missions.xml"; public async void DownloadFile(string path, string key) { AmazonS3Config config = new AmazonS3Config(); //config.ServiceURL = "https://missions69.s3.eu-west-3.amazonaws.com/missions.xml" ; config.UseHttp = true; config.RegionEndpoint = Amazon.RegionEndpoint.EUWest3; var client = new AmazonS3Client("AKIAJO3YO2ATRVV5UQYA", "4+SelI41UmF0oO8IiXazTizmLy60C82Eaem2nonH", config); Path.Combine(System.Environment.GetFolderPath(Environment.SpecialFolder.Personal), path); TransferUtility transferUtility = new TransferUtility(client); TransferUtilityDownloadRequest request = new TransferUtilityDownloadRequest(); request.Key = key; request.BucketName = bucketName; request.FilePath = path; System.Threading.CancellationToken cancellationToken = new System.Threading.CancellationToken(); await transferUtility.DownloadAsync(request, cancellationToken); }
public void CreateS3Directory(string bucket, string key, Action <string, string> logger = null) { if (transferUtil == null) { transferUtil = new TransferUtility(client); } if (!key.EndsWith("/")) { key = key + "/"; } key = key.Replace('\\', '/'); transferUtil.Upload(Stream.Null, bucket, key); if (logger != null) { logger(bucket, $"Created Directory [s3://{bucket}/{key}]."); } }
// s3 upload directory private static async Task UploadDirAsync(IAmazonS3 s3Client, string localDirectory, string s3Path) { try { // create the directoryTransferUtility object var directoryTransferUtility = new TransferUtility(s3Client); // Upload a directory //await directoryTransferUtility.UploadDirectoryAsync(localDirectory, s3Path, wildCard, SearchOption.AllDirectories); await directoryTransferUtility.UploadDirectoryAsync(localDirectory, s3Path); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered ***. 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> StoreFileAsync(FileInfo file) { // Create Bucket if not created already await CreateBucketAsync(_bucketName); var fileTransferUtility = new TransferUtility(_client); // Upload file with the name it has (NOT RECOMMENDED) await fileTransferUtility.UploadAsync(file.FullName, _bucketName); // Upload file with our custom name var newFileName = Guid.NewGuid().ToString(); newFileName = $"{newFileName}{file.Extension}"; await fileTransferUtility.UploadAsync(file.FullName, _bucketName, newFileName); var imageUrl = $"https://{_bucketName}.s3.{_regionName}.amazonaws.com/{newFileName}"; return(imageUrl); }
public void StartAmazonMain() { try { s3Client = new AmazonS3Client(_AccessKeyId, _SecretAccessKey, bucketRegion); var fileTransferUtility = new TransferUtility(s3Client); UploadFileWithFileNameAsync(fileTransferUtility).Wait(); UploadObjectKeyNameValueExplicitlyAsync(fileTransferUtility).Wait(); UploadDataFromIOStreamAsync(fileTransferUtility).Wait(); UploadDataWithAdvancedSetting(fileTransferUtility).Wait(); } 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 StreamCsvToS3Async(IEnumerable <MediaDetails> medias, string fileKey) { var output = new MemoryStream(); using (var writer = new StreamWriter(output)) { using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture)) { await csv.WriteRecordsAsync(medias); await csv.FlushAsync(); using (var transfer = new TransferUtility(Client)) { output.Position = 0; await transfer.UploadAsync(output, Bucket, fileKey); } } } }
// static AWS asynchronous upload function: 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("AWS file upload:\t\t\t\t" + "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 override bool Write(string fileName, byte[] data) { try { if ((!FileExists(fileName)) || Overwrite) { using (TransferUtility transferUtility = new TransferUtility(AWSClient)) { using (MemoryStream ms = new MemoryStream(data)) { transferUtility.Upload(ms, BucketName, AccessKey); } } } } catch { return(false); } return(true); }
private static void uploadtoS3(Stream fileToUpload, ILogger log, string filename) { var awsCredentials = new Amazon.Runtime.BasicAWSCredentials(s3Key, s3Secret); s3Client = new AmazonS3Client(awsCredentials, bucketRegion); try { var fileTransferUtility = new TransferUtility(s3Client); fileTransferUtility.UploadAsync(fileToUpload, bucketName, filename).Wait(); log.LogInformation("Upload 3 completed"); } catch (AmazonS3Exception e) { log.LogInformation("Error encountered on server. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { log.LogInformation("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } }
public string UploadFile(IFormFile formFile) { try { var awsConfig = (AwsSettings)_serviceProvider.GetService(typeof(AwsSettings)); var fileTransferUtility = new TransferUtility(new AmazonS3Client(awsConfig.AwsS3AccessKey, awsConfig.AwsS3SecretAccessKey, RegionEndpoint.USWest2)); var imageName = Guid.NewGuid().ToString(); imageName = imageName + Path.GetExtension(formFile.FileName); using (var stream = formFile.OpenReadStream()) { fileTransferUtility.UploadAsync(stream, awsConfig.AwsS3BucketName, imageName).Wait(); } return(imageName); } catch (Exception up) { _logger.LogInformation(up.Message); return(null); } }
//Uploads file to S3 private static async Task UploadFileAsync(string filePath, string exportlocation) { try { var fileTransferUtility = new TransferUtility(s3Client); // Option 1. Upload a file. The file name is used as the object key name. await fileTransferUtility.UploadAsync(filePath, string.Format(@"{0}/{1}", BUCKET_NAME, exportlocation)); Console.WriteLine("Upload 1 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 bool sendMyFileToS3(System.IO.Stream localFilePath, string bucketName, string subDirectoryInBucket, string fileNameInS3) { IAmazonS3 client = new AmazonS3Client(); TransferUtility utility = new TransferUtility(client); TransferUtilityUploadRequest request = new TransferUtilityUploadRequest(); if (subDirectoryInBucket == "" || subDirectoryInBucket == null) { request.BucketName = bucketName; //no subdirectory just bucket name } else { // subdirectory and bucket name request.BucketName = bucketName + @"/" + subDirectoryInBucket; } request.Key = fileNameInS3; //file name up in S3 request.InputStream = localFilePath; utility.Upload(request); //commensing the transfer return(true); //indicate that the file was sent }
static void ReadObjectData(string keyName, string outputPath) { try { var fileTransferUtility = new TransferUtility(getS3Client()); // Option 2. Specify object key name explicitly. fileTransferUtility.Download(outputPath, bucketName, keyName); Console.WriteLine("Downlaod completed"); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered ***. 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); } }
internal UploadDirectoryCommand(TransferUtility utility, TransferUtilityUploadDirectoryRequest request) { this._utility = utility; this._request = request; }