public async Task <IActionResult> Get(string tableName)
{
Console.WriteLine("*** Retrieving table information ***");
Console.WriteLine($"Searching for table: {tableName}");
DescribeTableRequest req = new DescribeTableRequest();
req.TableName = tableName;
try
{
var res = await _dynamoClient.DescribeTableAsync(req);
var description = res.Table;
Console.WriteLine($"Name: {description.TableName}");
Console.WriteLine($"# of items: {description.ItemCount}");
Console.WriteLine($"Provision Throughput (reads/sec): {description.ProvisionedThroughput.ReadCapacityUnits}");
Console.WriteLine($"Provision Throughput (writes/sec): {description.ProvisionedThroughput.WriteCapacityUnits}");
return(Ok(res.Table));
}
catch (AmazonDynamoDBException addbe)
{
return(AmazonExceptionHandlers.HandleAmazonDynamoDBException(addbe));
}
catch (AmazonServiceException ase)
{
AmazonExceptionHandlers.HandleAmazonServiceExceptionException(ase);
}
catch (AmazonClientException ace)
{
AmazonExceptionHandlers.HandleAmazonClientExceptionException(ace);
}
return(StatusCode(500));
}
private async Task EnsureTable()
{
try
{
var poll = await _client.DescribeTableAsync(_tableName);
}
catch (ResourceNotFoundException)
{
await CreateTable();
}
}
private async Task EnsureTable(string tableName, Func <Task> createTask)
{
try
{
await _client.DescribeTableAsync(tableName);
}
catch (ResourceNotFoundException)
{
_logger.LogWarning($"Provisioning DynamoDb table - {tableName}");
await createTask();
}
}
public async Task Provision()
{
try
{
var poll = await _client.DescribeTableAsync(_tableName);
}
catch (ResourceNotFoundException)
{
_logger.LogInformation($"Creating lock table {_tableName}");
await CreateTable();
await SetPurgeTTL();
}
}
public async Task Healthy_Dynamo_Connection_Returns_Healthy()
{
_awsDynamo.DescribeTableAsync(Arg.Any <string>()).Returns(new DescribeTableResponse
{
Table = new TableDescription
{
TableStatus = TableStatus.ACTIVE
}
});
var check = new DynamoDbHealthCheck(_pocoDynamo, new NullLoggerFactory());
var health = await check.CheckHealthAsync(new HealthCheckContext());
Assert.Equal(HealthStatus.Healthy, health.Status);
}
public static async void GetTablesDetails()
{
List <string> tables = await GetTablesList();
using (IAmazonDynamoDB client = GetDynamoDbClient())
{
foreach (string table in tables)
{
DescribeTableRequest describeTableRequest = new DescribeTableRequest(table);
DescribeTableResponse describeTableResponse = await client.DescribeTableAsync(describeTableRequest);
TableDescription tableDescription = describeTableResponse.Table;
Debug.WriteLine(string.Format("Printing information about table {0}:", tableDescription.TableName));
Debug.WriteLine(string.Format("Created at: {0}", tableDescription.CreationDateTime));
List <KeySchemaElement> keySchemaElements = tableDescription.KeySchema;
foreach (KeySchemaElement schema in keySchemaElements)
{
Debug.WriteLine(string.Format("Key name: {0}, key type: {1}", schema.AttributeName, schema.KeyType));
}
Debug.WriteLine(string.Format("Item count: {0}", tableDescription.ItemCount));
ProvisionedThroughputDescription throughput = tableDescription.ProvisionedThroughput;
Debug.WriteLine(string.Format("Read capacity: {0}", throughput.ReadCapacityUnits));
Debug.WriteLine(string.Format("Write capacity: {0}", throughput.WriteCapacityUnits));
List <AttributeDefinition> tableAttributes = tableDescription.AttributeDefinitions;
foreach (AttributeDefinition attDefinition in tableAttributes)
{
Debug.WriteLine(string.Format("Table attribute name: {0}", attDefinition.AttributeName));
Debug.WriteLine(string.Format("Table attribute type: {0}", attDefinition.AttributeType));
}
Debug.WriteLine(string.Format("Table size: {0}b", tableDescription.TableSizeBytes));
Debug.WriteLine(string.Format("Table status: {0}", tableDescription.TableStatus));
Debug.WriteLine("====================================================");
}
}
}
private async Task <string> SetupTable(IAmazonDynamoDB dynamoDBClient)
{
string tableName = "aws-sdk-dotnet-truncate-test-" + DateTime.Now.Ticks;
await dynamoDBClient.CreateTableAsync(
tableName,
new List <KeySchemaElement>
{
new KeySchemaElement {
KeyType = KeyType.HASH, AttributeName = "Id"
}
},
new List <AttributeDefinition>
{
new AttributeDefinition {
AttributeName = "Id", AttributeType = ScalarAttributeType.S
}
},
new ProvisionedThroughput { ReadCapacityUnits = 10, WriteCapacityUnits = 10 });
DescribeTableResponse response = null;
do
{
System.Threading.Thread.Sleep(300);
response = await dynamoDBClient.DescribeTableAsync(tableName);
} while (response.Table.TableStatus != TableStatus.ACTIVE);
return(tableName);
}
public async Task <TableDescription> GetResourceAsync(string name)
{
await CheckTableNamesLoaded();
if (!_tableNames.Contains(name))
{
return(null);
}
if (_cachedTableDescriptions.ContainsKey(name))
{
return(_cachedTableDescriptions[name]);
}
DescribeTableResponse tableResponse;
try
{
tableResponse = await _dynamoDb.DescribeTableAsync(name);
}
catch (ResourceNotFoundException)
{
return(null);
}
_cachedTableDescriptions.Add(tableResponse.Table.TableName, tableResponse.Table);
return(tableResponse.Table);
}
public void WaitUntilTableReady()
{
string status = null;
do
{
Thread.Sleep(5000);
try
{
var res = _dynamoDbClient.DescribeTableAsync(new DescribeTableRequest
{
TableName = "Requirements"
});
status = res.Result.Table.TableStatus;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine(ex);
throw;
}
}while (status != "ACTIVE");
{
Console.WriteLine("Table created successfully");
}
}
private void TryAgainToCreateTable(string tableName)
{
string status = string.Empty;
do
{
Thread.Sleep(5000);
try
{
var res = _amazonDynamoDBClient.DescribeTableAsync(new DescribeTableRequest()
{
TableName = tableName
});
status = res.Result.Table.TableStatus;
}
catch (Exception e)
{
throw;
}
}while (status != "ACTIVE");
{
Console.WriteLine("Table Created Successfully");
}
}
private async Task WaitUntilTableReadyAsync(string tableName)
{
string status = null;
// Let us wait until table is created. Call DescribeTable.
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = await _oDynamoDBClient.DescribeTableAsync(new DescribeTableRequest
{
TableName = tableName
});
Console.WriteLine("Table name: {0}, status: {1}",
res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (status != "ACTIVE");
}
private async Task WaitUntilTableReadyAsync(params string[] tableNames)
{
bool completed = false;
List <Task <DescribeTableResponse> > describeTasks = null;
IEnumerable <DescribeTableRequest> describeTableRequests = tableNames.Select(t => new DescribeTableRequest {
TableName = t
});
// Let us wait until table is created. Call DescribeTable.
do
{
describeTasks = new List <Task <DescribeTableResponse> >();
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
foreach (var req in describeTableRequests)
{
describeTasks.Add(_oDynamoDBClient.DescribeTableAsync(req));
}
await Task.WhenAll(describeTasks.ToArray());
completed = describeTasks.All(t => t.Result.Table.TableStatus == "ACTIVE");
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (!completed);
}
private void waitUntileTableRead(string table)
{
string status = null;
do
{
Thread.Sleep(5000);
try
{
var res = _client.DescribeTableAsync(new DescribeTableRequest
{
TableName = "testTemp"
});
status = res.Result.Table.TableStatus;
}
catch (Exception e)
{
Console.WriteLine(e);
}
} while (status != "ACTIVE");
{
Console.WriteLine("Success");
}
}
public async Task <bool> CheckHealthAsync()
{
//using AmazonDynamoDBClient client = new();
DescribeTableResponse tableData = await _amazonDynamoDBClient.DescribeTableAsync("Adverts");
return(string.Compare(tableData.Table.TableStatus, "active", true) == 0);
}
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();
}
private bool WaitUntilTableIsReady(IAmazonDynamoDB dynamoDBClient)
{
string status = null;
do
{
try
{
var res = dynamoDBClient.DescribeTableAsync(
new DescribeTableRequest
{
TableName = _tableName
});
status = res.Result.Table.TableStatus;
}
catch (Exception ex)
{
throw;
}
} while (status != "ACTIVE");
{
Console.WriteLine("Table created!");
return(true);
}
}
/*--------------------------------------------------------------------------
* checkingTableExistence_async
*--------------------------------------------------------------------------*/
public async Task <bool> checkingTableExistence_async(string tblNm)
{
DescribeTableResponse descResponse;
ListTablesResponse tblResponse = await client.ListTablesAsync();
if (tblResponse.TableNames.Contains(tblNm))
{
Console.WriteLine(" A table named {0} already exists in DynamoDB!", tblNm);
// If the table exists, get its description
try
{
descResponse = await client.DescribeTableAsync(tblNm);
}
catch (Exception ex)
{
throw new Exception($" However, its description is not available ({ex.Message})");
}
Console.WriteLine(" Status of the table: '{0}'.", descResponse.Table.TableStatus);
return(true);
}
return(false);
}
public void Scan()
{
var table = client.DescribeTableAsync(new DescribeTableRequest(tableName)).GetAwaiter().GetResult();
WriteMetrics($"There are {table.Table.ItemCount} entities in the db");
var request = new ScanRequest
{
TableName = tableName,
ReturnConsumedCapacity = "TOTAL",
Limit = 10000
};
var start = Stopwatch.GetTimestamp();
var response = client.ScanAsync(request).GetAwaiter().GetResult();
var time = (Stopwatch.GetTimestamp() - start) * 1000 / Stopwatch.Frequency;
WriteMetrics($"Scanning took {response.ConsumedCapacity.CapacityUnits} units, {time} ms, and returned {response.Count} elements.");
request = new ScanRequest
{
TableName = tableName,
ReturnConsumedCapacity = "TOTAL",
Limit = 100,
ExclusiveStartKey = response.LastEvaluatedKey
};
start = Stopwatch.GetTimestamp();
response = client.ScanAsync(request).GetAwaiter().GetResult();
time = (Stopwatch.GetTimestamp() - start) * 1000 / Stopwatch.Frequency;
WriteMetrics($"Scanning took {response.ConsumedCapacity.CapacityUnits} units, {time} ms, and returned {response.Count} elements.");
}
public async Task <AwsResource <TableDescription> > GetResourceAsync(string name)
{
if (_tableNames == null)
{
await GetResourceNamesAsync();
}
if (!_tableNames.Contains(name))
{
return(null);
}
if (_cachedTableDescriptions.ContainsKey(name))
{
return(_cachedTableDescriptions[name]);
}
var tableResponse = await _dynamoDb.DescribeTableAsync(name);
var dataItem = new AwsResource <TableDescription>(tableResponse.Table.TableName, tableResponse.Table);
_cachedTableDescriptions.Add(tableResponse.Table.TableName, dataItem);
return(dataItem);
}
public static async Task <DescribeTableResponse> WaitTillTableDeleted(IAmazonDynamoDB client, string tableName,
DeleteTableResponse response)
{
DescribeTableResponse resp = new DescribeTableResponse();
var tableDescription = response.TableDescription;
string status = tableDescription.TableStatus;
Int32 sleepDuration = 1000; // One second
while ((status == "DELETING") && (sleepDuration < 10000))
{
System.Threading.Thread.Sleep(sleepDuration);
resp = await client.DescribeTableAsync(new DescribeTableRequest
{
TableName = tableName
});
status = resp.Table.TableStatus;
sleepDuration *= 2;
}
return(resp);
}
public void isTableReady(string tablename)
{
string status = null;
do
{
Thread.Sleep(5000);
try
{
var result = _dynamoDbClient.DescribeTableAsync(new DescribeTableRequest
{
TableName = tablename
});
status = result.Result.Table.TableStatus;
}
catch (Amazon.Runtime.Internal.HttpErrorResponseException)
{
}
catch (ResourceNotFoundException)
{
}
}while (status != "ACTIVE");
{
Console.WriteLine("Table Created");
}
}
/// <summary>
/// Waits for successful creation of a DynamoDB table.
/// </summary>
/// <param name="client">An initialized DynamoDB client object.</param>
/// <param name="tableName">The name of the newly created DynamoDB table.</param>
/// <param name="response">A DescribeTableResponse object that can
/// confirm successful creation of the object.</param>
/// <returns>A DescribeTableResponse object containing information about
/// the newly created table.</returns>
public static async Task <DescribeTableResponse> WaitTillTableCreated(
IAmazonDynamoDB client,
string tableName,
CreateTableResponse response)
{
DescribeTableResponse resp = new DescribeTableResponse();
var tableDescription = response.TableDescription;
string status = tableDescription.TableStatus;
int sleepDuration = 1000; // One second
// Don't wait more than 10 seconds.
while ((status != "ACTIVE") && (sleepDuration < 10000))
{
System.Threading.Thread.Sleep(sleepDuration);
resp = await client.DescribeTableAsync(new DescribeTableRequest
{
TableName = tableName,
});
status = resp.Table.TableStatus;
sleepDuration *= 2;
}
return(resp);
}
private void WaitUntilTableReady(string tableName)
{
string status = null;
// Let us wait until table is created. Call DescribeTable.
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
var res = _amazonDynamoDB.DescribeTableAsync(new DescribeTableRequest
{
TableName = tableName
}).Result;
_logger.LogInformation("Table name: {TableName}, status: {TableStatus}",
res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException)
{
// DescribeTable is eventually consistent. So you might
// get resource not found. So we handle the potential exception.
}
} while (status != "ACTIVE");
}
private async Task <bool> TableIsReady()
{
try
{
var res = await _dynamoDb.DescribeTableAsync(new DescribeTableRequest
{
TableName = _config.TableName
});
return(res.Table.TableStatus == "ACTIVE");
}
catch (Exception e)
{
_logger.LogError(e, $"Table {_config.TableName} isn't ready'");
return(false);
}
}
private async Task <bool> TableIsReady()
{
try
{
var res = await _dynamoDb.DescribeTableAsync(new DescribeTableRequest
{
TableName = _config.TableName
});
return(res.Table.TableStatus == "ACTIVE");
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
public async Task <bool> CheckHealthAsync()
{
Console.WriteLine("Health checking...");
//using var client = new AmazonDynamoDBClient();
var tableData = await _client.DescribeTableAsync("Adverts");
return(string.Compare(tableData.Table.TableStatus, "active", true) == 0);
}
public async Task <bool> CheckHealthAsync()
{
using (var context = new DynamoDBContext(_client))
{
var tableData = await _client.DescribeTableAsync("Adverts");
return(String.Compare(tableData.Table.TableStatus, "Active", true) == 0);
}
}
private async Task EnsureInitializedImplAsync(IAmazonDynamoDB client, string rolesTableName)
{
var defaultProvisionThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
};
var globalSecondaryIndexes = new List <GlobalSecondaryIndex>
{
new GlobalSecondaryIndex
{
IndexName = "NormalizedName-DeletedOn-index",
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement("NormalizedName", KeyType.HASH),
new KeySchemaElement("DeletedOn", KeyType.RANGE)
},
ProvisionedThroughput = defaultProvisionThroughput,
Projection = new Projection
{
ProjectionType = ProjectionType.ALL
}
}
};
var tableNames = await client.ListAllTablesAsync();
if (!tableNames.Contains(rolesTableName))
{
await CreateTableAsync(client, rolesTableName, defaultProvisionThroughput, globalSecondaryIndexes);
return;
}
var response = await client.DescribeTableAsync(new DescribeTableRequest { TableName = rolesTableName });
var table = response.Table;
var indexesToAdd =
globalSecondaryIndexes.Where(
g => !table.GlobalSecondaryIndexes.Exists(gd => gd.IndexName.Equals(g.IndexName)));
var indexUpdates = indexesToAdd.Select(index => new GlobalSecondaryIndexUpdate
{
Create = new CreateGlobalSecondaryIndexAction
{
IndexName = index.IndexName,
KeySchema = index.KeySchema,
ProvisionedThroughput = index.ProvisionedThroughput,
Projection = index.Projection
}
}).ToList();
if (indexUpdates.Count > 0)
{
await UpdateTableAsync(client, rolesTableName, indexUpdates);
}
}
private static async Task <string> GetTableStatus(string tableName)
{
var response = await DynamoDBClient.DescribeTableAsync(new DescribeTableRequest
{
TableName = tableName
});
return(response.Table.TableStatus);
}
public async Task <bool> CheckHealthAsync()
{
using (var context = new DynamoDBContext(_amazonDynamoDB))
{
var tableData = await _amazonDynamoDB.DescribeTableAsync("Advert");
return(tableData.Table.TableStatus == TableStatus.ACTIVE);
}
}
private async Task<string> SetupTable(IAmazonDynamoDB dynamoDBClient)
{
string tableName = "aws-sdk-dotnet-truncate-test-" + DateTime.Now.Ticks;
await dynamoDBClient.CreateTableAsync(
tableName,
new List<KeySchemaElement>
{
new KeySchemaElement { KeyType = KeyType.HASH, AttributeName = "Id" }
},
new List<AttributeDefinition>
{
new AttributeDefinition { AttributeName = "Id", AttributeType = ScalarAttributeType.S }
},
new ProvisionedThroughput { ReadCapacityUnits = 10, WriteCapacityUnits = 10 });
DescribeTableResponse response = null;
do
{
System.Threading.Thread.Sleep(300);
response = await dynamoDBClient.DescribeTableAsync(tableName);
} while (response.Table.TableStatus != TableStatus.ACTIVE);
return tableName;
}
