awslimitchecker.services package¶

awslimitchecker.checker module¶

class awslimitchecker.checker.AwsLimitChecker(warning_threshold=80, critical_threshold=99, account_id=None, account_role=None, region=None, external_id=None, mfa_serial_number=None, mfa_token=None)[source]¶

Bases: object

Main AwsLimitChecker class - this should be the only externally-used portion of awslimitchecker.

Constructor builds self.services as a dict of service_name (str) to _AwsService instance, and sets limit thresholds.

Parameters:

warning_threshold (int) – the default warning threshold, as an integer percentage, for any limits without a specifically-set threshold. critical_threshold (int) – the default critical threshold, as an integer percentage, for any limits without a specifically-set threshold. account_id (str) – AWS Account ID (12-digit string, currently numeric) for the account to connect to (destination) via STS account_role (str) – the name of an IAM Role (in the destination account) to assume region (str) – AWS region name to connect to external_id (str) – (optional) the External ID string to use when assuming a role via STS. mfa_serial_number (str) – (optional) the MFA Serial Number string to use when assuming a role via STS. mfa_token (str) – (optional) the MFA Token string to use when assuming a role via STS.

__dict__ = dict_proxy({'set_limit_override': <function set_limit_override at 0x7fc18c034398>, '__module__': 'awslimitchecker.checker', 'find_usage': <function find_usage at 0x7fc18c0342a8>, 'get_service_names': <function get_service_names at 0x7fc18c034230>, 'set_threshold_overrides': <function set_threshold_overrides at 0x7fc18c034410>, 'get_version': <function get_version at 0x7fc18c0340c8>, 'check_thresholds': <function check_thresholds at 0x7fc18c034500>, 'set_threshold_override': <function set_threshold_override at 0x7fc18c034488>, 'get_limits': <function get_limits at 0x7fc18c0341b8>, 'set_limit_overrides': <function set_limit_overrides at 0x7fc18c034320>, '__dict__': <attribute '__dict__' of 'AwsLimitChecker' objects>, 'get_required_iam_policy': <function get_required_iam_policy at 0x7fc18c034578>, '__weakref__': <attribute '__weakref__' of 'AwsLimitChecker' objects>, '__doc__': None, '__init__': <function __init__ at 0x7fc18c02cf50>, 'get_project_url': <function get_project_url at 0x7fc18c034140>})¶

__init__(warning_threshold=80, critical_threshold=99, account_id=None, account_role=None, region=None, external_id=None, mfa_serial_number=None, mfa_token=None)[source]¶

Main AwsLimitChecker class - this should be the only externally-used portion of awslimitchecker.

Constructor builds self.services as a dict of service_name (str) to _AwsService instance, and sets limit thresholds.

Parameters:

warning_threshold (int) – the default warning threshold, as an integer percentage, for any limits without a specifically-set threshold. critical_threshold (int) – the default critical threshold, as an integer percentage, for any limits without a specifically-set threshold. account_id (str) – AWS Account ID (12-digit string, currently numeric) for the account to connect to (destination) via STS account_role (str) – the name of an IAM Role (in the destination account) to assume region (str) – AWS region name to connect to external_id (str) – (optional) the External ID string to use when assuming a role via STS. mfa_serial_number (str) – (optional) the MFA Serial Number string to use when assuming a role via STS. mfa_token (str) – (optional) the MFA Token string to use when assuming a role via STS.

__module__ = 'awslimitchecker.checker'¶

__weakref__¶

list of weak references to the object (if defined)

check_thresholds(service=None, use_ta=True)[source]¶

Check all limits and current usage against their specified thresholds; return all AwsLimit instances that have crossed one or more of their thresholds.

If service is specified, the returned dict has one element, the service name, whose value is a nested dict as described below; otherwise it includes all known services.

The returned AwsLimit objects can be interrogated for their limits (get_limit()) as well as the details of usage that crossed the thresholds (get_warnings() and get_criticals()).

See AwsLimit.check_thresholds().

