public async Task DeleteTable(string tableName)
{
if (await CheckExistTable(tableName))
{
await _amazonDynamoDB.DeleteTableAsync(tableName);
}
}
public async Task <IActionResult> Delete(string tableName)
{
System.Console.WriteLine($"Deleting {tableName} table.");
var req = new DeleteTableRequest();
req.TableName = tableName;
try
{
var res = await _dynamoClient.DeleteTableAsync(req);
Console.WriteLine($"Deleted table: {req.TableName}");
return(StatusCode(204));
}
catch (AmazonDynamoDBException addbe)
{
return(AmazonExceptionHandlers.HandleAmazonDynamoDBException(addbe));
}
catch (AmazonServiceException ase)
{
AmazonExceptionHandlers.HandleAmazonServiceExceptionException(ase);
}
catch (AmazonClientException ace)
{
AmazonExceptionHandlers.HandleAmazonClientExceptionException(ace);
}
return(StatusCode(500));
}
private static async Task DeleteTable(IAmazonDynamoDB client, CancellationToken token)
{
DeleteTableRequest request = new DeleteTableRequest(MyTableName);
await client.DeleteTableAsync(request, token);
DescribeTableResponse response;
string expectedExceptionMessage =
$"Requested resource not found: Table: {MyTableName} not found";
try
{
do
{
Thread.Sleep(2000);
Console.WriteLine($"Deleting table {MyTableName}...");
response = await client.DescribeTableAsync(MyTableName, token);
} while (response.Table.TableStatus == TableStatus.DELETING);
}
catch (ResourceNotFoundException e) when(CheckDeleteTableException(e, expectedExceptionMessage))
{
Console.WriteLine($"\nTable {MyTableName} was successfully deleted.");
}
Console.WriteLine("\nPress any key to continue...\n");
Console.ReadKey();
}
public async Task OneTimeTearDown()
{
await m_db
.DeleteTableAsync(m_tableName)
.ConfigureAwait(continueOnCapturedContext: false);
m_db.Dispose();
}
private static async Task DeleteTableIfExists(IAmazonDynamoDB client)
{
var tables = await client.ListTablesAsync();
if (tables.TableNames.Contains(TableName))
{
await client.DeleteTableAsync(new DeleteTableRequest(TableName));
}
}
public async Task DeleteDynamoDbTable(string tableName)
{
var request = new DeleteTableRequest
{
TableName = tableName
};
await _dynamoDbClient.DeleteTableAsync(request);
}
public async Task <IActionResult> DeleteAll()
{
var queryRequest = RequestBuilder(null);
var response = await ScanAsync(queryRequest);
var deletado = await _amazonDynamoDb.DeleteTableAsync(TableName);
return(Ok(deletado));
}
public static void TearDownStore(string tableName)
{
var request = new DeleteTableRequest()
{
TableName = tableName
};
_dynamoDbClient.DeleteTableAsync(request);
}
public async Task DeleteDynamoDbTable(string tableName)
{
var request = new DeleteTableRequest //create a DeleteTableRequest and set in the request the TableName
{
TableName = tableName
};
await _amazonDynamoDbClient.DeleteTableAsync(request);
}
public static async Task <DeleteTableResponse> RemoveTableAsync(IAmazonDynamoDB client, string table)
{
var response = await client.DeleteTableAsync(new DeleteTableRequest
{
TableName = table
});
return(response);
}
public async Task <DeleteTableResponse> DeleteTableExecution(string tableName)
{
var request = new DeleteTableRequest
{
TableName = tableName
};
var response = await _amazonDynamoDB.DeleteTableAsync(request);
return(response);
}
public async Task <DeleteTableResponse> ExecuteTableDelete(string tableName)
{
var request = new DeleteTableRequest
{
TableName = tableName
};
var response = await _dynamoClient.DeleteTableAsync(request);
return(response);
}
static async Task <DeleteTableResponse> RemoveTableAsync(bool debug, IAmazonDynamoDB client, string table)
{
DebugPrint(debug, "Removing " + table + " table ");
var response = await client.DeleteTableAsync(new DeleteTableRequest
{
TableName = table
});
return(response);
}
public async Task DropAllTables(string tablePrefix)
{
var currentTables = await _oDynamoDBClient.ListTablesAsync();
var tableNames = currentTables.TableNames.Where(t => t.StartsWith(tablePrefix));
foreach (var table in tableNames)
{
DeleteTableRequest deleteTableRequest = new DeleteTableRequest(table);
var result = _oDynamoDBClient.DeleteTableAsync(deleteTableRequest);
Thread.Sleep(10000);
}
}
public void Dispose()
{
try
{
DeleteTableResponse deleteTableResponse = tempDynamoDbClient
.DeleteTableAsync(DefaultTableName)
.Result;
}
catch (AggregateException)
{
// There is no such table.
}
}
public void Dispose()
{
try
{
DeleteTableResponse deleteTableResponse = amazonDynamoDbClient
.DeleteTableAsync(dynamoDbMetastoreImpl.TableName)
.Result;
}
catch (AggregateException)
{
// There is no such table.
}
}
public bool DeleteDb(string databaseName)
{
var status = _amazonDynamoDb.DescribeTableAsync(databaseName).GetAwaiter().GetResult().Table.TableStatus;
if (status == TableStatus.ACTIVE)
{
var result = _amazonDynamoDb.DeleteTableAsync(databaseName).GetAwaiter().GetResult();
return(result.HttpStatusCode == HttpStatusCode.OK);
}
return(false);
}
async Task DeleteTable(string table)
{
if (table.StartsWith(_prefix))
{
return;
}
Guid g;
if (Guid.TryParse(table.Substring(0, table.IndexOf("_", StringComparison.Ordinal)), out g))
{
// looks like a table for a different test run, lets remove it
try {
_logger.Information("Deleting table {TableName}", table);
await _db.DeleteTableAsync(new DeleteTableRequest {
TableName = table
});
await WaitTillTableIsDeleted(table);
} catch (ResourceNotFoundException) {
// swallow instances where the table no longer exists
}
}
}
private async Task RemoveInfectionsTableIfExists(IAmazonDynamoDB dbService)
{
try
{
string tableName = Constants.TableName;
var request = new DeleteTableRequest {
TableName = tableName
};
await dbService.DeleteTableAsync(request);
}
catch (ResourceNotFoundException)
{
}
}
/*--------------------------------------------------------------------------
* DeletingTable_async
*--------------------------------------------------------------------------*/
public async Task <bool> DeletingTable_async(string tableName)
{
Console.WriteLine(" -- Trying to delete the table named \"{0}\"...", tableName);
Task tblDelete = client.DeleteTableAsync(tableName);
try
{
await tblDelete;
}
catch (Exception ex)
{
Console.WriteLine(" ERROR: Failed to delete the table, because:\n " + ex.Message);
return(false);
}
Console.WriteLine(" -- Successfully deleted the table!");
return(true);
}
public static async Task <DeleteTableResponse> DeleteTable(IAmazonDynamoDB client, string tableName)
{
try
{
var response = await client.DeleteTableAsync(new DeleteTableRequest
{
TableName = tableName
});
return(response);
}
catch (ResourceNotFoundException)
{
// There is no such table.
return(null);
}
}
public override async Task DeleteAllAsync(CancellationToken cancellationToken)
{
Table table = _dynamoDBContext.GetTargetTable <TReadModel>();
await _dynamoDBClient.DeleteTableAsync(table.TableName, cancellationToken)
.ContinueWith(async response =>
{
var deleteTableResponse = response.Result.TableDescription;
await _dynamoDBClient.CreateTableAsync(
deleteTableResponse.TableName,
deleteTableResponse.KeySchema,
deleteTableResponse.AttributeDefinitions,
new ProvisionedThroughput(
deleteTableResponse.ProvisionedThroughput.ReadCapacityUnits,
deleteTableResponse.ProvisionedThroughput.WriteCapacityUnits),
cancellationToken).ConfigureAwait(false);
}, cancellationToken).ConfigureAwait(false);
}
public async Task AddImage_SavesAndReturnsResponse()
{
// Arrange
TestLambdaContext context;
APIGatewayProxyRequest request;
APIGatewayProxyResponse response;
var imageFunctions = new ImageFunctions(_ddbClient, _s3Client, _tableName, _bucketName);
var testImageRequest = new AddImageRequestModel
{
ImageType = "phone",
FileName = $"my-image.png",
ContentType = "image/png"
};
request = new APIGatewayProxyRequest
{
Body = JsonSerializer.Serialize(testImageRequest)
};
context = new TestLambdaContext();
// Act
response = await imageFunctions.AddImageAsync(request, context);
// Assert
Assert.Equal(201, response.StatusCode);
Assert.NotEmpty(response.Body);
var testResponse = JsonSerializer.Deserialize <AddImageResponseModel>(response.Body);
Assert.NotNull(testResponse);
Assert.NotEmpty(testResponse.Id);
Assert.NotEmpty(testResponse.Key);
Assert.NotEmpty(testResponse.UploadUrl);
// Clean up after the test
// Note: We don't need to create a bucket to test getting a pre-signed URL
var deleteTableResponse = await _ddbClient.DeleteTableAsync(_tableName);
Console.WriteLine($"Delete DDB table response: {deleteTableResponse.HttpStatusCode}");
}
public async Task CreateTablesAsync()
{
var response = await amazonDynamoDB.ListTablesAsync();
// first remove all the current tables so we are always starting fresh
foreach (var table in response.TableNames)
{
await amazonDynamoDB.DeleteTableAsync(table);
}
var createTableRequests = GetCreateTableRequests();
// now add all the tables the user needs
foreach (var createTableRequest in createTableRequests)
{
await amazonDynamoDB.CreateTableAsync(createTableRequest);
}
}
public Task DeleteTableAsync(string tableName)
{
if (string.IsNullOrWhiteSpace(tableName))
{
throw new ArgumentException($"Table name is required.", nameof(tableName));
}
return(deleteTableAsync());
async Task deleteTableAsync()
{
if (!await ExistsAsync(tableName))
{
throw new TableNotFoundException($"A table having name '{tableName}' does not exist.");
}
await _dynamoDb.DeleteTableAsync(tableName);
}
}
public async Task CreateTableAsync(CreateTableRequest request, bool resetTable = false, CancellationToken token = default)
{
try
{
await client.DescribeTableAsync(new DescribeTableRequest(request.TableName), token);
if (!resetTable)
{
return;
}
await client.DeleteTableAsync(new DeleteTableRequest(request.TableName), token);
}
catch
{
// If table doesn't exist, exception is thrown
}
await client.CreateTableAsync(request, token);
}
public async Task <bool> RemoveTableAsync(string tableName)
{
var itemRepo = new ItemRepo(new AmazonDynamoDBClient());
var request = new DeleteTableRequest
{
TableName = tableName
};
var response = await dynamoDB.DeleteTableAsync(request);
if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
try{
await itemRepo.RemoveItem("Table", tableName, null);
return(await Task.FromResult(true));
}catch {}
}
return(await Task.FromResult(false));
}
public static async void DeleteTableDemo(string tableName)
{
try
{
using (IAmazonDynamoDB client = GetDynamoDbClient())
{
DeleteTableRequest deleteTableRequest = new DeleteTableRequest(tableName);
DeleteTableResponse deleteTableResponse = await client.DeleteTableAsync(deleteTableRequest);
TableDescription tableDescription = deleteTableResponse.TableDescription;
TableStatus tableStatus = tableDescription.TableStatus;
Debug.WriteLine(string.Format("Delete table command sent to Amazon for table {0}, status after deletion: {1}", tableName
, tableDescription.TableStatus));
}
}
catch (AmazonDynamoDBException exception)
{
Debug.WriteLine(string.Concat("Exception while deleting DynamoDb table: {0}", exception.Message));
Debug.WriteLine(String.Concat("Error code: {0}, error type: {1}", exception.ErrorCode, exception.ErrorType));
}
}
private Amazon.DynamoDBv2.Model.DeleteTableResponse CallAWSServiceOperation(IAmazonDynamoDB client, Amazon.DynamoDBv2.Model.DeleteTableRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon DynamoDB", "DeleteTable");
try
{
#if DESKTOP
return(client.DeleteTable(request));
#elif CORECLR
return(client.DeleteTableAsync(request).GetAwaiter().GetResult());
#else
#error "Unknown build edition"
#endif
}
catch (AmazonServiceException exc)
{
var webException = exc.InnerException as System.Net.WebException;
if (webException != null)
{
throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException);
}
throw;
}
}
public static DeleteTableResponse DeleteTable(this IAmazonDynamoDB client, DeleteTableRequest request)
{
return(client.DeleteTableAsync(request).GetResult());
}
private async Task DeleteTable(IAmazonDynamoDB dynamoDBClient, string tableName)
{
await dynamoDBClient.DeleteTableAsync(tableName);
}
