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 GlobalSecondaryIndexDescription(string indexArn, string indexName, long indexSizeBytes, long itemCount, IReadOnlyList <KeySchemaElement> keySchema, Projection projection, bool backfilling, IndexStatus indexStatus, ProvisionedThroughputDescription provisionedThroughput) : base(indexArn, indexName, indexSizeBytes, itemCount, keySchema, projection) { Backfilling = backfilling; IndexStatus = indexStatus; ProvisionedThroughput = provisionedThroughput; }
public ModifiedThroughput(string table_name, string index_name, ProvisionedThroughputDescription current_provisioned_throughput) { this.table_name = table_name; this.index_name = index_name; this.current_provisioned_throughput = current_provisioned_throughput; this.new_provisioned_throughput = null; this.throughput_modification_results = new List <ThroughputModificationResult>(); }
protected override bool IsBlockedOut(ProvisionedThroughputDescription current_provisioned_throughput) { bool is_blocked_out = false; DateTime utc_now = DateTime.UtcNow; is_blocked_out = this.blockout_time_frames.Any(blockout_time_frame => utc_now >= blockout_time_frame.Item1 && utc_now < blockout_time_frame.Item2); return(is_blocked_out); }
public IncreaseDecreaseResult GetNewDecreaseCombinationModifierCapacityUnits(ProvisionedThroughputDescription current_provisioned_throughput) { IncreaseDecreaseResult decrease_combination_modifier_result = null; if (decrease != null && (decrease_combination_modifier.measurement_units > 0 || decrease_combination_modifier.measurement_percentage > 0)) { Decrease combination_decrease = new Decrease(decrease, decrease_combination_modifier); decrease_combination_modifier_result = combination_decrease.ApplyRule(consumed_capacity_units, current_capacity_units, current_provisioned_throughput); } return(decrease_combination_modifier_result); }
public ThroughputModificationResult ApplyRule(string table_name, string index_name, long?new_read_capacity_units, long?new_write_capacity_units, ProvisionedThroughputDescription current_provisioned_throughput) { ThroughputModificationResult throughput_modification_result = new ThroughputModificationResult(index_id); long current_read_capacity_units = current_provisioned_throughput.ReadCapacityUnits; long current_write_capacity_units = current_provisioned_throughput.WriteCapacityUnits; // if no new read capacity units has been determined and the current rule is set up with a read section, try to apply read rule if (!new_read_capacity_units.HasValue && read != null) { throughput_modification_result.read_result = read.ApplyRule(table_name, index_name, look_back_minutes, current_provisioned_throughput); new_read_capacity_units = throughput_modification_result.read_result.new_capacity_units; } // if no new write capacity units has been determined and the current rule is set up with a write section, try to apply write rule if (!new_write_capacity_units.HasValue && write != null) { throughput_modification_result.write_result = write.ApplyRule(table_name, index_name, look_back_minutes, current_provisioned_throughput); new_write_capacity_units = throughput_modification_result.write_result.new_capacity_units; } // look for decrease combination modifier eligibility if ( (new_write_capacity_units.HasValue && new_write_capacity_units.Value < current_write_capacity_units && !new_read_capacity_units.HasValue && read != null) || (new_read_capacity_units.HasValue && new_read_capacity_units.Value < current_read_capacity_units && !new_write_capacity_units.HasValue && write != null) ) { if (new_write_capacity_units.HasValue && new_write_capacity_units.Value < current_write_capacity_units && !new_read_capacity_units.HasValue && read != null) { throughput_modification_result.read_result.decrease_combination_modifier_result = read.GetNewDecreaseCombinationModifierCapacityUnits(current_provisioned_throughput); if (throughput_modification_result.read_result.decrease_combination_modifier_result != null) { new_read_capacity_units = throughput_modification_result.read_result.decrease_combination_modifier_result.new_capacity_units; throughput_modification_result.read_result.new_capacity_units = new_read_capacity_units; } } else // if (new_read_capacity_units.HasValue && new_read_capacity_units.Value < current_read_capacity_units && !new_write_capacity_units.HasValue && write != null) { throughput_modification_result.write_result.decrease_combination_modifier_result = write.GetNewDecreaseCombinationModifierCapacityUnits(current_provisioned_throughput); if (throughput_modification_result.write_result.decrease_combination_modifier_result != null) { new_write_capacity_units = throughput_modification_result.write_result.decrease_combination_modifier_result.new_capacity_units; throughput_modification_result.write_result.new_capacity_units = new_write_capacity_units; } } } // apply minimum/maximum throughput configured in the rule if (throughput_modification_result.read_result != null) { throughput_modification_result.read_result.ApplyAdjustmentConstraints(read.minimum_throughput, read.maximum_throughput); } if (throughput_modification_result.write_result != null) { throughput_modification_result.write_result.ApplyAdjustmentConstraints(write.minimum_throughput, write.maximum_throughput); } return(throughput_modification_result); }
protected override bool IsBlockedOut(ProvisionedThroughputDescription current_provisioned_throughput) { bool is_blocked_out = false; DateTime utc_now = DateTime.UtcNow; is_blocked_out = current_provisioned_throughput.NumberOfDecreasesToday == max_number_of_decreases; if (!is_blocked_out) { is_blocked_out = this.blockout_time_frames.Any(blockout_time_frame => utc_now >= blockout_time_frame.Item1 && utc_now < blockout_time_frame.Item2); } if (!is_blocked_out) { DateTime utc_today = utc_now.Date; DateTime last_decrease_date_time = current_provisioned_throughput.LastDecreaseDateTime; if (last_decrease_date_time < utc_today) { last_decrease_date_time = utc_today; } if (decrease_frequency == DecreaseFrequencies.EvenSpread) { DateTime utc_tomorrow = utc_today.AddDays(1); double total_remaining_minutes = (utc_tomorrow - last_decrease_date_time).TotalMinutes; List <Tuple <DateTime, DateTime> > remaining_blockout_time_frames = this.blockout_time_frames.Where(blockout_time_frame => last_decrease_date_time < blockout_time_frame.Item2).ToList(); double total_blocked_out_minutes = remaining_blockout_time_frames.Sum(remaining_blockout_time_frame => { if (last_decrease_date_time >= remaining_blockout_time_frame.Item1) { return((remaining_blockout_time_frame.Item2 - last_decrease_date_time).TotalMinutes); } else // if (last_decrease_date_time < blockout_time_frame.Item1) { return((remaining_blockout_time_frame.Item2 - remaining_blockout_time_frame.Item1).TotalMinutes); } }); double remaining_minutes = total_remaining_minutes - total_blocked_out_minutes; double next_eligible_run_time_minutes = remaining_minutes / ((max_number_of_decreases - current_provisioned_throughput.NumberOfDecreasesToday) + 1); DateTime next_eligible_run_time = last_decrease_date_time; for (int index = 0; index < remaining_blockout_time_frames.Count && next_eligible_run_time_minutes > 0; index++) { Tuple <DateTime, DateTime> remaining_blockout_time_frame = remaining_blockout_time_frames.ElementAt(index); DateTime current_start = remaining_blockout_time_frame.Item1; DateTime current_end = remaining_blockout_time_frame.Item2; if (next_eligible_run_time >= current_start) // if last decrease date is within a blockout timeframe, then move it to the end of blockout timeframe in question { next_eligible_run_time = current_end; } else // if (next_eligible_run_time < current_start) { // calculates the minutes available until the next blockout timeframe double minutes_until_blockout_time_frame = (current_start - next_eligible_run_time).TotalMinutes; if (next_eligible_run_time_minutes < minutes_until_blockout_time_frame) // if next blockout timeframe is later than minutes until next eligible run time { next_eligible_run_time = next_eligible_run_time.AddMinutes(next_eligible_run_time_minutes); next_eligible_run_time_minutes = 0; } else if (next_eligible_run_time_minutes > minutes_until_blockout_time_frame) { next_eligible_run_time = current_end; next_eligible_run_time_minutes -= minutes_until_blockout_time_frame; } else // if (next_eligible_run_time_minutes == minutes_until_blockout_time_frame) { next_eligible_run_time = current_end; next_eligible_run_time_minutes = 0; } } } if (next_eligible_run_time_minutes > 0) { next_eligible_run_time = next_eligible_run_time.AddMinutes(next_eligible_run_time_minutes); } is_blocked_out = utc_now < next_eligible_run_time; } else if (decrease_frequency == DecreaseFrequencies.Custom) { DateTime next_eligible_run_time = last_decrease_date_time.AddMinutes(decrease_frequency_custom_minutes); is_blocked_out = utc_now < next_eligible_run_time; } //else if (decrease_frequency == DecreaseFrequencies.Immediate) // skipped } return(is_blocked_out); }
public ReadWriteResult ApplyRule(string table_name, string index_name, int look_back_minutes, ProvisionedThroughputDescription current_provisioned_throughput) { ReadWriteResult read_write_result = new ReadWriteResult(); consumed_capacity_units = GetConsumedCapacityUnits(table_name, index_name, look_back_minutes); current_capacity_units = GetCurrentCapacityUnits(current_provisioned_throughput); read_write_result.consumed_capacity_units = consumed_capacity_units; read_write_result.look_back_minutes = look_back_minutes; // when provided poorly set up rules, favor increase over decrease for safety if (increase != null) { read_write_result.increase_result = this.increase.ApplyRule(consumed_capacity_units, current_capacity_units, current_provisioned_throughput); read_write_result.new_capacity_units = read_write_result.increase_result.new_capacity_units; } if (!read_write_result.new_capacity_units.HasValue && decrease != null) { read_write_result.decrease_result = this.decrease.ApplyRule(consumed_capacity_units, current_capacity_units, current_provisioned_throughput); read_write_result.new_capacity_units = read_write_result.decrease_result.new_capacity_units; } return(read_write_result); }
abstract protected long GetCurrentCapacityUnits(ProvisionedThroughputDescription current_provisioned_throughput);
protected override long GetCurrentCapacityUnits(ProvisionedThroughputDescription current_provisioned_throughput) { return(current_provisioned_throughput.WriteCapacityUnits); }
abstract protected bool IsBlockedOut(ProvisionedThroughputDescription current_provisioned_throughput);
public IncreaseDecreaseResult ApplyRule(long consumed_capacity_units, long current_capacity_units, ProvisionedThroughputDescription current_provisioned_throughput) { bool threshold_met = false; bool blocked_out = false; long?new_capacity_units = null; threshold_met = ThresholdMet(consumed_capacity_units, current_capacity_units); if (threshold_met) { blocked_out = IsBlockedOut(current_provisioned_throughput); if (!blocked_out) { new_capacity_units = GetNewCapacityUnits(current_capacity_units); } } IncreaseDecreaseResult increase_decrease_result = new IncreaseDecreaseResult(threshold, amount, threshold_met, blocked_out, new_capacity_units); return(increase_decrease_result); }
private static ModifiedThroughput BuildModifiedThroughput(string table_name, string index_name, ProvisionedThroughputDescription current_provisioned_throughput, List <ThroughputModification> throughput_modifications) { ModifiedThroughput modified_throughput = new ModifiedThroughput(table_name, index_name, current_provisioned_throughput); long?new_read_capacity_units = null; long?new_write_capacity_units = null; for (int index = 0; index < throughput_modifications.Count && (!new_read_capacity_units.HasValue || !new_write_capacity_units.HasValue); index++) { ThroughputModification throughput_modification = throughput_modifications.ElementAt(index); ThroughputModificationResult throughput_modification_result = throughput_modification.ApplyRule(table_name, index_name, new_read_capacity_units, new_write_capacity_units, current_provisioned_throughput); modified_throughput.throughput_modification_results.Add(throughput_modification_result); if (throughput_modification_result.read_result != null) { new_read_capacity_units = throughput_modification_result.read_result.new_capacity_units; } if (throughput_modification_result.write_result != null) { new_write_capacity_units = throughput_modification_result.write_result.new_capacity_units; } } new_read_capacity_units = new_read_capacity_units ?? current_provisioned_throughput.ReadCapacityUnits; new_write_capacity_units = new_write_capacity_units ?? current_provisioned_throughput.WriteCapacityUnits; if (new_read_capacity_units != current_provisioned_throughput.ReadCapacityUnits || new_write_capacity_units != current_provisioned_throughput.WriteCapacityUnits) { modified_throughput.new_provisioned_throughput = new ProvisionedThroughput { ReadCapacityUnits = new_read_capacity_units.Value, WriteCapacityUnits = new_write_capacity_units.Value }; } return(modified_throughput); }