Parameters:	service (string) – the name of one service to return results for use_ta (bool) – check Trusted Advisor for information on limits
Returns:	dict of service name (string) to nested dict of limit name (string) to limit (AwsLimit)
Return type:	dict

find_usage(service=None, use_ta=True)[source]¶

For each limit in the specified service (or all services if service is None), query the AWS API via boto3 and find the current usage amounts for that limit.

This method updates the current_usage attribute of the AwsLimit objects for each service, which can then be queried using get_limits().

Parameters:	service (None, or string service name to get) – _AwsService name, or None to check all services. use_ta (bool) – check Trusted Advisor for information on limits

get_limits(service=None, use_ta=True)[source]¶

Return all AwsLimit objects for the given service name, or for all services if service is None.

If service is specified, the returned dict has one element, the service name, whose value is a nested dict as described below.

Parameters:	service (string) – the name of one service to return limits for use_ta (bool) – check Trusted Advisor for information on limits
Returns:	dict of service name (string) to nested dict of limit name (string) to limit (AwsLimit)
Return type:	dict

get_project_url()[source]¶

Return the URL for the awslimitchecker project.

Returns:	URL of where to find awslimitchecker
Return type:	string

get_required_iam_policy()[source]¶

Return an IAM policy granting all of the permissions needed for awslimitchecker to fully function. This returns a dict suitable for json serialization to a valid IAM policy.

Internally, this calls required_iam_permissions() on each _AwsService instance.

Returns:	dict representation of IAM Policy
Return type:	dict

get_service_names()[source]¶

Return a list of all known service names

Returns:	list of service names
Return type:	list

get_version()[source]¶

Return the version of awslimitchecker currently running.

Returns:	current awslimitchecker version
Return type:	string

set_limit_override(service_name, limit_name, value, override_ta=True)[source]¶

Set a manual override on an AWS service limits, i.e. if you had limits increased by AWS support.

This method calls _AwsService.set_limit_override() on the corresponding _AwsService instance.

Explicitly set limit overrides using this method will take precedence over default limits. They will also take precedence over limit information obtained via Trusted Advisor, unless override_ta is set to False.

Parameters:	service_name (string) – the name of the service to override limit for limit_name (string) – the name of the limit to override: value (int) – the new (overridden) limit value) override_ta (bool) – whether or not to use this value even if Trusted Advisor supplies limit information
Raises:	ValueError if limit_name is not known to the service instance

set_limit_overrides(override_dict, override_ta=True)[source]¶

Set manual overrides on AWS service limits, i.e. if you had limits increased by AWS support. This takes a dict in the same form as that returned by get_limits(), i.e. service_name (str) keys to nested dict of limit_name (str) to limit value (int) like:

{
    'EC2': {
      'Running On-Demand t2.micro Instances': 1000,
      'Running On-Demand r3.4xlarge Instances': 1000,
    }
}

Internally, for each limit override for each service in override_dict, this method calls _AwsService.set_limit_override() on the corresponding _AwsService instance.

Explicitly set limit overrides using this method will take precedence over default limits. They will also take precedence over limit information obtained via Trusted Advisor, unless override_ta is set to False.

Parameters:	override_dict (dict) – dict of overrides to default limits override_ta (bool) – whether or not to use this value even if Trusted Advisor supplies limit information
Raises:	exceptions.ValueError if limit_name is not known to the service instance

set_threshold_override(service_name, limit_name, warn_percent=None, warn_count=None, crit_percent=None, crit_count=None)[source]¶

Set a manual override on the threshold (used for determining warning/critical status) for a specific limit. See AwsLimitChecker for information on Warning and Critical thresholds.

See AwsLimit.set_threshold_override().

Parameters:	service_name (string) – the name of the service to override limit for limit_name (string) – the name of the limit to override: warn_percent (int) – new warning threshold, percentage used warn_count (int) – new warning threshold, actual count/number crit_percent (int) – new critical threshold, percentage used crit_count (int) – new critical threshold, actual count/number

set_threshold_overrides(override_dict)[source]¶

