private async Task ReadObject(Stream stream, CancellationToken ct, string key) { using (var util = new TransferUtility(_s3)) { using (Stream srcStream = await util.OpenStreamAsync(_bucket, key).ConfigureAwait(false)) { await srcStream.CopyToAsync(stream, 64*1024, ct).ConfigureAwait(false); } } }
public async Task UploadFile(string name,IStorageFile storageFile) { var s3Client = new AmazonS3Client(credentials, RegionEndpoint.USEast1); var transferUtilityConfig = new TransferUtilityConfig { ConcurrentServiceRequests = 5, MinSizeBeforePartUpload = 20 * MB_SIZE, }; try { using (var transferUtility = new TransferUtility(s3Client, transferUtilityConfig)) { var uploadRequest = new TransferUtilityUploadRequest { BucketName = ExistingBucketName, Key = name, StorageFile = storageFile, // Set size of each part for multipart upload to 10 MB PartSize = 10 * MB_SIZE }; uploadRequest.UploadProgressEvent += OnUploadProgressEvent; await transferUtility.UploadAsync(uploadRequest); } } catch (AmazonServiceException ex) { // oResponse.OK = false; // oResponse.Message = "Network Error when connecting to AWS: " + ex.Message; } }
public override IEnumerable<PvcStream> Execute(IEnumerable<PvcStream> inputStreams) { var filteredInputStreams = FilterUploadedFiles(inputStreams); var transfer = new TransferUtility(this.s3client); foreach (var inputStream in filteredInputStreams) { if (inputStream.StreamName == null || inputStream.StreamName.Length == 0) continue; var uploadReq = new TransferUtilityUploadRequest(); uploadReq.BucketName = this.bucketName; uploadReq.InputStream = inputStream; uploadReq.Key = this.StreamNameToKey(inputStream.StreamName); uploadReq.Headers.ContentMD5 = this.keyMD5Sums[uploadReq.Key]; uploadReq.Headers.ContentType = MimeMapping.GetMimeMapping(inputStream.StreamName); if (inputStream.Tags.Contains("gzip")) { uploadReq.Headers.ContentEncoding = "gzip"; } transfer.Upload(uploadReq); }; return inputStreams; }
static void Main(string[] args) { try { TransferUtility fT = new TransferUtility(new AmazonS3Client(Amazon.RegionEndpoint.USEast1)); string fileKey = genKey(); TransferUtilityUploadRequest uR = new TransferUtilityUploadRequest { BucketName = bucketName, FilePath = filepath, CannedACL = S3CannedACL.PublicRead, Key = fileKey }; uR.Metadata.Add("Title", "Tiger"); fT.Upload(uR); Console.WriteLine("File Uploaded. Access \"S3.amazonaws.com/sheltdev/" + fileKey ); Console.ReadKey(false); } catch (AmazonS3Exception e) { Console.WriteLine(e.Message, e.InnerException); Console.ReadKey(false); } }
public async Task <S3Response> UploadFile(MemoryStream stream, string path, string bucket) { try { using (Amazon.S3.Transfer.TransferUtility transferUti = new Amazon.S3.Transfer.TransferUtility(_client)) { transferUti.Upload(stream, bucket, path); 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 }); } }
//For testing - allows mocking of files and s3 public S3FileSystem(AmazonS3 s3Client, Func<string, IFileStreamWrap> fileLoader) { Logger = new TraceLogger(); S3Client = s3Client; TransferUtility = new TransferUtility(s3Client); FileLoader = fileLoader; }
public S3FileSystem(IPsCmdletLogger logger, string accessKey, string secret, AmazonS3Config config) { Logger = logger ?? new TraceLogger(); S3Client = new AmazonS3Client(accessKey, secret, config); TransferUtility = new TransferUtility(S3Client); FileLoader = (fileFullName) => new FileWrap().Open(fileFullName, FileMode.Open, FileAccess.ReadWrite); }
public string DeleteImageFile(Hashtable State, string url) { string AWSAccessKey = ConfigurationManager.AppSettings["AWSAccessKey"]; string AWSSecretKey = ConfigurationManager.AppSettings["AWSSecretKey"]; string Bucket = ConfigurationManager.AppSettings["ImageBucket"]; TransferUtility transferUtility = new TransferUtility(AWSAccessKey, AWSSecretKey); try { DeleteObjectRequest request = new DeleteObjectRequest(); string file_name = url.Substring(url.LastIndexOf("/") + 1); string key = State["Username"].ToString() + "/" + file_name; request.WithBucketName(Bucket) .WithKey(key); using (DeleteObjectResponse response = transferUtility.S3Client.DeleteObject(request)) { WebHeaderCollection headers = response.Headers; } } catch (AmazonS3Exception ex) { Util util = new Util(); util.LogError(State, ex); return ex.Message + ": " + ex.StackTrace; } return "OK"; }
public void SendDocument(string filePath, string bucket, string destinationPath, string fileNamOnDestinationWithExtension = "index.html", bool isPublic = false) { try { var transferUtility = new TransferUtility(amazonS3Client); if (!transferUtility.S3Client.DoesS3BucketExist(bucket)) transferUtility.S3Client.PutBucket(new PutBucketRequest { BucketName = bucket }); var request = new TransferUtilityUploadRequest { BucketName = bucket, Key = string.Format("{0}/{1}", destinationPath, fileNamOnDestinationWithExtension), FilePath = filePath }; if (isPublic) request.Headers["x-amz-acl"] = "public-read"; request.UploadProgressEvent += uploadFileProgressCallback; transferUtility.Upload(request); transferUtility.Dispose(); } catch (Exception ex) { throw new Exception("Error send file to S3. " + ex.Message); } }
public void SimpleUpload() { var client = Client; using (var tu = new Amazon.S3.Transfer.TransferUtility(client)) { tu.Upload(fullPath, bucketName); var response = client.GetObjectMetadata(new GetObjectMetadataRequest { BucketName = bucketName, Key = testFile }); Assert.IsTrue(response.ETag.Length > 0); var downloadPath = fullPath + ".download"; var downloadRequest = new Amazon.S3.Transfer.TransferUtilityDownloadRequest { BucketName = bucketName, Key = testFile, FilePath = downloadPath }; tu.Download(downloadRequest); TestDownloadedFile(downloadPath); // empty out file, except for 1 byte File.WriteAllText(downloadPath, testContent.Substring(0, 1)); Assert.IsTrue(File.Exists(downloadPath)); tu.Download(downloadRequest); TestDownloadedFile(downloadPath); } }
public void DirectoryTesting() { var directory = TransferUtilityTests.CreateTestDirectory(10 * TransferUtilityTests.KILO_SIZE); var keyPrefix = directory.Name; var directoryPath = directory.FullName; using (var transferUtility = new Amazon.S3.Transfer.TransferUtility(s3EncryptionClientFileMode)) { TransferUtilityUploadDirectoryRequest uploadRequest = CreateUploadDirRequest(directoryPath, keyPrefix); transferUtility.UploadDirectory(uploadRequest); var newDir = TransferUtilityTests.GenerateDirectoryPath(); transferUtility.DownloadDirectory(bucketName, keyPrefix, newDir); TransferUtilityTests.ValidateDirectoryContents(s3EncryptionClientFileMode, bucketName, keyPrefix, directory); } using (var transferUtility = new Amazon.S3.Transfer.TransferUtility(s3EncryptionClientMetadataMode)) { TransferUtilityUploadDirectoryRequest uploadRequest = CreateUploadDirRequest(directoryPath, keyPrefix); transferUtility.UploadDirectory(uploadRequest); var newDir = TransferUtilityTests.GenerateDirectoryPath(); transferUtility.DownloadDirectory(bucketName, keyPrefix, newDir); TransferUtilityTests.ValidateDirectoryContents(s3EncryptionClientMetadataMode, bucketName, keyPrefix, directory); } }
public static void UploadFile(System.Tuple<string,string, DateTime> file, string existingBucketName) { NameValueCollection appConfig = ConfigurationManager.AppSettings; string accessKeyID = appConfig["AWSAccessKey"]; string secretAccessKey = appConfig["AWSSecretKey"]; try { TransferUtility fileTransferUtility = new TransferUtility(accessKeyID, secretAccessKey); // Use TransferUtilityUploadRequest to configure options. // In this example we subscribe to an event. TransferUtilityUploadRequest uploadRequest = new TransferUtilityUploadRequest() .WithBucketName(existingBucketName) .WithFilePath(file.Item1) .WithServerSideEncryptionMethod(ServerSideEncryptionMethod.AES256) .WithKey(file.Item2 + file.Item3.ToString("ddmmyyyymmmmhhss")); uploadRequest.UploadProgressEvent += new EventHandler<UploadProgressArgs> (uploadRequest_UploadPartProgressEvent); fileTransferUtility.Upload(uploadRequest); } catch (ArgumentException e) { Console.WriteLine(e.Message); } catch (AmazonS3Exception e) { Console.WriteLine(e.Message + e.InnerException); } }
//Pushes file to Amazon S3 with public read permissions public bool UploadFile(string localFile,string fileName, string contentType) { IAmazonS3 client = GetS3Client(); var result = false; try { var request = new TransferUtilityUploadRequest { BucketName = _BucketName, Key = _Prefix+fileName, FilePath = localFile, StorageClass = S3StorageClass.Standard, CannedACL = S3CannedACL.PublicRead, ContentType = contentType }; var fileTransferUtility = new TransferUtility(client); fileTransferUtility.Upload(request); //PutObjectResponse response2 = client.PutObject(request); result = true; } catch { return result; } return result; }
public string UploadFile(string localFilePath, string s3Folder) { string uploadedFileUrl = string.Empty; try { s3Folder = CorrectFolderPath(s3Folder); string key = s3Folder + Path.GetFileName(localFilePath); using (var transferUtility = new Amazon.S3.Transfer.TransferUtility(_awsS3Client)) { using (FileStream fs = new FileStream(localFilePath, FileMode.Open)) { var request = new TransferUtilityUploadRequest { BucketName = _bucketName, Key = key, InputStream = fs, CannedACL = S3CannedACL.PublicRead, }; transferUtility.Upload(request); } uploadedFileUrl = bucketUrl + key; } } catch (Exception ex) { throw new ApplicationException("S3 UploadfileToS3 - unexpected exception.", ex); } return(uploadedFileUrl); }
public async Task <string> UploadFileFromStream(Stream stream, string s3Key) { string uploadedFileUrl = string.Empty; try { using (var transferUtility = new Amazon.S3.Transfer.TransferUtility(_awsS3Client)) { using (stream) { var request = new TransferUtilityUploadRequest { BucketName = _bucketName, Key = s3Key, InputStream = stream, CannedACL = S3CannedACL.PublicRead, }; await transferUtility.UploadAsync(request); } uploadedFileUrl = bucketUrl + s3Key; } } catch (Exception ex) { throw new ApplicationException("S3 UploadFileFromStream - unexpected exception.", ex); } return(uploadedFileUrl); }
public BloomS3Client(string bucketName) { _bucketName = bucketName; _amazonS3 = AWSClientFactory.CreateAmazonS3Client(KeyManager.S3AccessKey, KeyManager.S3SecretAccessKey, new AmazonS3Config { ServiceURL = "https://s3.amazonaws.com" }); _transferUtility = new TransferUtility(_amazonS3); }
public void SetFileToS3(string _local_file_path, string _bucket_name, string _sub_directory, string _file_name_S3) { // Gelen Değerler : // _local_file_path : Lokal dosya yolu örn. "d:\filename.zip" // _bucket_name : S3 teki bucket adı ,Bucket önceden oluşturulmuş olmalıdır. // _sub_directory : Boş değilse S3 içinde klasör oluşturulur yada varsa içine ekler dosyayı. // _file_name_S3 : Dosyanın S3 içindeki adı // IAmazonS3 class'ı oluşturuyoruz ,Benim lokasyonum RegionEndpoint.EUCentral1 onun için onu seçiyorum // Sizde yüklemek istediğiniz bucket 'ın lokasyonuna göre değiştirmelisiniz. IAmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client(RegionEndpoint.EUCentral1); // Bir TransferUtility oluşturuyoruz(Türkçesi : Aktarım Programı). utility = new TransferUtility(client); // TransferUtilityUploadRequest oluşturuyoruz request = new TransferUtilityUploadRequest(); if (_sub_directory == "" || _sub_directory == null) { request.BucketName = _bucket_name; //Alt klasör girmediysek direk bucket'ın içine atıyor. } else { // Alt Klasör ve Bucket adı request.BucketName = _bucket_name + @"/" + _sub_directory; } request.Key = _file_name_S3; //Dosyanın S3 teki adı request.FilePath = _local_file_path; //Lokal Dosya Yolu }
public CraneChatS3Uploader() { m_CloudFrontRoot = new Uri(ConfigurationManager.AppSettings["CloudFrontRoot"]); m_BucketName = ConfigurationManager.AppSettings["BucketName"]; AmazonS3Config s3Config = new AmazonS3Config().WithServiceURL(ConfigurationManager.AppSettings["S3ServiceURL"].ToString()); AmazonS3 s3Client = AWSClientFactory.CreateAmazonS3Client(s3Config); m_s3transferUtility = new TransferUtility(s3Client); }
public AwsFileUpload(String name, String sourceFilePath, Stream stream, String bucketName, String accessKey, String secretKey, string originalFileName, string note, DateTime originalFileDate, bool isDownload, string md5, Int32 duration = 0, string resolution = "") : base(name, sourceFilePath, stream, originalFileName, note, originalFileDate, isDownload, duration, resolution) { this._bucketName = bucketName; if (!string.IsNullOrEmpty(md5)) base._md5 = md5; var fileTransferUtilityConfig = new TransferUtilityConfig { ConcurrentServiceRequests = 10 }; AWSConfigs.S3Config.UseSignatureVersion4 = true; string regionFromConfig = System.Configuration.ConfigurationSettings.AppSettings.Get("EndpointRegion"); RegionEndpoint regionEndpoint = RegionEndpoint.APNortheast1; switch (regionFromConfig.ToLower()) { case "apsoutheast1": regionEndpoint = RegionEndpoint.APSoutheast1; break; case "apsoutheast2": regionEndpoint = RegionEndpoint.APSoutheast2; break; case "cnnorth1": regionEndpoint = RegionEndpoint.CNNorth1; break; case "eucentral1": regionEndpoint = RegionEndpoint.EUCentral1; break; case "euwest1": regionEndpoint = RegionEndpoint.EUWest1; break; case "saeast1": regionEndpoint = RegionEndpoint.SAEast1; break; case "useast1": regionEndpoint = RegionEndpoint.USEast1; break; case "usgovcloudwest1": regionEndpoint = RegionEndpoint.USGovCloudWest1; break; case "uswest1": regionEndpoint = RegionEndpoint.USWest1; break; case "uswest2": regionEndpoint = RegionEndpoint.USWest2; break; default: break; //APNortheast1 } _amazonS3Client = new AmazonS3Client(new BasicAWSCredentials(accessKey, secretKey), regionEndpoint); _amazonS3Client.ExceptionEvent += amazonS3Client_ExceptionEvent; _fileTransferUtility = new TransferUtility(_amazonS3Client, fileTransferUtilityConfig); }
public AmazonS3StorageProvider(IAmazonS3StorageConfiguration amazonS3StorageConfiguration) { _amazonS3StorageConfiguration = amazonS3StorageConfiguration; var cred = new BasicAWSCredentials(_amazonS3StorageConfiguration.AWSAccessKey, _amazonS3StorageConfiguration.AWSSecretKey); //TODO: aws region to config _client = new AmazonS3Client(cred, RegionEndpoint.USEast1); var config = new TransferUtilityConfig(); _transferUtility = new TransferUtility(_client, config); }
internal TransferUtility GetTransferUtility(RegionEndpoint region) { TransferUtility output; if (!this.transferUtilitiesByRegion.TryGetValue(region.SystemName, out output)) { output = new TransferUtility(this.GetClient(region)); this.transferUtilitiesByRegion.Add(region.SystemName, output); } return output; }
protected override void ExecuteS3Task() { using ( TransferUtility transferUtility = new Amazon.S3.Transfer.TransferUtility( this.AccessKey, this.SecretAccessKey ) ) { TransferUtilityDownloadRequest downloadRequest = new TransferUtilityDownloadRequest { BucketName = this.BucketName, Key = this.SourceFile, FilePath = this.DestinationFile, }; // uploadRequest.AddHeader("x-amz-acl", "public-read"); transferUtility.Download( downloadRequest ); } }
protected override void ExecuteS3Task() { using (TransferUtility transferUtility = new Amazon.S3.Transfer.TransferUtility(this.AccessKey, this.SecretAccessKey)) { TransferUtilityDownloadRequest downloadRequest = new TransferUtilityDownloadRequest { BucketName = this.BucketName, Key = this.SourceFile, FilePath = this.DestinationFile, }; // uploadRequest.AddHeader("x-amz-acl", "public-read"); transferUtility.Download(downloadRequest); } }
protected void InitAWS() { //Amazon Configuration (depends on AWSProfileName key on Web.config) if (S3Client != null) { S3TransferUtil = new TransferUtility(S3Client); } else { S3TransferUtil = null; } }
public void Upload(FileSources fileSources) { if (fileSources.Count() > 0) { utility = new TransferUtility(client); foreach (var source in fileSources) { parallelTasks.Add(Task.Factory.StartNew(() => StartUpload(source))); } } Task.WaitAll(parallelTasks.ToArray()); }
public void Dispose() { if (_transferUtility != null) { _transferUtility.Dispose(); _transferUtility = null; } if (_amazonS3 != null) { _amazonS3.Dispose(); _amazonS3 = null; } }
public HttpResponseMessage ExternalPost() { HttpResponseMessage result = null; HttpRequest httpRequest = HttpContext.Current.Request; TransferUtility fileTransferUtility = new TransferUtility(new AmazonS3Client(ConfigService.AwsAccessKeyId , ConfigService.AwsSecretAccessKey , Amazon.RegionEndpoint.USWest2)); if (httpRequest.Files.Count > 0) { foreach (string file in httpRequest.Files) { HttpPostedFile postedFile = httpRequest.Files[file]; string guid = Guid.NewGuid().ToString(); string remoteFilePath = ConfigService.RemoteFilePath + guid + "_" + postedFile.FileName; TransferUtilityUploadRequest fileTransferUtilityRequest = new TransferUtilityUploadRequest { BucketName = ConfigService.BucketName, //FilePath = filePath, InputStream = postedFile.InputStream, //StorageClass = S3StorageClass.ReducedRedundancy, //PartSize = 6291456, // 6 MB. Key = remoteFilePath, //CannedACL = S3CannedACL.PublicRead }; fileTransferUtility.Upload(fileTransferUtilityRequest); string paraRemoteFilePath = "/" + remoteFilePath; ItemResponse<string> response = new ItemResponse<string>(); string userId = UserService.GetCurrentUserId(); ProfileService.UpdatePhotoPath(userId, paraRemoteFilePath); response.Item = remoteFilePath; return Request.CreateResponse(HttpStatusCode.Created, response.Item); } } else { result = Request.CreateResponse(HttpStatusCode.BadRequest); } return result; }
static void Main(string[] args) { try { TransferUtility fileTransferUtility = new TransferUtility(new AmazonS3Client(Amazon.RegionEndpoint.USEast1)); // 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 = 5242880, // 5 MB. Key = keyName, CannedACL = S3CannedACL.PublicRead }; fileTransferUtilityRequest.Metadata.Add("param1", "Value1"); fileTransferUtilityRequest.Metadata.Add("param2", "Value2"); fileTransferUtility.Upload(fileTransferUtilityRequest); Console.WriteLine("Upload 4 completed"); } catch (AmazonS3Exception s3Exception) { Console.WriteLine(s3Exception.Message, s3Exception.InnerException); } Console.WriteLine("Press any key to continue..."); Console.ReadKey(); }
public void Upload(string filePath) { try { TransferUtility fileTransferUtility = new TransferUtility(new AmazonS3Client(Amazon.RegionEndpoint.USEast1)); using (FileStream fileToUpload = new FileStream(filePath, FileMode.Open, FileAccess.Read)) { fileTransferUtility.Upload(fileToUpload, bucketName, keyName); } } catch (AmazonS3Exception ex) { Log.Error(ex.Message, ex.InnerException); } }
public static void uploadFile(string filePath, string existingBucketName, string AccessKey, string SecretKey, string sessionToken) { Console.WriteLine("filepath: "+filePath); Console.WriteLine("bucketname: " + existingBucketName); Console.WriteLine("ak: " + AccessKey); Console.WriteLine("sk: " + SecretKey); Console.WriteLine("st: " + sessionToken); try { AmazonS3Client sclient = new AmazonS3Client(AccessKey, SecretKey, sessionToken, Amazon.RegionEndpoint.USWest2); TransferUtility fileTransferUtility = new TransferUtility(sclient); /* Find way to increase time out timer because of large file size TransferUtilityConfig config = new TransferUtilityConfig(); config.DefaultTimeout = 11111; TransferUtility utility = new TransferUtility(config); */ // 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"); // 4.Specify advanced settings/options. TransferUtilityUploadRequest fileTransferUtilityRequest = new TransferUtilityUploadRequest { BucketName = existingBucketName, FilePath = filePath, StorageClass = S3StorageClass.ReducedRedundancy, PartSize = 6291456, // 6 MB. Key = keyName }; fileTransferUtility.Upload(fileTransferUtilityRequest); Console.WriteLine("Upload completed"); * */ } catch (AmazonS3Exception s3Exception) { Console.WriteLine(s3Exception.Message, s3Exception.InnerException); } }
/// <summary> /// This method loads the AWSProfileName that is set in the App.config and creates the transfer utility. /// </summary> private void loadConfiguration() { NameValueCollection appConfig = ConfigurationManager.AppSettings; if (string.IsNullOrEmpty(appConfig["AWSProfileName"])) { MessageBox.Show(this, "AWSProfileName is not set in the App.Config", "Error", MessageBoxButton.OK, MessageBoxImage.Error); this.Close(); return; } this._transferUtility = new TransferUtility(RegionEndpoint.USWest2); // Update the Bucket to the optionally supplied Bucket from the App.config. this.Bucket = appConfig["Bucket"]; }
public IPhoto UploadPhoto(Stream stream, string filename, string title, string descriptioSn, string tags) { TransferUtilityUploadRequest request = new TransferUtilityUploadRequest(); request.InputStream = stream; request.BucketName = photoBucket; request.Key = filename; request.CannedACL = Amazon.S3.Model.S3CannedACL.PublicRead; TransferUtility transferUtility = new TransferUtility(ConfigurationManager.AppSettings["AWSAccessKey"], ConfigurationManager.AppSettings["AWSSecretKey"]); transferUtility.Upload(request); S3Photo photo = new S3Photo(); photo.WebUrl = string.Format("http://s3.amazonaws.com/{0}/{1}", photoBucket, filename); photo.Title = filename; return photo; }
/////////////////////////////////////////////////////////////////////// // Methods & Functions // /////////////////////////////////////////////////////////////////////// /// <summary> /// Class constructor /// </summary> public AWSS3Helper(RegionEndpoint regionendpoint) { // Set configuration info AmazonS3Config config = new AmazonS3Config(); config.Timeout = new TimeSpan(1, 0, 0); config.ReadWriteTimeout = new TimeSpan(1, 0, 0); config.RegionEndpoint = regionendpoint; // Create S3 client S3client = Amazon.AWSClientFactory.CreateAmazonS3Client (Gadgets.LoadConfigurationSetting("AWSAccessKey", ""), Gadgets.LoadConfigurationSetting("AWSSecretKey", ""), config); // Create the file transfer utility class fileTransferUtility = new TransferUtility(S3client); }
private void UploadFileToS3(string filePath,string bucketname) { var awsAccessKey = accesskey; var awsSecretKey = secretkey; var existingBucketName = bucketname; var client = Amazon.AWSClientFactory.CreateAmazonS3Client(awsAccessKey, awsSecretKey, RegionEndpoint.USEast1); var uploadRequest = new TransferUtilityUploadRequest { FilePath = filePath, BucketName = existingBucketName, CannedACL = S3CannedACL.PublicRead }; var fileTransferUtility = new TransferUtility(client); fileTransferUtility.UploadAsync(uploadRequest); }
protected override void InnerExecute(string[] arguments) { _writer.WriteLine("Getting upload credentials... "); _writer.WriteLine(); var uploadCredentials = GetCredentials(); var temporaryFileName = Path.GetTempFileName(); try { using (var packageStream = new FileStream(temporaryFileName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)) using (var gzipStream = new GZipStream(packageStream, CompressionMode.Compress, true)) { var sourceDirectory = new DirectoryInfo(Directory.GetCurrentDirectory()); sourceDirectory.ToTar(gzipStream, excludedDirectoryNames: _excludedDirectories.ToArray()); } using (var s3Client = new AmazonS3Client(uploadCredentials.GetSessionCredentials())) using (var transferUtility = new TransferUtility(s3Client)) { var request = new TransferUtilityUploadRequest { FilePath = temporaryFileName, BucketName = uploadCredentials.Bucket, Key = uploadCredentials.ObjectKey, Timeout = (int)TimeSpan.FromHours(2).TotalMilliseconds, }; var progressBar = new MegaByteProgressBar(); request.UploadProgressEvent += (object x, UploadProgressArgs y) => progressBar .Update("Uploading package", y.TransferredBytes, y.TotalBytes); transferUtility.Upload(request); Console.CursorTop++; _writer.WriteLine(); } } finally { File.Delete(temporaryFileName); } TriggerAppHarborBuild(uploadCredentials); }
protected override void ExecuteS3Task() { if (!File.Exists(this.SourceFile)) { throw new BuildException("source-file does not exist: " + this.SourceFile); } using (TransferUtility transferUtility = new Amazon.S3.Transfer.TransferUtility(this.AccessKey, this.SecretAccessKey)) { TransferUtilityUploadRequest uploadRequest = new TransferUtilityUploadRequest { BucketName = this.BucketName, FilePath = this.SourceFile, Key = this.DestinationFile }; if (PublicRead) { uploadRequest.AddHeader("x-amz-acl", "public-read"); } transferUtility.Upload(uploadRequest); } }
private static async System.Threading.Tasks.Task <string> UploadFile(string fileName, Stream fileStream) { var extension = Path.GetExtension(fileName); var client = new AmazonS3Client("AKIAJNOS24TJ3PWZHKEQ", "+d+qIQ5Uv8dfFTdsdvBd0Hp0Exm5QY2YH1ZL8903", RegionEndpoint.USWest2); var transfer = new Amazon.S3.Transfer.TransferUtility(client); var request = new TransferUtilityUploadRequest(); request.BucketName = "sakjfkls-test-bucket"; request.InputStream = new MemoryStream(); request.Key = Guid.NewGuid().ToString() + extension; request.InputStream = fileStream; request.CannedACL = S3CannedACL.AuthenticatedRead; await transfer.UploadAsync(request); return(request.Key); }
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 <S3Response> DeleteFile(string bucketName, string pathAmazon) { try { using (Amazon.S3.Transfer.TransferUtility transferUti = new Amazon.S3.Transfer.TransferUtility(_client)) { var deleteObjectRequest = new DeleteObjectRequest { BucketName = bucketName, Key = pathAmazon }; await _client.DeleteObjectAsync(deleteObjectRequest); 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 void SimpleUpload() { var client = Client; using (var tu = new Amazon.S3.Transfer.TransferUtility(client)) { tu.Upload(testFilePath, testBucketName); var response = WaitUtils.WaitForComplete( () => { return(client.GetObjectMetadataAsync(new GetObjectMetadataRequest { BucketName = testBucketName, Key = TEST_FILENAME }).Result); }); Assert.True(response.ETag.Length > 0); var downloadPath = testFilePath + ".download"; var downloadRequest = new Amazon.S3.Transfer.TransferUtilityDownloadRequest { BucketName = testBucketName, Key = TEST_FILENAME, FilePath = downloadPath }; tu.Download(downloadRequest); TestDownloadedFile(downloadPath); // empty out file, except for 1 byte File.WriteAllText(downloadPath, TEST_CONTENT.Substring(0, 1)); Assert.True(File.Exists(downloadPath)); tu.Download(downloadRequest); TestDownloadedFile(downloadPath); } }
public S3Uploader(string bucketName) { this.bucketName = bucketName; this.transferUtility = new Amazon.S3.Transfer.TransferUtility("AKIAIALOFNWOTXDMVF3Q", "d0mcWo3UkDD95rE9KyFxowbmPnr9t1Y4RbmHvwGA"); }
public async Task DownloadTestFile() { var token = await S3Service.GetS3Token("upload"); string filePath = "c:/temp/download/test.jpg"; string awsAccessKeyId = token.accessKeyId; string awsSecretAccessKey = token.secretAccessKey; string awsSessionToken = token.sessionToken; string existingBucketName = token.bucket; string keyName = string.Format("{0}/{1}", token.path, Path.GetFileName(filePath)); var client = new AmazonS3Client(awsAccessKeyId, awsSecretAccessKey, awsSessionToken, RegionEndpoint.APSoutheast2); var fileTransferUtility = new TransferUtility(client); var request = new TransferUtilityDownloadRequest() { BucketName = existingBucketName, FilePath = filePath, Key = keyName, ServerSideEncryptionCustomerMethod = ServerSideEncryptionCustomerMethod.AES256, ServerSideEncryptionCustomerProvidedKey = token.uploadPassword, }; fileTransferUtility.Download(request); Console.WriteLine("download 1 completed"); }