Mini Shell
"""
Execution module for Amazon Elasticache using boto3
===================================================
.. versionadded:: 2017.7.0
:configuration: This module accepts explicit elasticache 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
elasticache.keyid: GKTADJGHEIQSXMKKRBJ08H
elasticache.key: askdjghsdfjkghWupUjasdflkdfklgjsdfjajkghs
A region may also be specified in the configuration:
.. code-block:: yaml
elasticache.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: boto3
"""
# keep lint from choking on _get_conn and _cache_id
# pylint: disable=E0602
import logging
import time
import salt.utils.compat
import salt.utils.versions
from salt.exceptions import CommandExecutionError, SaltInvocationError
log = logging.getLogger(__name__)
try:
# pylint: disable=unused-import
import boto3
import botocore
# pylint: enable=unused-import
logging.getLogger("boto3").setLevel(logging.CRITICAL)
HAS_BOTO3 = True
except ImportError:
HAS_BOTO3 = False
def __virtual__():
"""
Only load if boto libraries exist and if boto libraries are greater than
a given version.
"""
return salt.utils.versions.check_boto_reqs()
def __init__(opts):
if HAS_BOTO3:
__utils__["boto3.assign_funcs"](
__name__,
"elasticache",
get_conn_funcname="_get_conn",
cache_id_funcname="_cache_id",
exactly_one_funcname=None,
)
def _collect_results(func, item, args, marker="Marker"):
ret = []
Marker = args[marker] if marker in args else ""
while Marker is not None:
r = func(**args)
ret += r.get(item)
Marker = r.get(marker)
args.update({marker: Marker})
return ret
def _describe_resource(
name=None,
name_param=None,
res_type=None,
info_node=None,
conn=None,
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
if conn is None:
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
try:
func = "describe_" + res_type + "s"
f = getattr(conn, func)
except (AttributeError, KeyError) as e:
raise SaltInvocationError(f"No function '{func}()' found: {e.message}")
# Undocumented, but you can't pass 'Marker' if searching for a specific resource...
args.update({name_param: name} if name else {"Marker": ""})
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
return _collect_results(f, info_node, args)
except botocore.exceptions.ClientError as e:
log.debug(e)
return None
def _delete_resource(
name,
name_param,
desc,
res_type,
wait=0,
status_param=None,
status_gone="deleted",
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
"""
Delete a generic Elasticache resource.
"""
try:
wait = int(wait)
except Exception: # pylint: disable=broad-except
raise SaltInvocationError(
"Bad value ('{}') passed for 'wait' param - must be an "
"int or boolean.".format(wait)
)
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if name_param in args:
log.info(
"'name: %s' param being overridden by explicitly provided '%s: %s'",
name,
name_param,
args[name_param],
)
name = args[name_param]
else:
args[name_param] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
func = "delete_" + res_type
f = getattr(conn, func)
if wait:
func = "describe_" + res_type + "s"
s = globals()[func]
except (AttributeError, KeyError) as e:
raise SaltInvocationError(f"No function '{func}()' found: {e.message}")
try:
f(**args)
if not wait:
log.info("%s %s deletion requested.", desc.title(), name)
return True
log.info("Waiting up to %s seconds for %s %s to be deleted.", wait, desc, name)
orig_wait = wait
while wait > 0:
r = s(name=name, conn=conn)
if not r or r[0].get(status_param) == status_gone:
log.info("%s %s deleted.", desc.title(), name)
return True
sleep = wait if wait % 60 == wait else 60
log.info("Sleeping %s seconds for %s %s to be deleted.", sleep, desc, name)
time.sleep(sleep)
wait -= sleep
log.error("%s %s not deleted after %s seconds!", desc.title(), name, orig_wait)
return False
except botocore.exceptions.ClientError as e:
log.error("Failed to delete %s %s: %s", desc, name, e)
return False
def _create_resource(
name,
name_param=None,
desc=None,
res_type=None,
wait=0,
status_param=None,
status_good="available",
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
try:
wait = int(wait)
except Exception: # pylint: disable=broad-except
raise SaltInvocationError(
"Bad value ('{}') passed for 'wait' param - must be an "
"int or boolean.".format(wait)
)
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if name_param in args:
log.info(
"'name: %s' param being overridden by explicitly provided '%s: %s'",
name,
name_param,
args[name_param],
)
name = args[name_param]
else:
args[name_param] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
func = "create_" + res_type
f = getattr(conn, func)
if wait:
func = "describe_" + res_type + "s"
s = globals()[func]
except (AttributeError, KeyError) as e:
raise SaltInvocationError(f"No function '{func}()' found: {e.message}")
try:
f(**args)
if not wait:
log.info("%s %s created.", desc.title(), name)
return True
log.info(
"Waiting up to %s seconds for %s %s to be become available.",
wait,
desc,
name,
)
orig_wait = wait
while wait > 0:
r = s(name=name, conn=conn)
if r and r[0].get(status_param) == status_good:
log.info("%s %s created and available.", desc.title(), name)
return True
sleep = wait if wait % 60 == wait else 60
log.info(
"Sleeping %s seconds for %s %s to become available.", sleep, desc, name
)
time.sleep(sleep)
wait -= sleep
log.error(
"%s %s not available after %s seconds!", desc.title(), name, orig_wait
)
return False
except botocore.exceptions.ClientError as e:
msg = f"Failed to create {desc} {name}: {e}"
log.error(msg)
return False
def _modify_resource(
name,
name_param=None,
desc=None,
res_type=None,
wait=0,
status_param=None,
status_good="available",
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
try:
wait = int(wait)
except Exception: # pylint: disable=broad-except
raise SaltInvocationError(
"Bad value ('{}') passed for 'wait' param - must be an "
"int or boolean.".format(wait)
)
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if name_param in args:
log.info(
"'name: %s' param being overridden by explicitly provided '%s: %s'",
name,
name_param,
args[name_param],
)
name = args[name_param]
else:
args[name_param] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
func = "modify_" + res_type
f = getattr(conn, func)
if wait:
func = "describe_" + res_type + "s"
s = globals()[func]
except (AttributeError, KeyError) as e:
raise SaltInvocationError(f"No function '{func}()' found: {e.message}")
try:
f(**args)
if not wait:
log.info("%s %s modification requested.", desc.title(), name)
return True
log.info(
"Waiting up to %s seconds for %s %s to be become available.",
wait,
desc,
name,
)
orig_wait = wait
while wait > 0:
r = s(name=name, conn=conn)
if r and r[0].get(status_param) == status_good:
log.info("%s %s modified and available.", desc.title(), name)
return True
sleep = wait if wait % 60 == wait else 60
log.info(
"Sleeping %s seconds for %s %s to become available.", sleep, desc, name
)
time.sleep(sleep)
wait -= sleep
log.error(
"%s %s not available after %s seconds!", desc.title(), name, orig_wait
)
return False
except botocore.exceptions.ClientError as e:
msg = f"Failed to modify {desc} {name}: {e}"
log.error(msg)
return False
def describe_cache_clusters(
name=None, conn=None, region=None, key=None, keyid=None, profile=None, **args
):
"""
Return details about all (or just one) Elasticache cache clusters.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.describe_cache_clusters
salt myminion boto3_elasticache.describe_cache_clusters myelasticache
"""
return _describe_resource(
name=name,
name_param="CacheClusterId",
res_type="cache_cluster",
info_node="CacheClusters",
conn=conn,
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def cache_cluster_exists(
name, conn=None, region=None, key=None, keyid=None, profile=None
):
"""
Check to see if a cache cluster exists.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.cache_cluster_exists myelasticache
"""
return bool(
describe_cache_clusters(
name=name, conn=conn, region=region, key=key, keyid=keyid, profile=profile
)
)
def create_cache_cluster(
name,
wait=600,
security_groups=None,
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
"""
Create a cache cluster.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.create_cache_cluster name=myCacheCluster \
Engine=redis \
CacheNodeType=cache.t2.micro \
NumCacheNodes=1 \
SecurityGroupIds='[sg-11223344]' \
CacheSubnetGroupName=myCacheSubnetGroup
"""
if security_groups:
if not isinstance(security_groups, list):
security_groups = [security_groups]
sgs = __salt__["boto_secgroup.convert_to_group_ids"](
groups=security_groups, region=region, key=key, keyid=keyid, profile=profile
)
if "SecurityGroupIds" not in args:
args["SecurityGroupIds"] = []
args["SecurityGroupIds"] += sgs
args = {k: v for k, v in args.items() if not k.startswith("_")}
return _create_resource(
name,
name_param="CacheClusterId",
desc="cache cluster",
res_type="cache_cluster",
wait=wait,
status_param="CacheClusterStatus",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def modify_cache_cluster(
name,
wait=600,
security_groups=None,
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
"""
Update a cache cluster in place.
Notes: {ApplyImmediately: False} is pretty danged silly in the context of salt.
You can pass it, but for fairly obvious reasons the results over multiple
runs will be undefined and probably contrary to your desired state.
Reducing the number of nodes requires an EXPLICIT CacheNodeIdsToRemove be
passed, which until a reasonable heuristic for programmatically deciding
which nodes to remove has been established, MUST be decided and populated
intentionally before a state call, and removed again before the next. In
practice this is not particularly useful and should probably be avoided.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.create_cache_cluster name=myCacheCluster \
NotificationTopicStatus=inactive
"""
if security_groups:
if not isinstance(security_groups, list):
security_groups = [security_groups]
sgs = __salt__["boto_secgroup.convert_to_group_ids"](
groups=security_groups, region=region, key=key, keyid=keyid, profile=profile
)
if "SecurityGroupIds" not in args:
args["SecurityGroupIds"] = []
args["SecurityGroupIds"] += sgs
args = {k: v for k, v in args.items() if not k.startswith("_")}
return _modify_resource(
name,
name_param="CacheClusterId",
desc="cache cluster",
res_type="cache_cluster",
wait=wait,
status_param="CacheClusterStatus",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def delete_cache_cluster(
name, wait=600, region=None, key=None, keyid=None, profile=None, **args
):
"""
Delete a cache cluster.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.delete myelasticache
"""
return _delete_resource(
name,
name_param="CacheClusterId",
desc="cache cluster",
res_type="cache_cluster",
wait=wait,
status_param="CacheClusterStatus",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def describe_replication_groups(
name=None, conn=None, region=None, key=None, keyid=None, profile=None
):
"""
Return details about all (or just one) Elasticache replication groups.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.describe_replication_groups
salt myminion boto3_elasticache.describe_replication_groups myelasticache
"""
return _describe_resource(
name=name,
name_param="ReplicationGroupId",
res_type="replication_group",
info_node="ReplicationGroups",
conn=conn,
region=region,
key=key,
keyid=keyid,
profile=profile,
)
def replication_group_exists(name, region=None, key=None, keyid=None, profile=None):
"""
Check to see if a replication group exists.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.replication_group_exists myelasticache
"""
return bool(
describe_replication_groups(
name=name, region=region, key=key, keyid=keyid, profile=profile
)
)
def create_replication_group(
name,
wait=600,
security_groups=None,
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
"""
Create a replication group.
Params are extensive and variable - see
http://boto3.readthedocs.io/en/latest/reference/services/elasticache.html?#ElastiCache.Client.create_replication_group
for in-depth usage documentation.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.create_replication_group \
name=myelasticache \
ReplicationGroupDescription=description
"""
if security_groups:
if not isinstance(security_groups, list):
security_groups = [security_groups]
sgs = __salt__["boto_secgroup.convert_to_group_ids"](
groups=security_groups, region=region, key=key, keyid=keyid, profile=profile
)
if "SecurityGroupIds" not in args:
args["SecurityGroupIds"] = []
args["SecurityGroupIds"] += sgs
args = {k: v for k, v in args.items() if not k.startswith("_")}
return _create_resource(
name,
name_param="ReplicationGroupId",
desc="replication group",
res_type="replication_group",
wait=wait,
status_param="Status",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def modify_replication_group(
name,
wait=600,
security_groups=None,
region=None,
key=None,
keyid=None,
profile=None,
**args,
):
"""
Modify a replication group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.modify_replication_group \
name=myelasticache \
ReplicationGroupDescription=newDescription
"""
if security_groups:
if not isinstance(security_groups, list):
security_groups = [security_groups]
sgs = __salt__["boto_secgroup.convert_to_group_ids"](
groups=security_groups, region=region, key=key, keyid=keyid, profile=profile
)
if "SecurityGroupIds" not in args:
args["SecurityGroupIds"] = []
args["SecurityGroupIds"] += sgs
args = {k: v for k, v in args.items() if not k.startswith("_")}
return _modify_resource(
name,
name_param="ReplicationGroupId",
desc="replication group",
res_type="replication_group",
wait=wait,
status_param="Status",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def delete_replication_group(
name, wait=600, region=None, key=None, keyid=None, profile=None, **args
):
"""
Delete an ElastiCache replication group, optionally taking a snapshot first.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.delete_replication_group my-replication-group
"""
return _delete_resource(
name,
name_param="ReplicationGroupId",
desc="replication group",
res_type="replication_group",
wait=wait,
status_param="Status",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def describe_cache_subnet_groups(
name=None, conn=None, region=None, key=None, keyid=None, profile=None
):
"""
Return details about all (or just one) Elasticache replication groups.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.describe_cache_subnet_groups region=us-east-1
"""
return _describe_resource(
name=name,
name_param="CacheSubnetGroupName",
res_type="cache_subnet_group",
info_node="CacheSubnetGroups",
conn=conn,
region=region,
key=key,
keyid=keyid,
profile=profile,
)
def cache_subnet_group_exists(name, region=None, key=None, keyid=None, profile=None):
"""
Check to see if an ElastiCache subnet group exists.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.cache_subnet_group_exists my-subnet-group
"""
return bool(
describe_cache_subnet_groups(
name=name, region=region, key=key, keyid=keyid, profile=profile
)
)
def list_cache_subnet_groups(region=None, key=None, keyid=None, profile=None):
"""
Return a list of all cache subnet group names
Example:
.. code-block:: bash
salt myminion boto3_elasticache.list_cache_subnet_groups region=us-east-1
"""
return [
g["CacheSubnetGroupName"]
for g in describe_cache_subnet_groups(None, region, key, keyid, profile)
]
def create_cache_subnet_group(
name, subnets=None, region=None, key=None, keyid=None, profile=None, **args
):
"""
Create an ElastiCache subnet group
Example:
.. code-block:: bash
salt myminion boto3_elasticache.create_cache_subnet_group name=my-subnet-group \
CacheSubnetGroupDescription="description" \
subnets='[myVPCSubnet1,myVPCSubnet2]'
"""
if subnets:
if "SubnetIds" not in args:
args["SubnetIds"] = []
if not isinstance(subnets, list):
subnets = [subnets]
for subnet in subnets:
if subnet.startswith("subnet-"):
# Moderately safe assumption... :) Will be caught further down if incorrect.
args["SubnetIds"] += [subnet]
continue
sn = __salt__["boto_vpc.describe_subnets"](
subnet_names=subnet,
region=region,
key=key,
keyid=keyid,
profile=profile,
).get("subnets")
if not sn:
raise SaltInvocationError(
f"Could not resolve Subnet Name {subnet} to an ID."
)
if len(sn) == 1:
args["SubnetIds"] += [sn[0]["id"]]
elif len(sn) > 1:
raise CommandExecutionError(
f"Subnet Name {subnet} returned more than one ID."
)
args = {k: v for k, v in args.items() if not k.startswith("_")}
return _create_resource(
name,
name_param="CacheSubnetGroupName",
desc="cache subnet group",
res_type="cache_subnet_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def modify_cache_subnet_group(
name, subnets=None, region=None, key=None, keyid=None, profile=None, **args
):
"""
Modify an ElastiCache subnet group
Example:
.. code-block:: bash
salt myminion boto3_elasticache.modify_cache_subnet_group \
name=my-subnet-group \
subnets='[myVPCSubnet3]'
"""
if subnets:
if "SubnetIds" not in args:
args["SubnetIds"] = []
if not isinstance(subnets, list):
subnets = [subnets]
for subnet in subnets:
sn = __salt__["boto_vpc.describe_subnets"](
subnet_names=subnet,
region=region,
key=key,
keyid=keyid,
profile=profile,
).get("subnets")
if len(sn) == 1:
args["SubnetIds"] += [sn[0]["id"]]
elif len(sn) > 1:
raise CommandExecutionError(
f"Subnet Name {subnet} returned more than one ID."
)
elif subnet.startswith("subnet-"):
# Moderately safe assumption... :) Will be caught later if incorrect.
args["SubnetIds"] += [subnet]
else:
raise SaltInvocationError(
f"Could not resolve Subnet Name {subnet} to an ID."
)
args = {k: v for k, v in args.items() if not k.startswith("_")}
return _modify_resource(
name,
name_param="CacheSubnetGroupName",
desc="cache subnet group",
res_type="cache_subnet_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def delete_cache_subnet_group(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Delete an ElastiCache subnet group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.delete_subnet_group my-subnet-group region=us-east-1
"""
return _delete_resource(
name,
name_param="CacheSubnetGroupName",
desc="cache subnet group",
res_type="cache_subnet_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def describe_cache_security_groups(
name=None, conn=None, region=None, key=None, keyid=None, profile=None
):
"""
Return details about all (or just one) Elasticache cache clusters.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.describe_cache_security_groups
salt myminion boto3_elasticache.describe_cache_security_groups mycachesecgrp
"""
return _describe_resource(
name=name,
name_param="CacheSecurityGroupName",
res_type="cache_security_group",
info_node="CacheSecurityGroups",
conn=conn,
region=region,
key=key,
keyid=keyid,
profile=profile,
)
def cache_security_group_exists(name, region=None, key=None, keyid=None, profile=None):
"""
Check to see if an ElastiCache security group exists.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.cache_security_group_exists mysecuritygroup
"""
return bool(
describe_cache_security_groups(
name=name, region=region, key=key, keyid=keyid, profile=profile
)
)
def create_cache_security_group(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Create a cache security group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.create_cache_security_group mycachesecgrp Description='My Cache Security Group'
"""
return _create_resource(
name,
name_param="CacheSecurityGroupName",
desc="cache security group",
res_type="cache_security_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def delete_cache_security_group(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Delete a cache security group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.delete_cache_security_group myelasticachesg
"""
return _delete_resource(
name,
name_param="CacheSecurityGroupName",
desc="cache security group",
res_type="cache_security_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def authorize_cache_security_group_ingress(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Authorize network ingress from an ec2 security group to a cache security group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.authorize_cache_security_group_ingress \
mycachesecgrp \
EC2SecurityGroupName=someEC2sg \
EC2SecurityGroupOwnerId=SOMEOWNERID
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if "CacheSecurityGroupName" in args:
log.info(
"'name: %s' param being overridden by explicitly provided "
"'CacheSecurityGroupName: %s'",
name,
args["CacheSecurityGroupName"],
)
name = args["CacheSecurityGroupName"]
else:
args["CacheSubnetGroupName"] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
conn.authorize_cache_security_group_ingress(**args)
log.info(
"Authorized %s to cache security group %s.",
args["EC2SecurityGroupName"],
name,
)
return True
except botocore.exceptions.ClientError as e:
log.error("Failed to update security group %s: %s", name, e)
return False
def revoke_cache_security_group_ingress(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Revoke network ingress from an ec2 security group to a cache security
group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.revoke_cache_security_group_ingress \
mycachesecgrp \
EC2SecurityGroupName=someEC2sg \
EC2SecurityGroupOwnerId=SOMEOWNERID
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if "CacheSecurityGroupName" in args:
log.info(
"'name: %s' param being overridden by explicitly provided "
"'CacheSecurityGroupName: %s'",
name,
args["CacheSecurityGroupName"],
)
name = args["CacheSecurityGroupName"]
else:
args["CacheSubnetGroupName"] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
conn.revoke_cache_security_group_ingress(**args)
log.info(
"Revoked %s from cache security group %s.",
args["EC2SecurityGroupName"],
name,
)
return True
except botocore.exceptions.ClientError as e:
log.error("Failed to update security group %s: %s", name, e)
return False
def list_tags_for_resource(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
List tags on an Elasticache resource.
Note that this function is essentially useless as it requires a full AWS ARN for the
resource being operated on, but there is no provided API or programmatic way to find
the ARN for a given object from its name or ID alone. It requires specific knowledge
about the account number, AWS partition, and other magic details to generate.
If you happen to have those handy, feel free to utilize this however...
Example:
.. code-block:: bash
salt myminion boto3_elasticache.list_tags_for_resource \
name'=arn:aws:elasticache:us-west-2:0123456789:snapshot:mySnapshot'
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if "ResourceName" in args:
log.info(
"'name: %s' param being overridden by explicitly provided "
"'ResourceName: %s'",
name,
args["ResourceName"],
)
name = args["ResourceName"]
else:
args["ResourceName"] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
r = conn.list_tags_for_resource(**args)
if r and "Taglist" in r:
return r["TagList"]
return []
except botocore.exceptions.ClientError as e:
log.error("Failed to list tags for resource %s: %s", name, e)
return []
def add_tags_to_resource(name, region=None, key=None, keyid=None, profile=None, **args):
"""
Add tags to an Elasticache resource.
Note that this function is essentially useless as it requires a full AWS ARN for the
resource being operated on, but there is no provided API or programmatic way to find
the ARN for a given object from its name or ID alone. It requires specific knowledge
about the account number, AWS partition, and other magic details to generate.
If you happen to have those at hand though, feel free to utilize this function...
Example:
.. code-block:: bash
salt myminion boto3_elasticache.add_tags_to_resource \
name'=arn:aws:elasticache:us-west-2:0123456789:snapshot:mySnapshot' \
Tags="[{'Key': 'TeamOwner', 'Value': 'infrastructure'}]"
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if "ResourceName" in args:
log.info(
"'name: %s' param being overridden by explicitly provided "
"'ResourceName: %s'",
name,
args["ResourceName"],
)
name = args["ResourceName"]
else:
args["ResourceName"] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
conn.add_tags_to_resource(**args)
log.info("Added tags %s to %s.", args["Tags"], name)
return True
except botocore.exceptions.ClientError as e:
log.error("Failed to add tags to %s: %s", name, e)
return False
def remove_tags_from_resource(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Remove tags from an Elasticache resource.
Note that this function is essentially useless as it requires a full AWS ARN for the
resource being operated on, but there is no provided API or programmatic way to find
the ARN for a given object from its name or ID alone. It requires specific knowledge
about the account number, AWS partition, and other magic details to generate.
If you happen to have those at hand though, feel free to utilize this function...
Example:
.. code-block:: bash
salt myminion boto3_elasticache.remove_tags_from_resource \
name'=arn:aws:elasticache:us-west-2:0123456789:snapshot:mySnapshot' \
TagKeys="['TeamOwner']"
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if "ResourceName" in args:
log.info(
"'name: %s' param being overridden by explicitly provided "
"'ResourceName: %s'",
name,
args["ResourceName"],
)
name = args["ResourceName"]
else:
args["ResourceName"] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
conn.remove_tags_from_resource(**args)
log.info("Added tags %s to %s.", args["Tags"], name)
return True
except botocore.exceptions.ClientError as e:
log.error("Failed to add tags to %s: %s", name, e)
return False
def copy_snapshot(name, region=None, key=None, keyid=None, profile=None, **args):
"""
Make a copy of an existing snapshot.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.copy_snapshot name=mySnapshot \
TargetSnapshotName=copyOfMySnapshot
"""
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if "SourceSnapshotName" in args:
log.info(
"'name: %s' param being overridden by explicitly provided "
"'SourceSnapshotName: %s'",
name,
args["SourceSnapshotName"],
)
name = args["SourceSnapshotName"]
else:
args["SourceSnapshotName"] = name
args = {k: v for k, v in args.items() if not k.startswith("_")}
try:
conn.copy_snapshot(**args)
log.info("Snapshot %s copied to %s.", name, args["TargetSnapshotName"])
return True
except botocore.exceptions.ClientError as e:
log.error("Failed to copy snapshot %s: %s", name, e)
return False
def describe_cache_parameter_groups(
name=None, conn=None, region=None, key=None, keyid=None, profile=None
):
"""
Return details about all (or just one) Elasticache cache clusters.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.describe_cache_parameter_groups
salt myminion boto3_elasticache.describe_cache_parameter_groups myParameterGroup
"""
return _describe_resource(
name=name,
name_param="CacheParameterGroupName",
res_type="cache_parameter_group",
info_node="CacheParameterGroups",
conn=conn,
region=region,
key=key,
keyid=keyid,
profile=profile,
)
def create_cache_parameter_group(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Create a cache parameter group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.create_cache_parameter_group \
name=myParamGroup \
CacheParameterGroupFamily=redis2.8 \
Description="My Parameter Group"
"""
return _create_resource(
name,
name_param="CacheParameterGroupName",
desc="cache parameter group",
res_type="cache_parameter_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
def delete_cache_parameter_group(
name, region=None, key=None, keyid=None, profile=None, **args
):
"""
Delete a cache parameter group.
Example:
.. code-block:: bash
salt myminion boto3_elasticache.delete_cache_parameter_group myParamGroup
"""
return _delete_resource(
name,
name_param="CacheParameterGroupName",
desc="cache parameter group",
res_type="cache_parameter_group",
region=region,
key=key,
keyid=keyid,
profile=profile,
**args,
)
Zerion Mini Shell 1.0