public override bool EnsureCreated([NotNull] IModel model)
{
Check.NotNull(model, "model");
var created = false;
foreach (var type in model.EntityTypes)
{
var request = new CreateTableRequest(new AtsTable(type.TableName()));
created |= _connection.ExecuteRequest(request);
}
return created;
}
public bool CreateTableAndReadyForUse(CreateTableRequest request)
{
var status = client.CreateTable(request).CreateTableResult.TableDescription.TableStatus;
var count = 0;
while (!status.Equals("ACTIVE", StringComparison.InvariantCultureIgnoreCase) && count < UpdateStatusRepeatCount)
{
Thread.Sleep(UpdateStatusRepeatTimeOut);
status = client.DescribeTable(new DescribeTableRequest { TableName = request.TableName }).DescribeTableResult.Table.TableStatus;
count++;
}
return (status.Equals("ACTIVE", StringComparison.InvariantCultureIgnoreCase));
}
private ExecutionContext CreateExecutionContext(EndpointDiscoveryTestClient client, AmazonDynamoDBConfig config, bool required, SortedDictionary <string, string> identifiers)
{
var request = new CreateTableRequest();
var options = new InvokeOptions();
options.RequestMarshaller = new CreateTableRequestMarshaller();
options.EndpointDiscoveryMarshaller = new TestEndpointDiscoveryMarshaller(required, identifiers);
client.SetOptionsEndpointOperation(options);
var credentials = new ImmutableCredentials(AWS_ACCESS_KEY_ID, "test", "test");
var executionContext = new ExecutionContext(
new RequestContext(true, new NullSigner())
{
ClientConfig = config,
Request = options.RequestMarshaller.Marshall(request),
ImmutableCredentials = credentials,
OriginalRequest = request,
Options = options
},
new ResponseContext()
);
return(executionContext);
}
private async Task CreateEventTable()
{
var slugIndex = new GlobalSecondaryIndex
{
IndexName = "ix_slug",
KeySchema = new List <KeySchemaElement>
{
{
new KeySchemaElement
{
AttributeName = "event_slug",
KeyType = "HASH" //Partition key
}
},
{
new KeySchemaElement
{
AttributeName = "event_time",
KeyType = "RANGE" //Sort key
}
}
},
Projection = new Projection
{
ProjectionType = ProjectionType.KEYS_ONLY
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
}
};
var processedIndex = new GlobalSecondaryIndex
{
IndexName = "ix_not_processed",
KeySchema = new List <KeySchemaElement>
{
{
new KeySchemaElement
{
AttributeName = "not_processed",
KeyType = "HASH" //Partition key
}
},
{
new KeySchemaElement
{
AttributeName = "event_time",
KeyType = "RANGE" //Sort key
}
}
},
Projection = new Projection
{
ProjectionType = ProjectionType.KEYS_ONLY
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
}
};
var createRequest = new CreateTableRequest($"{_tablePrefix}-{DynamoPersistenceProvider.EVENT_TABLE}", new List <KeySchemaElement>
{
new KeySchemaElement("id", KeyType.HASH)
})
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition("id", ScalarAttributeType.S),
new AttributeDefinition("not_processed", ScalarAttributeType.N),
new AttributeDefinition("event_slug", ScalarAttributeType.S),
new AttributeDefinition("event_time", ScalarAttributeType.N)
},
GlobalSecondaryIndexes = new List <GlobalSecondaryIndex>
{
slugIndex,
processedIndex
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
}
};
await CreateTable(createRequest);
}
public static void Main(string[] args)
{
// First, set up a DynamoDB client for DynamoDB Local
AmazonDynamoDBConfig ddbConfig = new AmazonDynamoDBConfig();
ddbConfig.ServiceURL = "http://localhost:8000";
AmazonDynamoDBClient client;
try
{
client = new AmazonDynamoDBClient(ddbConfig);
}
catch (Exception ex)
{
Console.WriteLine("\n Error: failed to create a DynamoDB client; " + ex.Message);
PauseForDebugWindow();
return;
}
// Build a 'CreateTableRequest' for the new table
CreateTableRequest createRequest = new CreateTableRequest
{
TableName = "Movies",
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "year",
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "title",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "year",
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "title",
KeyType = "RANGE"
}
},
};
// Provisioned-throughput settings are required even though
// the local test version of DynamoDB ignores them
createRequest.ProvisionedThroughput = new ProvisionedThroughput(1, 1);
// Using the DynamoDB client, make a synchronous CreateTable request
CreateTableResponse createResponse;
try
{
createResponse = client.CreateTable(createRequest);
}
catch (Exception ex)
{
Console.WriteLine("\n Error: failed to create the new table; " + ex.Message);
PauseForDebugWindow();
return;
}
// Report the status of the new table...
Console.WriteLine("\n\n Created the \"Movies\" table successfully!\n Status of the new table: '{0}'", createResponse.TableDescription.TableStatus);
}
private void PopulateRequestFromSchemaObject(TableSchema schemaObject, CreateTableRequest request)
{
if (!schemaObject.HasDefinedKeys)
{
ThrowArgumentError("Key schema not defined on input object.", Schema);
}
if (!schemaObject.HasDefinedAttributes)
{
ThrowArgumentError("Attribute schema containing keys not defined on input object.", Schema);
}
request.KeySchema = schemaObject.KeySchema;
request.AttributeDefinitions = schemaObject.AttributeSchema;
// optional
if (schemaObject.HasDefinedLocalSecondaryIndices)
{
// reconstruct each lsi so that the schema builder cmdlets can opt to not
// set the primary hash key element, thus enabling re-use on multiple
// table creation pipelines
var requestIndices = new List <LocalSecondaryIndex>();
foreach (var definedLSI in schemaObject.LocalSecondaryIndexSchema)
{
var lsi = new LocalSecondaryIndex
{
IndexName = definedLSI.IndexName,
KeySchema = new List <KeySchemaElement>()
};
var hashKey = definedLSI.KeySchema.FirstOrDefault(k => k.KeyType.Equals(KeyType.HASH));
if (hashKey == null)
{
hashKey = schemaObject.KeySchema.FirstOrDefault(k => k.KeyType.Equals(KeyType.HASH));
if (hashKey == null)
{
throw new ArgumentException(string.Format("Unable to determine primary hash key from supplied schema to use in local secondary index {0}", definedLSI.IndexName));
}
// DynamoDB requires the hash key be first in the collection
lsi.KeySchema.Add(hashKey);
lsi.KeySchema.AddRange(definedLSI.KeySchema);
}
else
{
// primary hash already set, possibly from earlier setup so just re-use
lsi.KeySchema.AddRange(definedLSI.KeySchema);
}
if (definedLSI.Projection != null)
{
lsi.Projection = new Projection
{
ProjectionType = definedLSI.Projection.ProjectionType,
NonKeyAttributes = definedLSI.Projection.NonKeyAttributes
};
}
requestIndices.Add(lsi);
}
request.LocalSecondaryIndexes = requestIndices;
}
// optional
if (schemaObject.HasDefinedGlobalSecondaryIndices)
{
// reconstruct each lsi so that the schema builder cmdlets can opt to not
// set the primary hash key element, thus enabling re-use on multiple
// table creation pipelines
var requestIndices = new List <GlobalSecondaryIndex>();
foreach (var definedGSI in schemaObject.GlobalSecondaryIndexSchema)
{
var gsi = new GlobalSecondaryIndex
{
IndexName = definedGSI.IndexName,
KeySchema = new List <KeySchemaElement>(),
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = definedGSI.ProvisionedThroughput.ReadCapacityUnits,
WriteCapacityUnits = definedGSI.ProvisionedThroughput.WriteCapacityUnits
}
};
var hashKey = definedGSI.KeySchema.FirstOrDefault(k => k.KeyType.Equals(KeyType.HASH));
if (hashKey == null)
{
hashKey = schemaObject.KeySchema.FirstOrDefault(k => k.KeyType.Equals(KeyType.HASH));
if (hashKey == null)
{
throw new ArgumentException(string.Format("Unable to determine primary hash key from supplied schema to use in global secondary index {0}", definedGSI.IndexName));
}
// DynamoDB requires the hash key be first in the collection
gsi.KeySchema.Add(hashKey);
gsi.KeySchema.AddRange(definedGSI.KeySchema);
}
else
{
// primary hash already set, possibly from earlier setup so just re-use
gsi.KeySchema.AddRange(definedGSI.KeySchema);
}
if (definedGSI.Projection != null)
{
gsi.Projection = new Projection
{
ProjectionType = definedGSI.Projection.ProjectionType,
NonKeyAttributes = definedGSI.Projection.NonKeyAttributes
};
}
requestIndices.Add(gsi);
}
request.GlobalSecondaryIndexes = requestIndices;
}
}
public async Task<CreateTableResponse> CreateTableAsync(string tableName, MetadataPreference? metadataPreference = null)
{
var request = new CreateTableRequest(_account, tableName, metadataPreference);
var response = await request.ExecuteAsync();
return response.Payload;
}
private static void CreateTable()
{
var createTableRequest =
new CreateTableRequest()
{
TableName = tableName,
ProvisionedThroughput =
new ProvisionedThroughput()
{
ReadCapacityUnits = (long)1,
WriteCapacityUnits = (long)1
}
};
var attributeDefinitions = new List <AttributeDefinition>()
{
// Attribute definitions for table primary key
{ new AttributeDefinition()
{
AttributeName = "CustomerId", AttributeType = "S"
} },
{ new AttributeDefinition()
{
AttributeName = "OrderId", AttributeType = "N"
} },
// Attribute definitions for index primary key
{ new AttributeDefinition()
{
AttributeName = "OrderCreationDate", AttributeType = "N"
} },
{ new AttributeDefinition()
{
AttributeName = "IsOpen", AttributeType = "N"
} }
};
createTableRequest.AttributeDefinitions = attributeDefinitions;
// Key schema for table
var tableKeySchema = new List <KeySchemaElement>()
{
{ new KeySchemaElement()
{
AttributeName = "CustomerId", KeyType = "HASH"
} }, //Partition key
{ new KeySchemaElement()
{
AttributeName = "OrderId", KeyType = "RANGE"
} } //Sort key
};
createTableRequest.KeySchema = tableKeySchema;
var localSecondaryIndexes = new List <LocalSecondaryIndex>();
// OrderCreationDateIndex
LocalSecondaryIndex orderCreationDateIndex = new LocalSecondaryIndex()
{
IndexName = "OrderCreationDateIndex"
};
// Key schema for OrderCreationDateIndex
var indexKeySchema = new List <KeySchemaElement>()
{
{ new KeySchemaElement()
{
AttributeName = "CustomerId", KeyType = "HASH"
} }, //Partition key
{ new KeySchemaElement()
{
AttributeName = "OrderCreationDate", KeyType = "RANGE"
} } //Sort key
};
orderCreationDateIndex.KeySchema = indexKeySchema;
// Projection (with list of projected attributes) for
// OrderCreationDateIndex
var projection = new Projection()
{
ProjectionType = "INCLUDE"
};
var nonKeyAttributes = new List <string>()
{
"ProductCategory",
"ProductName"
};
projection.NonKeyAttributes = nonKeyAttributes;
orderCreationDateIndex.Projection = projection;
localSecondaryIndexes.Add(orderCreationDateIndex);
// IsOpenIndex
LocalSecondaryIndex isOpenIndex
= new LocalSecondaryIndex()
{
IndexName = "IsOpenIndex"
};
// Key schema for IsOpenIndex
indexKeySchema = new List <KeySchemaElement>()
{
{ new KeySchemaElement()
{
AttributeName = "CustomerId", KeyType = "HASH"
} }, //Partition key
{ new KeySchemaElement()
{
AttributeName = "IsOpen", KeyType = "RANGE"
} } //Sort key
};
// Projection (all attributes) for IsOpenIndex
projection = new Projection()
{
ProjectionType = "ALL"
};
isOpenIndex.KeySchema = indexKeySchema;
isOpenIndex.Projection = projection;
localSecondaryIndexes.Add(isOpenIndex);
// Add index definitions to CreateTable request
createTableRequest.LocalSecondaryIndexes = localSecondaryIndexes;
Console.WriteLine("Creating table " + tableName + "...");
client.CreateTable(createTableRequest);
WaitUntilTableReady(tableName);
}
/// <summary>
/// Create a table async.
/// </summary>
/// <param name="request">The create table request.</param>
/// <returns>The async task.</returns>
public async Task <CreateTableResponse> CreateTableAsync(CreateTableRequest request)
{
return(await _client.CreateTableAsync(request));
}
/// <summary>
/// Build a table from a create table request
/// We filter out any attributes that are not B, S, or N because DynamoDB does not currently support
/// creation of these types via the API. As these are not used for hash or range keys they are not
/// required to store items in DynamoDB
/// </summary>
/// <param name="createTableRequest">The request to build tables from</param>
/// <param name="ct"></param>
/// <returns>The response to table creation</returns>
public async Task <CreateTableResponse> Build(CreateTableRequest createTableRequest, CancellationToken ct = default(CancellationToken))
{
var modifiedTableRequest = RemoveNonSchemaAttributes(createTableRequest);
return(await _client.CreateTableAsync(modifiedTableRequest, ct));
}
private void CreateLSITable()
{
#region CreateTable LSI Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define table schema:
// Table has a hash-key "Author" and a range-key "Title"
List <KeySchemaElement> schema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Author", KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Title", KeyType = "RANGE"
}
};
// Define local secondary indexes:
// Table has two indexes, one on "Year" and the other on "Setting"
List <LocalSecondaryIndex> indexes = new List <LocalSecondaryIndex>
{
new LocalSecondaryIndex
{
IndexName = "YearsIndex",
KeySchema = new List <KeySchemaElement>
{
// Hash key must match table hash key
new KeySchemaElement {
AttributeName = "Author", KeyType = "HASH"
},
// Secondary index on "Year" attribute
new KeySchemaElement {
AttributeName = "Year", KeyType = "RANGE"
}
},
// Projection type is set to ALL, all attributes returned for this index
Projection = new Projection
{
ProjectionType = "ALL"
}
},
new LocalSecondaryIndex
{
IndexName = "SettingsIndex",
KeySchema = new List <KeySchemaElement>
{
// Hash key must match table hash key
new KeySchemaElement {
AttributeName = "Author", KeyType = "HASH"
},
// Secondary index on "Setting" attribute
new KeySchemaElement {
AttributeName = "Setting", KeyType = "RANGE"
}
},
// Projection type is set to INCLUDE, the specified attributes + keys are returned
Projection = new Projection
{
ProjectionType = "INCLUDE",
NonKeyAttributes = new List <string>
{
"Pages", "Genres"
}
}
}
};
// Define key attributes:
// The key attributes "Author" and "Title" are string types.
// The local secondary index attributes are "Year" (numerical) and "Setting" (string).
List <AttributeDefinition> definitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Author", AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Title", AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Year", AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "Setting", AttributeType = "S"
}
};
// Define table throughput:
// Table has capacity of 20 reads and 50 writes
ProvisionedThroughput throughput = new ProvisionedThroughput
{
ReadCapacityUnits = 20,
WriteCapacityUnits = 50
};
// Configure the CreateTable request
CreateTableRequest request = new CreateTableRequest
{
TableName = "SampleTable",
KeySchema = schema,
ProvisionedThroughput = throughput,
AttributeDefinitions = definitions,
LocalSecondaryIndexes = indexes
};
// View new table properties
TableDescription tableDescription = client.CreateTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Creation time: {0}", tableDescription.CreationDateTime);
Console.WriteLine("Item count: {0}", tableDescription.ItemCount);
Console.WriteLine("Table size (bytes): {0}", tableDescription.TableSizeBytes);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
// List table key schema
List <KeySchemaElement> tableSchema = tableDescription.KeySchema;
for (int i = 0; i < tableSchema.Count; i++)
{
KeySchemaElement element = tableSchema[i];
Console.WriteLine("Key: Name = {0}, KeyType = {1}",
element.AttributeName, element.KeyType);
}
// List attribute definitions
List <AttributeDefinition> attributeDefinitions = tableDescription.AttributeDefinitions;
for (int i = 0; i < attributeDefinitions.Count; i++)
{
AttributeDefinition definition = attributeDefinitions[i];
Console.WriteLine("Attribute: Name = {0}, Type = {1}",
definition.AttributeName, definition.AttributeType);
}
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
public void DataPlaneSamples()
{
{
#region CreateTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define table schema:
// Table has a hash-key "Author" and a range-key "Title"
List <KeySchemaElement> schema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Author", KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Title", KeyType = "RANGE"
}
};
// Define key attributes:
// The key attributes "Author" and "Title" are string types
List <AttributeDefinition> definitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Author", AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Title", AttributeType = "S"
}
};
// Define table throughput:
// Table has capacity of 20 reads and 50 writes
ProvisionedThroughput throughput = new ProvisionedThroughput
{
ReadCapacityUnits = 20,
WriteCapacityUnits = 50
};
// Configure the CreateTable request
CreateTableRequest request = new CreateTableRequest
{
TableName = "SampleTable",
KeySchema = schema,
ProvisionedThroughput = throughput,
AttributeDefinitions = definitions
};
// View new table properties
TableDescription tableDescription = client.CreateTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Creation time: {0}", tableDescription.CreationDateTime);
Console.WriteLine("Item count: {0}", tableDescription.ItemCount);
Console.WriteLine("Table size (bytes): {0}", tableDescription.TableSizeBytes);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
// List table key schema
List <KeySchemaElement> tableSchema = tableDescription.KeySchema;
for (int i = 0; i < tableSchema.Count; i++)
{
KeySchemaElement element = tableSchema[i];
Console.WriteLine("Key: Name = {0}, KeyType = {1}",
element.AttributeName, element.KeyType);
}
// List attribute definitions
List <AttributeDefinition> attributeDefinitions = tableDescription.AttributeDefinitions;
for (int i = 0; i < attributeDefinitions.Count; i++)
{
AttributeDefinition definition = attributeDefinitions[i];
Console.WriteLine("Attribute: Name = {0}, Type = {1}",
definition.AttributeName, definition.AttributeType);
}
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
{
#region DescribeTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Create DescribeTable request
DescribeTableRequest request = new DescribeTableRequest
{
TableName = "SampleTable"
};
// Issue DescribeTable request and retrieve the table description
TableDescription tableDescription = client.DescribeTable(request).Table;
// View new table properties
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Creation time: {0}", tableDescription.CreationDateTime);
Console.WriteLine("Item count: {0}", tableDescription.ItemCount);
Console.WriteLine("Table size (bytes): {0}", tableDescription.TableSizeBytes);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
// List table key schema
List <KeySchemaElement> tableSchema = tableDescription.KeySchema;
for (int i = 0; i < tableSchema.Count; i++)
{
KeySchemaElement element = tableSchema[i];
Console.WriteLine("Key: Name = {0}, KeyType = {1}",
element.AttributeName, element.KeyType);
}
// List attribute definitions
List <AttributeDefinition> attributeDefinitions = tableDescription.AttributeDefinitions;
for (int i = 0; i < attributeDefinitions.Count; i++)
{
AttributeDefinition definition = attributeDefinitions[i];
Console.WriteLine("Attribute: Name = {0}, Type = {1}",
definition.AttributeName, definition.AttributeType);
}
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
{
#region ListTables Paging Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
string startTableName = null;
do
{
// Configure ListTables request with the marker value
ListTablesRequest request = new ListTablesRequest
{
ExclusiveStartTableName = startTableName,
};
// Issue call
ListTablesResult result = client.ListTables(request);
// List retrieved tables
List <string> tables = result.TableNames;
Console.WriteLine("Retrieved tables: {0}",
string.Join(", ", tables));
// Update marker value from the result
startTableName = result.LastEvaluatedTableName;
} while (!string.IsNullOrEmpty(startTableName)); // Test marker value
#endregion
}
{
#region ListTables NonPaging Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Issue call
ListTablesResult result = client.ListTables();
// List retrieved tables
List <string> tables = result.TableNames;
Console.WriteLine("Retrieved tables: {0}",
string.Join(", ", tables));
#endregion
}
TableUtils.WaitUntilTableActive("SampleTable", TestClient);
{
#region UpdateTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define new table throughput:
// Table will now have capacity of 40 reads and 50 writes
ProvisionedThroughput throughput = new ProvisionedThroughput
{
ReadCapacityUnits = 40,
WriteCapacityUnits = 50
};
// Compose the UpdateTable request
UpdateTableRequest request = new UpdateTableRequest
{
TableName = "SampleTable",
ProvisionedThroughput = throughput
};
// View new table properties
TableDescription tableDescription = client.UpdateTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Throughput: Reads = {0}, Writes = {1}",
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
#endregion
}
TableUtils.WaitUntilTableActive("SampleTable", TestClient);
{
#region DeleteTable Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Configure the DeleteTable request
DeleteTableRequest request = new DeleteTableRequest
{
TableName = "SampleTable"
};
// Issue DeleteTable request and retrieve the table description
TableDescription tableDescription = client.DeleteTable(request).TableDescription;
Console.WriteLine("Table name: {0}", tableDescription.TableName);
Console.WriteLine("Table status: {0}", tableDescription.TableStatus);
#endregion
}
}
public void Test6GlobalSeconaryIndex()
{
var tableName = "GameHistory";
DeleteTable(tableName);
var gsiSeaonalKeyPlayer = new GlobalSecondaryIndex {
IndexName = "SeasonalKeyPlayerIndex",
ProvisionedThroughput = new ProvisionedThroughput {
ReadCapacityUnits = 5,
WriteCapacityUnits = 1
},
Projection = new Projection {
ProjectionType = "ALL"
},
KeySchema = new List <KeySchemaElement> {
{ new KeySchemaElement {
AttributeName = "SeasonId", KeyType = "HASH"
} },
{ new KeySchemaElement {
AttributeName = "KeyPlayerId", KeyType = "RANGE"
} }
}
};
var createTableRequest = new CreateTableRequest {
TableName = tableName,
KeySchema = new List <KeySchemaElement> {
new KeySchemaElement("GameId", KeyType.HASH),
new KeySchemaElement("GameType", KeyType.RANGE)
},
AttributeDefinitions = new List <AttributeDefinition> {
new AttributeDefinition("GameId", ScalarAttributeType.N),
new AttributeDefinition("GameType", ScalarAttributeType.N),
new AttributeDefinition("SeasonId", ScalarAttributeType.N),
new AttributeDefinition("KeyPlayerId", ScalarAttributeType.N)
},
ProvisionedThroughput = new ProvisionedThroughput(1, 1),
GlobalSecondaryIndexes = { gsiSeaonalKeyPlayer }
};
var response = Client.CreateTable(createTableRequest);
Assert.AreEqual(response.HttpStatusCode, HttpStatusCode.OK);
var queryRequest = new QueryRequest {
TableName = tableName,
IndexName = gsiSeaonalKeyPlayer.IndexName,
KeyConditionExpression = "SeasonId = :season_id and KeyPlayerId = :player_id",
ExpressionAttributeValues = new Dictionary <string, AttributeValue> {
{ ":season_id", new AttributeValue {
N = "1"
} },
{ ":player_id", new AttributeValue {
N = "1234"
} }
},
ScanIndexForward = true
};
var queryResponse = Client.Query(queryRequest);
}
private Table CreateTable()
{
CreateTableRequest createRequest = new CreateTableRequest()
.WithTableName(this._tableName)
.WithKeySchema(new KeySchema()
.WithHashKeyElement(new KeySchemaElement()
.WithAttributeName(ATTRIBUTE_SESSION_ID)
.WithAttributeType("S")))
.WithProvisionedThroughput(new ProvisionedThroughput()
.WithReadCapacityUnits(this._initialReadUnits)
.WithWriteCapacityUnits(this._initialWriteUnits));
createRequest.BeforeRequestEvent += this.UserAgentRequestEventHandler;
CreateTableResponse response = this._ddbClient.CreateTable(createRequest);
DescribeTableRequest descRequest = new DescribeTableRequest()
.WithTableName(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.DescribeTableResult.Table.TableStatus;
if (string.Equals(tableStatus, ACTIVE_STATUS, StringComparison.InvariantCultureIgnoreCase))
isActive = true;
}
Table table = Table.LoadTable(this._ddbClient, this._tableName, Table.DynamoDBConsumer.SessionStateProvider);
return table;
}
public CreateTableResponse CreateTable(CreateTableRequest request)
{
return client.CreateTable(request);
}
public void TestAPIWithParameter(string apiName)
{
var tableName = TestContext.tableName;
var pkSchema = TestContext.pkSchema;
var reservedThroughput = TestContext.reservedThroughput;
var primaryKey = TestContext.primaryKey;
var attribute = TestContext.attribute;
var condition = TestContext.condition;
var startPrimaryKey = TestContext.startPrimaryKey;
var endPrimaryKey = TestContext.endPrimaryKey;
var putRowConsumed = TestContext.putRowConsumed;
var getRowConsumed = TestContext.getRowConsumed;
var updateRowConsumed = TestContext.updateRowConsumed;
var deleteRowConsumed = TestContext.deleteRowConsumed;
var getRangeConsumed = TestContext.getRangeConsumed;
var updateOfAttributeForPut = TestContext.updateOfAttributeForPut;
var updateOfAttributeForDelete = TestContext.updateOfAttributeForDelete;
var columnsToGet = TestContext.columnsToGet;
var limit = TestContext.limit;
var direction = TestContext.direction;
var tableMeta = new TableMeta(tableName, pkSchema);
switch (apiName)
{
case "CreateTable":
var request0 = new CreateTableRequest(tableMeta, reservedThroughput);
OTSClient.CreateTable(request0);
return;
case "ListTable":
var request1 = new ListTableRequest();
var response1 = OTSClient.ListTable(request1);
Assert.AreEqual(new List <string>()
{
tableName
}, response1.TableNames);
return;
case "UpdateTable":
var request2 = new UpdateTableRequest(tableName, reservedThroughput);
var response2 = OTSClient.UpdateTable(request2);
if (reservedThroughput.Read.HasValue && reservedThroughput.Write.HasValue)
{
AssertCapacityUnit(
reservedThroughput,
response2.ReservedThroughputDetails.CapacityUnit);
}
Assert.IsTrue(response2.ReservedThroughputDetails.LastDecreaseTime >= 0);
Assert.IsTrue(response2.ReservedThroughputDetails.LastIncreaseTime >= 0);
Assert.IsTrue(response2.ReservedThroughputDetails.NumberOfDecreasesToday >= 0);
return;
case "DeleteTable":
var request3 = new DeleteTableRequest(tableName);
OTSClient.DeleteTable(request3);
var request31 = new ListTableRequest();
var response31 = OTSClient.ListTable(request31);
Assert.AreEqual(new List <string>()
{
}, response31.TableNames);
return;
case "DescribeTable":
var request4 = new DescribeTableRequest(tableName);
var response4 = OTSClient.DescribeTable(request4);
Assert.AreEqual(tableName, response4.TableMeta.TableName);
AssertPrimaryKeySchema(pkSchema, response4.TableMeta.PrimaryKeySchema);
AssertCapacityUnit(reservedThroughput, response4.ReservedThroughputDetails.CapacityUnit);
Assert.IsTrue(response4.ReservedThroughputDetails.LastDecreaseTime >= 0);
Assert.IsTrue(response4.ReservedThroughputDetails.LastIncreaseTime >= 0);
Assert.IsTrue(response4.ReservedThroughputDetails.NumberOfDecreasesToday >= 0);
return;
case "PutRow":
var request5 = new PutRowRequest(tableName, condition, primaryKey, attribute);
var response5 = OTSClient.PutRow(request5);
AssertCapacityUnit(putRowConsumed, response5.ConsumedCapacityUnit);
return;
case "GetRow":
var request6 = new GetRowRequest(tableName, primaryKey, columnsToGet);
var response6 = OTSClient.GetRow(request6);
AssertPrimaryKey(primaryKey, response6.PrimaryKey, columnsToGet);
AssertAttribute(attribute, response6.Attribute, columnsToGet);
AssertCapacityUnit(getRowConsumed, response6.ConsumedCapacityUnit);
return;
case "DeleteRow":
var request7 = new DeleteRowRequest(tableName, condition, primaryKey);
var response7 = OTSClient.DeleteRow(request7);
AssertCapacityUnit(deleteRowConsumed, response7.ConsumedCapacityUnit);
var request71 = new GetRowRequest(tableName, primaryKey);
var response71 = OTSClient.GetRow(request71);
AssertPrimaryKey(new PrimaryKey(), response71.PrimaryKey);
AssertAttribute(new AttributeColumns(), response71.Attribute);
return;
case "UpdateRow_Put":
var request8 = new UpdateRowRequest(tableName, condition, primaryKey, updateOfAttributeForPut);
var response8 = OTSClient.UpdateRow(request8);
AssertCapacityUnit(updateRowConsumed, response8.ConsumedCapacityUnit);
var request81 = new GetRowRequest(tableName, primaryKey);
var response81 = OTSClient.GetRow(request81);
AssertPrimaryKey(primaryKey, response81.PrimaryKey);
AssertAttribute(attribute, response81.Attribute);
AssertCapacityUnit(getRowConsumed, response81.ConsumedCapacityUnit);
return;
case "UpdateRow_Delete":
var request9 = new UpdateRowRequest(tableName, condition, primaryKey, updateOfAttributeForDelete);
var response9 = OTSClient.UpdateRow(request9);
AssertCapacityUnit(deleteRowConsumed, response9.ConsumedCapacityUnit);
var request91 = new GetRowRequest(tableName, primaryKey);
var response91 = OTSClient.GetRow(request91);
// Don't assert primary key
AssertAttribute(new AttributeColumns(), response91.Attribute);
return;
case "BatchGetRow":
var request11 = new BatchGetRowRequest();
request11.Add(tableName, new List <PrimaryKey>()
{
primaryKey
}, columnsToGet);
var response11 = OTSClient.BatchGetRow(request11);
Assert.AreEqual(1, response11.RowDataGroupByTable.Count);
Assert.IsTrue(response11.RowDataGroupByTable.ContainsKey(tableName));
Assert.AreEqual(1, response11.RowDataGroupByTable[tableName].Count);
if (!response11.RowDataGroupByTable[tableName][0].IsOK)
{
throw new OTSServerException(apiName, HttpStatusCode.OK,
response11.RowDataGroupByTable[tableName][0].ErrorCode,
response11.RowDataGroupByTable[tableName][0].ErrorMessage);
}
AssertPrimaryKey(primaryKey, response11.RowDataGroupByTable[tableName][0].PrimaryKey);
AssertAttribute(attribute, response11.RowDataGroupByTable[tableName][0].Attribute);
AssertCapacityUnit(getRowConsumed, response11.RowDataGroupByTable[tableName][0].Consumed);
return;
case "BatchWriteRow_Put":
var request12 = new BatchWriteRowRequest();
var rowChanges = new RowChanges();
rowChanges.AddPut(condition, primaryKey, attribute);
request12.Add(tableName, rowChanges);
var response12 = OTSClient.BatchWriteRow(request12);
Assert.AreEqual(1, response12.TableRespones.Count);
Assert.IsTrue(response12.TableRespones.ContainsKey(tableName));
Assert.AreEqual(1, response12.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(0, response12.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(0, response12.TableRespones[tableName].DeleteResponses.Count);
if (response12.TableRespones[tableName].PutResponses[0].IsOK)
{
AssertCapacityUnit(putRowConsumed,
response12.TableRespones[tableName].PutResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response12.TableRespones[tableName].PutResponses[0].ErrorCode,
response12.TableRespones[tableName].PutResponses[0].ErrorMessage);
}
var request121 = new GetRowRequest(tableName, primaryKey);
var response121 = OTSClient.GetRow(request121);
AssertPrimaryKey(primaryKey, response121.PrimaryKey);
AssertAttribute(attribute, response121.Attribute);
AssertCapacityUnit(getRowConsumed, response121.ConsumedCapacityUnit);
return;
case "BatchWriteRow_Update":
var request13 = new BatchWriteRowRequest();
var rowChanges2 = new RowChanges();
rowChanges2.AddUpdate(condition, primaryKey, updateOfAttributeForPut);
request13.Add(tableName, rowChanges2);
var response13 = OTSClient.BatchWriteRow(request13);
Assert.AreEqual(1, response13.TableRespones.Count);
Assert.IsTrue(response13.TableRespones.ContainsKey(tableName));
Assert.AreEqual(0, response13.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(1, response13.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(0, response13.TableRespones[tableName].DeleteResponses.Count);
if (response13.TableRespones[tableName].UpdateResponses[0].IsOK)
{
AssertCapacityUnit(updateRowConsumed,
response13.TableRespones[tableName].UpdateResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response13.TableRespones[tableName].UpdateResponses[0].ErrorCode,
response13.TableRespones[tableName].UpdateResponses[0].ErrorMessage);
}
var request131 = new GetRowRequest(tableName, primaryKey);
var response131 = OTSClient.GetRow(request131);
AssertPrimaryKey(primaryKey, response131.PrimaryKey);
AssertAttribute(attribute, response131.Attribute);
AssertCapacityUnit(getRowConsumed, response131.ConsumedCapacityUnit);
return;
case "BatchWriteRow_Delete":
var request14 = new BatchWriteRowRequest();
var rowChanges3 = new RowChanges();
rowChanges3.AddDelete(condition, primaryKey);
request14.Add(tableName, rowChanges3);
var response14 = OTSClient.BatchWriteRow(request14);
Assert.AreEqual(1, response14.TableRespones.Count);
Assert.IsTrue(response14.TableRespones.ContainsKey(tableName));
Assert.AreEqual(0, response14.TableRespones[tableName].PutResponses.Count);
Assert.AreEqual(0, response14.TableRespones[tableName].UpdateResponses.Count);
Assert.AreEqual(1, response14.TableRespones[tableName].DeleteResponses.Count);
if (response14.TableRespones[tableName].DeleteResponses[0].IsOK)
{
AssertCapacityUnit(deleteRowConsumed,
response14.TableRespones[tableName].DeleteResponses[0].Consumed);
}
else
{
throw new OTSServerException("/BatchWriteRow", HttpStatusCode.OK,
response14.TableRespones[tableName].DeleteResponses[0].ErrorCode,
response14.TableRespones[tableName].DeleteResponses[0].ErrorMessage);
}
var request141 = new GetRowRequest(tableName, primaryKey);
var response141 = OTSClient.GetRow(request141);
AssertPrimaryKey(new PrimaryKey(), response141.PrimaryKey);
AssertAttribute(new AttributeColumns(), response141.Attribute);
return;
case "GetRange":
var request15 = new GetRangeRequest(tableName, direction,
startPrimaryKey, endPrimaryKey,
columnsToGet, limit);
var response15 = OTSClient.GetRange(request15);
Assert.AreEqual(1, response15.RowDataList.Count);
Assert.AreEqual(null, response15.NextPrimaryKey);
AssertCapacityUnit(getRangeConsumed, response15.ConsumedCapacityUnit);
AssertPrimaryKey(primaryKey, response15.RowDataList[0].PrimaryKey, columnsToGet);
AssertAttribute(attribute, response15.RowDataList[0].Attribute, columnsToGet);
return;
default:
throw new Exception(String.Format("invalid api name: {0}", apiName));
}
}
private async Task CreateTable()
{
_logger.LogInformation("Creating Table");
try
{
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "id",
AttributeType = ScalarAttributeType.S
},
new AttributeDefinition
{
AttributeName = "csvType",
AttributeType = ScalarAttributeType.S
},
new AttributeDefinition
{
AttributeName = "csvLocation",
AttributeType = ScalarAttributeType.S
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "id",
KeyType = KeyType.HASH
},
new KeySchemaElement
{
AttributeName = "csvType",
KeyType = KeyType.RANGE
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
},
TableName = _config.TableName,
GlobalSecondaryIndexes = new List <GlobalSecondaryIndex>
{
new GlobalSecondaryIndex
{
IndexName = "latest-result",
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement("csvLocation", KeyType.HASH),
new KeySchemaElement("csvType", KeyType.RANGE)
},
Projection = new Projection {
ProjectionType = ProjectionType.ALL
},
ProvisionedThroughput = new ProvisionedThroughput(5, 5)
}
}
};
var response = await _dynamoDb.CreateTableAsync(request);
await WaitUntilTableReady(_config.TableName);
}
catch (Exception e)
{
_logger.LogError(e, "Create table error");
}
}
public async Task <string> CreateTableAsync(
Type contextType, Type entityType, string tableName)
{
InputValidator.ThrowIfAnyNullOrWhitespace(entityType, tableName);
var dynamoDbTableAttribute = entityType.GetCustomAttribute <DynamoDBTableAttribute>(true);
tableName = dynamoDbTableAttribute?.TableName ?? tableName;
var hashKeyMember = entityType
.GetProperties()
.SingleOrDefault(pi => pi.GetCustomAttributes()
.Any(attr => attr.GetType() == typeof(DynamoDBHashKeyAttribute)));
var hashKeyMemberAttribute = entityType
.GetProperty(hashKeyMember?.Name ?? string.Empty)
?.GetCustomAttribute <DynamoDBHashKeyAttribute>(true);
var hashKeyMemberType = entityType
.GetProperty(hashKeyMember?.Name ?? string.Empty)
?.PropertyType;
var entityConfigRequired = hashKeyMember == null;
var entityConfig = this.entityConfigurationProvider
.TryGetEntityConfiguration(contextType, entityType);
if (entityConfigRequired && entityConfig == null)
{
throw new DynamoContextConfigurationException(string.Format(
ExceptionMessage.EntityConfigurationNotFound, entityType.FullName));
}
var hashKeyMemberName = entityConfig?.HashKeyMemberName
?? hashKeyMemberAttribute.AttributeName
?? hashKeyMember.Name;
var hashKeyMemberAttributeType = new ScalarAttributeType(
hashKeyMemberType != null
? Constants.AttributeTypesMap[hashKeyMemberType]
: Constants.AttributeTypesMap[entityConfig.HashKeyMemberType]);
var readCapacityUnits = entityConfig?.ReadCapacityUnits
?? Constants.DefaultReadCapacityUnits;
var writeCapacityUnits = entityConfig?.WriteCapacityUnits
?? Constants.DefaultWriteCapacityUnits;
var gsisConfiguration = (entityConfig?.Indexes?.Count ?? 0) > 0
? entityConfig.Indexes
: this.indexConfigurationFactory.CreateIndexConfigByAttributes(entityType);
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = this.attributeDefinitionFactory.CreateAttributeDefinitions(
hashKeyMemberName, hashKeyMemberAttributeType, gsisConfiguration).ToList(),
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement(hashKeyMemberName, KeyType.HASH)
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = readCapacityUnits,
WriteCapacityUnits = writeCapacityUnits
},
GlobalSecondaryIndexes = gsisConfiguration.Count() == 0
? null
: this.indexFactory.CreateRequestIndexes(gsisConfiguration).ToList()
};
try
{
var response = await this.client.CreateTableAsync(request);
if (!response.HttpStatusCode.IsSuccessful())
{
throw new CreateTableFailedException(
response.ResponseMetadata.Metadata.JoinByNewLine());
}
return(request.TableName);
}
catch (Exception ex)
{
throw new CreateTableFailedException("Failed to create a table.", ex);
}
}
public async Task TestSourceFunctionAsyncRSMapIssue()
{
// Invoke the lambda function and confirm the string was upper cased.
AmazonDynamoDBClient client = new AmazonDynamoDBClient(RegionEndpoint.USEast1);
List <KeySchemaElement> schema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "guid", KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Data", KeyType = "RANGE"
}
};
// Define key attributes:
// The key attributes "Author" and "Title" are string types
List <AttributeDefinition> definitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "guid", AttributeType = "S"
},
new AttributeDefinition
{
AttributeName = "Data", AttributeType = "S"
}
};
// Define table throughput:
// Table has capacity of 20 reads and 50 writes
ProvisionedThroughput throughput = new ProvisionedThroughput
{
ReadCapacityUnits = 20,
WriteCapacityUnits = 50
};
// Configure the CreateTable request
CreateTableRequest request = new CreateTableRequest
{
TableName = "MDSSourceDynamoDBTestDat1",
KeySchema = schema,
ProvisionedThroughput = throughput,
AttributeDefinitions = definitions
};
// View new table properties
var tableDescription = await client.CreateTableAsync(request);
Console.WriteLine("Table name: {0}", tableDescription.TableDescription.TableName);
Console.WriteLine("Creation time: {0}", tableDescription.TableDescription.CreationDateTime);
Console.WriteLine("Item count: {0}", tableDescription.TableDescription.ItemCount);
Console.WriteLine("Table size (bytes): {0}", tableDescription.TableDescription.TableSizeBytes);
Console.WriteLine("Table status: {0}", tableDescription.TableDescription.TableStatus);
//dbList.Add()
Table Catolog = Table.LoadTable(client, tableDescription.TableDescription.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 client.DescribeTableAsync(new DescribeTableRequest
{
TableName = "MDSSourceDynamoDBTestDat1"
});
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");
Console.WriteLine("\n*** listing tables ***");
IAmazonS3 s3Client = new AmazonS3Client(RegionEndpoint.USEast1);
string inputData = "#BUSINESS_DATE|CURRENCY|CREDIT_TYPE|RATINGS|TODAY|DAY_1|DAYS_7|DAYS_30|DAYS_90|DAYS_365|YEARS_2|YEARS_3|LOAD_DATE\n20190828|USD|CORPS|AAA|17.506131099768|17.499652220154|17.689977433049|17.612596564917|17.531741482981|16.721663421274|22.812501511208|28.591981044712|08/29/2019";
var destinationBucketName = "spgmi-dest-buck-test";
var bucketName = "spgi-mds-data-dev-test2".ToLower();
var key = "MDR_EQUITY_PDR_ZSCORE_INCR_20191217032542.txt";
// Create a bucket an object to setup a test data.
await s3Client.PutBucketAsync(destinationBucketName);
try
{
await s3Client.PutObjectAsync(new PutObjectRequest
{
BucketName = bucketName,
Key = key,
ContentBody = inputData
});
// Setup the S3 event object that S3 notifications would create with the fields used by the Lambda function.
var s3Event = new S3Event
{
Records = new List <S3EventNotification.S3EventNotificationRecord>
{
new S3EventNotification.S3EventNotificationRecord
{
S3 = new S3EventNotification.S3Entity
{
Bucket = new S3EventNotification.S3BucketEntity {
Name = bucketName
},
Object = new S3EventNotification.S3ObjectEntity {
Key = key
}
}
}
}
};
var context = new TestLambdaContext();
// Invoke the lambda function and confirm the content type was returned.
var function = new Function(s3Client);
var contentType = await function.FunctionHandler(s3Event, context);
Assert.Equal("text/plain", contentType);
}
catch (Exception ex)
{
}
}
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
}
};
CreateTableResponse response = this._ddbClient.CreateTable(createRequest);
DescribeTableRequest descRequest = new DescribeTableRequest
{
TableName = this._tableName
};
// 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;
}
}
if (!string.IsNullOrEmpty(this._ttlAttributeName))
{
this._ddbClient.UpdateTimeToLive(new UpdateTimeToLiveRequest
{
TableName = this._tableName,
TimeToLiveSpecification = new TimeToLiveSpecification
{
AttributeName = this._ttlAttributeName,
Enabled = true
}
});
}
var tableConfig = CreateTableConfig();
Table table = Table.LoadTable(this._ddbClient, tableConfig);
return(table);
}
/// <summary>
/// Create a table async.
/// </summary>
/// <param name="request">The create table request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The async task.</returns>
public async Task <CreateTableResponse> CreateTableAsync(CreateTableRequest request, CancellationToken cancellationToken)
{
return(await _client.CreateTableAsync(request, cancellationToken));
}
public void CreateTable(AmazonDynamoDBClient client)
{
var postTableCreateRequest = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = nameof(MovieEntity.DirectorId),
AttributeType = ScalarAttributeType.S
},
new AttributeDefinition
{
AttributeName = nameof(MovieEntity.CreateDate),
AttributeType = ScalarAttributeType.S
},
new AttributeDefinition()
{
AttributeName = nameof(MovieEntity.MovieId),
AttributeType = ScalarAttributeType.S
}
},
TableName = "Movies",
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement()
{
AttributeName = nameof(MovieEntity.DirectorId),
KeyType = KeyType.HASH
},
new KeySchemaElement()
{
AttributeName = nameof(MovieEntity.CreateDate),
KeyType = KeyType.RANGE
}
},
GlobalSecondaryIndexes = new List <GlobalSecondaryIndex>
{
new GlobalSecondaryIndex
{
Projection = new Projection
{
ProjectionType = ProjectionType.ALL
},
IndexName = Constants.MoiveTableMovieIdGsi,
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = nameof(MovieEntity.MovieId),
KeyType = KeyType.HASH
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 5
}
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 6
},
};
CreateTableResponse result = client.CreateTableAsync(postTableCreateRequest).GetAwaiter().GetResult();
}
public CreateTableResponse CreateTable(string tableName, MetadataPreference? metadataPreference = null)
{
var request = new CreateTableRequest(_account, tableName, metadataPreference);
var response = request.Execute();
return response.Payload;
}
void CreateTableForType_(Type type)
{
_table = new CreateTableRequestBuilder()
.BuildFrom(type, "test_");
}
// Creates tables and it's key schema elements
public static void CreateTables()
{
// Create Widget table if not exist
List <string> currentTables = _client.ListTables().TableNames;
if (!currentTables.Contains(_tableNameWidget))
{
// Create table request
var request = new CreateTableRequest
{
TableName = _tableNameWidget,
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = KeyType.HASH
}
},
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = ScalarAttributeType.S
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
};
// Create the table
var response = _client.CreateTable(request);
}
// Create WidgetType table if not exist
if (!currentTables.Contains(_tableNameWidgetType))
{
// Create table request
var request = new CreateTableRequest
{
TableName = _tableNameWidgetType,
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = KeyType.HASH
}
},
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = ScalarAttributeType.S
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
};
// Create the table
var response = _client.CreateTable(request);
}
}
public static async Task CreateTableIfNotExistsAndWaitForTableToBecomeAvailable(this IAmazonDynamoDB client, CreateTableRequest createTableRequest)
{
TableDescription table = null;
try
{
DescribeTableRequest descRequest = new DescribeTableRequest()
{
TableName = createTableRequest.TableName
};
table = (await client.DescribeTableAsync(descRequest)).Table;
}
catch (AmazonServiceException ase)
{
if (!ase.ErrorCode.Equals("ResourceNotFoundException", StringComparison.InvariantCultureIgnoreCase))
{
throw ase;
}
}
// We are all done if it exists already
if (table != null && table.TableStatus == TableStatus.ACTIVE)
{
return;
}
if (table == null)
{
table = (await client.CreateTableAsync(createTableRequest)).TableDescription;
}
if (table.TableStatus != TableStatus.ACTIVE)
{
await client.WaitForTableToBecomeAvailable(createTableRequest.TableName);
}
}
public AmazonAnnotationPackageProvider()
{
var accessKeyId = ConfigurationManager.AppSettings["accessKeyId"];
var secretAccessKey = ConfigurationManager.AppSettings["secretAccessKey"];
this._bucketName = ConfigurationManager.AppSettings["bucketName"]?.ToLower();
this._extractionFolder = ConfigurationManager.AppSettings["extractionFolder"];
this._dbTableName = ConfigurationManager.AppSettings["dbTableName"];
var s3ServiceUrl = ConfigurationManager.AppSettings["s3ServiceUrl"];
var dynamoDbServiceUrl = ConfigurationManager.AppSettings["dynamoDbServiceUrl"];
if (string.IsNullOrEmpty(accessKeyId))
{
throw new ConfigurationErrorsException("The accessKeyId has not been configured. Please set it in the App.config");
}
if (string.IsNullOrEmpty(secretAccessKey))
{
throw new ConfigurationErrorsException("The secretAccessKey has not been configured. Please set it in the App.config");
}
if (string.IsNullOrEmpty(this._bucketName))
{
throw new ConfigurationErrorsException("The bucketName has not been configured. Please set it in the App.config");
}
if (string.IsNullOrEmpty(s3ServiceUrl) || string.IsNullOrEmpty(dynamoDbServiceUrl))
{
this._s3Client = new AmazonS3Client(accessKeyId, secretAccessKey, RegionEndpoint.USEast1);
this._dynamoDbClient = new AmazonDynamoDBClient(accessKeyId, secretAccessKey, RegionEndpoint.USEast1);
}
else
{
var s3Config = new AmazonS3Config
{
ServiceURL = s3ServiceUrl,
ForcePathStyle = true
};
var dbConfig = new AmazonDynamoDBConfig
{
ServiceURL = dynamoDbServiceUrl
};
this._s3Client = new AmazonS3Client(accessKeyId, secretAccessKey, s3Config);
this._dynamoDbClient = new AmazonDynamoDBClient(accessKeyId, secretAccessKey, dbConfig);
if (!this._s3Client.DoesS3BucketExist(this._bucketName))
{
this._s3Client.PutBucket(this._bucketName);
}
var createTableRequest = new CreateTableRequest
{
TableName = this._dbTableName,
AttributeDefinitions = new List <AttributeDefinition>(),
KeySchema = new List <KeySchemaElement>(),
GlobalSecondaryIndexes = new List <GlobalSecondaryIndex>(),
LocalSecondaryIndexes = new List <LocalSecondaryIndex>(),
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
}
};
createTableRequest.KeySchema = new[]
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = KeyType.HASH,
},
}.ToList();
createTableRequest.AttributeDefinitions = new[]
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = ScalarAttributeType.S,
}
}.ToList();
var tokenSource = new CancellationTokenSource();
var token = tokenSource.Token;
tokenSource.CancelAfter(10000);
var tables = this._dynamoDbClient.ListTablesAsync(token).GetAwaiter().GetResult();
if (!tables.TableNames.Contains(this._dbTableName))
{
this._dynamoDbClient.CreateTableAsync(createTableRequest).GetAwaiter().GetResult();
}
}
this._packagesToDownload = new Queue <AnnotationPackage>();
}
private async Task TryCreateTables()
{
try
{
await _dynamo.DeleteTableAsync(new DeleteTableRequest { TableName = "Animals" });
var response = await _dynamo.DescribeTableAsync(new DescribeTableRequest
{
TableName = "Animals"
});
}
catch (ResourceNotFoundException)
{
var request = new CreateTableRequest
{
TableName = "Animals",
AttributeDefinitions = new List <AttributeDefinition>
{
new AttributeDefinition
{
AttributeName = "Id",
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "Genus",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Id",
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "Genus",
KeyType = "RANGE"
},
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
},
GlobalSecondaryIndexes = new List <GlobalSecondaryIndex>
{
new GlobalSecondaryIndex
{
IndexName = "Animals_ByGenus",
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = "Genus",
KeyType = "HASH"
}
},
Projection = new Projection
{
ProjectionType = ProjectionType.ALL
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 10,
WriteCapacityUnits = 5
}
}
}
};
await _dynamo.CreateTableAsync(request);
var items = new[]
{
new Dictionary <string, AttributeValue>
{
{ "Id", new AttributeValue {
N = "1"
} },
{ "Genus", new AttributeValue {
S = "Microcarbo"
} },
{ "Family", new AttributeValue {
S = "Phalacrocoracidae"
} },
{ "Order", new AttributeValue {
S = "Suliformes"
} },
{ "Class", new AttributeValue {
S = "Aves"
} },
{ "CommonNames", new AttributeValue {
SS = new List <string> {
"Little cormorant", "Javanese Cormorant"
}
} },
{ "ScientificName", new AttributeValue {
S = "Microcarbo niger"
} },
}
};
foreach (var item in items)
{
await _dynamo.PutItemAsync("Animals", item);
}
}
}
public static CreateTableResponse CreateTable(this IAmazonDynamoDB client, CreateTableRequest request)
{
return(client.CreateTableAsync(request).GetResult());
}
private static void CreateTable()
{
// Attribute definitions
var attributeDefinitions = new List <AttributeDefinition>()
{
{ new AttributeDefinition {
AttributeName = "IssueId", AttributeType = "S"
} },
{ new AttributeDefinition {
AttributeName = "Title", AttributeType = "S"
} },
{ new AttributeDefinition {
AttributeName = "CreateDate", AttributeType = "S"
} },
{ new AttributeDefinition {
AttributeName = "DueDate", AttributeType = "S"
} }
};
// Key schema for table
var tableKeySchema = new List <KeySchemaElement>()
{
{
new KeySchemaElement {
AttributeName = "IssueId",
KeyType = "HASH" //Partition key
}
},
{
new KeySchemaElement {
AttributeName = "Title",
KeyType = "RANGE" //Sort key
}
}
};
// Initial provisioned throughput settings for the indexes
var ptIndex = new ProvisionedThroughput
{
ReadCapacityUnits = 1L,
WriteCapacityUnits = 1L
};
// CreateDateIndex
var createDateIndex = new GlobalSecondaryIndex()
{
IndexName = "CreateDateIndex",
ProvisionedThroughput = ptIndex,
KeySchema =
{
new KeySchemaElement {
AttributeName = "CreateDate", KeyType = "HASH" //Partition key
},
new KeySchemaElement {
AttributeName = "IssueId", KeyType = "RANGE" //Sort key
}
},
Projection = new Projection
{
ProjectionType = "INCLUDE",
NonKeyAttributes =
{
"Description", "Status"
}
}
};
// TitleIndex
var titleIndex = new GlobalSecondaryIndex()
{
IndexName = "TitleIndex",
ProvisionedThroughput = ptIndex,
KeySchema =
{
new KeySchemaElement {
AttributeName = "Title", KeyType = "HASH" //Partition key
},
new KeySchemaElement {
AttributeName = "IssueId", KeyType = "RANGE" //Sort key
}
},
Projection = new Projection
{
ProjectionType = "KEYS_ONLY"
}
};
// DueDateIndex
var dueDateIndex = new GlobalSecondaryIndex()
{
IndexName = "DueDateIndex",
ProvisionedThroughput = ptIndex,
KeySchema =
{
new KeySchemaElement {
AttributeName = "DueDate",
KeyType = "HASH" //Partition key
}
},
Projection = new Projection
{
ProjectionType = "ALL"
}
};
var createTableRequest = new CreateTableRequest
{
TableName = tableName,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = (long)1,
WriteCapacityUnits = (long)1
},
AttributeDefinitions = attributeDefinitions,
KeySchema = tableKeySchema,
GlobalSecondaryIndexes =
{
createDateIndex, titleIndex, dueDateIndex
}
};
Console.WriteLine("Creating table " + tableName + "...");
client.CreateTable(createTableRequest);
WaitUntilTableReady(tableName);
}
/// <summary>
/// Create table if it doesn't exist.
/// Sample code from https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LowLevelDotNetTableOperationsExample.html
/// </summary>
/// <param name="client"></param>
/// <param name="tabelName"></param>
/// <param name="primaryKey"></param>
/// <param name="sortKey"></param>
/// <returns></returns>
internal static async Task <string> SetupTable(AmazonDynamoDBClient client, string tabelName, string primaryKey, string sortKey = null)
{
Console.WriteLine("\n*** Creating table ***");
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = primaryKey,
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>
{
new KeySchemaElement
{
AttributeName = primaryKey,
KeyType = "HASH" //Partition key
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 5,
WriteCapacityUnits = 6
},
TableName = tabelName
};
if (!string.IsNullOrWhiteSpace(sortKey))
{
request.AttributeDefinitions.Add(new AttributeDefinition()
{
AttributeName = sortKey,
AttributeType = "S"
});
request.KeySchema.Add(new KeySchemaElement()
{
AttributeName = sortKey,
KeyType = "RANGE" // Sort Key
});
}
try
{
var response = await client.CreateTableAsync(request);
var tableDescription = response.TableDescription;
Console.WriteLine("{1}: {0} \t ReadsPerSec: {2} \t WritesPerSec: {3}",
tableDescription.TableStatus,
tableDescription.TableName,
tableDescription.ProvisionedThroughput.ReadCapacityUnits,
tableDescription.ProvisionedThroughput.WriteCapacityUnits);
string status = tableDescription.TableStatus;
Console.WriteLine(tabelName + " - " + status);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(tabelName);
}
/// <summary>
/// Build a table from a create table request
/// </summary>
/// <param name="createTableRequest">The request to build tables from</param>
/// <param name="ct"></param>
/// <returns>The response to table creation</returns>
public async Task <CreateTableResponse> Build(CreateTableRequest createTableRequest, CancellationToken ct = default(CancellationToken))
{
return(await _client.CreateTableAsync(createTableRequest, ct));
}
private async Task CreateTable(string tableName, List <KeySchemaElement> keys, List <AttributeDefinition> attributes, List <GlobalSecondaryIndex> secondaryIndexes = null, string ttlAttributeName = null)
{
var useProvisionedThroughput = readCapacityUnits > 0 && writeCapacityUnits > 0;
var request = new CreateTableRequest
{
TableName = tableName,
AttributeDefinitions = attributes,
KeySchema = keys,
BillingMode = useProvisionedThroughput ? BillingMode.PROVISIONED : BillingMode.PAY_PER_REQUEST,
ProvisionedThroughput = useProvisionedThroughput ? new ProvisionedThroughput
{
ReadCapacityUnits = readCapacityUnits,
WriteCapacityUnits = writeCapacityUnits
} : null
};
if (secondaryIndexes != null && secondaryIndexes.Count > 0)
{
if (useProvisionedThroughput)
{
var indexThroughput = new ProvisionedThroughput {
ReadCapacityUnits = readCapacityUnits, WriteCapacityUnits = writeCapacityUnits
};
secondaryIndexes.ForEach(i =>
{
i.ProvisionedThroughput = indexThroughput;
});
}
request.GlobalSecondaryIndexes = secondaryIndexes;
}
try
{
var response = await ddbClient.CreateTableAsync(request);
TableDescription description = null;
do
{
description = await GetTableDescription(tableName);
await Task.Delay(2000);
} while (description.TableStatus == TableStatus.CREATING);
if (!string.IsNullOrEmpty(ttlAttributeName))
{
await ddbClient.UpdateTimeToLiveAsync(new UpdateTimeToLiveRequest
{
TableName = tableName,
TimeToLiveSpecification = new TimeToLiveSpecification {
AttributeName = ttlAttributeName, Enabled = true
}
});
}
if (description.TableStatus != TableStatus.ACTIVE)
{
throw new InvalidOperationException($"Failure creating table {tableName}");
}
}
catch (Exception exc)
{
Logger.Error(ErrorCode.StorageProviderBase, $"Could not create table {tableName}", exc);
throw;
}
}
public async Task CreateTable()
{
var request = new CreateTableRequest
{
AttributeDefinitions = new List <AttributeDefinition>()
{
new AttributeDefinition
{
AttributeName = "UserId",
AttributeType = "N"
},
new AttributeDefinition
{
AttributeName = "MovieName",
AttributeType = "S"
}
},
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "UserId",
KeyType = "HASH"
},
new KeySchemaElement
{
AttributeName = "MovieName",
KeyType = "RANGE"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
},
TableName = "MovieRank",
GlobalSecondaryIndexes = new List <GlobalSecondaryIndex>
{
new GlobalSecondaryIndex {
IndexName = "MovieName-index",
KeySchema = new List <KeySchemaElement>()
{
new KeySchemaElement
{
AttributeName = "MovieName",
KeyType = "HASH"
}
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = 1,
WriteCapacityUnits = 1
},
Projection = new Projection
{
ProjectionType = "ALL"
}
}
}
};
var response = await DynamoDBClient.CreateTableAsync(request);
await WaitUntilTableActive(request.TableName);
}
/*--------------------------------------------------------------------------
* CreatingTable_async
*--------------------------------------------------------------------------*/
public async Task CreatingTable_async(CreateTableRequest request)
{
Task <bool> newTbl = CreateNewTable_async(request);
await newTbl;
}
protected virtual CreateTableRequest ToCreateTableRequest(DynamoMetadataType table)
{
var props = table.Type.GetSerializableProperties();
if (props.Length == 0)
{
throw new NotSupportedException($"{table.Name} does not have any serializable properties");
}
var keySchema = new List <KeySchemaElement> {
new KeySchemaElement(table.HashKey.Name, KeyType.HASH),
};
var attrDefinitions = new List <AttributeDefinition> {
new AttributeDefinition(table.HashKey.Name, table.HashKey.DbType),
};
if (table.RangeKey != null)
{
keySchema.Add(new KeySchemaElement(table.RangeKey.Name, KeyType.RANGE));
attrDefinitions.Add(new AttributeDefinition(table.RangeKey.Name, table.RangeKey.DbType));
}
var to = new CreateTableRequest
{
TableName = table.Name,
KeySchema = keySchema,
AttributeDefinitions = attrDefinitions,
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = table.ReadCapacityUnits ?? ReadCapacityUnits,
WriteCapacityUnits = table.WriteCapacityUnits ?? WriteCapacityUnits,
}
};
if (!table.LocalIndexes.IsEmpty())
{
to.LocalSecondaryIndexes = table.LocalIndexes.Map(x => new LocalSecondaryIndex
{
IndexName = x.Name,
KeySchema = x.ToKeySchemas(),
Projection = new Projection
{
ProjectionType = x.ProjectionType,
NonKeyAttributes = x.ProjectedFields.Safe().ToList(),
},
});
table.LocalIndexes.Each(x =>
{
if (x.RangeKey != null && attrDefinitions.All(a => a.AttributeName != x.RangeKey.Name))
{
attrDefinitions.Add(new AttributeDefinition(x.RangeKey.Name, x.RangeKey.DbType));
}
});
}
if (!table.GlobalIndexes.IsEmpty())
{
to.GlobalSecondaryIndexes = table.GlobalIndexes.Map(x => new GlobalSecondaryIndex
{
IndexName = x.Name,
KeySchema = x.ToKeySchemas(),
Projection = new Projection
{
ProjectionType = x.ProjectionType,
NonKeyAttributes = x.ProjectedFields.Safe().ToList(),
},
ProvisionedThroughput = new ProvisionedThroughput
{
ReadCapacityUnits = x.ReadCapacityUnits ?? ReadCapacityUnits,
WriteCapacityUnits = x.WriteCapacityUnits ?? WriteCapacityUnits,
}
});
table.GlobalIndexes.Each(x =>
{
if (x.HashKey != null && attrDefinitions.All(a => a.AttributeName != x.HashKey.Name))
{
attrDefinitions.Add(new AttributeDefinition(x.HashKey.Name, x.HashKey.DbType));
}
if (x.RangeKey != null && attrDefinitions.All(a => a.AttributeName != x.RangeKey.Name))
{
attrDefinitions.Add(new AttributeDefinition(x.RangeKey.Name, x.RangeKey.DbType));
}
});
}
return(to);
}