Set manual overrides on the threshold (used for determining warning/critical status) a dict of limits. See AwsLimitChecker for information on Warning and Critical thresholds.

Dict is composed of service name keys (string) to dict of limit names (string), to dict of threshold specifications. Each threhold specification dict can contain keys ‘warning’ or ‘critical’, each having a value of a dict containing keys ‘percent’ or ‘count’, to an integer value.

Example:

{
    'EC2': {
        'SomeLimit': {
            'warning': {
                'percent': 80,
                'count': 8,
            },
            'critical': {
                'percent': 90,
                'count': 9,
            }
        }
    }
}

See AwsLimit.set_threshold_override().

Parameters:	override_dict (dict) – nested dict of threshold overrides

awslimitchecker.connectable module¶

class awslimitchecker.connectable.Connectable[source]¶

Bases: object

Mix-in helper class for connecting to AWS APIs. Centralizes logic of connecting via regions and/or STS.

__dict__ = dict_proxy({'__module__': 'awslimitchecker.connectable', '_get_sts_token': <function _get_sts_token at 0x7fc18c0d67d0>, 'connect': <function connect at 0x7fc18c0d66e0>, '__dict__': <attribute '__dict__' of 'Connectable' objects>, 'credentials': None, '_boto3_connection_kwargs': <property object at 0x7fc18c0d52b8>, '__weakref__': <attribute '__weakref__' of 'Connectable' objects>, '__doc__': '\n Mix-in helper class for connecting to AWS APIs. Centralizes logic of\n connecting via regions and/or STS.\n ', 'connect_resource': <function connect_resource at 0x7fc18c0d6758>})¶

__module__ = 'awslimitchecker.connectable'¶

__weakref__¶

list of weak references to the object (if defined)

_boto3_connection_kwargs¶

Generate keyword arguments for boto3 connection functions. If self.account_id is None, this will just include region_name=self.region. Otherwise, call _get_sts_token() to get STS token credentials using boto3.STS.Client.assume_role and include those credentials in the return value.

Returns:	keyword arguments for boto3 connection functions
Return type:	dict

_get_sts_token()[source]¶

Assume a role via STS and return the credentials.

First connect to STS via boto3.client(), then assume a role using boto3.STS.Client.assume_role using self.account_id and self.account_role (and optionally self.external_id, self.mfa_serial_number, self.mfa_token). Return the resulting ConnectableCredentials object.

Returns:	STS assumed role credentials
Return type:	ConnectableCredentials

connect()[source]¶

Connect to an AWS API via boto3 low-level client and set self.conn to the boto3.client object (a botocore.client.* instance). If self.conn is not None, do nothing. This connects to the API name given by self.api_name.

Returns:	None

connect_resource()[source]¶

Connect to an AWS API via boto3 high-level resource connection and set self.resource_conn to the boto3.resource object (a boto3.resources.factory.*.ServiceResource instance). If self.resource_conn is not None, do nothing. This connects to the API name given by self.api_name.

Returns:	None

credentials = None¶

class awslimitchecker.connectable.ConnectableCredentials(creds_dict)[source]¶

Bases: object

boto’s (2.x) boto.sts.STSConnection.assume_role() returns a boto.sts.credentials.Credentials object, but boto3’s boto3.sts.STSConnection.assume_role just returns a dict. This class provides a compatible interface for boto3.

__dict__ = dict_proxy({'__dict__': <attribute '__dict__' of 'ConnectableCredentials' objects>, '__module__': 'awslimitchecker.connectable', '__weakref__': <attribute '__weakref__' of 'ConnectableCredentials' objects>, '__doc__': "\n boto's (2.x) :py:meth:`boto.sts.STSConnection.assume_role` returns a\n :py:class:`boto.sts.credentials.Credentials` object, but boto3's\n `boto3.sts.STSConnection.assume_role <https://boto3.readthedocs.org/en/\n latest/reference/services/sts.html#STS.Client.assume_role>`_ just returns\n a dict. This class provides a compatible interface for boto3.\n ", '__init__': <function __init__ at 0x7fc18c0d65f0>})¶

