// Delete file from the server private void DeleteFile(HttpContext context) { var _getlen = 10; var fileName = context.Request["f"]; var fileExt = fileName.Remove(0,fileName.LastIndexOf('.')).ToLower(); var hasThumb = Regex.Match(fileName.ToLower(),AmazonHelper.ImgExtensions()).Success; var keyName = GetKeyName(context,HttpUtility.UrlDecode(context.Request["f"])); var client = AmazonHelper.GetS3Client(); var extrequest = new GetObjectRequest() .WithByteRange(0,_getlen) .WithKey(keyName) .WithBucketName(StorageRoot); var extresponse = client.GetObject(extrequest); var length = extresponse.ContentLength; extresponse.Dispose(); if(length == _getlen + 1){ var delrequest = new DeleteObjectRequest() .WithKey(keyName) .WithBucketName(StorageRoot); var delresponse = client.DeleteObject(delrequest); delresponse.Dispose(); if(hasThumb){ try { keyName = keyName.Replace(fileName,"thumbs/" + fileName.Replace(fileExt,".png")); var thumbcheck = new GetObjectRequest() .WithByteRange(0,_getlen) .WithKey(keyName) .WithBucketName(StorageRoot); var thumbCheckResponse = client.GetObject(thumbcheck); length = extresponse.ContentLength; thumbCheckResponse.Dispose(); if(length == _getlen + 1){ var thumbdelrequest = new DeleteObjectRequest() .WithKey(keyName) .WithBucketName(StorageRoot); var thumbdelresponse = client.DeleteObject(thumbdelrequest); delresponse.Dispose(); } } catch (Exception ex) { var messg = ex.Message; } } } }
public static void ResizeImageAndUpload(AmazonS3 anAmazonS3Client, string aBucketName, string aCurrentPhotoName, string aNewImageName, int aSize) { GetObjectRequest myGetRequest = new GetObjectRequest().WithBucketName(aBucketName).WithKey(aCurrentPhotoName); GetObjectResponse myResponse = anAmazonS3Client.GetObject(myGetRequest); Stream myStream = myResponse.ResponseStream; ResizeAndUpload(myStream, anAmazonS3Client, aBucketName, aNewImageName, aSize); }
public override byte[] DownloadToByteArray(string container, string fileName) { client = AWSClientFactory.CreateAmazonS3Client(ExtendedProperties["accessKey"], ExtendedProperties["secretKey"], RegionEndpoint.USEast1); String S3_KEY = fileName; GetObjectRequest request = new GetObjectRequest() { BucketName = container, Key = S3_KEY, }; GetObjectResponse response = client.GetObject(request); int numBytesToRead = (int)response.ContentLength; int numBytesRead = 0; byte[] buffer = new byte[numBytesToRead]; while (numBytesToRead > 0) { int n = response.ResponseStream.Read(buffer, numBytesRead, numBytesToRead); if (n == 0) break; numBytesRead += n; numBytesToRead -= n; } return buffer; }
//AWS get an object public void GetObject(AmazonS3Client client, string bucketName, String keyName) { try { using (client) { Amazon.S3.Model.GetObjectRequest request = new Amazon.S3.Model.GetObjectRequest { BucketName = bucketName, Key = keyName }; using (GetObjectResponse response = client.GetObject(request)) { String dest = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), keyName); if (!File.Exists(dest)) { response.WriteResponseStreamToFile(dest); } } } } catch { } }
public static async Task <Stream> readStreamFromS3ToMemory(string bucketName, string keyName, string bucketRegion, string credential = @"embeded", AmazonS3Client s3client = null) { AmazonS3Client client; if (credential != @"embeded") { client = new AmazonS3Client(RegionEndpoint.GetBySystemName(bucketRegion)); } else if (s3client != null) { client = s3client; } else { client = new AmazonS3Client(); } Console.WriteLine("Getting object starts"); var request = new Amazon.S3.Model.GetObjectRequest { BucketName = bucketName, Key = keyName }; Console.WriteLine("BucketName: " + bucketName); Console.WriteLine("Key: " + keyName); GetObjectResponse response = await client.GetObjectAsync(request); return(response.ResponseStream); }
public Stream GetFileIfChangedSince(string s3Url, DateTime lastModified, out DateTime newLastModified) { S3PathParts path = _pathParser.Parse(s3Url); var request = new GetObjectRequest { BucketName = path.Bucket, Key = path.Key, ModifiedSinceDate = lastModified }; try { // Do NOT dispose of the response here because it will dispose of the response stream also // (and that is ALL it does). It's a little gross, but I'll accept it because the alternative // is to return a custom Stream that will dispose the response when the Stream itself is // disposed, which is grosser. GetObjectResponse response = _s3Client.GetObject(request); newLastModified = response.LastModified; return response.ResponseStream; } catch (AmazonS3Exception e) { if (e.StatusCode == HttpStatusCode.NotModified) { newLastModified = default(DateTime); return null; } throw; } }
public ActionResult ViewStats(string id) { using (var client = Amazon.AWSClientFactory.CreateAmazonS3Client(AwsAccessKey, AwsSecretAccessKey)) { var request = new GetObjectRequest(); request.WithBucketName("MyTwitterStats"); request.WithKey(id + ".json.gz"); GetObjectResponse response = null; try { response = client.GetObject(request); } catch (AmazonS3Exception) { //TODO: Log exception.ErrorCode return HttpNotFound(); } using (response) using (var stream = response.ResponseStream) using (var zipStream = new GZipStream(stream, CompressionMode.Decompress)) using (var reader = new StreamReader(zipStream)) { var jsonSerializer = JsonSerializer.Create(new JsonSerializerSettings()); var stats = jsonSerializer.Deserialize<Stats>(new JsonTextReader(reader)); return View(stats); } } }
public async Task <string> GetObject(string key) { try { // Create GetObject request var request = new Amazon.S3.Model.GetObjectRequest { BucketName = _bucket, Key = key }; // Issue GetObject request using (GetObjectResponse response = await _s3Client.GetObjectAsync(request)) // View GetObject response using (Stream responseStream = response.ResponseStream) using (StreamReader reader = new StreamReader(responseStream)) { return(reader.ReadToEnd()); } } catch (Exception e) { Console.WriteLine($"Error getting object {key} from bucket {_bucket}. Make sure it exists and your bucket is in the same region as this function."); Console.WriteLine(e.Message); Console.WriteLine(e.StackTrace); throw; } }
protected GetObjectRequest ConvertToGetObjectRequest(BaseDownloadRequest request) { GetObjectRequest getRequest = new GetObjectRequest() { BucketName = request.BucketName, Key = request.Key, VersionId = request.VersionId }; getRequest.BeforeRequestEvent += this.RequestEventHandler; if (request.IsSetModifiedSinceDate()) { getRequest.ModifiedSinceDate = request.ModifiedSinceDate; } if (request.IsSetUnmodifiedSinceDate()) { getRequest.UnmodifiedSinceDate = request.UnmodifiedSinceDate; } getRequest.ServerSideEncryptionCustomerMethod = request.ServerSideEncryptionCustomerMethod; getRequest.ServerSideEncryptionCustomerProvidedKey = request.ServerSideEncryptionCustomerProvidedKey; getRequest.ServerSideEncryptionCustomerProvidedKeyMD5 = request.ServerSideEncryptionCustomerProvidedKeyMD5; return getRequest; }
protected GetObjectRequest ConvertToGetObjectRequest(BaseDownloadRequest request) { GetObjectRequest getRequest = new GetObjectRequest() { BucketName = request.BucketName, Key = request.Key, VersionId = request.VersionId }; ((Amazon.Runtime.Internal.IAmazonWebServiceRequest)getRequest).AddBeforeRequestHandler(this.RequestEventHandler); if (request.IsSetModifiedSinceDate()) { getRequest.ModifiedSinceDate = request.ModifiedSinceDate; } if (request.IsSetUnmodifiedSinceDate()) { getRequest.UnmodifiedSinceDate = request.UnmodifiedSinceDate; } getRequest.ServerSideEncryptionCustomerMethod = request.ServerSideEncryptionCustomerMethod; getRequest.ServerSideEncryptionCustomerProvidedKey = request.ServerSideEncryptionCustomerProvidedKey; getRequest.ServerSideEncryptionCustomerProvidedKeyMD5 = request.ServerSideEncryptionCustomerProvidedKeyMD5; return getRequest; }
public S3ObjectAsString GetS3ObjectAsString(S3KeyBuilder s3Key) { var request = new GetObjectRequest { BucketName = AppConfigWebValues.Instance.S3BucketName, Key = s3Key.FullKey }; var obj = new S3ObjectAsString(); try { using (GetObjectResponse response = _client.GetObject(request)) using (Stream responseStream = response.ResponseStream) using (var reader = new StreamReader(responseStream)) { obj.Key = s3Key.FullKey; obj.ContentBody = reader.ReadToEnd(); } } catch (AmazonS3Exception s3x) { if (s3x.ErrorCode == S3Constants.NoSuchKey) return null; throw; } return obj; }
/// <summary> /// Reads a byte array from an S3 bucket /// </summary> /// <param name="location">The location of the data you want to read</param> /// <param name="guid">The guid of the content you're reading</param> /// <returns>A byte array interpretation of the data</returns> public byte[] ReadByteArray(StorageLocations location, string guid) { var keyName = string.Format("{0}/{1}.onx", StorageLocationToString(location), guid); var request = new GetObjectRequest().WithBucketName(Bucket).WithKey(keyName); return VariousFunctions.StreamToByteArray(_client.GetObject(request).ResponseStream); }
public async Task <GetObjectResponse> GetObjectAsync(string bucket, string key, CancellationToken cancellationToken = default) { this.Logger.LogDebug($"[{nameof(this.GetObjectAsync)}]"); this.Logger.LogTrace(JsonConvert.SerializeObject(new { bucket, key })); if (string.IsNullOrWhiteSpace(bucket)) { throw new ArgumentNullException(nameof(bucket)); } if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentNullException(nameof(key)); } var request = new Amazon.S3.Model.GetObjectRequest { BucketName = bucket, Key = key, }; this.Logger.LogTrace(JsonConvert.SerializeObject(value: request)); var response = await this.Repository.GetObjectAsync(request : request, cancellationToken : cancellationToken == default?this.CancellationToken.Token : cancellationToken); this.Logger.LogTrace(JsonConvert.SerializeObject(value: response)); return(response); }
public override Stream Open() { //Synchronously download to memory stream try { var req = new Amazon.S3.Model.GetObjectRequest() { BucketName = bucket, Key = key }; using (var s = provider.S3Client.GetObject(req)){ return(StreamExtensions.CopyToMemoryStream(s.ResponseStream)); } } catch (AmazonS3Exception se) { if (se.StatusCode == System.Net.HttpStatusCode.NotFound || "NoSuchKey".Equals(se.ErrorCode, StringComparison.OrdinalIgnoreCase)) { throw new FileNotFoundException("Amazon S3 file not found", se); } else if (se.StatusCode == System.Net.HttpStatusCode.Forbidden || "AccessDenied".Equals(se.ErrorCode, StringComparison.OrdinalIgnoreCase)) { throw new FileNotFoundException("Amazon S3 access denied - file may not exist", se); } else { throw; } } return(null); }
/// <summary> /// Reads a string from an S3 bucket /// </summary> /// <param name="location">The location of the data you want to read</param> /// <param name="guid">The guid of the content you're reading</param> /// <returns>A string interpretation of the data</returns> public string ReadString(StorageLocations location, string guid) { var keyName = string.Format("{0}/{1}.onx", StorageLocationToString(location), guid); var request = new GetObjectRequest().WithBucketName(Bucket).WithKey(keyName); return new StreamReader(_client.GetObject(request).ResponseStream, Encoding.ASCII).ReadToEnd(); }
public void TestAllFilesExistAndModifiedInOutput() { try { Init(); ListObjectsRequest inputFileObjects; String fileKey = null; inputFileObjects = new ListObjectsRequest { BucketName = DataTransformer.InputBucketName }; ListObjectsResponse listResponse; do { listResponse = DataTransformer.s3ForStudentBuckets.ListObjects(inputFileObjects); foreach (S3Object obj in listResponse.S3Objects) { fileKey = obj.Key; GetObjectRequest request = new GetObjectRequest() { BucketName = DataTransformer.OutputBucketName, Key = fileKey }; GetObjectResponse response = DataTransformer.s3ForStudentBuckets.GetObject(request); StreamReader reader = new StreamReader(response.ResponseStream); string content = reader.ReadToEnd(); if(!content.Contains(DataTransformer.JsonComment)) { Assert.Fail("Failure - Input file not transformed; output file does not contain JSON comment. " + fileKey); } } // Set the marker property inputFileObjects.Marker = listResponse.NextMarker; } while (listResponse.IsTruncated); } catch (AmazonServiceException ase) { Console.WriteLine("Error Message: " + ase.Message); Console.WriteLine("HTTP Status Code: " + ase.StatusCode); Console.WriteLine("AWS Error Code: " + ase.ErrorCode); Console.WriteLine("Error Type: " + ase.ErrorType); Console.WriteLine("Request ID: " + ase.RequestId); } catch (AmazonClientException ace) { Console.WriteLine("Error Message: " + ace.Message); } }
private static void GetObject(AmazonS3 s3Client, string bucket, string key) { var getObjectRequest = new GetObjectRequest().WithBucketName(bucket).WithKey(key); using (var getObjectResponse = s3Client.GetObject(getObjectRequest)) { var memoryStream = new MemoryStream(); getObjectResponse.ResponseStream.CopyTo(memoryStream); var content = Encoding.Default.GetString(memoryStream.ToArray()); Console.WriteLine(content); } }
public static void Get(string bucket, string key, string fileName) { AmazonS3 s3Client = AWSClientFactory.CreateAmazonS3Client(); FileInfo file = new FileInfo(key); Console.WriteLine("Download File " + bucket + ":" + key + " to " + fileName); GetObjectRequest get_req = new GetObjectRequest(); get_req.BucketName = bucket; get_req.Key = key; GetObjectResponse get_res = s3Client.GetObject(get_req); get_res.WriteResponseStreamToFile(fileName); Console.WriteLine(get_res.Metadata.AllKeys.FirstOrDefault()); }
void PerformGetRequest(string targetFile, GetObjectRequest request) { using (var response = httpRetryService.WithRetry(() => s3.GetObject(request))) { using (var stream = response.ResponseStream) { using (var outputStream = fileSystem.CreateWriteStream(targetFile)) { stream.CopyTo(outputStream); } } } }
public async Task<Stream> GetFileStreamAsync(string path, CancellationToken cancellationToken = default(CancellationToken)) { using (var client = CreateClient()) { var req = new GetObjectRequest { BucketName = _bucket, Key = path.Replace('\\', '/') }; var res = await client.GetObjectAsync(req, cancellationToken).AnyContext(); if (!res.HttpStatusCode.IsSuccessful()) return null; return res.ResponseStream; } }
/// <summary> /// Determines whether a blob item under the specified location exists. /// </summary> /// <param name="location">Descriptor of the item on the remote blob storage.</param> /// <returns>True if the item exists, otherwise - false</returns> public override bool BlobExists(IBlobContentLocation location) { var request = new GetObjectRequest().WithBucketName(this.bucketName).WithKey(location.FilePath); try { var response = transferUtility.S3Client.GetObject(request); return true; } catch (AmazonS3Exception err) { } return false; }
private void buttonGetFile_Click(object sender, EventArgs e) { try { var config = new AmazonS3Config { RegionEndpoint = Amazon.RegionEndpoint.APSoutheast2 }; if (this.checkBoxUseProxy.Checked) { var proxy = new WebProxy(this.textBoxProxy.Text, int.Parse(this.textBoxProxyPort.Text)) { BypassList = new string[] { textBoxProxyBypass.Text } }; WebRequest.DefaultWebProxy = proxy; } AmazonS3Client amazonS3Client = null; if (this.checkBoxUseKeySecret.Checked && this.checkBoxUseToken.Checked == false) { amazonS3Client = new AmazonS3Client(this.textBoxKey.Text, this.textBoxSecret.Text, config); } else if (this.checkBoxUseKeySecret.Checked && this.checkBoxUseToken.Checked) { amazonS3Client = new AmazonS3Client(this.textBoxKey.Text, this.textBoxSecret.Text, this.textBoxToken.Text, config); } else { amazonS3Client = new AmazonS3Client(config); } //textBoxOutput.Text = JsonConvert.SerializeObject(amazonS3Client.Config); var request = new GetObjectRequest { BucketName = this.textBoxBucket.Text, Key = this.textBoxFile.Text }; using (GetObjectResponse response = amazonS3Client.GetObject(request)) { using (var reader = new StreamReader(response.ResponseStream)) { this.textBoxOutput.Text = reader.ReadToEnd(); } } } catch (Exception ex) { this.textBoxOutput.Text = ex.ToString(); } }
public virtual void GetFileStream(string bucketName, string keyName, System.IO.Stream target) { GetObjectRequest objectGetRequest = new GetObjectRequest(); objectGetRequest.BucketName = bucketName; objectGetRequest.Key = keyName; using(GetObjectResponse objectGetResponse = m_client.GetObject(objectGetRequest)) using(System.IO.Stream s = objectGetResponse.ResponseStream) { try { s.ReadTimeout = (int)TimeSpan.FromMinutes(1).TotalMilliseconds; } catch { } Utility.Utility.CopyStream(s, target); } }
public static bool Download_File_From_S3(String bucketName, String destination_localPath, String keyName) { DateTime before = DateTime.Now; try { GetObjectRequest request = new GetObjectRequest().WithBucketName(bucketName).WithKey(keyName); using (GetObjectResponse response = s3_client.GetObject(request)) { string title = response.Metadata["x-amz-meta-title"]; if (!File.Exists(destination_localPath)) { response.WriteResponseStreamToFile(destination_localPath); } } } catch (Exception e) { Console.WriteLine("Caught Exception: " + e.Message); Type exType = e.GetType(); if (exType == typeof(AmazonS3Exception)) { AmazonS3Exception amazonS3Exception = (AmazonS3Exception)e; if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity"))) { Console.WriteLine("Please check the provided AWS Credentials."); Console.WriteLine("If you haven't signed up for Amazon S3, please visit http://aws.amazon.com/s3"); } else { Console.WriteLine("An error occurred with the message '{0}' when reading an object", amazonS3Exception.Message); } } Console.WriteLine("Downloading from s3 Bucket=" + bucketName + " into path=" + destination_localPath + " failed"); return false; } TimeSpan downloadTime = DateTime.Now - before; Console.WriteLine("Downloading from s3 Bucket=" + bucketName + " into path=" + destination_localPath + " took " + downloadTime.TotalMilliseconds.ToString() + " milliseconds"); return true; }
public byte[] RetrieveRequest(string source) { var key = source.Replace(_baseStorageEndpoint, ""); var getRequest = new GetObjectRequest() .WithBucketName(_configuration.BucketName) .WithKey(key); var response = _client.GetObject(getRequest); using (var memoryStream = new MemoryStream()) { response.ResponseStream.CopyTo(memoryStream); return memoryStream.ToArray(); } }
public FileData GetFile(string virtualPath) { var request = new GetObjectRequest() .WithBucketName(this.bucketName) .WithKey(FixPathForS3(virtualPath)); FileData file; using (var response = this.s3.GetObject(request)) { file = new FileData { Name = response.Key.Substring(response.Key.LastIndexOf('/') + 1), Updated = DateTime.Now, Created = DateTime.Now, Length = response.ContentLength, VirtualPath = FixPathForN2(response.Key) }; } return file; }
public AmazonS3Object GetFile(string key) { var request = new GetObjectRequest(); request.WithBucketName(this._bucketName).WithKey(key); try { var response = this._client.GetObject(request); return response.ToAmazonS3Object(); } catch (Exception ex) { Log.Error(string.Format("Cannot find the file with key {0}. Debug message: {1}", key, ex.Message)); return null; } }
protected override void ExecuteTask() { // Ensure the configured bucket exists if (!BucketExists(BucketName)) { Project.Log(Level.Error, "[ERROR] S3 Bucket: {0}, not found!", BucketName); return; } // Ensure the file exists if (!FileExists(FilePath)) { Project.Log(Level.Error, "File not found: {0}", FilePath); return; } // Get the file from S3 using (Client) { try { Project.Log(Level.Info, "Downloading \r\n file: {0}\r\n as: {1}", FilePath, Outputfile); GetObjectRequest request = new GetObjectRequest { Key = FilePath, BucketName = BucketName, Timeout = timeout }; using (var response = Client.GetObject(request)) { response.WriteResponseStreamToFile(Outputfile); } } catch (AmazonS3Exception ex) { ShowError(ex); } } // verify that the file actually downloaded if (File.Exists(Outputfile)) Project.Log(Level.Info, "Download successful.", Outputfile); else Project.Log(Level.Info, "Download FAILED!", Outputfile); }
public object GetObject(string bucketName, string keyName) { var request = new GetObjectRequest { BucketName = bucketName, Key = keyName }; using (_client) { using (var response = _client.GetObject(request)) { var reader = new StreamReader(response.ResponseStream); return reader.ReadToEnd(); } } }
/// <summary> /// /// </summary> /// <param name="key"></param> /// <returns></returns> public Amazon.S3.Model.GetObjectResponse Get(string key) { try { Amazon.S3.AmazonS3Client client = new Amazon.S3.AmazonS3Client(AWAPI_File_AmazonS3_AccessKey, AWAPI_File_AmazonS3_SecretKey); Amazon.S3.Model.GetObjectRequest req = new Amazon.S3.Model.GetObjectRequest(); req.BucketName = AWAPI_File_AmazonS3_BucketName; req.Key = key; Amazon.S3.Model.GetObjectResponse res = client.GetObject(req); return(res); } catch (Exception ex) { } return(null); }
public static byte[] GetFile(string name) { try { GetObjectRequest request = new GetObjectRequest(); request.WithBucketName(BucketName) .WithKey(name); AmazonS3Config config = new AmazonS3Config(); config.CommunicationProtocol = Protocol.HTTP; using (MemoryStream ms = new MemoryStream()) using (AmazonS3 client = Amazon.AWSClientFactory.CreateAmazonS3Client(AccessKeyID, SecretAccessKeyID, config)) using (GetObjectResponse response = client.GetObject(request)) { if (response != null) { response.ResponseStream.CopyTo(ms); return ms.ToArray(); } else return null; } } catch (AmazonS3Exception amazonS3Exception) { #if(DEBUG) if (amazonS3Exception.ErrorCode != null && (amazonS3Exception.ErrorCode.Equals("InvalidAccessKeyId") || amazonS3Exception.ErrorCode.Equals("InvalidSecurity"))) { Console.WriteLine("Please check the provided AWS Credentials."); Console.WriteLine("If you haven't signed up for Amazon S3, please visit http://aws.amazon.com/s3"); } else { Console.WriteLine("An error occurred with the message '{0}' when deleting an object", amazonS3Exception.Message); } #endif return null; } catch (Exception e) { return null; } }
public bool OpenFile(object FileObject, ITableMetadata TableMeta) { //throw new NotImplementedException(); var fileName = (S3Object)FileObject; AmazonS3 s3 = AWSClientFactory.CreateAmazonS3Client(); var gor = new GetObjectRequest().WithBucketName(fileName.BucketName).WithKey(fileName.Key); var file = s3.GetObject(gor); string text = ""; using (var ms = new MemoryStream()) { System.Diagnostics.Trace.WriteLine("Started reading file"); file.ResponseStream.CopyTo(ms); //actually fetches the file from S3 System.Diagnostics.Trace.WriteLine("Finished reading file"); using (var gzipStream = new GZipStream(new MemoryStream(ms.ToArray()), CompressionMode.Decompress)) { System.Diagnostics.Trace.WriteLine("Decompressing file"); const int size = 4096; byte[] buffer = new byte[size]; using (MemoryStream memory = new MemoryStream()) { int count = 0; do { count = gzipStream.Read(buffer, 0, size); if (count > 0) { memory.Write(buffer, 0, count); } } while (count > 0); var memArray = memory.ToArray(); text = ASCIIEncoding.ASCII.GetString(memArray); } System.Diagnostics.Trace.WriteLine("Finished decompressing file"); } } Lines = text.Split(TableMeta.ColumnDelimiters, StringSplitOptions.RemoveEmptyEntries); System.Diagnostics.Trace.WriteLine("Finished reading file"); lineCount = -1; return true; }
/// <summary> /// Check if the file exists or not /// </summary> /// <param name="fileName"></param> /// <returns></returns> public Amazon.S3.Model.GetObjectResponse Get(string fileName) { try { Amazon.S3.AmazonS3Client client = new Amazon.S3.AmazonS3Client(ConfigurationLibrary.Config.fileAmazonS3AccessKey, ConfigurationLibrary.Config.fileAmazonS3SecreyKey); Amazon.S3.Model.GetObjectRequest req = new Amazon.S3.Model.GetObjectRequest(); req.BucketName = GetBucketNameFromUrl(fileName); // ConfigurationLibrary.Config.fileAmazonS3BucketName; req.Key = fileName; Amazon.S3.Model.GetObjectResponse res = client.GetObject(req); return(res); } catch (Exception ex) { } return(null); }
protected GetObjectRequest ConvertToGetObjectRequest(BaseDownloadRequest request) { GetObjectRequest getRequest = new GetObjectRequest() .WithBucketName(request.BucketName) .WithKey(request.Key) .WithTimeout(request.Timeout) .WithVersionId(request.VersionId); if (request.IsSetModifiedSinceDate()) { getRequest.ModifiedSinceDate = request.ModifiedSinceDate; } if (request.IsSetUnmodifiedSinceDate()) { getRequest.UnmodifiedSinceDate = request.UnmodifiedSinceDate; } return getRequest; }
public byte[] DownloadStream(string bucketName, string keyName) { var getObjectRequest = new GetObjectRequest() { BucketName = bucketName, Key = keyName }; var getObjectResponse = _client.GetObject(getObjectRequest); var s = getObjectResponse.ResponseStream; var buffer = new byte[16 * 1026]; var retStream = new MemoryStream(); int readStream; while ((readStream = s.Read(buffer, 0, buffer.Length)) > 0) { retStream.Write(buffer, 0, readStream); } return retStream.ToArray(); }
public async Task<Stream> Load(string path) { using (var api = AmazonS3Helper.GetApi(_account)) { string bucket; string filename; GetBucketAndKey(path, out bucket, out filename); var request = new GetObjectRequest { BucketName = bucket, Key = filename }; var response = await api.GetObjectAsync(request); return response.ResponseStream; } }
public static void Main(string[] args) { // Create a client AmazonS3Client client = new AmazonS3Client(); string time = PutObj(client); // Create a GetObject request GetObjectRequest getObjRequest = new GetObjectRequest { BucketName = "com.loofah.photos", Key = time }; System.Console.WriteLine(time); // Issue request and remember to dispose of the response using (GetObjectResponse getObjResponse = client.GetObject(getObjRequest)) { getObjResponse.WriteResponseStreamToFile("C:\\Users\\Ryan\\Pictures\\" + time + ".jpg", false); } System.Console.Read(); }
public override async Task <Stream> OpenAsync(string virtualPath, NameValueCollection queryString) { var path = ParseAndFilterPath(virtualPath); var time = Stopwatch.StartNew(); long bytesFetched = 0; //Synchronously download to memory stream try { var req = new Amazon.S3.Model.GetObjectRequest() { BucketName = path.Bucket, Key = path.Key }; using (var s = await S3Client.GetObjectAsync(req)){ using (var stream = s.ResponseStream) { var copy = (Stream)await stream.CopyToMemoryStreamAsync(); bytesFetched = copy.Length; return(copy); } } } catch (AmazonS3Exception se) { if (se.StatusCode == System.Net.HttpStatusCode.NotFound || "NoSuchKey".Equals(se.ErrorCode, StringComparison.OrdinalIgnoreCase)) { throw new FileNotFoundException("Amazon S3 file not found", se); } else if (se.StatusCode == System.Net.HttpStatusCode.Forbidden || "AccessDenied".Equals(se.ErrorCode, StringComparison.OrdinalIgnoreCase)) { throw new FileNotFoundException("Amazon S3 access denied - file may not exist", se); } else { throw; } } finally { time.Stop(); this.ReportReadTicks(time.ElapsedTicks, bytesFetched); } }
//--- Methods --- public async Task FunctionHandler(S3Event uploadEvent, ILambdaContext context) { string bucket = uploadEvent.Records[0].S3.Bucket.Name; string objectKey = uploadEvent.Records[0].S3.Object.Key; using (var client = new AmazonS3Client(Amazon.RegionEndpoint.USEast1)) { S3Model.GetObjectRequest request = new S3Model.GetObjectRequest { BucketName = bucket, Key = objectKey }; using (S3Model.GetObjectResponse response = await client.GetObjectAsync(request)) using (Stream responseStream = response.ResponseStream) using (StreamReader reader = new StreamReader(responseStream)) { while (reader.Peek() >= 0) { LambdaLogger.Log($"{reader.ReadLine().Replace("\t", " | ")}"); } } } }
public static GetObjectResponse GetFile(AwsCommonParams commonParams, string bucketName, string filePath) { // We need to strip off any leading '/' in the path or // else it creates a path with an empty leading segment // This also implements behavior consistent with the // edit counterpart routine for verification purposes if (filePath.StartsWith("/")) { filePath = filePath.Substring(1); } using (var s3 = new Amazon.S3.AmazonS3Client( commonParams.ResolveCredentials(), commonParams.RegionEndpoint)) { var s3Requ = new Amazon.S3.Model.GetObjectRequest { BucketName = bucketName, //Prefix = filePath, Key = filePath, }; //var s3Resp = s3.ListObjects(s3Requ); try { var s3Resp = s3.GetObject(s3Requ); return(s3Resp); } catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.NotFound) { return(null); } } }
public async Task GetObjectFromS3Async(string bucketName) { const string keyName = "Calendario 2018 (003).pdf"; try { var request = new Amazon.S3.Model.GetObjectRequest { BucketName = bucketName, Key = keyName }; string responseBody; using (var response = await _client.GetObjectAsync(request)) using (var responseStream = response.ResponseStream) using (var reader = new StreamReader(responseStream)) { responseBody = reader.ReadToEnd(); } var pathAndFileName = $"C:\\S3Temp\\{keyName}"; var createText = responseBody; File.WriteAllText(pathAndFileName, createText); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when reading an object", e.Message); } catch (Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when reading an object", e.Message); } }