private void CreateUserTable()
{
Console.WriteLine("Creating Table");
tableName = "User";
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "UserName",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "UserName",
KeyType = "HASH" // Partition Key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
},
TableName = tableName
};
var response = _dynamoDbClient.CreateTableAsync(request);
WaitUntilTableReady(tableName);
}
public async Task Initialize(bool createTables = false, ProvisionedThroughput provisionedThroughput = null, StreamSpecification streamSpecification = null)
{
if (createTables)
{
Table table = _dynamoDBContext.GetTargetTable <TReadModel>();
var createTableRequest = new CreateTableRequest()
{
ProvisionedThroughput = provisionedThroughput,
TableName = table.TableName,
LocalSecondaryIndexes = table.LocalSecondaryIndexes
.Select(kv => new LocalSecondaryIndex()
{
KeySchema = kv.Value.KeySchema,
IndexName = kv.Value.IndexName,
Projection = kv.Value.Projection
}).ToList(),
GlobalSecondaryIndexes = table.GlobalSecondaryIndexes.Select(kv => new GlobalSecondaryIndex()
{
KeySchema = kv.Value.KeySchema,
Projection = kv.Value.Projection,
IndexName = kv.Value.IndexName,
ProvisionedThroughput = new ProvisionedThroughput(kv.Value.ProvisionedThroughput.ReadCapacityUnits, kv.Value.ProvisionedThroughput.WriteCapacityUnits)
}).ToList(),
AttributeDefinitions = table.Attributes,
StreamSpecification = streamSpecification,
KeySchema = table.Keys.Select(kv => new KeySchemaElement(kv.Key, kv.Value.IsHash ? KeyType.HASH : KeyType.RANGE)).ToList()
};
await _dynamoDBClient.CreateTableAsync(createTableRequest).ConfigureAwait(false);
}
}
public async Task InitializeGameTable()
{
var tables = (await _client.ListTablesAsync()).TableNames;
if (!tables.Contains("Games"))
{
var request = new CreateTableRequest
{
TableName = "Games",
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "GameId",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "GameId",
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
}
};
await _client.CreateTableAsync(request);
}
}
private async Task CreateTableAsync()
{
try
{
await _client.CreateTableAsync(new CreateTableRequest
{
TableName = _settings.TableName,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeType = ScalarAttributeType.S,
AttributeName = ColumnNames.ResourceId
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
KeyType = KeyType.HASH,
AttributeName = ColumnNames.ResourceId
}
},
BillingMode = BillingMode.PAY_PER_REQUEST
});
// need to wait a bit since the table has just been created
await Task.Delay(TimeSpan.FromSeconds(10));
}
catch (ResourceInUseException)
{
// ignore, already exists
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
await Policy.Handle <Exception>(exception =>
{
_logger.LogError(exception, "Failed to create Dynamo table");
return(true);
}).WaitAndRetryForeverAsync(i => TimeSpan.FromSeconds(5)).ExecuteAsync(async() => {
_logger.LogInformation("Creating Dynamo table");
return(await _dynamo.CreateTableAsync("Payments",
new List <KeySchemaElement> {
new KeySchemaElement {
AttributeName = "PaymentId", KeyType = KeyType.HASH
}
},
new List <AttributeDefinition> {
new AttributeDefinition {
AttributeName = "PaymentId", AttributeType = ScalarAttributeType.S
}
},
new ProvisionedThroughput {
ReadCapacityUnits = 5, WriteCapacityUnits = 5
},
cancellationToken));
});
}
//Create Table if it does not exists
private async Task CreateTable(IAmazonDynamoDB amazonDynamoDBclient, string tableName)
{
//Write Log to Cloud Watch using LambdaLogger.Log Method
LambdaLogger.Log(string.Format("Creating {0} Table", tableName));
var tableCollection = await amazonDynamoDBclient.ListTablesAsync();
if (!tableCollection.TableNames.Contains(tableName))
{
await amazonDynamoDBclient.CreateTableAsync(new CreateTableRequest
{
TableName = tableName,
KeySchema = new List <KeySchemaElement> {
{ new KeySchemaElement {
AttributeName = "Username", KeyType = KeyType.HASH
} }
},
AttributeDefinitions = new List <AttributeDefinition> {
new AttributeDefinition {
AttributeName = "Username", AttributeType = "S"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
},
});
}
}
private async Task <bool> SetUpTable()
{
var createRequest = new CreateTableRequest
{
TableName = Constants.UserTableName,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "id",
AttributeType = "N"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "id",
KeyType = "HASH" //Partition key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 3,
WriteCapacityUnits = 3
}
};
await _amazonDynamoDB.CreateTableAsync(createRequest);
return(true);
}
public async Task CreateDynamoTable(string tableName)
{
//Might want to do a check to wait for the table to be created before passing back a response
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
}
},
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
}
};
await _dynamoDbClient.CreateTableAsync(request);
}
/// <summary>
/// Creates tables that don't exist, with LocalIndexes and GlobalIndexes when found
/// </summary>
/// <param name="assembly">The assembly that contains DynamoDb entities</param>
/// <returns></returns>
public async Task <StringBuilder> CreateTablesAsync(Assembly assembly)
{
StringBuilder oSb = new StringBuilder();
var currentTables = await _oDynamoDBClient.ListTablesAsync();
var tableNames = currentTables.TableNames;
var types = GetTypesWithDynamoTableAttribute(assembly);
var tablePrefix = _dynamoConfig.TablePrefix;
var requests = ReturnCreateTableRequests(types, tablePrefix, tableNames);
List <Task <CreateTableResponse> > createTableTasks = new List <Task <CreateTableResponse> >();
foreach (var reqCreateTable in requests)
{
createTableTasks.Add(_oDynamoDBClient.CreateTableAsync(reqCreateTable));
}
await Task.WhenAll(createTableTasks.ToArray());
var createdTableNames = createTableTasks.Select(t => t.Result.TableDescription.TableName);
// tables aren't created instantly
await WaitUntilTableReadyAsync(createdTableNames.ToArray());
foreach (var kv in createdTableNames)
{
oSb.AppendLine($"{kv}");
}
return(oSb);
}
private void CreateTempTable()
{
Console.WriteLine("Creating table");
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
},
TableName = "testTemp"
};
var response = _client.CreateTableAsync(request);
waitUntileTableRead("testTemp");
}
public DynamoDbGlobalTableTest(DynamoDBContainerFixture dynamoDbContainerFixture, ConfigFixture configFixture)
{
hostName = dynamoDbContainerFixture.HostName;
this.configFixture = configFixture;
// Use AWS SDK to create client and initialize table
AmazonDynamoDBConfig amazonDynamoDbConfig = new AmazonDynamoDBConfig
{
ServiceURL = dynamoDbContainerFixture.ServiceUrl,
AuthenticationRegion = "us-west-2",
};
tempDynamoDbClient = new AmazonDynamoDBClient(amazonDynamoDbConfig);
CreateTableRequest request = new CreateTableRequest
{
TableName = DefaultTableName,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition(PartitionKey, ScalarAttributeType.S),
new AttributeDefinition(SortKey, ScalarAttributeType.N),
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement(PartitionKey, KeyType.HASH),
new KeySchemaElement(SortKey, KeyType.RANGE),
},
ProvisionedThroughput = new ProvisionedThroughput(1L, 1L),
};
tempDynamoDbClient.CreateTableAsync(request).Wait();
}
private async Task CreateDeliveryTable()
{
_logger.LogInformation($"Creating new DynamoDb table {Constants.DynamoDb.DeliveryTableName}");
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = nameof(DeliveryRecord.DeliveryId),
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = Constants.DynamoDb.DeliveryTablePartitionKey,
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput()
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 10
},
TableName = Constants.DynamoDb.DeliveryTableName
};
await _dynamoDbClient.CreateTableAsync(request);
}
public async Task CreateDynamoDbTable(string tableName)
{
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
}
},
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
}
};
await _dynamoDbClient.CreateTableAsync(request);
}
private Amazon.DynamoDBv2.Model.CreateTableResponse CallAWSServiceOperation(IAmazonDynamoDB client, Amazon.DynamoDBv2.Model.CreateTableRequest request)
{
Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon DynamoDB", "CreateTable");
try
{
#if DESKTOP
return(client.CreateTable(request));
#elif CORECLR
return(client.CreateTableAsync(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 Task CreateTableAsync(
string tableName,
IReadOnlyList <KeySchemaElement> keySchema,
IReadOnlyList <AttributeDefinition> attributes,
ProvisionedThroughput provisionedThroughput)
{
if (string.IsNullOrWhiteSpace(tableName))
{
throw new ArgumentException("Table name is required.", nameof(tableName));
}
return(createTableAsync());
async Task createTableAsync()
{
if (!await IsExistingTableAsync(tableName))
{
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = attributes.ToList(),
KeySchema = keySchema.ToList(),
ProvisionedThroughput = provisionedThroughput
};
await _dynamoDb.CreateTableAsync(request);
}
}
}
private async Task CreateTable()
{
var createTableRequest = new CreateTableRequest
{
TableName = ShortLink.TableName,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = nameof(ShortLink.Key),
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = nameof(ShortLink.Key),
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput(5, 5)
};
await _dynamoDbClient.CreateTableAsync(createTableRequest);
}
private async Task <CreateTableResponse> CreateTableIfNotExists(List <string> existingTables, string tableName)
{
if (!existingTables.Contains(tableName))
{
var createRequest = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH" //Partition key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
},
};
return(await amazonDynamoDb.CreateTableAsync(createRequest));
}
return(null);
}
public static async Task <DescribeTableResponse> CreateTableForum(IAmazonDynamoDB client)
{
string tableName = "Forum";
var response = await client.CreateTableAsync(new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Name",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Name", // forum Title
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});
var result = await WaitTillTableCreated(client, tableName, response);
return(result);
}
private async Task CreateTable()
{
var createRequest = new CreateTableRequest(_tableName, new List <KeySchemaElement>()
{
new KeySchemaElement("id", KeyType.HASH)
})
{
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition("id", ScalarAttributeType.S)
},
BillingMode = BillingMode.PAY_PER_REQUEST
};
var createResponse = await _client.CreateTableAsync(createRequest);
int i = 0;
bool created = false;
while ((i < 20) && (!created))
{
try
{
await Task.Delay(1000);
var poll = await _client.DescribeTableAsync(_tableName);
created = (poll.Table.TableStatus == TableStatus.ACTIVE);
i++;
}
catch (ResourceNotFoundException)
{
}
}
}
public async Task <IActionResult> Create([FromBody] CreateTableRequest request)
{
Console.WriteLine("Request Info:");
Console.WriteLine("\tTableName:");
Console.WriteLine($"\t{request.TableName}");
if (request.ProvisionedThroughput != null)
{
Console.WriteLine("\tReadCapacityUnits:");
Console.WriteLine($"\t{request.ProvisionedThroughput.ReadCapacityUnits}");
Console.WriteLine("\tWriteCapacityUnits:");
Console.WriteLine($"\t{request.ProvisionedThroughput.WriteCapacityUnits}");
}
if (request.KeySchema != null)
{
System.Console.WriteLine("\tKeySchemas:");
foreach (var k in request.KeySchema)
{
Console.WriteLine("\tAttributeName");
Console.WriteLine($"\t{k.AttributeName}");
Console.WriteLine("\tKeyType");
Console.WriteLine($"\t{k.KeyType}");
}
}
try
{
var res = await _dynamoClient.CreateTableAsync(request);
Console.WriteLine("Created table");
System.Console.WriteLine("\tTableName");
System.Console.WriteLine($"\t{res.TableDescription.TableName}");
System.Console.WriteLine("\tTableArn");
System.Console.WriteLine($"\t{res.TableDescription.TableArn}");
System.Console.WriteLine("\tTableId");
System.Console.WriteLine($"\t{res.TableDescription.TableId}");
System.Console.WriteLine("\tTableStatus");
System.Console.WriteLine($"\t{res.TableDescription.TableStatus}");
return(new JsonResult(
new
{
message = $"Creating new table: {res.TableDescription.TableName}",
TableDescription = res.TableDescription
})
{
StatusCode = 202
});
}
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 <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);
}
/// <summary>
/// Creates a table in dynamodb.
/// </summary>
/// <param name="tableName">The name of the table to create.</param>
/// <param name="tableThroughput">Initial provisioned throughput settings for the table.</param>
/// <param name="indexThroughput">Initial provisioned throughput settings for the indexes.</param>
public async void CreateTable(
string tableName,
ProvisionedThroughput tableThroughput,
ProvisionedThroughput indexThroughput)
{
_logger.LogInformation("Starting CreateTable using table name {TableName}.", tableName);
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH"
}
},
ProvisionedThroughput = tableThroughput
};
try
{
var response = await _amazonDynamoDB.CreateTableAsync(request);
var tableDescription = response.TableDescription;
_logger.LogInformation("{TableStatus}: {TableName} \t ReadsPerSec: {ReadCapacityUnits} \t WritesPerSec: {WriteCapacityUnits}",
tableDescription.TableStatus,
tableDescription.TableName,
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
string status = tableDescription.TableStatus;
_logger.LogInformation("{TableName} - {Status}", tableName, status);
if (status != "ACTIVE")
{
//Await for table to be created
WaitUntilTableReady(tableName);
}
}
catch (ResourceInUseException rx)
{
_logger.LogInformation("The table has already been created. {Message}", rx.Message);
}
catch (Exception ex)
{
_logger.LogError("There was a fatal error when provisioning dynamodb. {Exception}", ex);
//throw exception and kill the service.
throw ex;
}
}
private async Task CreateIfNotExist(CreateTableRequest request, string tableName)
{
if (await TableExist(tableName))
{
return;
}
await _dynamoDb.CreateTableAsync(request);
}
static async Task <CreateTableResponse> MakeTableAsync(IAmazonDynamoDB client, string table)
{
var response = await client.CreateTableAsync(new CreateTableRequest
{
TableName = table,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "ID",
AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Area",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "ID",
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Area",
KeyType = "RANGE"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
});
// Wait for table to be created
bool ready = false;
int wait = 1; // Milliseconds to wait
while (!ready)
{
Thread.Sleep(wait);
var resp = await client.DescribeTableAsync(new DescribeTableRequest
{
TableName = table
});
ready = (resp.Table.TableStatus == TableStatus.ACTIVE);
wait *= 2;
}
return(response);
}
public void CreateTable(string tableName, string templatePath, string logicalName)
{
var createTableReq = TemplateParser.GetDynamoDbTable(templatePath, logicalName);
createTableReq.TableName = tableName;
var tableTask = dynamoDbClient.CreateTableAsync(createTableReq);
tableTask.Wait();
WaitUntilTableIsActive(tableName);
}
private static async Task CreateTable(IAmazonDynamoDB client, CancellationToken token)
{
CreateTableRequest request = new CreateTableRequest()
{
TableName = MyTableName,
AttributeDefinitions =
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "Movie",
AttributeType = "S"
}
},
KeySchema =
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH" // Partition Key
},
new KeySchemaElement
{
AttributeName = "Movie",
KeyType = "Range" // Sort Key
}
},
BillingMode = BillingMode.PAY_PER_REQUEST
};
await client.CreateTableAsync(request, token);
DescribeTableResponse response;
do
{
Thread.Sleep(1000);
Console.WriteLine($"Creating table {MyTableName}...");
response = await client.DescribeTableAsync(MyTableName, token);
} while (response.Table.TableStatus == TableStatus.CREATING);
if (response.Table.TableStatus == TableStatus.ACTIVE)
{
Console.WriteLine($"\nTable {MyTableName} was successfully created.");
}
Console.WriteLine("\nPress any key to continue...\n");
Console.ReadKey();
}
/// <summary>
/// Helper function to create a testing table
/// </summary>
/// <returns></returns>
private async Task SetupTableAsync()
{
var listTablesResponse = await _dynamoDbClient.ListTablesAsync(new ListTablesRequest());
var existingTestTable =
listTablesResponse.TableNames.FindAll(s => s.StartsWith(TablePrefix)).FirstOrDefault();
if (existingTestTable == null)
{
_tableName = TablePrefix + DateTime.Now.Ticks;
CreateTableRequest request = new CreateTableRequest
{
TableName = _tableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 2,
WriteCapacityUnits = 2
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "IncidentId"
}
},
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "IncidentId",
AttributeType = ScalarAttributeType.S
}
}
};
await _dynamoDbClient.CreateTableAsync(request);
var describeRequest = new DescribeTableRequest {
TableName = _tableName
};
DescribeTableResponse response;
do
{
Thread.Sleep(1000);
response = await _dynamoDbClient.DescribeTableAsync(describeRequest);
} while (response.Table.TableStatus != TableStatus.ACTIVE);
}
else
{
Console.WriteLine($"Using existing test table {existingTestTable}");
_tableName = existingTestTable;
}
}
public async Task Initialise()
{
var request = new ListTablesRequest
{
Limit = 10
};
var response = await _amazonDynamoDb.ListTablesAsync(request);
var results = response.TableNames;
if (!results.Contains(PendingRequestsTableName))
{
var createRequest = new CreateTableRequest
{
TableName = PendingRequestsTableName,
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "ApplicationId",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "ApplicationId",
KeyType = "HASH" //Partition key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 2,
WriteCapacityUnits = 2
}
};
await _amazonDynamoDb.CreateTableAsync(createRequest);
}
}
public async Task CreateOwnerTable()
{
try
{
var tableName = "Owners";
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "OwnerId",
AttributeType = "N"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "OwnerId",
KeyType = "HASH" // Partition Key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
},
TableName = tableName
};
DynamoDbClient.CreateTableAsync(request);
WaitUntilTableReady(tableName);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// Creates the Recipes table, if it does not already exist.
/// </summary>
/// <returns>True if there's a good table to use, false otherwise.</returns>
public static async Task <bool> EnsureTableExists(IAmazonDynamoDB client)
{
Console.WriteLine($"Dynamo URL is {client.Config.ServiceURL}");
Console.WriteLine($"Dynamo RegionName is {client.Config.RegionEndpointServiceName}");
var request = new ListTablesRequest {
Limit = 10
};
var response = await client.ListTablesAsync(request);
if (!response.TableNames.Contains("Recipe"))
{
var createRequest = new CreateTableRequest
{
TableName = "Recipe",
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "UserId",
AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "RecipeId",
AttributeType = "N"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "UserId",
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "RecipeId",
KeyType = "RANGE"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
}
};
var created = await client.CreateTableAsync(createRequest);
return(created.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
return(true); // It already existed.
}
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;
}
