Mini Shell
"""
Connection module for Amazon Autoscale Groups
.. versionadded:: 2014.7.0
:configuration: This module accepts explicit autoscale credentials but can also
utilize IAM roles assigned to the instance through Instance Profiles.
Dynamic credentials are then automatically obtained from AWS API and no
further configuration is necessary. More Information available at:
.. code-block:: text
http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html
If IAM roles are not used you need to specify them either in a pillar or
in the minion's config file:
.. code-block:: yaml
asg.keyid: GKTADJGHEIQSXMKKRBJ08H
asg.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
A region may also be specified in the configuration:
.. code-block:: yaml
asg.region: us-east-1
If a region is not specified, the default is us-east-1.
It's also possible to specify key, keyid and region via a profile, either
as a passed in dict, or as a string to pull from pillars or minion config:
.. code-block:: yaml
myprofile:
keyid: GKTADJGHEIQSXMKKRBJ08H
key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
region: us-east-1
:depends: boto
:depends: boto3
"""
# keep lint from choking on _get_conn and _cache_id
# pylint: disable=E0602
import datetime
import email.mime.multipart
import logging
import sys
import time
import salt.utils.compat
import salt.utils.json
import salt.utils.odict as odict
import salt.utils.versions
log = logging.getLogger(__name__)
DATE_FORMAT = "%Y-%m-%dT%H:%M:%SZ"
try:
import boto
import boto.ec2
import boto.ec2.autoscale as autoscale
import boto.ec2.blockdevicemapping as blockdevicemapping
import boto.ec2.instance
logging.getLogger("boto").setLevel(logging.CRITICAL)
import boto3 # pylint: disable=unused-import
from botocore.exceptions import ClientError
logging.getLogger("boto3").setLevel(logging.CRITICAL)
HAS_BOTO = True
except ImportError:
HAS_BOTO = False
def __virtual__():
"""
Only load if boto libraries exist.
"""
has_boto_reqs = salt.utils.versions.check_boto_reqs()
if has_boto_reqs is True:
__utils__["boto.assign_funcs"](
__name__, "asg", module="ec2.autoscale", pack=__salt__
)
setattr(
sys.modules[__name__],
"_get_ec2_conn",
__utils__["boto.get_connection_func"]("ec2"),
)
return has_boto_reqs
def __init__(opts):
if HAS_BOTO:
__utils__["boto3.assign_funcs"](
__name__, "autoscaling", get_conn_funcname="_get_conn_autoscaling_boto3"
)
def exists(name, region=None, key=None, keyid=None, profile=None):
"""
Check to see if an autoscale group exists.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.exists myasg region=us-east-1
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
_conn = conn.get_all_groups(names=[name])
if _conn:
return True
else:
msg = f"The autoscale group does not exist in region {region}"
log.debug(msg)
return False
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return False
def get_config(name, region=None, key=None, keyid=None, profile=None):
"""
Get the configuration for an autoscale group.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.get_config myasg region=us-east-1
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
asg = conn.get_all_groups(names=[name])
if asg:
asg = asg[0]
else:
return {}
ret = odict.OrderedDict()
attrs = [
"name",
"availability_zones",
"default_cooldown",
"desired_capacity",
"health_check_period",
"health_check_type",
"launch_config_name",
"load_balancers",
"max_size",
"min_size",
"placement_group",
"vpc_zone_identifier",
"tags",
"termination_policies",
"suspended_processes",
]
for attr in attrs:
# Tags are objects, so we need to turn them into dicts.
if attr == "tags":
_tags = []
for tag in asg.tags:
_tag = odict.OrderedDict()
_tag["key"] = tag.key
_tag["value"] = tag.value
_tag["propagate_at_launch"] = tag.propagate_at_launch
_tags.append(_tag)
ret["tags"] = _tags
# Boto accepts a string or list as input for vpc_zone_identifier,
# but always returns a comma separated list. We require lists in
# states.
elif attr == "vpc_zone_identifier":
ret[attr] = getattr(asg, attr).split(",")
# convert SuspendedProcess objects to names
elif attr == "suspended_processes":
suspended_processes = getattr(asg, attr)
ret[attr] = sorted(x.process_name for x in suspended_processes)
else:
ret[attr] = getattr(asg, attr)
# scaling policies
policies = conn.get_all_policies(as_group=name)
ret["scaling_policies"] = []
for policy in policies:
ret["scaling_policies"].append(
dict(
[
("name", policy.name),
("adjustment_type", policy.adjustment_type),
("scaling_adjustment", policy.scaling_adjustment),
("min_adjustment_step", policy.min_adjustment_step),
("cooldown", policy.cooldown),
]
)
)
# scheduled actions
actions = conn.get_all_scheduled_actions(as_group=name)
ret["scheduled_actions"] = {}
for action in actions:
end_time = None
if action.end_time:
end_time = action.end_time.isoformat()
ret["scheduled_actions"][action.name] = dict(
[
("min_size", action.min_size),
("max_size", action.max_size),
# AWS bug
("desired_capacity", int(action.desired_capacity)),
("start_time", action.start_time.isoformat()),
("end_time", end_time),
("recurrence", action.recurrence),
]
)
return ret
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return {}
def create(
name,
launch_config_name,
availability_zones,
min_size,
max_size,
desired_capacity=None,
load_balancers=None,
default_cooldown=None,
health_check_type=None,
health_check_period=None,
placement_group=None,
vpc_zone_identifier=None,
tags=None,
termination_policies=None,
suspended_processes=None,
scaling_policies=None,
scheduled_actions=None,
region=None,
notification_arn=None,
notification_types=None,
key=None,
keyid=None,
profile=None,
):
"""
Create an autoscale group.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.create myasg mylc '["us-east-1a", "us-east-1e"]' 1 10 load_balancers='["myelb", "myelb2"]' tags='[{"key": "Name", value="myasg", "propagate_at_launch": True}]'
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if isinstance(availability_zones, str):
availability_zones = salt.utils.json.loads(availability_zones)
if isinstance(load_balancers, str):
load_balancers = salt.utils.json.loads(load_balancers)
if isinstance(vpc_zone_identifier, str):
vpc_zone_identifier = salt.utils.json.loads(vpc_zone_identifier)
if isinstance(tags, str):
tags = salt.utils.json.loads(tags)
# Make a list of tag objects from the dict.
_tags = []
if tags:
for tag in tags:
try:
key = tag.get("key")
except KeyError:
log.error("Tag missing key.")
return False
try:
value = tag.get("value")
except KeyError:
log.error("Tag missing value.")
return False
propagate_at_launch = tag.get("propagate_at_launch", False)
_tag = autoscale.Tag(
key=key,
value=value,
resource_id=name,
propagate_at_launch=propagate_at_launch,
)
_tags.append(_tag)
if isinstance(termination_policies, str):
termination_policies = salt.utils.json.loads(termination_policies)
if isinstance(suspended_processes, str):
suspended_processes = salt.utils.json.loads(suspended_processes)
if isinstance(scheduled_actions, str):
scheduled_actions = salt.utils.json.loads(scheduled_actions)
retries = 30
while True:
try:
_asg = autoscale.AutoScalingGroup(
name=name,
launch_config=launch_config_name,
availability_zones=availability_zones,
min_size=min_size,
max_size=max_size,
desired_capacity=desired_capacity,
load_balancers=load_balancers,
default_cooldown=default_cooldown,
health_check_type=health_check_type,
health_check_period=health_check_period,
placement_group=placement_group,
tags=_tags,
vpc_zone_identifier=vpc_zone_identifier,
termination_policies=termination_policies,
suspended_processes=suspended_processes,
)
conn.create_auto_scaling_group(_asg)
# create scaling policies
_create_scaling_policies(conn, name, scaling_policies)
# create scheduled actions
_create_scheduled_actions(conn, name, scheduled_actions)
# create notifications
if notification_arn and notification_types:
conn.put_notification_configuration(
_asg, notification_arn, notification_types
)
log.info("Created ASG %s", name)
return True
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
msg = "Failed to create ASG %s", name
log.error(msg)
return False
def update(
name,
launch_config_name,
availability_zones,
min_size,
max_size,
desired_capacity=None,
load_balancers=None,
default_cooldown=None,
health_check_type=None,
health_check_period=None,
placement_group=None,
vpc_zone_identifier=None,
tags=None,
termination_policies=None,
suspended_processes=None,
scaling_policies=None,
scheduled_actions=None,
notification_arn=None,
notification_types=None,
region=None,
key=None,
keyid=None,
profile=None,
):
"""
Update an autoscale group.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.update myasg mylc '["us-east-1a", "us-east-1e"]' 1 10 load_balancers='["myelb", "myelb2"]' tags='[{"key": "Name", value="myasg", "propagate_at_launch": True}]'
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
conn3 = _get_conn_autoscaling_boto3(
region=region, key=key, keyid=keyid, profile=profile
)
if not conn:
return False, "failed to connect to AWS"
if isinstance(availability_zones, str):
availability_zones = salt.utils.json.loads(availability_zones)
if isinstance(load_balancers, str):
load_balancers = salt.utils.json.loads(load_balancers)
if isinstance(vpc_zone_identifier, str):
vpc_zone_identifier = salt.utils.json.loads(vpc_zone_identifier)
if isinstance(tags, str):
tags = salt.utils.json.loads(tags)
if isinstance(termination_policies, str):
termination_policies = salt.utils.json.loads(termination_policies)
if isinstance(suspended_processes, str):
suspended_processes = salt.utils.json.loads(suspended_processes)
if isinstance(scheduled_actions, str):
scheduled_actions = salt.utils.json.loads(scheduled_actions)
# Massage our tagset into add / remove lists
# Use a boto3 call here b/c the boto2 call doeesn't implement filters
current_tags = conn3.describe_tags(
Filters=[{"Name": "auto-scaling-group", "Values": [name]}]
).get("Tags", [])
current_tags = [
{
"key": t["Key"],
"value": t["Value"],
"resource_id": t["ResourceId"],
"propagate_at_launch": t.get("PropagateAtLaunch", False),
}
for t in current_tags
]
add_tags = []
desired_tags = []
if tags:
tags = __utils__["boto3.ordered"](tags)
for tag in tags:
try:
key = tag.get("key")
except KeyError:
log.error("Tag missing key.")
return False, f"Tag {tag} missing key"
try:
value = tag.get("value")
except KeyError:
log.error("Tag missing value.")
return False, f"Tag {tag} missing value"
propagate_at_launch = tag.get("propagate_at_launch", False)
_tag = {
"key": key,
"value": value,
"resource_id": name,
"propagate_at_launch": propagate_at_launch,
}
if _tag not in current_tags:
add_tags.append(_tag)
desired_tags.append(_tag)
delete_tags = [t for t in current_tags if t not in desired_tags]
retries = 30
while True:
try:
_asg = autoscale.AutoScalingGroup(
connection=conn,
name=name,
launch_config=launch_config_name,
availability_zones=availability_zones,
min_size=min_size,
max_size=max_size,
desired_capacity=desired_capacity,
load_balancers=load_balancers,
default_cooldown=default_cooldown,
health_check_type=health_check_type,
health_check_period=health_check_period,
placement_group=placement_group,
tags=add_tags,
vpc_zone_identifier=vpc_zone_identifier,
termination_policies=termination_policies,
)
if notification_arn and notification_types:
conn.put_notification_configuration(
_asg, notification_arn, notification_types
)
_asg.update()
# Seems the update call doesn't handle tags, so we'll need to update
# that separately.
if add_tags:
log.debug("Adding/updating tags from ASG: %s", add_tags)
conn.create_or_update_tags([autoscale.Tag(**t) for t in add_tags])
if delete_tags:
log.debug("Deleting tags from ASG: %s", delete_tags)
conn.delete_tags([autoscale.Tag(**t) for t in delete_tags])
# update doesn't handle suspended_processes either
# Resume all processes
_asg.resume_processes()
# suspend any that are specified. Note that the boto default of empty
# list suspends all; don't do that.
if suspended_processes:
_asg.suspend_processes(suspended_processes)
log.info("Updated ASG %s", name)
# ### scaling policies
# delete all policies, then recreate them
for policy in conn.get_all_policies(as_group=name):
conn.delete_policy(policy.name, autoscale_group=name)
_create_scaling_policies(conn, name, scaling_policies)
# ### scheduled actions
# delete all scheduled actions, then recreate them
for scheduled_action in conn.get_all_scheduled_actions(as_group=name):
conn.delete_scheduled_action(
scheduled_action.name, autoscale_group=name
)
_create_scheduled_actions(conn, name, scheduled_actions)
return True, ""
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
msg = f"Failed to update ASG {name}"
log.error(msg)
return False, str(e)
def _create_scaling_policies(conn, as_name, scaling_policies):
"helper function to create scaling policies"
if scaling_policies:
for policy in scaling_policies:
policy = autoscale.policy.ScalingPolicy(
name=policy["name"],
as_name=as_name,
adjustment_type=policy["adjustment_type"],
scaling_adjustment=policy["scaling_adjustment"],
min_adjustment_step=policy.get("min_adjustment_step", None),
cooldown=policy["cooldown"],
)
conn.create_scaling_policy(policy)
def _create_scheduled_actions(conn, as_name, scheduled_actions):
"""
Helper function to create scheduled actions
"""
if scheduled_actions:
for name, action in scheduled_actions.items():
if "start_time" in action and isinstance(action["start_time"], str):
action["start_time"] = datetime.datetime.strptime(
action["start_time"], DATE_FORMAT
)
if "end_time" in action and isinstance(action["end_time"], str):
action["end_time"] = datetime.datetime.strptime(
action["end_time"], DATE_FORMAT
)
conn.create_scheduled_group_action(
as_name,
name,
desired_capacity=action.get("desired_capacity"),
min_size=action.get("min_size"),
max_size=action.get("max_size"),
start_time=action.get("start_time"),
end_time=action.get("end_time"),
recurrence=action.get("recurrence"),
)
def delete(name, force=False, region=None, key=None, keyid=None, profile=None):
"""
Delete an autoscale group.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.delete myasg region=us-east-1
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
conn.delete_auto_scaling_group(name, force)
msg = f"Deleted autoscale group {name}."
log.info(msg)
return True
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
msg = f"Failed to delete autoscale group {name}"
log.error(msg)
return False
def get_cloud_init_mime(cloud_init):
"""
Get a mime multipart encoded string from a cloud-init dict. Currently
supports boothooks, scripts and cloud-config.
CLI Example:
.. code-block:: bash
salt myminion boto.get_cloud_init_mime <cloud init>
"""
if isinstance(cloud_init, str):
cloud_init = salt.utils.json.loads(cloud_init)
_cloud_init = email.mime.multipart.MIMEMultipart()
if "boothooks" in cloud_init:
for script_name, script in cloud_init["boothooks"].items():
_script = email.mime.text.MIMEText(script, "cloud-boothook")
_cloud_init.attach(_script)
if "scripts" in cloud_init:
for script_name, script in cloud_init["scripts"].items():
_script = email.mime.text.MIMEText(script, "x-shellscript")
_cloud_init.attach(_script)
if "cloud-config" in cloud_init:
cloud_config = cloud_init["cloud-config"]
_cloud_config = email.mime.text.MIMEText(
salt.utils.yaml.safe_dump(cloud_config, default_flow_style=False),
"cloud-config",
)
_cloud_init.attach(_cloud_config)
return _cloud_init.as_string()
def launch_configuration_exists(name, region=None, key=None, keyid=None, profile=None):
"""
Check for a launch configuration's existence.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.launch_configuration_exists mylc
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
lc = conn.get_all_launch_configurations(names=[name])
if lc:
return True
else:
msg = "The launch configuration does not exist in region {}".format(
region
)
log.debug(msg)
return False
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return False
def get_all_launch_configurations(region=None, key=None, keyid=None, profile=None):
"""
Fetch and return all Launch Configuration with details.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.get_all_launch_configurations
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
return conn.get_all_launch_configurations()
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return []
def list_launch_configurations(region=None, key=None, keyid=None, profile=None):
"""
List all Launch Configurations.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.list_launch_configurations
"""
ret = get_all_launch_configurations(region, key, keyid, profile)
return [r.name for r in ret]
def describe_launch_configuration(
name, region=None, key=None, keyid=None, profile=None
):
"""
Dump details of a given launch configuration.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.describe_launch_configuration mylc
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
lc = conn.get_all_launch_configurations(names=[name])
if lc:
return lc[0]
else:
msg = "The launch configuration does not exist in region {}".format(
region
)
log.debug(msg)
return None
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return None
def create_launch_configuration(
name,
image_id,
key_name=None,
vpc_id=None,
vpc_name=None,
security_groups=None,
user_data=None,
instance_type="m1.small",
kernel_id=None,
ramdisk_id=None,
block_device_mappings=None,
instance_monitoring=False,
spot_price=None,
instance_profile_name=None,
ebs_optimized=False,
associate_public_ip_address=None,
volume_type=None,
delete_on_termination=True,
iops=None,
use_block_device_types=False,
region=None,
key=None,
keyid=None,
profile=None,
):
"""
Create a launch configuration.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.create_launch_configuration mylc image_id=ami-0b9c9f62 key_name='mykey' security_groups='["mygroup"]' instance_type='c3.2xlarge'
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if isinstance(security_groups, str):
security_groups = salt.utils.json.loads(security_groups)
if isinstance(block_device_mappings, str):
block_device_mappings = salt.utils.json.loads(block_device_mappings)
_bdms = []
if block_device_mappings:
# Boto requires objects for the mappings and the devices.
_block_device_map = blockdevicemapping.BlockDeviceMapping()
for block_device_dict in block_device_mappings:
for block_device, attributes in block_device_dict.items():
_block_device = blockdevicemapping.EBSBlockDeviceType()
for attribute, value in attributes.items():
setattr(_block_device, attribute, value)
_block_device_map[block_device] = _block_device
_bdms = [_block_device_map]
# If a VPC is specified, then determine the secgroup id's within that VPC, not
# within the default VPC. If a security group id is already part of the list,
# convert_to_group_ids leaves that entry without attempting a lookup on it.
if security_groups and (vpc_id or vpc_name):
security_groups = __salt__["boto_secgroup.convert_to_group_ids"](
security_groups,
vpc_id=vpc_id,
vpc_name=vpc_name,
region=region,
key=key,
keyid=keyid,
profile=profile,
)
lc = autoscale.LaunchConfiguration(
name=name,
image_id=image_id,
key_name=key_name,
security_groups=security_groups,
user_data=user_data,
instance_type=instance_type,
kernel_id=kernel_id,
ramdisk_id=ramdisk_id,
block_device_mappings=_bdms,
instance_monitoring=instance_monitoring,
spot_price=spot_price,
instance_profile_name=instance_profile_name,
ebs_optimized=ebs_optimized,
associate_public_ip_address=associate_public_ip_address,
volume_type=volume_type,
delete_on_termination=delete_on_termination,
iops=iops,
use_block_device_types=use_block_device_types,
)
retries = 30
while True:
try:
conn.create_launch_configuration(lc)
log.info("Created LC %s", name)
return True
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
msg = f"Failed to create LC {name}"
log.error(msg)
return False
def delete_launch_configuration(name, region=None, key=None, keyid=None, profile=None):
"""
Delete a launch configuration.
CLI Example:
.. code-block:: bash
salt myminion boto_asg.delete_launch_configuration mylc
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
conn.delete_launch_configuration(name)
log.info("Deleted LC %s", name)
return True
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
msg = f"Failed to delete LC {name}"
log.error(msg)
return False
def get_scaling_policy_arn(
as_group, scaling_policy_name, region=None, key=None, keyid=None, profile=None
):
"""
Return the arn for a scaling policy in a specific autoscale group or None
if not found. Mainly used as a helper method for boto_cloudwatch_alarm, for
linking alarms to scaling policies.
CLI Example:
.. code-block:: bash
salt '*' boto_asg.get_scaling_policy_arn mygroup mypolicy
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while retries > 0:
retries -= 1
try:
policies = conn.get_all_policies(as_group=as_group)
for policy in policies:
if policy.name == scaling_policy_name:
return policy.policy_arn
log.error("Could not convert: %s", as_group)
return None
except boto.exception.BotoServerError as e:
if e.error_code != "Throttling":
raise
log.debug("Throttled by API, will retry in 5 seconds")
time.sleep(5)
log.error("Maximum number of retries exceeded")
return None
def get_all_groups(region=None, key=None, keyid=None, profile=None):
"""
Return all AutoScale Groups visible in the account
(as a list of boto.ec2.autoscale.group.AutoScalingGroup).
.. versionadded:: 2016.11.0
CLI Example:
.. code-block:: bash
salt-call boto_asg.get_all_groups region=us-east-1 --output yaml
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
next_token = ""
asgs = []
while next_token is not None:
ret = conn.get_all_groups(next_token=next_token)
asgs += [a for a in ret]
next_token = ret.next_token
return asgs
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return []
def list_groups(region=None, key=None, keyid=None, profile=None):
"""
Return all AutoScale Groups visible in the account
(as a list of names).
.. versionadded:: 2016.11.0
CLI Example:
.. code-block:: bash
salt-call boto_asg.list_groups region=us-east-1
"""
return [
a.name
for a in get_all_groups(region=region, key=key, keyid=keyid, profile=profile)
]
def get_instances(
name,
lifecycle_state="InService",
health_status="Healthy",
attribute="private_ip_address",
attributes=None,
region=None,
key=None,
keyid=None,
profile=None,
):
"""
return attribute of all instances in the named autoscale group.
CLI Example:
.. code-block:: bash
salt-call boto_asg.get_instances my_autoscale_group_name
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
ec2_conn = _get_ec2_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
asgs = conn.get_all_groups(names=[name])
break
except boto.exception.BotoServerError as e:
if retries and e.code == "Throttling":
log.debug("Throttled by AWS API, retrying in 5 seconds...")
time.sleep(5)
retries -= 1
continue
log.error(e)
return False
if len(asgs) != 1:
log.debug(
"name '%s' returns multiple ASGs: %s", name, [asg.name for asg in asgs]
)
return False
asg = asgs[0]
instance_ids = []
# match lifecycle_state and health_status
for i in asg.instances:
if lifecycle_state is not None and i.lifecycle_state != lifecycle_state:
continue
if health_status is not None and i.health_status != health_status:
continue
instance_ids.append(i.instance_id)
# get full instance info, so that we can return the attribute
instances = ec2_conn.get_only_instances(instance_ids=instance_ids)
if attributes:
return [
[_convert_attribute(instance, attr) for attr in attributes]
for instance in instances
]
else:
# properly handle case when not all instances have the requested attribute
return [
_convert_attribute(instance, attribute)
for instance in instances
if getattr(instance, attribute)
]
def _convert_attribute(instance, attribute):
if attribute == "tags":
tags = dict(getattr(instance, attribute))
return {
key.encode("utf-8"): value.encode("utf-8") for key, value in tags.items()
}
return getattr(instance, attribute).encode("ascii")
def enter_standby(
name,
instance_ids,
should_decrement_desired_capacity=False,
region=None,
key=None,
keyid=None,
profile=None,
):
"""
Switch desired instances to StandBy mode
.. versionadded:: 2016.11.0
CLI Example:
.. code-block:: bash
salt-call boto_asg.enter_standby my_autoscale_group_name '["i-xxxxxx"]'
"""
conn = _get_conn_autoscaling_boto3(
region=region, key=key, keyid=keyid, profile=profile
)
try:
response = conn.enter_standby(
InstanceIds=instance_ids,
AutoScalingGroupName=name,
ShouldDecrementDesiredCapacity=should_decrement_desired_capacity,
)
except ClientError as e:
err = __utils__["boto3.get_error"](e)
if e.response.get("Error", {}).get("Code") == "ResourceNotFoundException":
return {"exists": False}
return {"error": err}
return all(
activity["StatusCode"] != "Failed" for activity in response["Activities"]
)
def exit_standby(
name,
instance_ids,
should_decrement_desired_capacity=False,
region=None,
key=None,
keyid=None,
profile=None,
):
"""
Exit desired instances from StandBy mode
.. versionadded:: 2016.11.0
CLI Example:
.. code-block:: bash
salt-call boto_asg.exit_standby my_autoscale_group_name '["i-xxxxxx"]'
"""
conn = _get_conn_autoscaling_boto3(
region=region, key=key, keyid=keyid, profile=profile
)
try:
response = conn.exit_standby(
InstanceIds=instance_ids, AutoScalingGroupName=name
)
except ClientError as e:
err = __utils__["boto3.get_error"](e)
if e.response.get("Error", {}).get("Code") == "ResourceNotFoundException":
return {"exists": False}
return {"error": err}
return all(
activity["StatusCode"] != "Failed" for activity in response["Activities"]
)
Zerion Mini Shell 1.0