public bool DeleteFile(string NomeArquivo)
{
try
{
//abre a conecao com o aws s3 atraves da credencial e region
String AccessKeyID = this.AccessKeyIDS3;
String SecretAccessKey = this.SecretAccessKeyS3;
AWSCredentials credentials = new BasicAWSCredentials(AccessKeyID, SecretAccessKey);
var client = new AmazonS3Client(credentials, GetRegion(this.RegionS3));
//monta o obj para ser realizado o request
DeleteObjectRequest deleteObjectRequest = new DeleteObjectRequest
{
BucketName = this.BucketS3,
Key = NomeArquivo
};
//envia ao servido o request para ser deletado do servidor
DeleteObjectResponse response = client.DeleteObject(deleteObjectRequest);
return(true);
}
catch (AmazonS3Exception)
{
return(false);
}
catch (Exception)
{
return(false);
}
}
public async Task FullPreSignTest()
{
int expireIn = 100;
string url = SignedObjectClient.SignPutObject(BucketName, "test.zip", null, TimeSpan.FromSeconds(expireIn));
using (MemoryStream ms = new MemoryStream(Encoding.ASCII.GetBytes("hello world")))
{
PutObjectResponse?putResp = await SignedObjectClient.PutObjectAsync(url, ms).ConfigureAwait(false);
Assert.Equal(200, putResp.StatusCode);
}
url = SignedObjectClient.SignGetObject(BucketName, "test.zip", TimeSpan.FromSeconds(expireIn));
GetObjectResponse?getResp = await SignedObjectClient.GetObjectAsync(url).ConfigureAwait(false);
Assert.Equal(200, getResp.StatusCode);
url = SignedObjectClient.SignDeleteObject(BucketName, "test.zip", TimeSpan.FromSeconds(expireIn));
DeleteObjectResponse deleteResp = await SignedObjectClient.DeleteObjectAsync(url).ConfigureAwait(false);
Assert.Equal(204, deleteResp.StatusCode);
url = SignedObjectClient.SignHeadObject(BucketName, "test.zip", TimeSpan.FromSeconds(expireIn));
HeadObjectResponse headResp = await SignedObjectClient.HeadObjectAsync(url).ConfigureAwait(false);
Assert.Equal(404, headResp.StatusCode);
}
public async Task DeleteImage(string fileName, int bucketChoice)
{
string bucketname = "moonshinephotostest";
string key = "photoAlbums/" + fileName;
//switch (choice) {
// case 0:
// bucketname = BandImageBucketName;
// break;
// case 1:
// bucketname = GalleryBucketName;
// break;
//}
try
{
DeleteObjectResponse resp = await _client.DeleteObjectAsync(bucketname, key);
Console.WriteLine("Delete Successful!");
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine("Delete Failed!");
}
}
/// <summary>
/// Removes an object
/// </summary>
/// <param name="objectKey">Object's key</param>
/// <returns>Removed object's key</returns>
public Task <string> AwsDeleteObject(string objectKey) => AwsFunc <string>(
async(client) =>
{
try
{
_logger.LogInformation("Delete {0} from Amazon S3 store bucket.", objectKey);
DeleteObjectRequest request = new DeleteObjectRequest {
BucketName = _awsBucketName, Key = objectKey
};
DeleteObjectResponse response = await client.DeleteObjectAsync(request);
string logMessage = $"Status code {response.HttpStatusCode} for Amazon S3 request";
if (response.HttpStatusCode == System.Net.HttpStatusCode.NoContent ||
response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
_logger.LogInformation(logMessage);
return(objectKey);
}
else
{
_logger.LogError(logMessage);
}
}
catch (AmazonS3Exception e)
{
_logger.LogError("Error encountered on server. Message:'{0}' when deleting an object", e.Message);
}
catch (Exception e)
{
_logger.LogError("Error encountered on server. Message:'{0}' when deleting an object", e.Message);
}
return(null);
});
/// <summary>
/// 删除文件
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
public static async Task DeleteAnObjectAsync(string key)
{
try
{
// 1. Delete object-specify only key name for the object.
var deleteRequest1 = new DeleteObjectRequest
{
BucketName = bucketName,
Key = key
};
DeleteObjectResponse response1 = await client.DeleteObjectAsync(deleteRequest1);
Console.WriteLine("Silme İşlem Başarı ile gerçekleştirildi");
}
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);
}
}
private void DeleteObjectFinished(object sender, deleteCompletedEventArgs e)
{
object[] state = (object[]) e.UserState;
OperationFinished<DeleteObjectResponse> deleteObjectCompleted =
(OperationFinished<DeleteObjectResponse>) state[0];
DeleteObjectResponse response;
if (e.Error != null)
{
response = new DeleteObjectResponse
{
Status = DeleteObjectStatus.Failed,
UserState = state[1],
Error = e.Error
};
}
else
{
response = new DeleteObjectResponse
{
Status = StatusMessageParser.ParseDeleteObjectStatus(e.Result),
UserState = state[1]
};
response.Error = response.Status == DeleteObjectStatus.Unknown
?
new UnknownOperationStatusException(e.Result)
:
null;
}
deleteObjectCompleted(response);
}
private void DeleteFolder(string path, IAmazonS3 client)
{
EnsureInitialized();
if (_client == null)
{
return;
}
//TODO: Refractor to use async deletion?
foreach (var folder in ListFolders(path))
{
DeleteFolder(folder.GetPath(), client);
}
foreach (var file in ListFiles(path))
{
DeleteFile(file.GetPath(), client);
}
var request = new DeleteObjectRequest()
{
BucketName = BucketName,
Key = path
};
DeleteObjectResponse response = client.DeleteObject(request);
}
private async Task <bool> S3Delete(string key)
{
try
{
DeleteObjectRequest request = new DeleteObjectRequest
{
BucketName = _AwsSettings.Bucket,
Key = key
};
DeleteObjectResponse response = await _S3Client.DeleteObjectAsync(request);
int statusCode = (int)response.HttpStatusCode;
if (response != null)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public async Task <bool> RemoveFileFromS3(string name, string bucketName)
{
DeleteObjectRequest deleteRequest = new DeleteObjectRequest
{
Key = name,
BucketName = bucketName
};
try
{
using (client = new AmazonS3Client(await GetTemporaryCredentials(), RegionEndpoint.APSoutheast2))
{
DeleteObjectResponse response = await client.DeleteObjectAsync(deleteRequest);
if (response.HttpStatusCode == HttpStatusCode.NoContent)
{
return(true);
}
return(false);
}
}catch (AmazonS3Exception e)
{
return(false);
}
}
public async Task <bool> FunctionHandler(FileInfo fileInfo, ILambdaContext context)
{
context.Logger.LogLine(JsonConvert.SerializeObject(fileInfo));
var request = new CopyObjectRequest
{
SourceBucket = fileInfo.Bucket, SourceKey = fileInfo.Key, DestinationBucket = fileInfo.result ? "videos-validation-passed" : "videos-validation-failed",
DestinationKey = fileInfo.Key
};
context.Logger.LogLine("copy object");
CopyObjectResponse response = await this.s3Client.CopyObjectAsync(request).ConfigureAwait(false);
if (response.HttpStatusCode != HttpStatusCode.OK)
{
return(false);
}
context.Logger.LogLine("delete object");
DeleteObjectResponse objectResponse = await this.s3Client.DeleteObjectAsync(new DeleteObjectRequest { Key = fileInfo.Key, BucketName = fileInfo.Bucket }).ConfigureAwait(false);
return(objectResponse.HttpStatusCode == HttpStatusCode.OK);
}
public async Task <GenericResponse> DeleteFile(string filePath, string bucketName)
{
GenericResponse result = new GenericResponse();
try
{
var deleteFileRequest = new DeleteObjectRequest
{
BucketName = bucketName,
Key = filePath
};
DeleteObjectResponse fileDeleteResponse = await _client.DeleteObjectAsync(deleteFileRequest);
result.Value = fileDeleteResponse.ResponseMetadata.RequestId;
result.Text = $"Success {filePath} has been deleted";
}
catch (AmazonS3Exception awsEx)
{
var errorMessage = awsEx.ErrorCode;
}
catch (Exception ex)
{
var errorMessage = ex.Message;
}
return(result);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
DeleteObjectResponse response = new DeleteObjectResponse();
return(response);
}
private static void DisplayDeleteObjectResponse(DeleteObjectResponse deleteObjectResponse)
{
var writer = Console.Out;
writer.WriteLine($"{nameof(deleteObjectResponse.HttpStatusCode)}: {deleteObjectResponse.HttpStatusCode}");
Construction.DisplayResponseMetadata(writer, deleteObjectResponse.ResponseMetadata);
}
private bool MoveToArchive(string fileName, string archiveLocation, string bucketName)
{
CopyObjectRequest copyRequest = new CopyObjectRequest()
{
SourceBucket = bucketName,
SourceKey = fileName,
DestinationBucket = bucketName,
DestinationKey = archiveLocation + fileName
};
CopyObjectResponse copyResponse = _client.CopyObject(copyRequest);
if (copyResponse.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
DeleteObjectRequest deleteRequest = new DeleteObjectRequest()
{
BucketName = bucketName,
Key = fileName
};
DeleteObjectResponse deleteResponse = _client.DeleteObject(deleteRequest);
if (deleteResponse.HttpStatusCode == System.Net.HttpStatusCode.NoContent)
{
return(true);
}
}
return(false);
}
public bool DeleteS3Object(string fileName, string username, string bucketName)
{
bool status = false;
SetS3Client();
DeleteObjectRequest request = new DeleteObjectRequest()
{
BucketName = bucketName,
Key = username + "/" + fileName
};
try
{
DeleteObjectResponse response = s3Client.DeleteObject(request);
status = !response.ResponseMetadata.RequestId.Equals(String.Empty);
}
catch (Exception ex)
{
throw ex;
}
return(status);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
DeleteObjectResponse deleteObjectResponse = new DeleteObjectResponse();
UnmarshallResult(context, deleteObjectResponse);
return(deleteObjectResponse);
}
private static async Task UploadDownloadStandard(AmazonS3Client client, string bucketName, string objectName)
{
Console.WriteLine();
Console.WriteLine("Using the standard API");
//We upload and object to the bucket with "Hello World" inside it.
await using MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes("Hello World"));
PutObjectResponse putResp = await client.PutObjectAsync(bucketName, objectName, memoryStream);
if (putResp.IsSuccess)
{
Console.WriteLine("Successfully uploaded the object");
GetObjectResponse getResp = await client.GetObjectAsync(bucketName, objectName);
//Here we try to download the object again. If successful, we should see it print the content to the screen.
if (getResp.IsSuccess)
{
Console.WriteLine("Success! The object contained: " + await getResp.Content.AsStringAsync());
//Finally, we clean up after us and remove the object.
DeleteObjectResponse delResp = await client.DeleteObjectAsync(bucketName, objectName);
Console.WriteLine(delResp.IsSuccess ? "Successfully deleted the object" : "Failed deleting the object");
}
else
{
Console.WriteLine("Failed downloading object");
}
}
else
{
Console.WriteLine("Failed uploading object");
}
}
public void DeleteBucket(string bucketName, string bucketKey = null)
{
#region Delete Bucket Policy
DeleteBucketPolicyResponse delBucketResp = new DeleteBucketPolicyResponse();
Console.WriteLine("Bucket policy del -1");
delBucketResp = s3Client.DeleteBucketPolicy(bucketName);
Console.WriteLine("Bucket policy del -2");
Console.WriteLine("s3Client");
#endregion
if (bucketKey != null)
{
GetObjectRequest getObjectRequest = new GetObjectRequest();
getObjectRequest.BucketName = bucketName;
getObjectRequest.Key = bucketKey;
// GetObjectResponse getObjectResponse = s3Client.GetObject(getObjectRequest);
DeleteObjectResponse deleteObjectResponse = s3Client.DeleteObject(bucketName, bucketKey);
}
#region Delete Bucket Request
DeleteBucketRequest req = new DeleteBucketRequest();
Console.WriteLine("Req");
req.BucketName = bucketName;
Console.WriteLine(bucketName);
req.UseClientRegion = true;
#endregion
#region Delete Bucket Responce
DeleteBucketResponse resp = s3Client.DeleteBucket(req);
Console.WriteLine("Bucket deleted");
#endregion
}
static void DeletingAnObject()
{
try
{
DeleteObjectRequest request = new DeleteObjectRequest();
request.WithBucketName(bucketName)
.WithKey(keyName);
using (DeleteObjectResponse response = client.DeleteObject(request))
{
System.Net.WebHeaderCollection headers = response.Headers;
foreach (string key in headers.Keys)
{
Console.WriteLine("Response Header: {0}, Value: {1}", key, headers.Get(key));
}
}
}
catch (AmazonS3Exception amazonS3Exception)
{
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);
}
}
}
public void DeleteFile(string remotePath)
{
DeleteObjectRequest req = new DeleteObjectRequest();
req.BucketName = CurrentBucketName;
req.Key = remotePath;
DeleteObjectResponse resp = _transfer.S3Client.DeleteObject(req);
}
//Method to delete a file in a bucket
//
public async Task DeleteFileAsync(IAmazonS3 s3Client, string bucketName, string key)
{
DeleteObjectResponse response = await s3Client.DeleteObjectAsync(new DeleteObjectRequest
{
BucketName = bucketName,
Key = key
});
}
public async Task DeleteMarker()
{
await UploadAsync(nameof(DeleteMarker)).ConfigureAwait(false);
DeleteObjectResponse resp = await ObjectClient.DeleteObjectAsync(BucketName, nameof(DeleteMarker)).ConfigureAwait(false);
Assert.True(resp.IsDeleteMarker);
}
public async Task <bool> DeleteFileAsync(string fileName)
{
DeleteObjectResponse response =
await this.awsClient.DeleteObjectAsync(this.bucketName, fileName);
bool status = response.HttpStatusCode == HttpStatusCode.NoContent ? true : false;
return(status);
}
static async Task delete_file(AmazonS3Client client, String key, String bucketName)
{
var deleteObjectRequest = new DeleteObjectRequest {
BucketName = bucketName,
Key = key
};
DeleteObjectResponse response = await client.DeleteObjectAsync(deleteObjectRequest);
}
public void Delete(string blobName)
{
DeleteObjectRequest request = new DeleteObjectRequest();
request.BucketName = BucketName;
request.Key = blobName;
DeleteObjectResponse response = _client.DeleteObject(request);
}
public void DeleteVersion(string remotePath, string versionID)
{
DeleteObjectRequest req = new DeleteObjectRequest();
req.BucketName = CurrentBucketName;
req.Key = remotePath;
req.VersionId = versionID;
DeleteObjectResponse resp = _transfer.S3Client.DeleteObject(req);
}
public void DeleteObject(string bucketName, string keyName)
{
DeleteObjectRequest objectDeleteRequest = new DeleteObjectRequest();
objectDeleteRequest.BucketName = bucketName;
objectDeleteRequest.Key = keyName;
using (DeleteObjectResponse objectDeleteResponse = m_client.DeleteObject(objectDeleteRequest))
{ }
}
public void DeleteObject(string bucketName, string keyName)
{
DeleteObjectRequest objectDeleteRequest = new DeleteObjectRequest()
{
BucketName = bucketName,
Key = keyName
};
DeleteObjectResponse objectDeleteResponse = m_client.DeleteObject(objectDeleteRequest);
}
/// <summary>
/// Supprime le fichier.
/// </summary>
/// <param name="id">Identifiant du fichier.</param>
public void DeleteFile(string id)
{
FileModel fileModel = GetFile(id);
var deleteFileRequest = new DeleteObjectRequest {
BucketName = _bucketName, Key = fileModel.Key
};
DeleteObjectResponse fileDeleteResponse = _amazonS3Client.DeleteObjectAsync(deleteFileRequest).Result;
_fileRepository.Delete(id);
}
public async Task DeleteObjectRequestPayer()
{
PutObjectResponse putResp = await ObjectClient.PutObjectAsync(BucketName, nameof(DeleteObjectRequestPayer), null, req => req.RequestPayer = Payer.Requester).ConfigureAwait(false);
Assert.True(putResp.RequestCharged);
DeleteObjectResponse delResp = await ObjectClient.DeleteObjectAsync(BucketName, nameof(DeleteObjectRequestPayer), req => req.RequestPayer = Payer.Requester).ConfigureAwait(false);
Assert.True(delResp.RequestCharged);
}
private void DeleteFile(string path, IAmazonS3 client)
{
var request = new DeleteObjectRequest()
{
BucketName = BucketName,
Key = path
};
DeleteObjectResponse response = client.DeleteObject(request);
}
