private async Task WaitUntilTableReady()
{
string status = null;
do
{
System.Threading.Thread.Sleep(5000); // Wait 5 seconds.
try
{
DescribeTableResponse res = await client.DescribeTableAsync(new DescribeTableRequest
{
TableName = tableName
});
Console.WriteLine("Table name: {0}, status: {1}",
res.Table.TableName,
res.Table.TableStatus);
status = res.Table.TableStatus;
}
catch (ResourceNotFoundException ex)
{
Console.WriteLine(ex);
}
} while (status != "ACTIVE");
}
private bool LockTableExists()
{
try
{
DescribeTableResponse result = _client.DescribeTableAsync(new DescribeTableRequest(_tableName))
.Result;
if (result.HttpStatusCode != HttpStatusCode.OK)
{
return(false);
}
var tableActiveOrUpdated = _availableTableStatuses.Contains(result.Table.TableStatus);
return(tableActiveOrUpdated);
}
catch (ResourceNotFoundException)
{
return(false);
}
catch (Exception)
{
return(false);
}
}
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 async Task <string> Add(AdvertModel model)
{
AdvertDbModel dbModel = _mapper.Map <AdvertDbModel>(model);
dbModel.Id = Guid.NewGuid().ToString();
dbModel.CreationDateTime = DateTime.UtcNow;
dbModel.Status = AdvertStatus.Pending;
using (AmazonDynamoDBClient client = new AmazonDynamoDBClient())
{
DescribeTableResponse table = await client.DescribeTableAsync("Adverts");
bool tableStatus = string.Compare(table.Table.TableStatus, "active", true) == 0;
if (tableStatus)
{
using (DynamoDBContext context = new DynamoDBContext(client))
{
await context.SaveAsync(dbModel);
}
}
}
return(dbModel.Id);
}
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 <bool> CheckHealthAsync()
{
//using AmazonDynamoDBClient client = new();
DescribeTableResponse tableData = await _amazonDynamoDBClient.DescribeTableAsync("Adverts");
return(string.Compare(tableData.Table.TableStatus, "active", true) == 0);
}
private TableDescriptionSource SetupPagingTest()
{
var firstTableName = "Table-1";
_firstPage = new ListTablesResponse
{
LastEvaluatedTableName = firstTableName,
TableNames = new List <string>
{
firstTableName
}
};
var secondTableName = "Table-2";
_secondPage = new ListTablesResponse
{
LastEvaluatedTableName = secondTableName,
TableNames = new List <string>
{
secondTableName
}
};
_thirdPage = new ListTablesResponse
{
TableNames = new List <string>
{
"Table-3"
}
};
var describeSecondTableResponse = new DescribeTableResponse
{
Table = new TableDescription
{
TableName = secondTableName
}
};
var dynamoDbMock = new Mock <IAmazonDynamoDB>();
dynamoDbMock.Setup(s => s.ListTablesAsync(
It.Is <string>(r => r == null), It.IsAny <CancellationToken>()
)).ReturnsAsync(_firstPage);
dynamoDbMock.Setup(s => s.ListTablesAsync(
It.Is <string>(r => r == firstTableName),
It.IsAny <CancellationToken>()
)).ReturnsAsync(_secondPage);
dynamoDbMock.Setup(s => s.ListTablesAsync(
It.Is <string>(r => r == secondTableName),
It.IsAny <CancellationToken>()
)).ReturnsAsync(_thirdPage);
dynamoDbMock.Setup(s => s.DescribeTableAsync(It.Is <string>(r => r == secondTableName),
It.IsAny <CancellationToken>()))
.ReturnsAsync(describeSecondTableResponse);
return(new TableDescriptionSource(dynamoDbMock.Object));
}
/// <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);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
DescribeTableResponse response = new DescribeTableResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("ColumnList", targetDepth))
{
var unmarshaller = new ListUnmarshaller <ColumnMetadata, ColumnMetadataUnmarshaller>(ColumnMetadataUnmarshaller.Instance);
response.ColumnList = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("NextToken", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.NextToken = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("TableName", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.TableName = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
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("====================================================");
}
}
}
public static DescribeTableResponse Unmarshall(UnmarshallerContext _ctx)
{
DescribeTableResponse describeTableResponse = new DescribeTableResponse();
describeTableResponse.HttpResponse = _ctx.HttpResponse;
describeTableResponse.RequestId = _ctx.StringValue("DescribeTable.RequestId");
describeTableResponse.Success = _ctx.BooleanValue("DescribeTable.Success");
DescribeTableResponse.DescribeTable_Data data = new DescribeTableResponse.DescribeTable_Data();
List <DescribeTableResponse.DescribeTable_Data.DescribeTable_ColumnInfo> data_list = new List <DescribeTableResponse.DescribeTable_Data.DescribeTable_ColumnInfo>();
for (int i = 0; i < _ctx.Length("DescribeTable.Data.List.Length"); i++)
{
DescribeTableResponse.DescribeTable_Data.DescribeTable_ColumnInfo columnInfo = new DescribeTableResponse.DescribeTable_Data.DescribeTable_ColumnInfo();
columnInfo.ColumnName = _ctx.StringValue("DescribeTable.Data.List[" + i + "].ColumnName");
columnInfo.ColumnType = _ctx.StringValue("DescribeTable.Data.List[" + i + "].ColumnType");
columnInfo.Extra = _ctx.StringValue("DescribeTable.Data.List[" + i + "].Extra");
columnInfo.Index = _ctx.StringValue("DescribeTable.Data.List[" + i + "].Index");
columnInfo.IsAllowNull = _ctx.StringValue("DescribeTable.Data.List[" + i + "].IsAllowNull");
columnInfo.IsPk = _ctx.StringValue("DescribeTable.Data.List[" + i + "].IsPk");
data_list.Add(columnInfo);
}
data.List = data_list;
describeTableResponse.Data = data;
return(describeTableResponse);
}
internal static async Task <bool> BuildMatchingStatus(TableStatus tableStatus, string tableName, AmazonDynamoDBClient dynamodbClient)
{
DescribeTableResponse describeTableResponse = await Build(tableName, dynamodbClient);
bool isMatchingStatus = describeTableResponse.Table.TableStatus == tableStatus;
return(isMatchingStatus);
}
internal static async Task <long> BuildCount(string tableName, AmazonDynamoDBClient dynamodbClient)
{
DescribeTableResponse describeTableResponse = await Build(tableName, dynamodbClient);
long count = describeTableResponse.Table.ItemCount;
return(count);
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
DescribeTableResponse response = new DescribeTableResponse();
context.Read();
UnmarshallResult(context, response);
return(response);
}
public async Task <bool> Checkhealth()
{
using (AmazonDynamoDBClient client = new AmazonDynamoDBClient())
{
DescribeTableResponse checkTabela = await client.DescribeTableAsync("Anuncios");
return(string.Compare(checkTabela.Table.TableStatus, "active", true) == 0);
}
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
DescribeTableResponse response = new DescribeTableResponse();
context.Read();
response.DescribeTableResult = DescribeTableResultUnmarshaller.GetInstance().Unmarshall(context);
return(response);
}
private async Task <int> getTableCount(string table)
{
DescribeTableResponse description = await _client.DescribeTableAsync(table);
// The reason for the 2, at the start I only inserted 2 records and
// since Dynamodb takes 6 hours to update the item count,
// so it is useful for the first 6 hours of production and that is it.
return(description.Table.ItemCount == 0 ? 2 : (int)description.Table.ItemCount);
}
private async Task <TableStatus> GetTableStatusAsync()
{
DescribeTableResponse response = await _dynamoDbClient.DescribeTableAsync(new DescribeTableRequest
{
TableName = _tableName
});
return(response.Table.TableStatus);
}
private Table CreateTable()
{
CreateTableRequest createRequest = new CreateTableRequest
{
TableName = this._tableName,
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = ATTRIBUTE_SESSION_ID, KeyType = "HASH"
}
},
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = ATTRIBUTE_SESSION_ID, AttributeType = "S"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = this._initialReadUnits,
WriteCapacityUnits = this._initialWriteUnits
}
};
createRequest.BeforeRequestEvent += this.UserAgentRequestEventHandler;
CreateTableResponse response = this._ddbClient.CreateTable(createRequest);
DescribeTableRequest descRequest = new DescribeTableRequest
{
TableName = this._tableName
};
descRequest.BeforeRequestEvent += this.UserAgentRequestEventHandler;
// Wait till table is active
bool isActive = false;
while (!isActive)
{
Thread.Sleep(DESCRIBE_INTERVAL);
DescribeTableResponse descResponse = this._ddbClient.DescribeTable(descRequest);
string tableStatus = descResponse.Table.TableStatus;
if (string.Equals(tableStatus, ACTIVE_STATUS, StringComparison.InvariantCultureIgnoreCase))
{
isActive = true;
}
}
Table table = Table.LoadTable(this._ddbClient, this._tableName, Table.DynamoDBConsumer.SessionStateProvider, DynamoDBEntryConversion.V1);
return(table);
}
public async Task <bool> CheckHealthAsync()
{
Console.WriteLine("Health checking...");
using (AmazonDynamoDBClient client = GetDynamoDBClient())
{
DescribeTableResponse tableData = await client.DescribeTableAsync(TABLE_NAME);
return(string.Compare(tableData.Table.TableStatus, "active", true) == 0);
}
}
public static void TableOperations()
{
// 创建表
OTSClient otsClient = Config.GetClient();
{
Console.WriteLine("Start create table...");
PrimaryKeySchema primaryKeySchema = new PrimaryKeySchema
{
{ "pk0", ColumnValueType.Integer },
{ "pk1", ColumnValueType.String }
};
TableMeta tableMeta = new TableMeta(TableName, primaryKeySchema);
CapacityUnit reservedThroughput = new CapacityUnit(0, 0);
CreateTableRequest request = new CreateTableRequest(tableMeta, reservedThroughput);
otsClient.CreateTable(request);
Console.WriteLine("Table is created: " + TableName);
}
//// 更新表
//{
// Thread.Sleep(60 * 1000); // 每次更新表需要至少间隔1分钟
// Console.WriteLine("Start update table...");
// CapacityUnit reservedThroughput = new CapacityUnit(0, 0); // 将预留CU调整为0，0
// UpdateTableRequest request = new UpdateTableRequest(TableName, reservedThroughput);
// UpdateTableResponse response = otsClient.UpdateTable(request);
// Console.WriteLine("LastIncreaseTime: " + response.ReservedThroughputDetails.LastIncreaseTime);
// Console.WriteLine("LastDecreaseTime: " + response.ReservedThroughputDetails.LastDecreaseTime);
// Console.WriteLine("NumberOfDecreaseToday: " + response.ReservedThroughputDetails.LastIncreaseTime);
// Console.WriteLine("ReadCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Read);
// Console.WriteLine("WriteCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Write);
//}
// 描述表
{
Console.WriteLine("Start describe table...");
DescribeTableRequest request = new DescribeTableRequest(TableName);
DescribeTableResponse response = otsClient.DescribeTable(request);
Console.WriteLine("LastIncreaseTime: " + response.ReservedThroughputDetails.LastIncreaseTime);
Console.WriteLine("LastDecreaseTime: " + response.ReservedThroughputDetails.LastDecreaseTime);
Console.WriteLine("NumberOfDecreaseToday: " + response.ReservedThroughputDetails.LastIncreaseTime);
Console.WriteLine("ReadCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Read);
Console.WriteLine("WriteCapacity: " + response.ReservedThroughputDetails.CapacityUnit.Write);
}
//// 删除表
//{
// Console.WriteLine("Start delete table...");
// DeleteTableRequest request = new DeleteTableRequest(TableName);
// otsClient.DeleteTable(request);
// Console.WriteLine("Table is deleted.");
//}
}
public static async Task <bool> GetTableObject(string tableName, bool isRestore)
{
if (!CreateClient())
{
return(false);
}
var request = new DescribeTableRequest
{
TableName = tableName
};
try
{
_describeTableResponse = await _client.DescribeTableAsync(request);
}
catch (Exception ex)
{
ShowError("Failed to get table {0}'s details. {1}", tableName, GetFullErrorMessage(ex));
return(false);
}
if (_describeTableResponse?.Table == null)
{
_describeTableResponse = null;
ShowError("Table {0} doesn't exist", tableName);
return(false);
}
//Only restore data into empty table, to avoid restoring into a live environment
if (isRestore && _describeTableResponse.Table.ItemCount > 0)
{
ShowError("Cannot restore data into table {0} because it contains {1} records already. You can only restore data in empty tables", _tableName, _describeTableResponse.Table.ItemCount);
return(false);
}
// Now, create a Table object for the specified table
try
{
_table = Table.LoadTable(_client, tableName);
}
catch (Exception ex)
{
ShowError("Error: failed to load the '{0}' table. {1}", tableName, ex.Message);
return(false);
}
return(true);
}
public async Task <string> GetTableAsync(string tableName)
{
DescribeTableResponse response = null;
try
{
response = await GetClientInstance().DescribeTableAsync(tableName, new System.Threading.CancellationToken());
}
catch (Exception e)
{
return(e.Message);
}
return($"Table: { response.Table }, Status: { response.Table.TableStatus }");
}
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
DescribeTableResponse response = new DescribeTableResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("Table", targetDepth))
{
response.Table = TableDescriptionUnmarshaller.GetInstance().Unmarshall(context);
continue;
}
}
return(response);
}
private async Task SetupTableAsync()
{
var createTableRequest = new CreateTableRequest
{
TableName = _tableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1, // TODO: Not sure?
WriteCapacityUnits = 1
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
KeyType = KeyType.HASH,
AttributeName = "Id"
}
},
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = ScalarAttributeType.S
}
}
};
await _ddbClient.CreateTableAsync(createTableRequest);
var describeTableRequest = new DescribeTableRequest
{
TableName = _tableName
};
DescribeTableResponse describeTableResponse = null;
do
{
Thread.Sleep(1000);
describeTableResponse = await _ddbClient.DescribeTableAsync(describeTableRequest);
} while(describeTableResponse.Table.TableStatus != TableStatus.ACTIVE);
}
private bool TableExists(string tableName)
{
bool tableExists = false;
TryCatch.Try(
tryAction: () =>
{
DescribeTableResponse response = Client.DescribeTableAsync(tableName).Result;
tableExists = true;
},
catchAction: caughtException =>
{
tableExists = false;
},
catchableExceptions: new List <Type> {
typeof(ResourceNotFoundException)
});
return(tableExists);
}
public async Task SetupTable()
{
using (var client = new AmazonDynamoDBClient(_region))
{
CreateTableRequest request = new CreateTableRequest
{
TableName = _targetTableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 2,
WriteCapacityUnits = 2
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
KeyType = KeyType.HASH,
AttributeName = nameof(Driver.Id)
}
},
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = nameof(Driver.Id),
AttributeType = ScalarAttributeType.S
}
}
};
await client.CreateTableAsync(request);
var describeRequest = new DescribeTableRequest {
TableName = _targetTableName
};
DescribeTableResponse response = null;
do
{
Thread.Sleep(1000);
response = await client.DescribeTableAsync(describeRequest);
} while (response.Table.TableStatus != TableStatus.ACTIVE);
}
}
public static void DeleteTables(IAmazonDynamoDB client, Predicate <string> tableNameMatch)
{
try
{
var tableNames = client.ListTables().TableNames;
foreach (var tableName in tableNames)
{
DescribeTableResponse descResponse = client.DescribeTable(new DescribeTableRequest {
TableName = tableName
});
if (descResponse.Table == null)
{
continue;
}
TableDescription table = descResponse.Table;
if (table.TableStatus == TableStatus.ACTIVE && tableNameMatch(table.TableName))
{
Console.WriteLine("Table: {0}, {1}, {2}, {3}", table.TableName, table.TableStatus, table.ProvisionedThroughput.ReadCapacityUnits, table.ProvisionedThroughput.WriteCapacityUnits);
Console.WriteLine("Deleting table " + table.TableName + "...");
try
{
client.DeleteTable(new DeleteTableRequest {
TableName = table.TableName
});
WaitUntilTableDeleted(table.TableName, client);
Console.WriteLine("Succeeded!");
}
catch
{
Console.WriteLine("Failed!");
}
}
}
Console.WriteLine(tableNames.Count);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
public async Task <string> AddAsync(AdvertModel model)
{
AdvertDbModel dbModel = _mapper.Map <AdvertDbModel>(model);
dbModel.Id = Guid.NewGuid().ToString();
dbModel.CreationDateTime = DateTime.UtcNow;
dbModel.Status = AdvertStatus.Pending;
using (AmazonDynamoDBClient client = GetDynamoDBClient())
{
DescribeTableResponse table = await client.DescribeTableAsync(TABLE_NAME);
using (var context = new DynamoDBContext(client))
{
await context.SaveAsync(dbModel);
}
}
return(dbModel.Id);
}
private async Task SetupTableAsync()
{
CreateTableRequest request = new CreateTableRequest
{
TableName = this.TableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 2,
WriteCapacityUnits = 2
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
KeyType = KeyType.HASH,
AttributeName = "Id"
}
},
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = ScalarAttributeType.S
}
}
};
await this.DDBClient.CreateTableAsync(request);
var describeRequest = new DescribeTableRequest {
TableName = this.TableName
};
DescribeTableResponse response = null;
do
{
Thread.Sleep(1000);
response = await this.DDBClient.DescribeTableAsync(describeRequest);
} while (response.Table.TableStatus != TableStatus.ACTIVE);
}
