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))