__init__(creds_dict)[source]¶

__module__ = 'awslimitchecker.connectable'¶

__weakref__¶

list of weak references to the object (if defined)

awslimitchecker.limit module¶

class awslimitchecker.limit.AwsLimit(name, service, default_limit, def_warning_threshold, def_critical_threshold, limit_type=None, limit_subtype=None, ta_service_name=None, ta_limit_name=None)[source]¶

Bases: object

Describes one specific AWS service limit, as well as its current utilization, default limit, thresholds, and any Trusted Advisor information about this limit.

Parameters:

name (string) – the name of this limit (may contain spaces); if possible, this should be the name used by AWS, i.e. TrustedAdvisor service (_AwsService) – the _AwsService class that this limit is for default_limit (int) – the default value of this limit for new accounts def_warning_threshold (int) – the default warning threshold, as an integer percentage. def_critical_threshold (int) – the default critical threshold, as an integer percentage. limit_type – the type of resource this limit describes, specified as one of the type names used in CloudFormation # noqa such as “AWS::EC2::Instance” or “AWS::RDS::DBSubnetGroup”. limit_subtype (str) – resource sub-type for this limit, if applicable, such as “t2.micro” or “SecurityGroup” ta_service_name (str) – The service name returned by Trusted Advisor for this limit, if different from the name of service ta_limit_name (str) – The limit name returned by Trusted Advisor for this limit, if different from name.

Raises:

ValueError

__dict__ = dict_proxy({'__module__': 'awslimitchecker.limit', 'get_current_usage_str': <function get_current_usage_str at 0x7fc18c0df5f0>, 'check_thresholds': <function check_thresholds at 0x7fc18c0df848>, 'ta_service_name': <property object at 0x7fc18c0d5a48>, 'get_limit': <function get_limit at 0x7fc18c0df500>, '_set_ta_unlimited': <function _set_ta_unlimited at 0x7fc18c0df398>, '__dict__': <attribute '__dict__' of 'AwsLimit' objects>, '_get_thresholds': <function _get_thresholds at 0x7fc18c0df758>, '_add_current_usage': <function _add_current_usage at 0x7fc18c0df668>, '__init__': <function __init__ at 0x7fc18c0df230>, 'ta_limit_name': <property object at 0x7fc18c0d5aa0>, 'set_limit_override': <function set_limit_override at 0x7fc18c0df2a8>, 'get_criticals': <function get_criticals at 0x7fc18c0df938>, '_set_ta_limit': <function _set_ta_limit at 0x7fc18c0df320>, '__weakref__': <attribute '__weakref__' of 'AwsLimit' objects>, '_set_api_limit': <function _set_api_limit at 0x7fc18c0df410>, 'get_current_usage': <function get_current_usage at 0x7fc18c0df578>, 'set_threshold_override': <function set_threshold_override at 0x7fc18c0df7d0>, '_reset_usage': <function _reset_usage at 0x7fc18c0df6e0>, 'get_limit_source': <function get_limit_source at 0x7fc18c0df488>, 'get_warnings': <function get_warnings at 0x7fc18c0df8c0>, '__doc__': None})¶

__init__(name, service, default_limit, def_warning_threshold, def_critical_threshold, limit_type=None, limit_subtype=None, ta_service_name=None, ta_limit_name=None)[source]¶

Describes one specific AWS service limit, as well as its current utilization, default limit, thresholds, and any Trusted Advisor information about this limit.

Parameters:

name (string) – the name of this limit (may contain spaces); if possible, this should be the name used by AWS, i.e. TrustedAdvisor service (_AwsService) – the _AwsService class that this limit is for default_limit (int) – the default value of this limit for new accounts def_warning_threshold (int) – the default warning threshold, as an integer percentage. def_critical_threshold (int) – the default critical threshold, as an integer percentage. limit_type – the type of resource this limit describes, specified as one of the type names used in CloudFormation # noqa such as “AWS::EC2::Instance” or “AWS::RDS::DBSubnetGroup”. limit_subtype (str) – resource sub-type for this limit, if applicable, such as “t2.micro” or “SecurityGroup” ta_service_name (str) – The service name returned by Trusted Advisor for this limit, if different from the name of service ta_limit_name (str) – The limit name returned by Trusted Advisor for this limit, if different from name.

Raises:

ValueError

__module__ = 'awslimitchecker.limit'¶

__weakref__¶

list of weak references to the object (if defined)

_add_current_usage(value, resource_id=None, aws_type=None)[source]¶

Add a new current usage value for this limit.

Creates a new AwsLimitUsage instance and appends it to the internal list. If more than one usage value is given to this service, they should have id and aws_type set.

This method should only be called from the _AwsService instance that created and manages this Limit.

Parameters:	value (int or float) – the numeric usage value resource_id (string) – If there can be multiple usage values for one limit, an AWS ID for the resource this instance describes aws_type (string) – if id is not None, the AWS resource type that ID represents. As a convention, we use the AWS Resource Type names used by CloudFormation # noqa

_get_thresholds()[source]¶

Get the warning and critical thresholds for this Limit.

Return type is a 4-tuple of:

1. warning integer (usage) threshold, or None
2. warning percent threshold
3. critical integer (usage) threshold, or None
4. critical percent threshold

Return type:	tuple

_reset_usage()[source]¶

Discard all current usage data.

_set_api_limit(limit_value)[source]¶

Set the value for the limit as reported by the service’s API.

This method should only be called from the Service class.

Parameters:	limit_value (int) – the API limit value

_set_ta_limit(limit_value)[source]¶

Set the value for the limit as reported by Trusted Advisor.

This method should only be called by TrustedAdvisor.

Parameters:	limit_value (int) – the Trusted Advisor limit value

_set_ta_unlimited()[source]¶

Set state to indicate that TrustedAdvisor reports this limit as having no maximum (unlimited).

This method should only be called by TrustedAdvisor.

check_thresholds()[source]¶

Check this limit’s current usage against the specified default thresholds, and any custom theresholds that have been set on the class instance. Return True if usage is within thresholds, or false if warning or critical thresholds have been surpassed.

This method sets internal variables in this instance which can be queried via get_warnings() and get_criticals() to obtain further details about the thresholds that were crossed.

Note This function returns False if any thresholds were crossed. Please be aware of this when setting threshold overrides to suppress alerts. Each threshold (warn_percent, warn_count, crit_percent, crit_count) that has been set is evaluated individually and the result appended to a list of warnings or criticals, respectively. If any of these evaluations failed, the method returns False.

Returns:	False if any thresholds were crossed, True otherwise
Return type:	bool

get_criticals()[source]¶

Return a list of AwsLimitUsage instances that crossed the critical threshold. These objects are comparable and can be sorted.

Return type:	list

get_current_usage()[source]¶

Get the current usage for this limit, as a list of AwsLimitUsage instances.

Returns:	list of current usage values
Return type:	list of AwsLimitUsage

get_current_usage_str()[source]¶

Get the a string describing the current usage for this limit.

If no usage has been added for this limit, the result will be “<unknown>”.

If the limit has only one current usage instance, this will be that instance’s __str__() value.

If the limit has more than one current usage instance, this will be the a string of the form max: X (Y) where X is the __str__() value of the instance with the maximum value, and Y is a comma-separated list of the __str__() values of all usage instances in ascending order.

Returns:	representation of current usage
Return type:	string

get_limit()[source]¶

Returns the effective limit value for this Limit, taking into account limit overrides and Trusted Advisor data. None is returned for limits that are explicitly unlimited.

Returns:	effective limit value, int or None

get_limit_source()[source]¶

Return SOURCE_DEFAULT if get_limit() returns the default limit, SOURCE_OVERRIDE if it returns a manually-overridden limit, SOURCE_TA if it returns a limit from Trusted Advisor, or SOURCE_API if it returns a limit retrieved from the service’s API.

Returns:	one of SOURCE_DEFAULT, SOURCE_OVERRIDE, or SOURCE_TA, or SOURCE_API
Return type:	int

get_warnings()[source]¶

Return a list of AwsLimitUsage instances that crossed the warning threshold. These objects are comparable and can be sorted.

Return type:	list

set_limit_override(limit_value, override_ta=True)[source]¶

Set a new value for this limit, to override the default (such as when AWS Support has increased a limit of yours). If override_ta is True, this value will also supersede any found through Trusted Advisor.

Parameters:	limit_value (int) – the new limit value override_ta (bool) – whether or not to also override Trusted Advisor information

set_threshold_override(warn_percent=None, warn_count=None, crit_percent=None, crit_count=None)[source]¶

Override the default warning and critical thresholds used to evaluate this limit’s usage. Theresholds can be specified as a percentage of the limit, or as a usage count, or both.

Note: The percent thresholds (warn_percent and crit_percent) have default values that are set globally for awslimitchecker, unlike the count thresholds. When setting threshold overrides to quiet or suppress alerts for a limit, you must set the percent thresholds. If you only set overrides for the count thresholds, the percent thresholds will continue to be evaluated at their awslimitchecker-wide default, and likely prevent alerts from being suppressed.

see check_thresholds() for further information on threshold evaluation.

Parameters:	warn_percent (int) – new warning threshold, percentage used warn_count (int) – new warning threshold, actual count/number crit_percent (int) – new critical threshold, percentage used crit_count (int) – new critical threshold, actual count/number

ta_limit_name¶

Return the effective Trusted Advisor limit name that this limit’s data will have. This should be self._ta_limit_name if set, otherwise self.name.

Returns:	Trusted Advisor limit data name
Return type:	str

ta_service_name¶

Return the effective Trusted Advisor service name that this limit’s data will have. This should be self._ta_service_name if set, otherwise the name of self.service.

Returns:	Trusted Advisor service data name
Return type:	str

class awslimitchecker.limit.AwsLimitUsage(limit, value, resource_id=None, aws_type=None)[source]¶

Bases: object

This object describes the usage of an AWS resource, with the capability of containing information about the resource beyond an integer usage.

The simplest case is an account- / region-wide count, such as the number of running EC2 Instances, in which case a simple integer value is sufficient. In this case, the AwsLimit would have one instance of this class for the single value.

In more complex cases, such as the “Subnets per VPC”, the limit is applied by AWS on multiple resources (once per VPC). In this case, the AwsLimit should have one instance of this class per VPC, so we can determine which VPCs have crossed thresholds.

AwsLimitUsage objects are comparable based on their numeric value.

Parameters:	limit (AwsLimit) – the AwsLimit that this instance describes value (int or float) – the numeric usage value resource_id (string) – If there can be multiple usage values for one limit, an AWS ID for the resource this instance describes aws_type (string) – if id is not None, the AWS resource type that ID represents. As a convention, we use the AWS Resource Type names used by CloudFormation # noqa

__dict__ = dict_proxy({'__ne__': <function __ne__ at 0x7fc18c0dfc80>, '__module__': 'awslimitchecker.limit', '__weakref__': <attribute '__weakref__' of 'AwsLimitUsage' objects>, '__str__': <function __str__ at 0x7fc18c0dfb90>, 'get_value': <function get_value at 0x7fc18c0dfb18>, '__init__': <function __init__ at 0x7fc18c0dfaa0>, '__gt__': <function __gt__ at 0x7fc18c0dfcf8>, '__dict__': <attribute '__dict__' of 'AwsLimitUsage' objects>, '__lt__': <function __lt__ at 0x7fc18c0dfd70>, '__eq__': <function __eq__ at 0x7fc18c0dfc08>, '__doc__': None, '__ge__': <function __ge__ at 0x7fc18c0dfde8>})¶

__eq__(other)[source]¶

__ge__(other)[source]¶

__gt__(other)[source]¶

__init__(limit, value, resource_id=None, aws_type=None)[source]¶

This object describes the usage of an AWS resource, with the capability of containing information about the resource beyond an integer usage.

The simplest case is an account- / region-wide count, such as the number of running EC2 Instances, in which case a simple integer value is sufficient. In this case, the AwsLimit would have one instance of this class for the single value.

In more complex cases, such as the “Subnets per VPC”, the limit is applied by AWS on multiple resources (once per VPC). In this case, the AwsLimit should have one instance of this class per VPC, so we can determine which VPCs have crossed thresholds.

AwsLimitUsage objects are comparable based on their numeric value.

Parameters:	limit (AwsLimit) – the AwsLimit that this instance describes value (int or float) – the numeric usage value resource_id (string) – If there can be multiple usage values for one limit, an AWS ID for the resource this instance describes aws_type (string) – if id is not None, the AWS resource type that ID represents. As a convention, we use the AWS Resource Type names used by CloudFormation # noqa

__lt__(other)[source]¶

__module__ = 'awslimitchecker.limit'¶

__ne__(other)[source]¶

__str__()[source]¶

Return a string representation of this object.

If id is not set, return value formatted as a string; otherwise, return a string of the format id=value.

Return type:	string

__weakref__¶

list of weak references to the object (if defined)

get_value()[source]¶

Get the current usage value

Returns:	current usage value
Return type:	int or float

awslimitchecker.limit.SOURCE_API = 3¶

indicates a limit value that came from the service’s API

awslimitchecker.limit.SOURCE_DEFAULT = 0¶

indicates a limit value that came from hard-coded defaults in awslimitchecker

awslimitchecker.limit.SOURCE_OVERRIDE = 1¶

indicates a limit value that came from user-defined limit overrides

awslimitchecker.limit.SOURCE_TA = 2¶

indicates a limit value that came from Trusted Advisor

awslimitchecker.runner module¶

class awslimitchecker.runner.Runner[source]¶

Bases: object

__dict__ = dict_proxy({'__module__': 'awslimitchecker.runner', 'color_output': <function color_output at 0x7fc18bf12b90>, 'parse_args': <function parse_args at 0x7fc18bf128c0>, '__weakref__': <attribute '__weakref__' of 'Runner' objects>, 'list_services': <function list_services at 0x7fc18bf12938>, 'check_thresholds': <function check_thresholds at 0x7fc18bf12c80>, 'console_entry_point': <function console_entry_point at 0x7fc18bf12d70>, '__doc__': None, 'list_defaults': <function list_defaults at 0x7fc18bf12a28>, 'iam_policy': <function iam_policy at 0x7fc18bf12aa0>, '__dict__': <attribute '__dict__' of 'Runner' objects>, 'set_limit_overrides': <function set_limit_overrides at 0x7fc18bf12cf8>, 'list_limits': <function list_limits at 0x7fc18bf129b0>, 'print_issue': <function print_issue at 0x7fc18bf12c08>, '__init__': <function __init__ at 0x7fc18bf12848>, 'show_usage': <function show_usage at 0x7fc18bf12b18>})¶

__init__()[source]¶

__module__ = 'awslimitchecker.runner'¶

__weakref__¶

list of weak references to the object (if defined)

check_thresholds()[source]¶

color_output(s, color)[source]¶

console_entry_point()[source]¶

iam_policy()[source]¶

list_defaults()[source]¶

list_limits()[source]¶

list_services()[source]¶

parse_args(argv)[source]¶

parse arguments/options

Parameters:	argv (list) – argument list to parse, usually sys.argv[1:]
Returns:	parsed arguments
Return type:	argparse.Namespace

print_issue(service_name, limit, crits, warns)[source]¶

Parameters:	service_name (str) – the name of the service limit (AwsLimit) – the Limit this relates to crits – the specific usage values that crossed the critical threshold crits – the specific usage values that crossed the warning threshold

set_limit_overrides(overrides)[source]¶

show_usage()[source]¶