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); }