diff --git a/dynamic_dynamodb/calculators/__init__.py b/dynamic_dynamodb/calculators.py similarity index 57% rename from dynamic_dynamodb/calculators/__init__.py rename to dynamic_dynamodb/calculators.py index 91ba185..f720d4f 100644 --- a/dynamic_dynamodb/calculators/__init__.py +++ b/dynamic_dynamodb/calculators.py @@ -40,6 +40,42 @@ def decrease_reads_in_percent( return updated_provisioning +def decrease_reads_in_units( + current_provisioning, units, min_provisioned_reads, log_tag): + """ Decrease the current_provisioning with units units + + :type current_provisioning: int + :param current_provisioning: The current provisioning + :type units: int + :param units: How many units should we decrease with + :returns: int -- New provisioning value + :type min_provisioned_reads: int + :param min_provisioned_reads: Configured min provisioned reads + :type log_tag: str + :param log_tag: Prefix for the log + """ + updated_provisioning = int(current_provisioning) - int(units) + min_provisioned_reads = __get_min_reads( + current_provisioning, + min_provisioned_reads, + log_tag) + + if updated_provisioning < min_provisioned_reads: + logger.info( + '{0} - Reached provisioned reads min limit: {1:d}'.format( + log_tag, + min_provisioned_reads)) + + return min_provisioned_reads + + logger.debug( + '{0} - Read provisioning will be decreased to {1:d} units'.format( + log_tag, + updated_provisioning)) + + return updated_provisioning + + def decrease_writes_in_percent( current_provisioning, percent, min_provisioned_writes, log_tag): """ Decrease the current_provisioning with percent % @@ -56,7 +92,46 @@ def decrease_writes_in_percent( """ decrease = int(float(current_provisioning)*(float(percent)/100)) updated_provisioning = current_provisioning - decrease - min_provisioned_writes = __get_min_writes(min_provisioned_writes) + min_provisioned_writes = __get_min_writes( + current_provisioning, + min_provisioned_writes, + log_tag) + + if updated_provisioning < min_provisioned_writes: + logger.info( + '{0} - Reached provisioned writes min limit: {1:d}'.format( + log_tag, + min_provisioned_writes)) + + return min_provisioned_writes + + logger.debug( + '{0} - Write provisioning will be decreased to {1:d} units'.format( + log_tag, + updated_provisioning)) + + return updated_provisioning + + +def decrease_writes_in_units( + current_provisioning, units, min_provisioned_writes, log_tag): + """ Decrease the current_provisioning with units units + + :type current_provisioning: int + :param current_provisioning: The current provisioning + :type units: int + :param units: How many units should we decrease with + :returns: int -- New provisioning value + :type min_provisioned_writes: int + :param min_provisioned_writes: Configured min provisioned writes + :type log_tag: str + :param log_tag: Prefix for the log + """ + updated_provisioning = int(current_provisioning) - int(units) + min_provisioned_writes = __get_min_writes( + current_provisioning, + min_provisioned_writes, + log_tag) if updated_provisioning < min_provisioned_writes: logger.info( @@ -74,6 +149,79 @@ def decrease_writes_in_percent( return updated_provisioning +def increase_reads_in_percent( + current_provisioning, percent, max_provisioned_reads, log_tag): + """ Increase the current_provisioning with percent % + + :type current_provisioning: int + :param current_provisioning: The current provisioning + :type percent: int + :param percent: How many percent should we increase with + :type max_provisioned_reads: int + :param max_provisioned_reads: Configured max provisioned reads + :returns: int -- New provisioning value + :type log_tag: str + :param log_tag: Prefix for the log + """ + increase = int(math.ceil(float(current_provisioning)*(float(percent)/100))) + updated_provisioning = current_provisioning + increase + + if max_provisioned_reads > 0: + if updated_provisioning > max_provisioned_reads: + logger.info( + '{0} - Reached provisioned reads max limit: {1}'.format( + log_tag, + max_provisioned_reads)) + + return max_provisioned_reads + + logger.debug( + '{0} - Read provisioning will be increased to {1} units'.format( + log_tag, + updated_provisioning)) + + return updated_provisioning + + +def increase_reads_in_units( + current_provisioning, units, max_provisioned_reads, log_tag): + """ Increase the current_provisioning with units units + + :type current_provisioning: int + :param current_provisioning: The current provisioning + :type units: int + :param units: How many units should we increase with + :returns: int -- New provisioning value + :type max_provisioned_reads: int + :param max_provisioned_reads: Configured max provisioned reads + :returns: int -- New provisioning value + :type log_tag: str + :param log_tag: Prefix for the log + """ + updated_provisioning = 0 + + if int(units) > int(current_provisioning): + updated_provisioning = 2 * int(current_provisioning) + else: + updated_provisioning = int(current_provisioning) + int(units) + + if max_provisioned_reads > 0: + if updated_provisioning > max_provisioned_reads: + logger.info( + '{0} - Reached provisioned reads max limit: {1}'.format( + log_tag, + max_provisioned_reads)) + + return max_provisioned_reads + + logger.debug( + '{0} - Read provisioning will be increased to {1:d} units'.format( + log_tag, + updated_provisioning)) + + return updated_provisioning + + def increase_writes_in_percent( current_provisioning, percent, max_provisioned_writes, log_tag): """ Increase the current_provisioning with percent % @@ -109,34 +257,37 @@ def increase_writes_in_percent( return updated_provisioning -def increase_reads_in_percent( - current_provisioning, percent, max_provisioned_reads, log_tag): - """ Increase the current_provisioning with percent % +def increase_writes_in_units( + current_provisioning, units, max_provisioned_writes, log_tag): + """ Increase the current_provisioning with units units :type current_provisioning: int :param current_provisioning: The current provisioning - :type percent: int - :param percent: How many percent should we increase with - :type max_provisioned_reads: int - :param max_provisioned_reads: Configured max provisioned reads + :type units: int + :param units: How many units should we increase with :returns: int -- New provisioning value + :type max_provisioned_writes: int + :param max_provisioned_writes: Configured max provisioned writes :type log_tag: str :param log_tag: Prefix for the log """ - increase = int(math.ceil(float(current_provisioning)*(float(percent)/100))) - updated_provisioning = current_provisioning + increase + updated_provisioning = 0 + if int(units) > int(current_provisioning): + updated_provisioning = 2 * int(current_provisioning) + else: + updated_provisioning = int(current_provisioning) + int(units) - if max_provisioned_reads > 0: - if updated_provisioning > max_provisioned_reads: + if max_provisioned_writes > 0: + if updated_provisioning > max_provisioned_writes: logger.info( - '{0} - Reached provisioned reads max limit: {1}'.format( + '{0} - Reached provisioned writes max limit: {1}'.format( log_tag, - max_provisioned_reads)) + max_provisioned_writes)) - return max_provisioned_reads + return max_provisioned_writes logger.debug( - '{0} - Read provisioning will be increased to {1} units'.format( + '{0} - Write provisioning will be increased to {1:d} units'.format( log_tag, updated_provisioning)) diff --git a/dynamic_dynamodb/calculators/gsi.py b/dynamic_dynamodb/calculators/gsi.py deleted file mode 100644 index 88ad779..0000000 --- a/dynamic_dynamodb/calculators/gsi.py +++ /dev/null @@ -1,194 +0,0 @@ -# -*- coding: utf-8 -*- -""" Module with various calculators """ -from dynamic_dynamodb.log_handler import LOGGER as logger -from dynamic_dynamodb.config_handler import get_gsi_option -from dynamic_dynamodb import calculators - - -def decrease_reads_in_units( - current_provisioning, units, table_name, table_key, gsi_name, gsi_key): - """ Decrease the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we decrease with - :type table_name: str - :param table_name: Name of the DynamoDB table - :type table_key: str - :param table_key: Table configuration option key name - :type gsi_name: str - :param gsi_name: Name of the GSI - :type gsi_key: str - :param gsi_key: Name of the key - :returns: int -- New provisioning value - """ - updated_provisioning = int(current_provisioning) - int(units) - min_provisioned_reads = calculators.get_min_reads( - current_provisioning, - get_gsi_option(table_key, gsi_key, 'min_provisioned_reads'), - '{0} - GSI: {1}'.format(table_name, gsi_name)) - - if updated_provisioning < min_provisioned_reads: - logger.info( - '{0} - GSI: {1} - ' - 'Reached provisioned reads min limit: {2:d}'.format( - table_name, - gsi_name, - min_provisioned_reads)) - - return min_provisioned_reads - - logger.debug( - '{0} - GSI: {1} - ' - 'Read provisioning will be decreased to {2:d} units'.format( - table_name, - gsi_name, - updated_provisioning)) - - return updated_provisioning - - -def increase_reads_in_units( - current_provisioning, units, table_name, table_key, gsi_name, gsi_key): - """ Increase the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we increase with - :type table_name: str - :param table_name: Name of the DynamoDB table - :type table_key: str - :param table_key: Table configuration option key name - :type gsi_name: str - :param gsi_name: Name of the GSI - :type gsi_key: str - :param gsi_key: Name of the key - :returns: int -- New provisioning value - """ - updated_provisioning = 0 - - if int(units) > int(current_provisioning): - updated_provisioning = 2 * int(current_provisioning) - else: - updated_provisioning = int(current_provisioning) + int(units) - - if get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'): - max_provisioned_reads = int(get_gsi_option( - table_key, gsi_key, 'max_provisioned_reads')) - else: - max_provisioned_reads = 0 - - if (max_provisioned_reads > 0 and - updated_provisioning > max_provisioned_reads): - logger.info( - '{0} - GSI: {1} - ' - 'Reached provisioned reads max limit: {2:d}'.format( - table_name, - gsi_name, - max_provisioned_reads)) - - return max_provisioned_reads - - logger.debug( - '{0} - GSI: {1} - ' - 'Read provisioning will be increased to {2:d} units'.format( - table_name, - gsi_name, - updated_provisioning)) - - return updated_provisioning - - -def decrease_writes_in_units( - current_provisioning, units, table_name, table_key, gsi_name, gsi_key): - """ Decrease the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we decrease with - :type table_name: str - :param table_name: Name of the DynamoDB table - :type table_key: str - :param table_key: Table configuration option key name - :type gsi_name: str - :param gsi_name: Name of the GSI - :type gsi_key: str - :param gsi_key: Name of the key - :returns: int -- New provisioning value - """ - updated_provisioning = int(current_provisioning) - int(units) - min_provisioned_writes = calculators.get_min_writes( - current_provisioning, - get_gsi_option(table_key, gsi_key, 'min_provisioned_writes'), - '{0} - GSI: {1}'.format(table_name, gsi_name)) - - if updated_provisioning < min_provisioned_writes: - logger.info( - '{0} - GSI: {1} - ' - 'Reached provisioned writes min limit: {2:d}'.format( - table_name, - gsi_name, - min_provisioned_writes)) - - return min_provisioned_writes - - logger.debug( - '{0} - GSI: {1} - ' - 'Write provisioning will be decreased to {2:d} units'.format( - table_name, - gsi_name, - updated_provisioning)) - - return updated_provisioning - - -def increase_writes_in_units( - current_provisioning, units, table_name, table_key, gsi_name, gsi_key): - """ Increase the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we increase with - :type table_name: str - :param table_name: Name of the DynamoDB table - :type table_key: str - :param table_key: Table configuration option key name - :type gsi_name: str - :param gsi_name: Name of the GSI - :type gsi_key: str - :param gsi_key: Name of the key - :returns: int -- New provisioning value - """ - updated_provisioning = 0 - if int(units) > int(current_provisioning): - updated_provisioning = 2 * int(current_provisioning) - else: - updated_provisioning = int(current_provisioning) + int(units) - - if get_gsi_option(table_key, gsi_key, 'max_provisioned_writes') > 0: - if (updated_provisioning > get_gsi_option( - table_key, gsi_key, 'max_provisioned_writes')): - - logger.info( - '{0} - GSI: {1} - ' - 'Reached provisioned writes max limit: {2:d}'.format( - table_name, - gsi_name, - int(get_gsi_option( - table_name, gsi_key, 'max_provisioned_writes')))) - - return get_gsi_option( - table_key, gsi_key, 'max_provisioned_writes') - - logger.debug( - '{0} - GSI: {1} - ' - 'Write provisioning will be increased to {2:d} units'.format( - table_name, - gsi_name, - updated_provisioning)) - - return updated_provisioning diff --git a/dynamic_dynamodb/calculators/table.py b/dynamic_dynamodb/calculators/table.py deleted file mode 100644 index f506166..0000000 --- a/dynamic_dynamodb/calculators/table.py +++ /dev/null @@ -1,154 +0,0 @@ -# -*- coding: utf-8 -*- -""" Module with various calculators """ -from dynamic_dynamodb.log_handler import LOGGER as logger -from dynamic_dynamodb.config_handler import get_table_option -from dynamic_dynamodb import calculators - - -def decrease_reads_in_units(current_provisioning, units, key_name, table_name): - """ Decrease the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we decrease with - :returns: int -- New provisioning value - :type key_name: str - :param key_name: Name of the key - :type table_name: str - :param table_name: Name of the DynamoDB table - """ - updated_provisioning = int(current_provisioning) - int(units) - min_provisioned_reads = calculators.get_min_reads( - current_provisioning, - get_table_option(key_name, 'min_provisioned_reads'), - table_name) - - if updated_provisioning < min_provisioned_reads: - logger.info( - '{0} - Reached provisioned reads min limit: {1:d}'.format( - table_name, - min_provisioned_reads)) - - return min_provisioned_reads - - logger.debug( - '{0} - Read provisioning will be decreased to {1:d} units'.format( - table_name, - updated_provisioning)) - - return updated_provisioning - - -def increase_reads_in_units(current_provisioning, units, key_name, table_name): - """ Increase the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we increase with - :returns: int -- New provisioning value - :type key_name: str - :param key_name: Name of the key - :type table_name: str - :param table_name: Name of the DynamoDB table - """ - updated_provisioning = 0 - - if int(units) > int(current_provisioning): - updated_provisioning = 2 * int(current_provisioning) - else: - updated_provisioning = int(current_provisioning) + int(units) - - if get_table_option(key_name, 'max_provisioned_reads') > 0: - if (updated_provisioning > - get_table_option(key_name, 'max_provisioned_reads')): - - logger.info( - '{0} - Reached provisioned reads max limit: {1:d}'.format( - table_name, - int(get_table_option(key_name, 'max_provisioned_reads')))) - - return get_table_option(key_name, 'max_provisioned_reads') - - logger.debug( - '{0} - Read provisioning will be increased to {1:d} units'.format( - table_name, - updated_provisioning)) - - return updated_provisioning - - -def decrease_writes_in_units( - current_provisioning, units, key_name, table_name): - """ Decrease the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we decrease with - :returns: int -- New provisioning value - :type key_name: str - :param key_name: Name of the key - :type table_name: str - :param table_name: Name of the DynamoDB table - """ - updated_provisioning = int(current_provisioning) - int(units) - min_provisioned_writes = calculators.get_min_writes( - current_provisioning, - get_table_option(key_name, 'min_provisioned_writes'), - table_name) - - if updated_provisioning < min_provisioned_writes: - logger.info( - '{0} - Reached provisioned writes min limit: {1:d}'.format( - table_name, - min_provisioned_writes)) - - return min_provisioned_writes - - logger.debug( - '{0} - Write provisioning will be decreased to {1:d} units'.format( - table_name, - updated_provisioning)) - - return updated_provisioning - - -def increase_writes_in_units( - current_provisioning, units, key_name, table_name): - """ Increase the current_provisioning with units units - - :type current_provisioning: int - :param current_provisioning: The current provisioning - :type units: int - :param units: How many units should we increase with - :returns: int -- New provisioning value - :type key_name: str - :param key_name: Name of the key - :type table_name: str - :param table_name: Name of the DynamoDB table - """ - updated_provisioning = 0 - if int(units) > int(current_provisioning): - updated_provisioning = 2 * int(current_provisioning) - else: - updated_provisioning = int(current_provisioning) + int(units) - - if get_table_option(key_name, 'max_provisioned_writes') > 0: - if (updated_provisioning > - get_table_option(key_name, 'max_provisioned_writes')): - - logger.info( - '{0} - Reached provisioned writes max limit: {1:d}'.format( - table_name, - int(get_table_option(key_name, 'max_provisioned_writes')))) - - return get_table_option(key_name, 'max_provisioned_writes') - - logger.debug( - '{0} - Write provisioning will be increased to {1:d} units'.format( - table_name, - updated_provisioning)) - - return updated_provisioning diff --git a/dynamic_dynamodb/core/gsi.py b/dynamic_dynamodb/core/gsi.py index 6145f62..c28f09f 100644 --- a/dynamic_dynamodb/core/gsi.py +++ b/dynamic_dynamodb/core/gsi.py @@ -4,7 +4,6 @@ from dynamic_dynamodb.aws import dynamodb from dynamic_dynamodb import calculators -from dynamic_dynamodb.calculators import gsi as gsi_calc from dynamic_dynamodb.core import circuit_breaker from dynamic_dynamodb.statistics import gsi as gsi_stats from dynamic_dynamodb.log_handler import LOGGER as logger @@ -178,21 +177,17 @@ def __ensure_provisioning_reads(table_name, table_key, gsi_name, gsi_key): elif consumed_read_units_percent >= reads_upper_threshold: if increase_reads_unit == 'percent': - updated_provisioning = gsi_calc.increase_reads_in_percent( + updated_provisioning = calculators.increase_reads_in_percent( updated_read_units, increase_reads_with, - table_name, - table_key, - gsi_name, - gsi_key,) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) else: - updated_provisioning = gsi_calc.increase_reads_in_units( + updated_provisioning = calculators.increase_reads_in_units( updated_read_units, increase_reads_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) if updated_read_units != updated_provisioning: update_needed = True @@ -203,21 +198,17 @@ def __ensure_provisioning_reads(table_name, table_key, gsi_name, gsi_key): if throttled_reads_upper_threshold > 0: if increase_reads_unit == 'percent': - updated_provisioning = gsi_calc.increase_reads_in_percent( + updated_provisioning = calculators.increase_reads_in_percent( updated_read_units, increase_reads_with, - table_name, - table_key, - gsi_name, - gsi_key,) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) else: - updated_provisioning = gsi_calc.increase_reads_in_units( + updated_provisioning = calculators.increase_reads_in_units( updated_read_units, increase_reads_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) if updated_read_units != updated_provisioning: update_needed = True @@ -232,13 +223,11 @@ def __ensure_provisioning_reads(table_name, table_key, gsi_name, gsi_key): get_gsi_option(table_key, gsi_key, 'min_provisioned_reads'), '{0} - GSI: {1}'.format(table_name, gsi_name)) else: - updated_provisioning = gsi_calc.decrease_reads_in_units( + updated_provisioning = calculators.decrease_reads_in_units( updated_read_units, decrease_reads_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'min_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) if updated_read_units != updated_provisioning: update_needed = True @@ -318,21 +307,17 @@ def __ensure_provisioning_writes(table_name, table_key, gsi_name, gsi_key): elif consumed_write_units_percent >= writes_upper_threshold: if increase_writes_unit == 'percent': - updated_provisioning = gsi_calc.increase_writes_in_percent( + updated_provisioning = calculators.increase_writes_in_percent( updated_write_units, increase_writes_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) else: - updated_provisioning = gsi_calc.increase_writes_in_units( + updated_provisioning = calculators.increase_writes_in_units( updated_write_units, increase_writes_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) if updated_write_units != updated_provisioning: update_needed = True @@ -342,21 +327,17 @@ def __ensure_provisioning_writes(table_name, table_key, gsi_name, gsi_key): if throttled_writes_upper_threshold > 0: if increase_writes_unit == 'percent': - updated_provisioning = gsi_calc.increase_writes_in_percent( + updated_provisioning = calculators.increase_writes_in_percent( updated_write_units, increase_writes_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) else: - updated_provisioning = gsi_calc.increase_writes_in_units( + updated_provisioning = calculators.increase_writes_in_units( updated_write_units, increase_writes_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'max_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) if updated_write_units != updated_provisioning: update_needed = True @@ -371,13 +352,11 @@ def __ensure_provisioning_writes(table_name, table_key, gsi_name, gsi_key): get_gsi_option(table_key, gsi_key, 'min_provisioned_writes'), '{0} - GSI: {1}'.format(table_name, gsi_name)) else: - updated_provisioning = gsi_calc.decrease_writes_in_units( + updated_provisioning = calculators.decrease_writes_in_units( updated_write_units, decrease_writes_with, - table_name, - table_key, - gsi_name, - gsi_key) + get_gsi_option(table_key, gsi_key, 'min_provisioned_reads'), + '{0} - GSI: {1}'.format(table_name, gsi_name)) if updated_write_units != updated_provisioning: update_needed = True diff --git a/dynamic_dynamodb/core/table.py b/dynamic_dynamodb/core/table.py index d849f40..2682b93 100644 --- a/dynamic_dynamodb/core/table.py +++ b/dynamic_dynamodb/core/table.py @@ -4,7 +4,6 @@ from dynamic_dynamodb.aws import dynamodb from dynamic_dynamodb import calculators -from dynamic_dynamodb.calculators import table as table_calc from dynamic_dynamodb.core import circuit_breaker from dynamic_dynamodb.statistics import table as table_stats from dynamic_dynamodb.log_handler import LOGGER as logger @@ -155,10 +154,10 @@ def __ensure_provisioning_reads(table_name, key_name): get_table_option(key_name, 'max_provisioned_reads'), table_name) else: - updated_provisioning = table_calc.increase_reads_in_units( + updated_provisioning = calculators.increase_reads_in_units( updated_read_units, increase_reads_with, - key_name, + get_table_option(key_name, 'max_provisioned_reads'), table_name) if updated_read_units != updated_provisioning: @@ -175,10 +174,10 @@ def __ensure_provisioning_reads(table_name, key_name): get_table_option(key_name, 'max_provisioned_reads'), table_name) else: - updated_provisioning = table_calc.increase_reads_in_units( + updated_provisioning = calculators.increase_reads_in_units( updated_read_units, increase_reads_with, - key_name, + get_table_option(key_name, 'max_provisioned_reads'), table_name) if updated_read_units != updated_provisioning: @@ -194,10 +193,10 @@ def __ensure_provisioning_reads(table_name, key_name): get_table_option(key_name, 'min_provisioned_reads'), table_name) else: - updated_provisioning = table_calc.decrease_reads_in_units( + updated_provisioning = calculators.decrease_reads_in_units( updated_read_units, decrease_reads_with, - key_name, + get_table_option(key_name, 'min_provisioned_reads'), table_name) if updated_read_units != updated_provisioning: @@ -276,10 +275,10 @@ def __ensure_provisioning_writes(table_name, key_name): get_table_option(key_name, 'max_provisioned_writes'), table_name) else: - updated_provisioning = table_calc.increase_writes_in_units( + updated_provisioning = calculators.increase_writes_in_units( updated_write_units, increase_writes_with, - key_name, + get_table_option(key_name, 'max_provisioned_reads'), table_name) if updated_write_units != updated_provisioning: @@ -296,10 +295,10 @@ def __ensure_provisioning_writes(table_name, key_name): get_table_option(key_name, 'max_provisioned_writes'), table_name) else: - updated_provisioning = table_calc.increase_writes_in_units( + updated_provisioning = calculators.increase_writes_in_units( updated_write_units, increase_writes_with, - key_name, + get_table_option(key_name, 'max_provisioned_reads'), table_name) if updated_write_units != updated_provisioning: @@ -315,10 +314,10 @@ def __ensure_provisioning_writes(table_name, key_name): get_table_option(key_name, 'min_provisioned_writes'), table_name) else: - updated_provisioning = table_calc.decrease_writes_in_units( + updated_provisioning = calculators.decrease_writes_in_units( updated_write_units, decrease_writes_with, - key_name, + get_table_option(key_name, 'min_provisioned_reads'), table_name) if updated_write_units != updated_provisioning: