def main():
argument_spec = dict(
name=dict(required=True),
schedule_expression=dict(),
event_pattern=dict(),
state=dict(choices=['present', 'disabled', 'absent'],
default='present'),
description=dict(),
role_arn=dict(),
targets=dict(type='list', default=[], elements='dict'),
)
module = AnsibleAWSModule(argument_spec=argument_spec)
rule_data = dict([(rf, module.params.get(rf))
for rf in CloudWatchEventRuleManager.RULE_FIELDS])
targets = module.params.get('targets')
state = module.params.get('state')
client = module.client('events')
cwe_rule = CloudWatchEventRule(module, client=client, **rule_data)
cwe_rule_manager = CloudWatchEventRuleManager(cwe_rule, targets)
if state == 'present':
cwe_rule_manager.ensure_present()
elif state == 'disabled':
cwe_rule_manager.ensure_disabled()
elif state == 'absent':
cwe_rule_manager.ensure_absent()
else:
module.fail_json(msg="Invalid state '{0}' provided".format(state))
module.exit_json(**cwe_rule_manager.fetch_aws_state())
def main():
arg_spec = dict(name=dict(type='str', required=True),
scope=dict(type='str',
required=True,
choices=['CLOUDFRONT', 'REGIONAL']))
module = AnsibleAWSModule(argument_spec=arg_spec)
name = module.params.get("name")
scope = module.params.get("scope")
wafv2 = module.client('wafv2')
# check if web acl exists
response = list_web_acls(wafv2, scope, module.fail_json_aws)
id = None
retval = {}
for item in response.get('WebACLs'):
if item.get('Name') == name:
id = item.get('Id')
if id:
existing_acl = get_web_acl(wafv2, name, scope, id,
module.fail_json_aws)
arn = existing_acl.get('WebACL').get('ARN')
retval = camel_dict_to_snake_dict(
list_wafv2_resources(wafv2, arn, module.fail_json_aws))
module.exit_json(**retval)
def main():
argument_spec = dict(
state=dict(default='present', choices=['present', 'absent']),
name=dict(),
vpn_gateway_id=dict(),
vpc_id=dict(),
asn=dict(type='int'),
wait_timeout=dict(type='int', default=320),
type=dict(default='ipsec.1', choices=['ipsec.1']),
tags=dict(default=None,
required=False,
type='dict',
aliases=['resource_tags']),
)
module = AnsibleAWSModule(argument_spec=argument_spec,
required_if=[['state', 'present', ['name']]])
state = module.params.get('state').lower()
try:
client = module.client('ec2')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
if state == 'present':
(changed, results) = ensure_vgw_present(client, module)
else:
(changed, results) = ensure_vgw_absent(client, module)
module.exit_json(changed=changed, vgw=results)
def main():
argument_spec = dict(
id=dict(required=False),
job_run_states=dict(required=False, type=list, default=[]),
managed_endpoint_states=dict(required=False, type=list, default=[]),
list_job_runs=dict(required=False, type=bool),
list_managed_endpoints=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=(
('list_job_runs', True, ['id']),
('list_managed_endpoints', True, ['id']),
),
mutually_exclusive=[(
'list_job_runs',
'list_managed_endpoints',
)],
)
client = module.client('emr-containers',
retry_decorator=AWSRetry.exponential_backoff())
it, paginate = _emr_containers(client, module)
if module.params['list_job_runs']:
module.exit_json(
job_runs=aws_response_list_parser(paginate, it, 'jobRuns'))
elif module.params['list_managed_endpoints']:
module.exit_json(managed_endpoints=aws_response_list_parser(
paginate, it, 'endpoints'))
else:
module.exit_json(
clusters=aws_response_list_parser(paginate, it, 'virtualClusters'))
def main():
argument_spec = dict(
state=dict(default='present', choices=['present', 'absent']),
name=dict(),
vpn_gateway_id=dict(),
vpc_id=dict(),
asn=dict(type='int'),
wait_timeout=dict(type='int', default=320),
type=dict(default='ipsec.1', choices=['ipsec.1']),
tags=dict(default=None,
required=False,
type='dict',
aliases=['resource_tags']),
)
module = AnsibleAWSModule(argument_spec=argument_spec,
required_if=[['state', 'present', ['name']]])
state = module.params.get('state').lower()
client = module.client(
'ec2', retry_decorator=VGWRetry.jittered_backoff(retries=10))
if state == 'present':
(changed, results) = ensure_vgw_present(client, module)
else:
(changed, results) = ensure_vgw_absent(client, module)
module.exit_json(changed=changed, vgw=results)
def main():
argument_spec = dict(
name=dict(required=False, aliases=['group_name']),
list_groups=dict(required=False, type=bool),
list_group_resources=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=(('list_group_resources', True, ['name']), ),
mutually_exclusive=[(
'list_groups',
'list_group_resources',
)],
)
client = module.client('resource-groups',
retry_decorator=AWSRetry.exponential_backoff())
it, paginate = _resource_groups(client, module)
if module.params['list_groups']:
module.exit_json(
groups=aws_response_list_parser(paginate, it, 'GroupIdentifiers'))
elif module.params['list_group_resources']:
module.exit_json(group_resources=aws_response_list_parser(
paginate, it, 'Resources'))
else:
module.fail_json("unknown options are passed")
def main():
argument_spec = dict(
vpc_id=dict(),
name=dict(),
nacl_id=dict(),
subnets=dict(required=False, type='list', default=list(), elements='str'),
tags=dict(required=False, type='dict'),
ingress=dict(required=False, type='list', default=list(), elements='list'),
egress=dict(required=False, type='list', default=list(), elements='list'),
state=dict(default='present', choices=['present', 'absent']),
)
module = AnsibleAWSModule(argument_spec=argument_spec,
supports_check_mode=True,
required_one_of=[['name', 'nacl_id']],
required_if=[['state', 'present', ['vpc_id']]])
state = module.params.get('state').lower()
client = module.client('ec2')
invocations = {
"present": setup_network_acl,
"absent": remove_network_acl
}
(changed, results) = invocations[state](client, module)
module.exit_json(changed=changed, nacl_id=results)
def main():
argument_spec = dict(
db_snapshot_identifier=dict(aliases=['snapshot_name']),
db_instance_identifier=dict(),
db_cluster_identifier=dict(),
db_cluster_snapshot_identifier=dict(),
snapshot_type=dict(
choices=['automated', 'manual', 'shared', 'public']))
module = AnsibleAWSModule(argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[[
'db_snapshot_identifier',
'db_instance_identifier',
'db_cluster_identifier',
'db_cluster_snapshot_identifier'
]])
conn = module.client('rds',
retry_decorator=AWSRetry.jittered_backoff(retries=10))
results = dict()
if not module.params['db_cluster_identifier'] and not module.params[
'db_cluster_snapshot_identifier']:
results['snapshots'] = standalone_snapshot_info(module, conn)
if not module.params['db_snapshot_identifier'] and not module.params[
'db_instance_identifier']:
results['cluster_snapshots'] = cluster_snapshot_info(module, conn)
module.exit_json(changed=False, **results)
def main():
argument_spec = dict(
name=dict(type='str', required=True),
state=dict(type='str', required=True, choices=['present', 'absent']),
suffix=dict(type='str', required=False, default='index.html'),
error_key=dict(type='str', required=False, no_log=False),
redirect_all_requests=dict(type='str', required=False),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
mutually_exclusive=[['redirect_all_requests', 'suffix'],
['redirect_all_requests', 'error_key']],
)
try:
client_connection = module.client('s3')
resource_connection = module.resource('s3')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
state = module.params.get("state")
if state == 'present':
enable_or_update_bucket_as_website(client_connection,
resource_connection, module)
elif state == 'absent':
disable_bucket_as_website(client_connection, module)
def main():
argument_spec = dict(
query=dict(choices=['services', 'endpoints'], required=True),
filters=dict(default={}, type='dict'),
vpc_endpoint_ids=dict(type='list', elements='str'),
)
module = AnsibleAWSModule(argument_spec=argument_spec,
supports_check_mode=True)
if module._name == 'ec2_vpc_endpoint_facts':
module.deprecate(
"The 'ec2_vpc_endpoint_facts' module has been renamed to 'ec2_vpc_endpoint_info'",
date='2021-12-01',
collection_name='community.aws')
# Validate Requirements
try:
connection = module.client('ec2')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
invocations = {
'services': get_supported_services,
'endpoints': get_endpoints,
}
results = invocations[module.params.get('query')](connection, module)
module.exit_json(**results)
def main():
argument_spec = dict(
list_outposts=dict(required=False, type=bool),
list_sites=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=(),
mutually_exclusive=[(
'list_outposts',
'list_sites',
)],
)
client = module.client('outposts',
retry_decorator=AWSRetry.exponential_backoff())
it, paginate = _outposts(client, module)
if module.params['list_outposts']:
module.exit_json(
outposts=aws_response_list_parser(paginate, it, 'Outposts'))
elif module.params['list_sites']:
module.exit_json(sites=aws_response_list_parser(paginate, it, 'Sites'))
else:
module.fail_json("unknown options are passed")
def main():
argument_spec = dict(
name=dict(required=False, default=[], type='list', elements='str'),
sort=dict(required=False,
default=None,
choices=[
'launch_configuration_name', 'image_id', 'created_time',
'instance_type', 'kernel_id', 'ramdisk_id', 'key_name'
]),
sort_order=dict(required=False,
default='ascending',
choices=['ascending', 'descending']),
sort_start=dict(required=False, type='int'),
sort_end=dict(required=False, type='int'),
)
module = AnsibleAWSModule(argument_spec=argument_spec)
if module._name == 'ec2_lc_facts':
module.deprecate(
"The 'ec2_lc_facts' module has been renamed to 'ec2_lc_info'",
date='2021-12-01',
collection_name='community.aws')
try:
connection = module.client('autoscaling')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
list_launch_configs(connection, module)
def main():
argument_spec = dict(
filters=dict(default=dict(), type='dict'),
peer_connection_ids=dict(default=None, type='list', elements='str'),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
if module._name == 'ec2_vpc_peering_facts':
module.deprecate(
"The 'ec2_vpc_peering_facts' module has been renamed to 'ec2_vpc_peering_info'",
date='2021-12-01',
collection_name='community.aws')
try:
ec2 = module.client('ec2', retry_decorator=AWSRetry.jittered_backoff())
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
# Turn the boto3 result in to ansible friendly_snaked_names
results = [
camel_dict_to_snake_dict(peer) for peer in get_vpc_peers(ec2, module)
]
# Turn the boto3 result in to ansible friendly tag dictionary
for peer in results:
peer['tags'] = boto3_tag_list_to_ansible_dict(peer.get('tags', []))
module.exit_json(result=results, vpc_peering_connections=results)
def main():
argument_spec = dict(
filters=dict(default={}, type='dict'),
nat_gateway_ids=dict(default=[], type='list', elements='str'),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
supports_check_mode=True,
)
if module._name == 'ec2_vpc_nat_gateway_facts':
module.deprecate(
"The 'ec2_vpc_nat_gateway_facts' module has been renamed to 'ec2_vpc_nat_gateway_info'",
date='2021-12-01',
collection_name='community.aws')
try:
connection = module.client('ec2',
retry_decorator=AWSRetry.jittered_backoff())
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
results = get_nat_gateways(connection, module)
module.exit_json(result=results)
def main():
module = AnsibleAWSModule(
argument_spec={
'state': dict(type='str', choices=['present', 'absent'], default='present'),
'authorized_account_id': dict(type='str', required=True),
'authorized_aws_region': dict(type='str', required=True),
},
supports_check_mode=False,
)
result = {'changed': False}
params = {
'AuthorizedAccountId': module.params.get('authorized_account_id'),
'AuthorizedAwsRegion': module.params.get('authorized_aws_region'),
}
client = module.client('config', retry_decorator=AWSRetry.jittered_backoff())
resource_status = resource_exists(client, module, params)
if module.params.get('state') == 'present':
if not resource_status:
create_resource(client, module, params, result)
else:
update_resource(client, module, params, result)
if module.params.get('state') == 'absent':
if resource_status:
delete_resource(client, module, params, result)
module.exit_json(changed=result['changed'])
def main():
argument_spec = dict(
autoscaling_group_name=dict(required=True, type='str'),
lifecycle_hook_name=dict(required=True, type='str'),
transition=dict(type='str', choices=['autoscaling:EC2_INSTANCE_TERMINATING', 'autoscaling:EC2_INSTANCE_LAUNCHING']),
role_arn=dict(type='str'),
notification_target_arn=dict(type='str'),
notification_meta_data=dict(type='str'),
heartbeat_timeout=dict(type='int'),
default_result=dict(default='ABANDON', choices=['ABANDON', 'CONTINUE']),
state=dict(default='present', choices=['present', 'absent'])
)
module = AnsibleAWSModule(argument_spec=argument_spec,
required_if=[['state', 'present', ['transition']]])
state = module.params.get('state')
connection = module.client('autoscaling')
changed = False
if state == 'present':
changed = create_lifecycle_hook(connection, module)
elif state == 'absent':
changed = delete_lifecycle_hook(connection, module)
module.exit_json(changed=changed)
def main():
argument_spec = dict(
cluster_ids=dict(required=False, type=list),
describe_clusters=dict(required=False, type=bool),
describe_backups=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=[
('describe_clusters', True, ['cluster_ids']),
('describe_backups', True, ['cluster_ids']),
],
mutually_exclusive=[],
)
client = module.client('cloudhsmv2', retry_decorator=AWSRetry.exponential_backoff())
_it, paginate = _cloudhsm(client, module)
if module.params['describe_clusters']:
module.exit_json(clusters=aws_response_list_parser(paginate, _it, 'Clusters'))
elif module.params['describe_backups']:
module.exit_json(backups=aws_response_list_parser(paginate, _it, 'Backups'))
else:
module.fail_json("unknown options are passed")
def main():
argument_spec = dict(
database_name=dict(required=False),
list_databases=dict(required=False, type=bool),
list_tables=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=(('list_tables', True, ['database_name']), ),
mutually_exclusive=[(
'list_databases',
'list_tables',
)],
)
client = module.client('timestream-write',
retry_decorator=AWSRetry.exponential_backoff())
it, paginate = _timestream_write(client, module)
if module.params['list_databases']:
module.exit_json(
databases=aws_response_list_parser(paginate, it, 'Databases'))
elif module.params['list_tables']:
module.exit_json(
tables=aws_response_list_parser(paginate, it, 'Tables'))
else:
module.fail_json("unknown options are passed")
def main():
argument_spec = dict(
option_group_name=dict(default='', type='str'),
marker=dict(type='str'),
max_records=dict(type='int', default=100),
engine_name=dict(type='str', default=''),
major_engine_version=dict(type='str', default=''),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[
['option_group_name', 'engine_name'],
['option_group_name', 'major_engine_version'],
],
required_together=[
['engine_name', 'major_engine_version'],
],
)
# Validate Requirements
try:
connection = module.client('rds',
retry_decorator=AWSRetry.jittered_backoff())
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
results = list_option_groups(connection, module)
module.exit_json(result=results)
def main():
argument_spec = dict(
filters=dict(default={}, type='dict')
)
module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True)
if module._name == 'aws_region_facts':
module.deprecate("The 'aws_region_facts' module has been renamed to 'aws_region_info'", date='2021-12-01', collection_name='community.aws')
connection = module.client('ec2', retry_decorator=AWSRetry.jittered_backoff())
# Replace filter key underscores with dashes, for compatibility
sanitized_filters = dict(module.params.get('filters'))
for k in module.params.get('filters').keys():
if "_" in k:
sanitized_filters[k.replace('_', '-')] = sanitized_filters[k]
del sanitized_filters[k]
try:
regions = connection.describe_regions(
aws_retry=True,
Filters=ansible_dict_to_boto3_filter_list(sanitized_filters)
)
except (BotoCoreError, ClientError) as e:
module.fail_json_aws(e, msg="Unable to describe regions.")
module.exit_json(regions=[camel_dict_to_snake_dict(r) for r in regions['Regions']])
def main():
argument_spec = (dict(allocated_capacity=dict(type='int'),
command_name=dict(type='str', default='glueetl'),
command_script_location=dict(type='str'),
connections=dict(type='list', elements='str'),
default_arguments=dict(type='dict'),
description=dict(type='str'),
max_concurrent_runs=dict(type='int'),
max_retries=dict(type='int'),
name=dict(required=True, type='str'),
role=dict(type='str'),
state=dict(required=True,
choices=['present', 'absent'],
type='str'),
timeout=dict(type='int')))
module = AnsibleAWSModule(argument_spec=argument_spec,
required_if=[
('state', 'present',
['role', 'command_script_location'])
])
connection = module.client('glue')
state = module.params.get("state")
glue_job = _get_glue_job(connection, module, module.params.get("name"))
if state == 'present':
create_or_update_glue_job(connection, module, glue_job)
else:
delete_glue_job(connection, module, glue_job)
def main():
argument_spec = dict(
load_balancer_arn=dict(type='str'),
target_group_arns=dict(type='list', elements='str'),
names=dict(type='list', elements='str'),
collect_targets_health=dict(default=False, type='bool',
required=False),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
mutually_exclusive=[[
'load_balancer_arn', 'target_group_arns', 'names'
]],
supports_check_mode=True,
)
if module._name == 'elb_target_group_facts':
module.deprecate(
"The 'elb_target_group_facts' module has been renamed to 'elb_target_group_info'",
date='2021-12-01',
collection_name='community.aws')
try:
connection = module.client('elbv2')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
list_target_groups(connection, module)
def main():
argument_spec = dict(lookup=dict(default='tag', choices=['tag', 'id']),
propagating_vgw_ids=dict(type='list', elements='str'),
purge_routes=dict(default=True, type='bool'),
purge_subnets=dict(default=True, type='bool'),
purge_tags=dict(default=False, type='bool'),
route_table_id=dict(),
routes=dict(default=[], type='list', elements='dict'),
state=dict(default='present',
choices=['present', 'absent']),
subnets=dict(type='list', elements='str'),
tags=dict(type='dict', aliases=['resource_tags']),
vpc_id=dict())
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=[['lookup', 'id', ['route_table_id']],
['lookup', 'tag', ['vpc_id']],
['state', 'present', ['vpc_id']]],
supports_check_mode=True)
retry_decorator = AWSRetry.jittered_backoff(retries=10)
connection = module.client('ec2', retry_decorator=retry_decorator)
state = module.params.get('state')
if state == 'present':
result = ensure_route_table_present(connection, module)
elif state == 'absent':
result = ensure_route_table_absent(connection, module)
module.exit_json(**result)
def main():
argument_spec = dict(
gateway_id=dict(type='str'),
lookup=dict(default='tag', choices=['tag', 'id']),
propagating_vgw_ids=dict(type='list', elements='str'),
purge_routes=dict(default=True, type='bool'),
purge_subnets=dict(default=True, type='bool'),
purge_tags=dict(default=False, type='bool'),
route_table_id=dict(),
routes=dict(default=[], type='list', elements='dict'),
state=dict(default='present', choices=['present', 'absent']),
subnets=dict(type='list', elements='str'),
tags=dict(type='dict', aliases=['resource_tags']),
vpc_id=dict()
)
module = AnsibleAWSModule(argument_spec=argument_spec,
required_if=[['lookup', 'id', ['route_table_id']],
['lookup', 'tag', ['vpc_id']],
['state', 'present', ['vpc_id']]],
supports_check_mode=True)
# The tests for RouteTable existing uses its own decorator, we can safely
# retry on InvalidRouteTableID.NotFound
retry_decorator = AWSRetry.jittered_backoff(retries=10, catch_extra_error_codes=['InvalidRouteTableID.NotFound'])
connection = module.client('ec2', retry_decorator=retry_decorator)
state = module.params.get('state')
if state == 'present':
result = ensure_route_table_present(connection, module)
elif state == 'absent':
result = ensure_route_table_absent(connection, module)
module.exit_json(**result)
def main():
argument_spec = dict(
deregister_unused=dict(type='bool', default=False),
target_az=dict(type='str'),
target_group_arn=dict(type='str'),
target_group_name=dict(type='str'),
target_id=dict(type='str', required=True),
target_port=dict(type='int'),
target_status=dict(choices=[
'initial', 'healthy', 'unhealthy', 'unused', 'draining',
'unavailable'
],
type='str'),
target_status_timeout=dict(type='int', default=60),
state=dict(required=True, choices=['present', 'absent'], type='str'),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
mutually_exclusive=[['target_group_arn', 'target_group_name']],
)
try:
connection = module.client('elbv2')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
state = module.params.get("state")
if state == 'present':
register_target(connection, module)
else:
deregister_target(connection, module)
def main():
argument_spec = dict(
entity_type=dict(required=False),
catalog=dict(required=False, choices=['AWSMarketplace'], default='AWSMarketplace'),
list_change_sets=dict(required=False, type=bool),
list_entities=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=(
('list_change_sets', True, ['catalog']),
('list_entities', True, ['catalog', 'entity_type']),
),
mutually_exclusive=[
(
'list_change_sets',
'list_entities',
)
],
)
client = module.client('marketplace-catalog', retry_decorator=AWSRetry.exponential_backoff())
it, paginate = _marketplace_catalog(client, module)
if module.params['list_change_sets']:
module.exit_json(change_sets=aws_response_list_parser(paginate, it, 'ChangeSetSummaryList'))
elif module.params['list_entities']:
module.exit_json(entities=aws_response_list_parser(paginate, it, 'EntitySummaryList'))
else:
module.fail_json("unknown options are passed")
def main():
argument_spec = dict(
state=dict(required=True, choices=['present', 'absent']),
name=dict(required=True),
engine=dict(),
description=dict(),
params=dict(aliases=['parameters'], type='dict'),
immediate=dict(type='bool', aliases=['apply_immediately']),
tags=dict(type='dict', default={}),
purge_tags=dict(type='bool', default=False),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=[['state', 'present', ['description', 'engine']]],
)
try:
conn = module.client('rds')
except (botocore.exceptions.ClientError,
botocore.exceptions.BotoCoreError) as e:
module.fail_json_aws(e, msg='Failed to connect to AWS')
state = module.params.get('state')
if state == 'present':
ensure_present(module, conn)
if state == 'absent':
ensure_absent(module, conn)
def main():
argument_spec = dict(
connection_token=dict(required=False),
attachment_id=dict(required=False),
contact_id=dict(required=False),
get_attachment=dict(required=False, type=bool),
get_transcript=dict(required=False, type=bool),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
required_if=(
('get_attachment', True, ['connection_token', 'attachment_id']),
('get_transcript', True, ['connection_token', 'contact_id']),
),
mutually_exclusive=[(
'get_attachment',
'get_transcript',
)],
)
client = module.client('connectparticipant',
retry_decorator=AWSRetry.exponential_backoff())
_it, paginate = _connect(client, module)
if module.params['get_attachment']:
module.exit_json(attachment=camel_dict_to_snake_dict(_it))
elif module.params['get_transcript']:
module.exit_json(
transcript=aws_response_list_parser(paginate, _it, 'Transcript'))
else:
module.fail_json("unknown options are passed")
def main():
argument_spec = dict(
name=dict(required=True),
managed_policies=dict(default=[],
type='list',
aliases=['managed_policy']),
users=dict(default=[], type='list'),
state=dict(choices=['present', 'absent'], required=True),
purge_users=dict(default=False, type='bool'),
purge_policies=dict(default=False,
type='bool',
aliases=['purge_policy',
'purge_managed_policies']))
module = AnsibleAWSModule(argument_spec=argument_spec,
supports_check_mode=True)
connection = module.client('iam')
state = module.params.get("state")
if state == 'present':
create_or_update_group(connection, module)
else:
destroy_group(connection, module)
def main():
"""
Main entry point.
:return dict: ansible facts
"""
argument_spec = dict(
state=dict(required=False,
default='present',
choices=['present', 'absent']),
function_name=dict(required=True),
name=dict(required=True, aliases=['alias_name']),
function_version=dict(type='int',
required=False,
default=0,
aliases=['version']),
description=dict(required=False, default=None),
)
module = AnsibleAWSModule(
argument_spec=argument_spec,
supports_check_mode=True,
mutually_exclusive=[],
required_together=[],
)
client = module.client('lambda',
retry_decorator=AWSRetry.jittered_backoff())
validate_params(module)
results = lambda_alias(module, client)
module.exit_json(**camel_dict_to_snake_dict(results))
