internal DescribeTableResponse DescribeTable(DescribeTableRequest request)
{
var marshaller = new DescribeTableRequestMarshaller();
var unmarshaller = DescribeTableResponseUnmarshaller.Instance;
return(Invoke <DescribeTableRequest, DescribeTableResponse>(request, marshaller, unmarshaller));
}
public TableDescription GetTableInformation(string tableName)
{
Console.WriteLine("\n*** Retrieving table information ***");
var request = new DescribeTableRequest
{
TableName = tableName
};
try
{
var response = client.DescribeTable(request);
TableDescription description = response.Table;
/*Console.WriteLine("Name: {0}", description.TableName);
* Console.WriteLine("# of items: {0}", description.ItemCount);
* Console.WriteLine("Provision Throughput (reads/sec): {0}",
* description.ProvisionedThroughput.ReadCapacityUnits);
* Console.WriteLine("Provision Throughput (writes/sec): {0}",
* description.ProvisionedThroughput.WriteCapacityUnits);*/
return(description);
}
catch (ResourceNotFoundException ex)
{
throw ex;
}
}
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 async Task <List <DataCollectionMetrics> > GetDataCollectionMetricsAsync(DataContainer container)
{
using (var client = new DynamoDBClientBuilder(container.ConnectionString).GetClient()) {
var tables = await client.GetTables().ConfigureAwait(false);
var metrics = new List <DataCollectionMetrics>();
foreach (var table in tables)
{
var request = new DescribeTableRequest(table);
var response = await client.DescribeTableAsync(request).ConfigureAwait(false);
var tbl = response.Table;
metrics.Add(new DataCollectionMetrics
{
Name = tbl.TableName,
UsedSpaceKB = tbl.TableSizeBytes / 1000,
TotalSpaceKB = tbl.TableSizeBytes / 1000,
RowCount = tbl.ItemCount,
});
}
return(metrics);
}
}
private void GetTableDetails(AmazonDynamoDBClient client)
{
resultText.text += ("\n*** Retrieving table information ***\n");
var request = new DescribeTableRequest
{
TableName = @"speedmath_scores"
};
client.DescribeTableAsync(request, (result) =>
{
if (result.Exception != null)
{
resultText.text += result.Exception.Message;
Debug.Log(result.Exception);
return;
}
var response = result.Response;
TableDescription description = response.Table;
resultText.text += ("Name: " + description.TableName + "\n");
resultText.text += ("# of items: " + description.ItemCount + "\n");
resultText.text += ("Provision Throughput (reads/sec): " +
description.ProvisionedThroughput.ReadCapacityUnits + "\n");
resultText.text += ("Provision Throughput (reads/sec): " +
description.ProvisionedThroughput.WriteCapacityUnits + "\n");
}, null);
}
protected async Task WaitForTableToCompleteAsync(string datePrefix = "")
{
bool busy = true;
var tableNameWithPrefixs = TablePrefix + datePrefix + TableName;
int counter = 0;
do
{
var request = new DescribeTableRequest
{
TableName = tableNameWithPrefixs
};
var response = await Client.DescribeTableAsync(request);
busy = (response.Table.TableStatus != TableStatus.ACTIVE);
if (busy)
{
Thread.Sleep(1000);
counter++;
if (counter > 600)
{
throw new TimeoutException("DynamoDB table busy for longer than expected");
}
}
} while (busy);
}
public async Task SetupTable()
{
if (!(IsAccessKeySet && IsSecretKeySet && IsRegionNameSet && IsTableNameSet))
{
throw new InvalidOperationException("Not configured yet.");
}
SetupGeoDataManager();
var config = _geoDataManager.GeoDataManagerConfiguration;
var dtr = new DescribeTableRequest()
{
TableName = config.TableName
};
Task t = Task.FromResult(false);
try
{
await config.DynamoDBClient.DescribeTableAsync(dtr);
if (Status == Status.NotStarted)
{
Status = Status.Ready;
}
}
catch (ResourceNotFoundException e)
{
t = StartLoadData();
}
await t;
}
/// <summary>
/// <para>Returns information about the table, including the current status of the table, when it was created, the primary key schema, and any
/// indexes on the table.</para>
/// </summary>
///
/// <param name="describeTableRequest">Container for the necessary parameters to execute the DescribeTable service method on
/// AmazonDynamoDBv2.</param>
///
/// <returns>The response from the DescribeTable service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="T:Amazon.DynamoDBv2.Model.ResourceNotFoundException" />
/// <exception cref="T:Amazon.DynamoDBv2.Model.InternalServerErrorException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task <DescribeTableResponse> DescribeTableAsync(DescribeTableRequest describeTableRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DescribeTableRequestMarshaller();
var unmarshaller = DescribeTableResponseUnmarshaller.GetInstance();
return(Invoke <IRequest, DescribeTableRequest, DescribeTableResponse>(describeTableRequest, marshaller, unmarshaller, signer, cancellationToken));
}
public async Task <IActionResult> Get(string tableName)
{
Console.WriteLine("*** Retrieving table information ***");
Console.WriteLine($"Searching for table: {tableName}");
DescribeTableRequest req = new DescribeTableRequest();
req.TableName = tableName;
try
{
var res = await _dynamoClient.DescribeTableAsync(req);
var description = res.Table;
Console.WriteLine($"Name: {description.TableName}");
Console.WriteLine($"# of items: {description.ItemCount}");
Console.WriteLine($"Provision Throughput (reads/sec): {description.ProvisionedThroughput.ReadCapacityUnits}");
Console.WriteLine($"Provision Throughput (writes/sec): {description.ProvisionedThroughput.WriteCapacityUnits}");
return(Ok(res.Table));
}
catch (AmazonDynamoDBException addbe)
{
return(AmazonExceptionHandlers.HandleAmazonDynamoDBException(addbe));
}
catch (AmazonServiceException ase)
{
AmazonExceptionHandlers.HandleAmazonServiceExceptionException(ase);
}
catch (AmazonClientException ace)
{
AmazonExceptionHandlers.HandleAmazonClientExceptionException(ace);
}
return(StatusCode(500));
}
public async Task <IActionResult> GetTableStatus(string tableName)
{
Console.WriteLine("*** Retrieving table status information ***");
Console.WriteLine($"Searching for table status: {tableName}");
DescribeTableRequest req = new DescribeTableRequest();
req.TableName = tableName;
try
{
var res = await _dynamoClient.DescribeTableAsync(req);
var description = res.Table.TableStatus;
return(Ok(description));
}
catch (AmazonDynamoDBException addbe)
{
return(AmazonExceptionHandlers.HandleAmazonDynamoDBException(addbe));
}
catch (AmazonServiceException ase)
{
AmazonExceptionHandlers.HandleAmazonServiceExceptionException(ase);
}
catch (AmazonClientException ace)
{
AmazonExceptionHandlers.HandleAmazonClientExceptionException(ace);
}
return(StatusCode(500));
}
// Use this for initialization
void Start()
{
// Load all sprites in the Kenney.nl resource folder.
allSprites = Resources.LoadAll <Sprite>("Kenney.nl");
selectedHair = selectedHairImage.overrideSprite.name;
selectedFace = selectedFaceImage.overrideSprite.name;
selectedBody = selectedBodyImage.overrideSprite.name;
selectedShirt = selectedShirtImage.overrideSprite.name;
selectedPants = selectedPantsImage.overrideSprite.name;
selectedShoes = selectedShoesImage.overrideSprite.name;
// Setup our credentials which will use our Cognito identity pool to hand us short-term session credentials,
// giving us access to what we have provided access to with our IAM role policies, in this case, access to our
// DynamoDB table.
credentials = new CognitoAWSCredentials(cognitoIdentityPoolString, RegionEndpoint.USEast1);
credentials.GetIdentityIdAsync(delegate(AmazonCognitoIdentityResult <string> result)
{
if (result.Exception != null)
{
Debug.LogError("exception hit: " + result.Exception.Message);
}
// Create a DynamoDB client, passing in our credentials from Cognito.
var ddbClient = new AmazonDynamoDBClient(credentials, RegionEndpoint.USEast1);
resultText.text += ("\n*** Retrieving table information ***\n");
// Create a DescribeTableRequest to get information about our table, and ensure we can access it.
var request = new DescribeTableRequest
{
TableName = @"CharacterCreator"
};
ddbClient.DescribeTableAsync(request, (ddbresult) =>
{
if (result.Exception != null)
{
resultText.text += result.Exception.Message;
Debug.Log(result.Exception);
return;
}
var response = ddbresult.Response;
// Debug information
TableDescription description = response.Table;
resultText.text += ("Name: " + description.TableName + "\n");
resultText.text += ("# of items: " + description.ItemCount + "\n");
resultText.text += ("Provision Throughput (reads/sec): " + description.ProvisionedThroughput.ReadCapacityUnits + "\n");
resultText.text += ("Provision Throughput (reads/sec): " + description.ProvisionedThroughput.WriteCapacityUnits + "\n");
}, null);
// Set our _client field to the dynamoDB client.
_client = ddbClient;
// Fetch any stored characters from the DB
FetchAllCharactersFromAWS();
});
}
private async Task <long> GetItemsCount(string tableName, AmazonDynamoDBClient client)
{
var request = new DescribeTableRequest(tableName);
var response = await client.DescribeTableAsync(request).ConfigureAwait(false);
return(response.Table.ItemCount);
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeTable operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeTable operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <DescribeTableResponse> DescribeTableAsync(DescribeTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new DescribeTableRequestMarshaller();
var unmarshaller = DescribeTableResponseUnmarshaller.Instance;
return(InvokeAsync <DescribeTableRequest, DescribeTableResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
internal static async Task <DescribeTableResponse> Build(string tableName, AmazonDynamoDBClient dynamodbClient)
{
DescribeTableRequest describeTableRequest = new DescribeTableRequest()
{
TableName = tableName
};
return(await dynamodbClient.DescribeTableAsync(describeTableRequest));
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeTable operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the DescribeTable operation on AmazonRedshiftDataAPIServiceClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDescribeTable
/// operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/redshift-data-2019-12-20/DescribeTable">REST API Reference for DescribeTable Operation</seealso>
public virtual IAsyncResult BeginDescribeTable(DescribeTableRequest request, AsyncCallback callback, object state)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTableResponseUnmarshaller.Instance;
return(BeginInvoke(request, options, callback, state));
}
/// <summary>
/// Describes the detailed information about a table from metadata in the cluster. The
/// information includes its columns. A token is returned to page through the column list.
/// Depending on the authorization method, use one of the following combinations of request
/// parameters:
///
/// <ul> <li>
/// <para>
/// AWS Secrets Manager - specify the Amazon Resource Name (ARN) of the secret and the
/// cluster identifier that matches the cluster in the secret.
/// </para>
/// </li> <li>
/// <para>
/// Temporary credentials - specify the cluster identifier, the database name, and the
/// database user name. Permission to call the <code>redshift:GetClusterCredentials</code>
/// operation is required to use this method.
/// </para>
/// </li> </ul>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DescribeTable service method.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the DescribeTable service method, as returned by RedshiftDataAPIService.</returns>
/// <exception cref="Amazon.RedshiftDataAPIService.Model.InternalServerException">
/// The Amazon Redshift Data API operation failed due to invalid input.
/// </exception>
/// <exception cref="Amazon.RedshiftDataAPIService.Model.ValidationException">
/// The Amazon Redshift Data API operation failed due to invalid input.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/redshift-data-2019-12-20/DescribeTable">REST API Reference for DescribeTable Operation</seealso>
public virtual Task <DescribeTableResponse> DescribeTableAsync(DescribeTableRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTableResponseUnmarshaller.Instance;
return(InvokeAsync <DescribeTableResponse>(request, options, cancellationToken));
}
/// <summary>
/// GetTableDescriptionAsync will get a Table's description from DynamoDb
/// </summary>
/// <param name="tableName"></param>
/// <returns>A Task of type DescribeTableResponse</returns>
public virtual async Task <DescribeTableResponse> GetTableDescriptionAsync(string tableName)
{
var request = new DescribeTableRequest
{
TableName = tableName
};
return(await _client.DescribeTableAsync(request).ConfigureAwait(false));
}
internal virtual DescribeTableResponse DescribeTable(DescribeTableRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = DescribeTableRequestMarshaller.Instance;
options.ResponseUnmarshaller = DescribeTableResponseUnmarshaller.Instance;
return(Invoke <DescribeTableResponse>(request, options));
}
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 void DescribeTableTest()
{
CreateTable();
var otsClient = OTSClient;
var request = new DescribeTableRequest(TestTableName);
var response = otsClient.DescribeTable(request);
Assert.AreEqual(response.TableMeta.TableName, TestTableName);
DeleteTable();
}
/// <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 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.");
//}
}
/// <summary>
/// Returns information about the <paramref name="table"/>, including the current status of the <paramref name="table"/>, when it was created, the primary key schema, and any indexes on the <paramref name="table"/> as an asynchronous operation.
/// </summary>
/// <param name="table">The name of the table to describe.</param>
/// <param name="setup">The <see cref="AsyncOptions" /> which need to be configured.</param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <DescribeTableResponse> DescribeAsync(string table, Action <AsyncOptions> setup = null)
{
DynamoValidator.ThrowIfTableNameIsNotValid(table);
var options = setup.ConfigureOptions();
var dtr = new DescribeTableRequest()
{
TableName = table
};
return(Client.DescribeTableAsync(dtr, options.CancellationToken));
}
public void DescribeTable()
{
DescribeTableRequest request = new DescribeTableRequest {
TableName = TableName
};
var response = client.DescribeTable(request);
if (response.HttpStatusCode.IsSuccess())
{
Console.WriteLine($"TableArn: {response.Table.TableArn}");
}
}
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);
}
internal DescribeTableResponse DescribeTable(DescribeTableRequest request)
{
var task = DescribeTableAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
/// <summary>
/// Initiates the asynchronous execution of the DescribeTable operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB"/>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the DescribeTable operation.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
/// <returns>void</returns>
public void DescribeTableAsync(DescribeTableRequest request, AmazonServiceCallback callback, object state)
{
if (!AmazonInitializer.IsInitialized)
{
throw new Exception("AWSPrefab is not added to the scene");
}
ThreadPool.QueueUserWorkItem(new WaitCallback(delegate
{
var marshaller = new DescribeTableRequestMarshaller();
var unmarshaller = DescribeTableResponseUnmarshaller.Instance;
Invoke(request, callback, state, marshaller, unmarshaller, signer);
}));
return;
}
public Task <DescribeTableResponse> DescribeTableAsync(DescribeTableRequest request, CancellationToken cancellationToken = default)
{
Guard.ArgumentNotNull(request, "request can not be null");
try
{
AmazonDynamoDBClient client = GetAmazonDynamoDbClient();
var result = client.DescribeTableAsync(request);
return(result);
}
catch (AmazonDynamoDBException ex)
{
throw ex;
}
}
private async Task WaitForTableToBeReady()
{
var config = _geoDataManager.GeoDataManagerConfiguration;
var dtr = new DescribeTableRequest {
TableName = config.TableName
};
var result = await config.DynamoDBClient.DescribeTableAsync(dtr);
while (result.Table.TableStatus != TableStatus.ACTIVE)
{
await Task.Delay(2000);
result = await config.DynamoDBClient.DescribeTableAsync(dtr);
}
}
/// <summary>
/// 查询单个表的详细信息。
/// </summary>
/// <param name="req"><see cref="DescribeTableRequest"/></param>
/// <returns><see cref="DescribeTableResponse"/></returns>
public DescribeTableResponse DescribeTableSync(DescribeTableRequest req)
{
JsonResponseModel <DescribeTableResponse> rsp = null;
try
{
var strResp = this.InternalRequestSync(req, "DescribeTable");
rsp = JsonConvert.DeserializeObject <JsonResponseModel <DescribeTableResponse> >(strResp);
}
catch (JsonSerializationException e)
{
throw new TencentCloudSDKException(e.Message);
}
return(rsp.Response);
}
public DescribeTableResponse GetDescriptionTable(DescribeTableRequest request)
{
return client.DescribeTable(request);
}
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;
}
