public void Delete( string name ) { using ( AmazonS3 client = AWSClientFactory.CreateAmazonS3Client( this.amazonKey, this.amazonSecret ) ) { DeleteObjectRequest request = new DeleteObjectRequest { BucketName = this.amazonBucket, Key = name }; client.DeleteObject( request ); } if ( !name.EndsWith( ".lock" ) ) { this.Delete( name + ".lock" ); } }
public void DeleteObject(String bucketPath) { try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = _bucketName, Key = bucketPath }; var response = _client.DeleteObjectAsync(deleteObjectRequest).Result; } 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); } }
/// <summary> /// Deletes object from amazon s3 /// </summary> /// <param name="objectKey"></param> public void DeleteObject(string objectKey) { try { using (var client = new AmazonS3Client(awsAccessKeyId, awsSecretAccessKey, Amazon.RegionEndpoint.EUWest2)) // using (var client = new AmazonS3Client(Amazon.RegionEndpoint.EUWest2)) { var request = new DeleteObjectRequest { BucketName = bucketName, Key = objectKey }; client.DeleteObject(request); } } catch (Exception ex) { Program.ErrorLogging(ex); } }
public async Task Delete(string key) { var deleteRequest = new DeleteObjectRequest { BucketName = this.BucketName, Key = key }; try { var response = await this.S3Client.DeleteObjectAsync(deleteRequest); Logger.LogInformation($"Deleted object {key} from bucket {this.BucketName}. Request Id: {response.ResponseMetadata.RequestId}"); } catch (AmazonS3Exception e) { this.Response.StatusCode = (int)e.StatusCode; var writer = new StreamWriter(this.Response.Body); writer.Write(e.Message); } }
public async Task <bool> EliminarFoto(Trabajador t) { try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = bucketName, //key es la ubicación donde se encuentra la foto Key = string.Format($"fotos/trabajador/{t.IdNegocio}/{t.Rut}/foto.png"), }; DeleteObjectResponse response = await awsclient.DeleteObjectAsync(deleteObjectRequest); return(response.HttpStatusCode == HttpStatusCode.OK); } catch (Exception e) { Console.WriteLine(e.Message); return(false); } }
public async Task DeleteObject(string bucketName, string keyName) { try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = bucketName, Key = keyName }; await client.DeleteObjectAsync(deleteObjectRequest); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered on server. Message:'{0}' when deleting an object", e.Message, keyName); } catch (Exception e) { Console.WriteLine("Unknown encountered on server. Message:'{0}' when deleting an object", e.Message, keyName); } }
private async Task ProcessMessageAsync(SQSEvent.SQSMessage message, ILambdaContext context) { context.Logger.LogLine($"Processed message {message.Body}"); DeleteObjectRequest deleteRequest = new DeleteObjectRequest() { BucketName = "taskmaster-storage", Key = message.Body }; DeleteObjectRequest deleteThumbnailRequest = new DeleteObjectRequest() { BucketName = "taskmaster-thumbnail", Key = $"thumbnail-{message.Body}" }; // TODO: Do interesting work based on the new message await S3Client.DeleteObjectAsync(deleteRequest); await S3Client.DeleteObjectAsync(deleteThumbnailRequest); }
public async Task <bool> Delete(string path) { using (var client = GetClient()) { var request = new DeleteObjectRequest { BucketName = _bucketName, Key = path }; var response = await client.DeleteObjectAsync(request).ConfigureAwait(false); if (response.HttpStatusCode != HttpStatusCode.NoContent) { throw new Exception("HTTP " + response.HttpStatusCode); } return(true); } }
public bool DeleteBucketObject(string bucketName, string objectKey) { try { var request = new DeleteObjectRequest { BucketName = bucketName, Key = objectKey }; var response = GetClient().DeleteObjectAsync(request); Console.WriteLine(" Object {0} removed!", objectKey); return(true); } catch (Exception ex) { return(false); } }
public override async Task <bool> DeleteAsync(BlobProviderDeleteArgs args) { var blobName = BlobNameCalculator.Calculate(args); if (await BlobExistsAsync(args, blobName)) { var request = new DeleteObjectRequest(args.ContainerName, blobName); try { var result = GetClient(args).DeleteObject(request); return(true); } catch (Exception ee) { return(false); // throw; } } return(false); }
public async Task DeleteFileAsync(string fileName) { try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = _bucket, Key = fileName }; var result = await _client.DeleteObjectAsync(deleteObjectRequest); } catch (AmazonS3Exception) { throw; } catch (Exception) { throw; } }
protected void DeleteFileInner(AmazonS3Client Client, string BucketName, string Key, SemaphoreSlim Semaphore, DeleteState State) { try { Semaphore.Wait(); DeleteObjectRequest Request = new DeleteObjectRequest(); Request.BucketName = BucketName; Request.Key = Key; Client.DeleteObject(Request); if (State != null) { Interlocked.Increment(ref State.NumFiles); } } finally { Semaphore.Release(); } }
private string DeleteFromS3(string fileName) { try { AWSCredentials awsCredentials = new BasicAWSCredentials(_accessKey, _secretAccess); AmazonS3Client amazonS3 = new AmazonS3Client(awsCredentials, Amazon.RegionEndpoint.USWest2); DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest { BucketName = _existingBucketName, Key = fileName }; amazonS3.DeleteObject(deleteObjectRequest); } catch (AmazonS3Exception s3Exception) { Console.WriteLine(s3Exception.Message, s3Exception.InnerException); } return(blogPhotoKey); }
public void Delete(string domain, string path, bool quotaDelete) { using (var client = GetClient()) { var key = MakePath(domain, path); if (quotaDelete) { QuotaDelete(domain, client, key); } Recycle(client, domain, key); var request = new DeleteObjectRequest { BucketName = _bucket, Key = key }; client.DeleteObject(request); } }
public void DeleteFile(string fileKey) { try { DeleteObjectRequest request = new DeleteObjectRequest { Key = fileKey, BucketName = _bucketName }; DeleteObjectResponse response = _awsS3Client.DeleteObject(request); if (response.HttpStatusCode != System.Net.HttpStatusCode.NoContent) { throw new ApplicationException("S3 DeleteFile - received status code " + response.HttpStatusCode.ToString() + "."); } } catch (Exception ex) { throw new ApplicationException("S3 DeleteFile - unexpected exception.", ex); } }
public async Task DeleteObjectInS3Async(string fileName) { try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = configuration["AWSS3Bucket:BucketName"], Key = $"{configuration["AWSS3Bucket:Key"]}/{fileName}", }; var result = await s3Client.DeleteObjectAsync(deleteObjectRequest); } catch (AmazonS3Exception e) { throw new AmazonS3Exception($"Error encountered on server when deleting an object. Message: {e.Message}"); } catch (Exception e) { throw new Exception($"Unknown encountered on server when deleting an object. Message:{e.Message}"); } }
/// <summary> /// Deletes "dataname" from the bucket "bucketname" /// </summary> public bool DeleteDataItem(string bucketname, string dataname) { // Reset error info ClearErrorInfo(); // Delete data try { DeleteObjectRequest request = new DeleteObjectRequest(); request.BucketName = bucketname; request.Key = dataname; S3client.DeleteObject(request); } catch (Exception ex) { ErrorCode = -1; ErrorMessage = ex.Message; } return(ErrorCode == 0); }
public JsonResult DeleteImageFromS3(string objectKey) { try { AmazonS3Client s3Client = new AmazonS3Client(); DeleteObjectRequest request = new DeleteObjectRequest(); request.BucketName = _awsBucketName; request.Key = objectKey; s3Client.DeleteObject(request); s3Client.Dispose(); return(Json(true)); } catch (Exception ex) { ErrorLoggingClass errorLog = new ErrorLoggingClass(); errorLog.logError(ex.Message, ex.Source, ex.StackTrace, "Enter Fish", "FishController", "DeleteImageFromS3", User.Identity.Name, null); return(Json(false)); } }
public bool DeleteFile(string bucketName, string subDirectoryInBucket, string fileNameInS3) { bool IsComplete = true; #region Creating a new S3 Sub-Folder under AWS LRCA Folder string strAWSAccessKey = System.Configuration.ConfigurationManager.AppSettings["AWSAccessKey"]; string strAWSSecretKey = System.Configuration.ConfigurationManager.AppSettings["AWSSecretKey"]; AmazonS3Config config = new AmazonS3Config(); //config.ServiceURL = "sourcespoon.s3.amazonaws.com"; config.ServiceURL = "testsourcespoon.s3.amazonaws.com"; config.RegionEndpoint = Amazon.RegionEndpoint.USEast1; AmazonS3Client s3Client = new AmazonS3Client( strAWSAccessKey, strAWSSecretKey, config ); using (IAmazonS3 s3ClientInterface = s3Client) { try { DeleteObjectRequest request = new DeleteObjectRequest(); request.BucketName = bucketName; request.Key = subDirectoryInBucket + "/" + fileNameInS3; s3Client.DeleteObject(request); } catch (AmazonS3Exception ex) { IsComplete = false; ErrorHandler.ErrorLogging(ex, false); ErrorHandler.ReadError(); } } return(IsComplete); #endregion }
public async void DeleteFile(string pictureUri) { if (pictureUri != null && pictureUri != "") { string[] separatingStrings = { $"https://{settings.AWSS3.BucketName}.s3.{settings.AWSS3.BucketRegion}.amazonaws.com/" }; string[] words = pictureUri.Split(separatingStrings, System.StringSplitOptions.RemoveEmptyEntries); string key = ""; foreach (var word in words) { key = word; } try { var region = Amazon.RegionEndpoint.GetBySystemName(settings.AWSS3.BucketRegion); var s3Client = new AmazonS3Client(settings.AWSS3.Key, settings.AWSS3.SecretKey, region); DeleteObjectRequest request = new DeleteObjectRequest { BucketName = settings.AWSS3.BucketName, Key = key }; DeleteObjectResponse response = await s3Client.DeleteObjectAsync(request); if (response != null) { return; } } catch (Exception e) { Console.WriteLine(e.Message); } } }
public async Task <UploadResponse> RemoveUploadedFile(String fileName) { try { var client = new AmazonS3Client(accessKey, accessSecret, Amazon.RegionEndpoint.EUCentral1); var request = new DeleteObjectRequest { BucketName = bucket, Key = fileName }; var response = await client.DeleteObjectAsync(request); if (response.HttpStatusCode == System.Net.HttpStatusCode.OK) { return(new UploadResponse { HasSucceed = true, FileName = fileName }); } else { return(new UploadResponse { HasSucceed = false, FileName = fileName }); } } catch (Exception ex) { return(new UploadResponse { HasSucceed = false, Message = ex.Message }); } }
public bool deleteFilesInDirectory(int id) { DeleteObjectResponse response = null; bool ok = false; try { if (id > 0) { Image image = _imagesService.Get(id); if (image != null) { string fileNameAtAws = image.ImageUrl; AWSCredentials awsCredentials = new BasicAWSCredentials(_configService.AwsAccessKeyId, _configService.AwsSecret); AmazonS3Client client = new AmazonS3Client(awsCredentials, Amazon.RegionEndpoint.USWest2); DeleteObjectRequest fileDeleteRequest = new DeleteObjectRequest(); fileDeleteRequest.BucketName = _configService.AwsBucketName; fileDeleteRequest.Key = fileNameAtAws; bool keyExists = ExistsKey(client, fileNameAtAws, fileDeleteRequest.BucketName); if (keyExists) { response = client.DeleteObject(fileDeleteRequest); ok = true; } } } } catch (AmazonS3Exception) { throw; } return(ok); }
public override void DeleteExpired(string domain, string path, TimeSpan oldThreshold) { using (var client = GetClient()) { var s3Obj = GetS3Objects(domain, path); foreach (var s3Object in s3Obj) { var request = new GetObjectMetadataRequest { BucketName = _bucket, Key = s3Object.Key }; var metadata = client.GetObjectMetadata(request); var privateExpireKey = metadata.Metadata["private-expire"]; if (string.IsNullOrEmpty(privateExpireKey)) { continue; } long fileTime; if (!long.TryParse(privateExpireKey, out fileTime)) { continue; } if (DateTime.UtcNow <= DateTime.FromFileTimeUtc(fileTime)) { continue; } //Delete it var deleteObjectRequest = new DeleteObjectRequest { BucketName = _bucket, Key = s3Object.Key }; client.DeleteObject(deleteObjectRequest); } } }
public async Task <bool> DeleteImageAsync(AnnotationImage image) { try { // Delete image from S3 var deleteObjectRequest = new DeleteObjectRequest { BucketName = this._bucketName, Key = $"{image.Package.PackageName.ReplaceSpecialCharacters()}/{image.ImageName.ReplaceSpecialCharacters()}" }; var response = await this._s3Client.DeleteObjectAsync(deleteObjectRequest).ConfigureAwait(false); // Delete image from DynamoDB using (var context = new DynamoDBContext(this._dynamoDbClient)) { var dbConfig = new DynamoDBOperationConfig { OverrideTableName = this._dbTableName }; var package = await context.LoadAsync <AnnotationPackageDto>(image.Package.ExternalId, dbConfig).ConfigureAwait(false); package.Images?.RemoveAll(o => o.ImageName.Equals(image.ImageName)); await context.SaveAsync(package, dbConfig).ConfigureAwait(false); } // Delete local image var localImagePath = Path.Combine(this._extractionFolder, image.Package.PackageName, image.ImageName); if (File.Exists(localImagePath)) { File.Delete(localImagePath); } return(true); } catch (Exception e) { return(false); } }
public void RemoveFolder(Uri uri) { CheckUri(uri); try { var sourceKey = HttpUtility.UrlDecode(uri.AbsolutePath).TrimStart('/'); using (var client = CreateAmazonS3Client()) { var request = new DeleteObjectRequest() .WithKey(sourceKey) .WithBucketName(bucketName); client.DeleteObject(request); } } catch (Exception e) { throw new StorageException(string.Format("Failed to delete object. Uri: {0}", uri), e); } }
public void DeleteFile(string folderName, string fileName) { //folder ignored - packages stored on top level of S3 bucket if (String.IsNullOrWhiteSpace(folderName)) { throw new ArgumentNullException("folderName"); } if (String.IsNullOrWhiteSpace(fileName)) { throw new ArgumentNullException("fileName"); } var request = new DeleteObjectRequest(); request.WithBucketName(clientContext.BucketName); request.WithKey(fileName); using (AmazonS3 client = clientContext.CreateInstance()) { S3Response response = WrapRequestInErrorHandler(() => client.DeleteObject(request)); } }
private static async Task DeleteObjectNonVersionedBucketAsync() { try { var deleteObjectRequest = new DeleteObjectRequest { BucketName = bucketName, Key = keyName }; Console.WriteLine("Deleting an object"); await client.DeleteObjectAsync(deleteObjectRequest); } 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); } }
private void Delete(S3BucketKeyInfo bki) { var request = new DeleteObjectRequest { BucketName = bki.BucketName, Key = bki.Key }; try { S3Client.DeleteObject(request); } catch (AmazonS3Exception s3x) { if (IsMissingObjectException(s3x)) { return; } throw; } }
public void DeleteFile(string key) { if (string.IsNullOrWhiteSpace(key)) { throw new ArgumentNullException("key", "is null"); } if (Encoding.UTF8.GetByteCount(key) > 1023) { throw new ArgumentOutOfRangeException("key", key, "too long"); } using (this.client = new AmazonS3Client(accessKeyId, accessKeySecret, endpoint)) { var request = new DeleteObjectRequest() { BucketName = bucketName, Key = key, }; var response = this.client.DeleteObject(request); } }
public void delete_file(string folderName, string fileName) { // It's allowed to have an empty folder name. // if (String.IsNullOrWhiteSpace(folderName)) throw new ArgumentNullException("folderName"); if (String.IsNullOrWhiteSpace(fileName)) { throw new ArgumentNullException("fileName"); } folderName = (string.IsNullOrEmpty(folderName) ? String.Empty : folderName.Substring(folderName.Length - 1, 1) == "/" ? folderName : folderName + "/"); fileName = string.Format("{0}{1}", folderName, fileName); var request = new DeleteObjectRequest(); request.WithBucketName(clientContext.BucketName); request.WithKey(fileName); using (AmazonS3 client = clientContext.create_instance()) { S3Response response = wrap_request_in_error_handler(() => client.DeleteObject(request)); } }
public async Task <string> DeleteFile([FromRoute] string fileName) { string result = String.Empty; string path = this._defaultFolder + "/" + fileName; try { DeleteObjectRequest request = new DeleteObjectRequest() { BucketName = _bucketName, Key = path // <- in S3 key as path }; DeleteObjectResponse rsponse = await this._s3Client.DeleteObjectAsync(request); result = string.Format($"{ this._bucketName}/{path} "); } catch (Exception ex) { result = ex.Message; } return(result); }
/// <summary> /// Deletes an existing object by type and id. /// </summary> /// <param name="type">Object type.</param> /// <param name="id">Object id for the object to be deleted.</param> /// <param name="deleteConnections">Flag indicating if the delete should also delete any existing connections with the object. /// If <code>deleteConnections=False</code> and any existing connections are present, then this operation will fail.</param> /// <param name="options">Request specific api options. These will override the global settings for the app for this request.</param> public async static Task DeleteAsync(string type, string id, bool deleteConnections = false, ApiOptions options = null) { var request = new DeleteObjectRequest() { Id = id, Type = type, DeleteConnections = deleteConnections }; ApiOptions.Apply(request, options); var response = await request.ExecuteAsync(); if (response.Status.IsSuccessful == false) throw response.Status.ToFault(); }