AnsibleAWSModule related cleanup (batch 2) (#65987)

* Remove redundant use of ec2_argument_spec where we're using AnsibleAWSModule

* Use module.client() instead of the get_aws_connection_info/boto3_conn combo.

* AnsibleAWSModule handles 'HAS_BOTO3'

* Remove unused imports

* Update error message that lambda_policy integration test is looking for when the region's missing

* Revert redshift and s3_bucket

lib/ansible/modules/cloud/amazon/_lambda_facts.py

@@ -90,7 +90,7 @@ lambda_facts.function.TheName:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import camel_dict_to_snake_dict, get_aws_connection_info, boto3_conn
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 import json
 import datetime
 import sys
@@ -100,7 +100,7 @@ import re
 try:
     from botocore.exceptions import ClientError
 except ImportError:
-    pass  # protected by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def fix_return(node):
@@ -361,16 +361,7 @@ def main():
         if len(function_name) > 64:
             module.fail_json(msg='Function name "{0}" exceeds 64 character limit'.format(function_name))
 
-    try:
+    client = module.client('lambda')
-        region, endpoint, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
-        aws_connect_kwargs.update(dict(region=region,
-                                       endpoint=endpoint,
-                                       conn_type='client',
-                                       resource='lambda'
-                                       ))
-        client = boto3_conn(module, **aws_connect_kwargs)
-    except ClientError as e:
-        module.fail_json_aws(e, "trying to set up boto connection")
 
     this_module = sys.modules[__name__]
 

lib/ansible/modules/cloud/amazon/aws_caller_info.py

@@ -70,7 +70,7 @@ from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 try:
     from botocore.exceptions import BotoCoreError, ClientError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def main():

lib/ansible/modules/cloud/amazon/aws_codepipeline.py

@@ -207,7 +207,7 @@ from ansible.module_utils.ec2 import camel_dict_to_snake_dict, compare_policies
 try:
     import botocore
 except ImportError:
-    pass  # will be detected by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def create_pipeline(client, name, role_arn, artifact_store, stages, version, module):

lib/ansible/modules/cloud/amazon/aws_inspector_target.py

@@ -104,7 +104,6 @@ updated_at:
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils.ec2 import AWSRetry
 from ansible.module_utils.ec2 import (
-    HAS_BOTO3,
     ansible_dict_to_boto3_tag_list,
     boto3_tag_list_to_ansible_dict,
     camel_dict_to_snake_dict,
@@ -114,7 +113,7 @@ from ansible.module_utils.ec2 import (
 try:
     import botocore
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 @AWSRetry.backoff(tries=5, delay=5, backoff=2.0)
@@ -133,9 +132,6 @@ def main():
         required_if=required_if,
     )
 
-    if not HAS_BOTO3:
-        module.fail_json(msg='boto3 and botocore are required for this module')
-
     name = module.params.get('name')
     state = module.params.get('state').lower()
     tags = module.params.get('tags')

lib/ansible/modules/cloud/amazon/aws_ses_identity.py

@@ -230,7 +230,7 @@ import time
 try:
     from botocore.exceptions import BotoCoreError, ClientError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def get_verification_attributes(connection, module, identity, retries=0, retryDelay=10):

lib/ansible/modules/cloud/amazon/aws_ses_identity_policy.py

@@ -94,7 +94,7 @@ import json
 try:
     from botocore.exceptions import BotoCoreError, ClientError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def get_identity_policy(connection, module, identity, policy_name):

lib/ansible/modules/cloud/amazon/aws_sgw_info.py

@@ -181,7 +181,7 @@ from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 try:
     from botocore.exceptions import BotoCoreError, ClientError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 class SGWInformationManager(object):

lib/ansible/modules/cloud/amazon/ec2_eip.py

@@ -233,10 +233,10 @@ public_ip:
 try:
     import botocore.exceptions
 except ImportError:
-    pass  # Taken care of by ec2.HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule, is_boto3_error_code
-from ansible.module_utils.ec2 import AWSRetry, ansible_dict_to_boto3_filter_list, ec2_argument_spec
+from ansible.module_utils.ec2 import AWSRetry, ansible_dict_to_boto3_filter_list
 
 
 def associate_ip_and_device(ec2, module, address, private_ip_address, device_id, allow_reassociation, check_mode, is_instance=True):
@@ -529,8 +529,7 @@ def generate_tag_dict(module, tag_name, tag_value):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         device_id=dict(required=False, aliases=['instance_id']),
         public_ip=dict(required=False, aliases=['ip']),
         state=dict(required=False, default='present',
@@ -545,7 +544,7 @@ def main():
         tag_name=dict(),
         tag_value=dict(),
         public_ipv4_pool=dict()
-    ))
+    )
 
     module = AnsibleAWSModule(
         argument_spec=argument_spec,

lib/ansible/modules/cloud/amazon/ec2_instance.py

@@ -808,16 +808,13 @@ try:
     import boto3
     import botocore.exceptions
 except ImportError:
-    pass
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.six import text_type, string_types
 from ansible.module_utils.six.moves.urllib import parse as urlparse
 from ansible.module_utils._text import to_bytes, to_native
 import ansible.module_utils.ec2 as ec2_utils
-from ansible.module_utils.ec2 import (boto3_conn,
+from ansible.module_utils.ec2 import (AWSRetry,
-                                      ec2_argument_spec,
-                                      get_aws_connection_info,
-                                      AWSRetry,
                                       ansible_dict_to_boto3_filter_list,
                                       compare_aws_tags,
                                       boto3_tag_list_to_ansible_dict,
@@ -1675,8 +1672,7 @@ def run_instances(ec2, **instance_spec):
 
 def main():
     global module
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         state=dict(default='present', choices=['present', 'started', 'running', 'stopped', 'restarted', 'rebooted', 'terminated', 'absent']),
         wait=dict(default=True, type='bool'),
         wait_timeout=dict(default=600, type='int'),
@@ -1711,7 +1707,7 @@ def main():
         instance_ids=dict(default=[], type='list'),
         network=dict(default=None, type='dict'),
         volumes=dict(default=None, type='list'),
-    ))
+    )
     # running/present are synonyms
     # as are terminated/absent
     module = AnsibleAWSModule(

lib/ansible/modules/cloud/amazon/ec2_key.py

@@ -134,13 +134,12 @@ key:
 import uuid
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import ec2_argument_spec, get_aws_connection_info, boto3_conn
 from ansible.module_utils._text import to_bytes
 
 try:
     from botocore.exceptions import ClientError
 except ImportError:
-    pass
+    pass  # caught by AnsibleAWSModule
 
 
 def extract_key_data(key):
@@ -242,23 +241,18 @@ def delete_key_pair(module, ec2_client, name, finish_task=True):
 
 def main():
 
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        name=dict(required=True),
-        dict(
+        key_material=dict(),
-            name=dict(required=True),
+        force=dict(type='bool', default=True),
-            key_material=dict(),
+        state=dict(default='present', choices=['present', 'absent']),
-            force=dict(type='bool', default=True),
+        wait=dict(type='bool', removed_in_version='2.14'),
-            state=dict(default='present', choices=['present', 'absent']),
+        wait_timeout=dict(type='int', removed_in_version='2.14')
-            wait=dict(type='bool', removed_in_version='2.14'),
-            wait_timeout=dict(type='int', removed_in_version='2.14')
-        )
     )
 
     module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True)
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    ec2_client = module.client('ec2')
-
-    ec2_client = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_params)
 
     name = module.params['name']
     state = module.params.get('state')

lib/ansible/modules/cloud/amazon/ec2_placement_group.py

@@ -91,10 +91,7 @@ placement_group:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (AWSRetry,
+from ansible.module_utils.ec2 import AWSRetry
-                                      boto3_conn,
-                                      ec2_argument_spec,
-                                      get_aws_connection_info)
 try:
     from botocore.exceptions import (BotoCoreError, ClientError)
 except ImportError:
@@ -167,13 +164,10 @@ def delete_placement_group(connection, module):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        name=dict(required=True, type='str'),
-        dict(
+        state=dict(default='present', choices=['present', 'absent']),
-            name=dict(required=True, type='str'),
+        strategy=dict(default='cluster', choices=['cluster', 'spread'])
-            state=dict(default='present', choices=['present', 'absent']),
-            strategy=dict(default='cluster', choices=['cluster', 'spread'])
-        )
     )
 
     module = AnsibleAWSModule(
@@ -181,12 +175,7 @@ def main():
         supports_check_mode=True
     )
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(
+    connection = module.client('ec2')
-        module, boto3=True)
-
-    connection = boto3_conn(module,
-                            resource='ec2', conn_type='client',
-                            region=region, endpoint=ec2_url, **aws_connect_params)
 
     state = module.params.get("state")
 

lib/ansible/modules/cloud/amazon/ec2_placement_group_info.py

@@ -75,14 +75,10 @@ placement_groups:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (connect_to_aws,
-                                      boto3_conn,
-                                      ec2_argument_spec,
-                                      get_aws_connection_info)
 try:
     from botocore.exceptions import (BotoCoreError, ClientError)
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def get_placement_groups_details(connection, module):
@@ -112,11 +108,8 @@ def get_placement_groups_details(connection, module):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        names=dict(type='list', default=[])
-        dict(
-            names=dict(type='list', default=[])
-        )
     )
 
     module = AnsibleAWSModule(
@@ -126,12 +119,7 @@ def main():
     if module._module._name == 'ec2_placement_group_facts':
         module._module.deprecate("The 'ec2_placement_group_facts' module has been renamed to 'ec2_placement_group_info'", version='2.13')
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(
+    connection = module.client('ec2')
-        module, boto3=True)
-
-    connection = boto3_conn(module,
-                            resource='ec2', conn_type='client',
-                            region=region, endpoint=ec2_url, **aws_connect_params)
 
     placement_groups = get_placement_groups_details(connection, module)
     module.exit_json(changed=False, placement_groups=placement_groups)

lib/ansible/modules/cloud/amazon/ec2_vpc_egress_igw.py

@@ -62,17 +62,12 @@ vpc_id:
 
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
-    boto3_conn,
-    ec2_argument_spec,
-    get_aws_connection_info,
-    camel_dict_to_snake_dict
-)
 
 try:
     import botocore
 except ImportError:
-    pass  # will be picked up by HAS_BOTO3 in AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def delete_eigw(module, conn, eigw_id):
@@ -167,16 +162,14 @@ def describe_eigws(module, conn, vpc_id):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         vpc_id=dict(required=True),
         state=dict(default='present', choices=['present', 'absent'])
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True)
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    connection = module.client('ec2')
-    connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_params)
 
     vpc_id = module.params.get('vpc_id')
     state = module.params.get('state')

lib/ansible/modules/cloud/amazon/ec2_vpc_igw.py

@@ -88,14 +88,11 @@ vpc_id:
 try:
     import botocore
 except ImportError:
-    pass  # Handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils.ec2 import (
     AWSRetry,
-    boto3_conn,
-    ec2_argument_spec,
-    get_aws_connection_info,
     camel_dict_to_snake_dict,
     boto3_tag_list_to_ansible_dict,
     ansible_dict_to_boto3_filter_list,
@@ -257,13 +254,10 @@ class AnsibleEc2Igw(object):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        vpc_id=dict(required=True),
-        dict(
+        state=dict(default='present', choices=['present', 'absent']),
-            vpc_id=dict(required=True),
+        tags=dict(default=dict(), required=False, type='dict', aliases=['resource_tags'])
-            state=dict(default='present', choices=['present', 'absent']),
-            tags=dict(default=dict(), required=False, type='dict', aliases=['resource_tags'])
-        )
     )
 
     module = AnsibleAWSModule(

lib/ansible/modules/cloud/amazon/ec2_vpc_nacl_info.py

@@ -107,12 +107,10 @@ nacls:
             sample: [[100, 'all', 'allow', '0.0.0.0/0', null, null, null, null]]
 '''
 
-import traceback
-
 try:
     from botocore.exceptions import ClientError, BotoCoreError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils._text import to_native

lib/ansible/modules/cloud/amazon/ec2_vpc_route_table.py

@@ -234,7 +234,6 @@ import re
 from time import sleep
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils.aws.waiters import get_waiter
-from ansible.module_utils.ec2 import ec2_argument_spec, boto3_conn, get_aws_connection_info
 from ansible.module_utils.ec2 import ansible_dict_to_boto3_filter_list
 from ansible.module_utils.ec2 import camel_dict_to_snake_dict, snake_dict_to_camel_dict
 from ansible.module_utils.ec2 import ansible_dict_to_boto3_tag_list, boto3_tag_list_to_ansible_dict
@@ -244,7 +243,7 @@ from ansible.module_utils.ec2 import compare_aws_tags, AWSRetry
 try:
     import botocore
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 CIDR_RE = re.compile(r'^(\d{1,3}\.){3}\d{1,3}/\d{1,2}$')
@@ -715,21 +714,18 @@ def ensure_route_table_present(connection, module):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        lookup=dict(default='tag', choices=['tag', 'id']),
-        dict(
+        propagating_vgw_ids=dict(type='list'),
-            lookup=dict(default='tag', choices=['tag', 'id']),
+        purge_routes=dict(default=True, type='bool'),
-            propagating_vgw_ids=dict(type='list'),
+        purge_subnets=dict(default=True, type='bool'),
-            purge_routes=dict(default=True, type='bool'),
+        purge_tags=dict(default=False, type='bool'),
-            purge_subnets=dict(default=True, type='bool'),
+        route_table_id=dict(),
-            purge_tags=dict(default=False, type='bool'),
+        routes=dict(default=[], type='list'),
-            route_table_id=dict(),
+        state=dict(default='present', choices=['present', 'absent']),
-            routes=dict(default=[], type='list'),
+        subnets=dict(type='list'),
-            state=dict(default='present', choices=['present', 'absent']),
+        tags=dict(type='dict', aliases=['resource_tags']),
-            subnets=dict(type='list'),
+        vpc_id=dict()
-            tags=dict(type='dict', aliases=['resource_tags']),
-            vpc_id=dict()
-        )
     )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,
@@ -738,10 +734,7 @@ def main():
                                            ['state', 'present', ['vpc_id']]],
                               supports_check_mode=True)
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    connection = module.client('ec2')
-
-    connection = boto3_conn(module, conn_type='client', resource='ec2',
-                            region=region, endpoint=ec2_url, **aws_connect_params)
 
     state = module.params.get('state')
 

lib/ansible/modules/cloud/amazon/ec2_vpc_subnet.py

@@ -214,7 +214,6 @@ subnet:
 
 
 import time
-import traceback
 
 try:
     import botocore
@@ -225,8 +224,7 @@ from ansible.module_utils._text import to_text
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils.aws.waiters import get_waiter
 from ansible.module_utils.ec2 import (ansible_dict_to_boto3_filter_list, ansible_dict_to_boto3_tag_list,
-                                      ec2_argument_spec, camel_dict_to_snake_dict, get_aws_connection_info,
+                                      camel_dict_to_snake_dict, boto3_tag_list_to_ansible_dict, compare_aws_tags, AWSRetry)
-                                      boto3_conn, boto3_tag_list_to_ansible_dict, compare_aws_tags, AWSRetry)
 
 
 def get_subnet_info(subnet):
@@ -563,21 +561,18 @@ def ensure_subnet_absent(conn, module):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        az=dict(default=None, required=False),
-        dict(
+        cidr=dict(required=True),
-            az=dict(default=None, required=False),
+        ipv6_cidr=dict(default='', required=False),
-            cidr=dict(required=True),
+        state=dict(default='present', choices=['present', 'absent']),
-            ipv6_cidr=dict(default='', required=False),
+        tags=dict(default={}, required=False, type='dict', aliases=['resource_tags']),
-            state=dict(default='present', choices=['present', 'absent']),
+        vpc_id=dict(required=True),
-            tags=dict(default={}, required=False, type='dict', aliases=['resource_tags']),
+        map_public=dict(default=False, required=False, type='bool'),
-            vpc_id=dict(required=True),
+        assign_instances_ipv6=dict(default=False, required=False, type='bool'),
-            map_public=dict(default=False, required=False, type='bool'),
+        wait=dict(type='bool', default=True),
-            assign_instances_ipv6=dict(default=False, required=False, type='bool'),
+        wait_timeout=dict(type='int', default=300, required=False),
-            wait=dict(type='bool', default=True),
+        purge_tags=dict(default=True, type='bool')
-            wait_timeout=dict(type='int', default=300, required=False),
-            purge_tags=dict(default=True, type='bool')
-        )
     )
 
     required_if = [('assign_instances_ipv6', True, ['ipv6_cidr'])]
@@ -590,8 +585,7 @@ def main():
     if not module.botocore_at_least("1.7.0"):
         module.warn("botocore >= 1.7.0 is required to use wait_timeout for custom wait times")
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    connection = module.client('ec2')
-    connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_params)
 
     state = module.params.get('state')
 

lib/ansible/modules/cloud/amazon/ec2_vpc_vpn_info.py

@@ -170,8 +170,7 @@ except ImportError:
     pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (ansible_dict_to_boto3_filter_list, ec2_argument_spec,
+from ansible.module_utils.ec2 import ansible_dict_to_boto3_filter_list, boto3_tag_list_to_ansible_dict, camel_dict_to_snake_dict
-                                      boto3_conn, boto3_tag_list_to_ansible_dict, camel_dict_to_snake_dict)
 
 
 def date_handler(obj):
@@ -199,12 +198,9 @@ def list_vpn_connections(connection, module):
 
 def main():
 
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        vpn_connection_ids=dict(default=[], type='list'),
-        dict(
+        filters=dict(default={}, type='dict')
-            vpn_connection_ids=dict(default=[], type='list'),
-            filters=dict(default={}, type='dict')
-        )
     )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,

lib/ansible/modules/cloud/amazon/ecs_service.py

@@ -485,13 +485,12 @@ DEPLOYMENT_CONFIGURATION_TYPE_MAP = {
 }
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import ec2_argument_spec
 from ansible.module_utils.ec2 import snake_dict_to_camel_dict, map_complex_type, get_ec2_security_group_ids_from_names
 
 try:
     import botocore
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 class EcsServiceManager:
@@ -652,8 +651,7 @@ class EcsServiceManager:
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         state=dict(required=True, choices=['present', 'absent', 'deleting']),
         name=dict(required=True, type='str'),
         cluster=dict(required=False, type='str'),
@@ -677,7 +675,7 @@ def main():
         launch_type=dict(required=False, choices=['EC2', 'FARGATE']),
         service_registries=dict(required=False, type='list', default=[]),
         scheduling_strategy=dict(required=False, choices=['DAEMON', 'REPLICA'])
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,
                               supports_check_mode=True,

lib/ansible/modules/cloud/amazon/ecs_service_info.py

@@ -139,10 +139,10 @@ services:
 try:
     import botocore
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import ec2_argument_spec, AWSRetry
+from ansible.module_utils.ec2 import AWSRetry
 
 
 class EcsServiceManager:
@@ -219,13 +219,12 @@ def chunks(l, n):
 
 def main():
 
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         details=dict(type='bool', default=False),
         events=dict(type='bool', default=True),
         cluster=dict(),
         service=dict(type='list')
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True)
     is_old_facts = module._name == 'ecs_service_facts'

lib/ansible/modules/cloud/amazon/ecs_task.py

@@ -221,12 +221,12 @@ task:
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils.basic import missing_required_lib
-from ansible.module_utils.ec2 import ec2_argument_spec, get_ec2_security_group_ids_from_names, ansible_dict_to_boto3_tag_list
+from ansible.module_utils.ec2 import get_ec2_security_group_ids_from_names, ansible_dict_to_boto3_tag_list
 
 try:
     import botocore
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 class EcsExecManager:
@@ -340,8 +340,7 @@ class EcsExecManager:
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         operation=dict(required=True, choices=['run', 'start', 'stop']),
         cluster=dict(required=False, type='str'),  # R S P
         task_definition=dict(required=False, type='str'),  # R* S*
@@ -353,7 +352,7 @@ def main():
         network_configuration=dict(required=False, type='dict'),
         launch_type=dict(required=False, choices=['EC2', 'FARGATE']),
         tags=dict(required=False, type='dict')
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True,
                               required_if=[('launch_type', 'FARGATE', ['network_configuration'])])

lib/ansible/modules/cloud/amazon/ecs_taskdefinition.py

@@ -218,12 +218,11 @@ taskdefinition:
 
 try:
     import botocore
-    HAS_BOTO3 = True
 except ImportError:
-    HAS_BOTO3 = False
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, camel_dict_to_snake_dict, ec2_argument_spec, get_aws_connection_info
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 from ansible.module_utils._text import to_text
 
 
@@ -233,8 +232,7 @@ class EcsTaskManager:
     def __init__(self, module):
         self.module = module
 
-        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
+        self.ecs = module.client('ecs')
-        self.ecs = boto3_conn(module, conn_type='client', resource='ecs', region=region, endpoint=ec2_url, **aws_connect_kwargs)
 
     def describe_task(self, task_name):
         try:
@@ -325,8 +323,7 @@ class EcsTaskManager:
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         state=dict(required=True, choices=['present', 'absent']),
         arn=dict(required=False, type='str'),
         family=dict(required=False, type='str'),
@@ -340,16 +337,13 @@ def main():
         launch_type=dict(required=False, choices=['EC2', 'FARGATE']),
         cpu=dict(),
         memory=dict(required=False, type='str')
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,
                               supports_check_mode=True,
                               required_if=[('launch_type', 'FARGATE', ['cpu', 'memory'])]
                               )
 
-    if not HAS_BOTO3:
-        module.fail_json(msg='boto3 is required.')
-
     task_to_describe = None
     task_mgr = EcsTaskManager(module)
     results = dict(changed=False)

lib/ansible/modules/cloud/amazon/ecs_taskdefinition_info.py

@@ -303,27 +303,24 @@ placement_constraints:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import camel_dict_to_snake_dict, boto3_conn, ec2_argument_spec, get_aws_connection_info
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 
 try:
     import botocore
 except ImportError:
-    pass  # will be detected by imported AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         task_definition=dict(required=True, type='str')
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True)
     if module._name == 'ecs_taskdefinition_facts':
         module.deprecate("The 'ecs_taskdefinition_facts' module has been renamed to 'ecs_taskdefinition_info'", version='2.13')
 
-    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
+    ecs = module.client('ecs')
-    ecs = boto3_conn(module, conn_type='client', resource='ecs',
-                     region=region, endpoint=ec2_url, **aws_connect_kwargs)
 
     try:
         ecs_td = ecs.describe_task_definition(taskDefinition=module.params['task_definition'])['taskDefinition']

lib/ansible/modules/cloud/amazon/efs_info.py

@@ -182,7 +182,7 @@ except ImportError:
     pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, get_aws_connection_info, ec2_argument_spec, AWSRetry
+from ansible.module_utils.ec2 import get_aws_connection_info, AWSRetry
 from ansible.module_utils.ec2 import camel_dict_to_snake_dict, boto3_tag_list_to_ansible_dict
 from ansible.module_utils._text import to_native
 
@@ -193,16 +193,14 @@ class EFSConnection(object):
     STATE_DELETING = 'deleting'
     STATE_DELETED = 'deleted'
 
-    def __init__(self, module, region, **aws_connect_params):
+    def __init__(self, module):
         try:
-            self.connection = boto3_conn(module, conn_type='client',
+            self.connection = module.client('efs')
-                                         resource='efs', region=region,
-                                         **aws_connect_params)
             self.module = module
         except Exception as e:
             module.fail_json(msg="Failed to connect to AWS: %s" % to_native(e))
 
-        self.region = region
+        self.region = get_aws_connection_info(module, boto3=True)[0]
 
     @AWSRetry.exponential_backoff(catch_extra_error_codes=['ThrottlingException'])
     def list_file_systems(self, **kwargs):
@@ -360,13 +358,12 @@ def main():
     """
     Module action handler
     """
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         id=dict(),
         name=dict(aliases=['creation_token']),
         tags=dict(type="dict", default={}),
         targets=dict(type="list", default=[])
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,
                               supports_check_mode=True)
@@ -375,8 +372,7 @@ def main():
         module.deprecate("The 'efs_facts' module has been renamed to 'efs_info', "
                          "and the renamed one no longer returns ansible_facts", version='2.13')
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    connection = EFSConnection(module)
-    connection = EFSConnection(module, region, **aws_connect_params)
 
     name = module.params.get('name')
     fs_id = module.params.get('id')

lib/ansible/modules/cloud/amazon/elasticache_info.py

@@ -227,15 +227,13 @@ elasticache_clusters:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, ec2_argument_spec, get_aws_connection_info
+from ansible.module_utils.ec2 import get_aws_connection_info, camel_dict_to_snake_dict, AWSRetry, boto3_tag_list_to_ansible_dict
-from ansible.module_utils.ec2 import camel_dict_to_snake_dict, AWSRetry
-from ansible.module_utils.ec2 import boto3_tag_list_to_ansible_dict
 
 
 try:
     import botocore
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 @AWSRetry.exponential_backoff()
@@ -262,9 +260,7 @@ def get_elasticache_tags_with_backoff(client, cluster_id):
 
 def get_aws_account_id(module):
     try:
-        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
+        client = module.client('sts')
-        client = boto3_conn(module, conn_type='client', resource='sts',
-                            region=region, endpoint=ec2_url, **aws_connect_kwargs)
     except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
         module.fail_json_aws(e, msg="Can't authorize connection")
 
@@ -274,7 +270,8 @@ def get_aws_account_id(module):
         module.fail_json_aws(e, msg="Couldn't obtain AWS account id")
 
 
-def get_elasticache_clusters(client, module, region):
+def get_elasticache_clusters(client, module):
+    region = get_aws_connection_info(module, boto3=True)[0]
     try:
         clusters = describe_cache_clusters_with_backoff(client, cluster_id=module.params.get('name'))
     except (botocore.exceptions.ClientError, botocore.exceptions.BotoCoreError) as e:
@@ -297,21 +294,16 @@ def get_elasticache_clusters(client, module, region):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        name=dict(required=False),
-        dict(
-            name=dict(required=False),
-        )
     )
     module = AnsibleAWSModule(argument_spec=argument_spec, supports_check_mode=True)
     if module._name == 'elasticache_facts':
         module.deprecate("The 'elasticache_facts' module has been renamed to 'elasticache_info'", version='2.13')
 
-    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
+    client = module.client('elasticache')
-    client = boto3_conn(module, conn_type='client', resource='elasticache',
-                        region=region, endpoint=ec2_url, **aws_connect_kwargs)
 
-    module.exit_json(elasticache_clusters=get_elasticache_clusters(client, module, region))
+    module.exit_json(elasticache_clusters=get_elasticache_clusters(client, module))
 
 
 if __name__ == '__main__':

lib/ansible/modules/cloud/amazon/elb_application_lb.py

@@ -462,8 +462,7 @@ vpc_id:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, get_aws_connection_info, camel_dict_to_snake_dict, ec2_argument_spec, \
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict, boto3_tag_list_to_ansible_dict, compare_aws_tags
-    boto3_tag_list_to_ansible_dict, compare_aws_tags, HAS_BOTO3
 
 from ansible.module_utils.aws.elbv2 import ApplicationLoadBalancer, ELBListeners, ELBListener, ELBListenerRules, ELBListenerRule
 from ansible.module_utils.aws.elb_utils import get_elb_listener_rules
@@ -591,38 +590,35 @@ def delete_elb(elb_obj):
 
 def main():
 
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        access_logs_enabled=dict(type='bool'),
-        dict(
+        access_logs_s3_bucket=dict(type='str'),
-            access_logs_enabled=dict(type='bool'),
+        access_logs_s3_prefix=dict(type='str'),
-            access_logs_s3_bucket=dict(type='str'),
+        deletion_protection=dict(type='bool'),
-            access_logs_s3_prefix=dict(type='str'),
+        http2=dict(type='bool'),
-            deletion_protection=dict(type='bool'),
+        idle_timeout=dict(type='int'),
-            http2=dict(type='bool'),
+        listeners=dict(type='list',
-            idle_timeout=dict(type='int'),
+                       elements='dict',
-            listeners=dict(type='list',
+                       options=dict(
-                           elements='dict',
+                           Protocol=dict(type='str', required=True),
-                           options=dict(
+                           Port=dict(type='int', required=True),
-                               Protocol=dict(type='str', required=True),
+                           SslPolicy=dict(type='str'),
-                               Port=dict(type='int', required=True),
+                           Certificates=dict(type='list'),
-                               SslPolicy=dict(type='str'),
+                           DefaultActions=dict(type='list', required=True),
-                               Certificates=dict(type='list'),
+                           Rules=dict(type='list')
-                               DefaultActions=dict(type='list', required=True),
+                       )
-                               Rules=dict(type='list')
+                       ),
-                           )
+        name=dict(required=True, type='str'),
-                           ),
+        purge_listeners=dict(default=True, type='bool'),
-            name=dict(required=True, type='str'),
+        purge_tags=dict(default=True, type='bool'),
-            purge_listeners=dict(default=True, type='bool'),
+        subnets=dict(type='list'),
-            purge_tags=dict(default=True, type='bool'),
+        security_groups=dict(type='list'),
-            subnets=dict(type='list'),
+        scheme=dict(default='internet-facing', choices=['internet-facing', 'internal']),
-            security_groups=dict(type='list'),
+        state=dict(choices=['present', 'absent'], default='present'),
-            scheme=dict(default='internet-facing', choices=['internet-facing', 'internal']),
+        tags=dict(type='dict'),
-            state=dict(choices=['present', 'absent'], default='present'),
+        wait_timeout=dict(type='int'),
-            tags=dict(type='dict'),
+        wait=dict(default=False, type='bool'),
-            wait_timeout=dict(type='int'),
+        purge_rules=dict(default=True, type='bool')
-            wait=dict(default=False, type='bool'),
-            purge_rules=dict(default=True, type='bool')
-        )
     )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,

lib/ansible/modules/cloud/amazon/elb_classic_lb_info.py

@@ -144,14 +144,9 @@ elbs:
         vpc_id: vpc-c248fda4
 '''
 
-import traceback
-
 from ansible.module_utils.aws.core import AnsibleAWSModule
 from ansible.module_utils.ec2 import (
     AWSRetry,
-    boto3_conn,
-    ec2_argument_spec,
-    get_aws_connection_info,
     camel_dict_to_snake_dict,
     boto3_tag_list_to_ansible_dict
 )
@@ -159,7 +154,7 @@ from ansible.module_utils.ec2 import (
 try:
     import botocore
 except ImportError:
-    pass
+    pass  # caught by AnsibleAWSModule
 
 
 @AWSRetry.backoff(tries=5, delay=5, backoff=2.0)
@@ -200,18 +195,15 @@ def lb_instance_health(connection, load_balancer_name, instances, state):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         names={'default': [], 'type': 'list'}
     )
-    )
     module = AnsibleAWSModule(argument_spec=argument_spec,
                               supports_check_mode=True)
     if module._name == 'elb_classic_lb_facts':
         module.deprecate("The 'elb_classic_lb_facts' module has been renamed to 'elb_classic_lb_info'", version='2.13')
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    connection = module.client('elb')
-    connection = boto3_conn(module, conn_type='client', resource='elb', region=region, endpoint=ec2_url, **aws_connect_params)
 
     try:
         elbs = list_elbs(connection, module.params.get('names'))

lib/ansible/modules/cloud/amazon/elb_target_group.py

@@ -373,10 +373,10 @@ import time
 try:
     import botocore
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (camel_dict_to_snake_dict, boto3_tag_list_to_ansible_dict, ec2_argument_spec,
+from ansible.module_utils.ec2 import (camel_dict_to_snake_dict, boto3_tag_list_to_ansible_dict,
                                       compare_aws_tags, ansible_dict_to_boto3_tag_list)
 from distutils.version import LooseVersion
 
@@ -802,34 +802,31 @@ def delete_target_group(connection, module):
 def main():
     protocols_list = ['http', 'https', 'tcp', 'tls', 'udp', 'tcp_udp', 'HTTP',
                       'HTTPS', 'TCP', 'TLS', 'UDP', 'TCP_UDP']
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        deregistration_delay_timeout=dict(type='int'),
-        dict(
+        health_check_protocol=dict(choices=protocols_list),
-            deregistration_delay_timeout=dict(type='int'),
+        health_check_port=dict(),
-            health_check_protocol=dict(choices=protocols_list),
+        health_check_path=dict(),
-            health_check_port=dict(),
+        health_check_interval=dict(type='int'),
-            health_check_path=dict(),
+        health_check_timeout=dict(type='int'),
-            health_check_interval=dict(type='int'),
+        healthy_threshold_count=dict(type='int'),
-            health_check_timeout=dict(type='int'),
+        modify_targets=dict(default=True, type='bool'),
-            healthy_threshold_count=dict(type='int'),
+        name=dict(required=True),
-            modify_targets=dict(default=True, type='bool'),
+        port=dict(type='int'),
-            name=dict(required=True),
+        protocol=dict(choices=protocols_list),
-            port=dict(type='int'),
+        purge_tags=dict(default=True, type='bool'),
-            protocol=dict(choices=protocols_list),
+        stickiness_enabled=dict(type='bool'),
-            purge_tags=dict(default=True, type='bool'),
+        stickiness_type=dict(default='lb_cookie'),
-            stickiness_enabled=dict(type='bool'),
+        stickiness_lb_cookie_duration=dict(type='int'),
-            stickiness_type=dict(default='lb_cookie'),
+        state=dict(required=True, choices=['present', 'absent']),
-            stickiness_lb_cookie_duration=dict(type='int'),
+        successful_response_codes=dict(),
-            state=dict(required=True, choices=['present', 'absent']),
+        tags=dict(default={}, type='dict'),
-            successful_response_codes=dict(),
+        target_type=dict(default='instance', choices=['instance', 'ip', 'lambda']),
-            tags=dict(default={}, type='dict'),
+        targets=dict(type='list'),
-            target_type=dict(default='instance', choices=['instance', 'ip', 'lambda']),
+        unhealthy_threshold_count=dict(type='int'),
-            targets=dict(type='list'),
+        vpc_id=dict(),
-            unhealthy_threshold_count=dict(type='int'),
+        wait_timeout=dict(type='int', default=200),
-            vpc_id=dict(),
+        wait=dict(type='bool', default=False)
-            wait_timeout=dict(type='int', default=200),
-            wait=dict(type='bool', default=False)
-        )
     )
 
     module = AnsibleAWSModule(argument_spec=argument_spec, required_if=[

lib/ansible/modules/cloud/amazon/elb_target_info.py

@@ -220,8 +220,7 @@ except ImportError:
     pass
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (HAS_BOTO3, camel_dict_to_snake_dict,
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict, AWSRetry
-                                      AWSRetry)
 
 
 class Target(object):

lib/ansible/modules/cloud/amazon/iam_group.py

@@ -185,9 +185,9 @@ from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 from ansible.module_utils.ec2 import AWSRetry
 
 try:
-    from botocore.exceptions import BotoCoreError, ClientError, ParamValidationError
+    from botocore.exceptions import BotoCoreError, ClientError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def compare_attached_group_policies(current_attached_policies, new_attached_policies):

lib/ansible/modules/cloud/amazon/iam_password_policy.py

@@ -108,8 +108,7 @@ except ImportError:
     pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, get_aws_connection_info, AWSRetry
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
-from ansible.module_utils.ec2 import camel_dict_to_snake_dict, boto3_tag_list_to_ansible_dict
 
 
 class IAMConnection(object):

lib/ansible/modules/cloud/amazon/iam_role_info.py

@@ -157,8 +157,7 @@ except ImportError:
     pass  # caught by AnsibleAWSModule
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, get_aws_connection_info, ec2_argument_spec, AWSRetry
+from ansible.module_utils.ec2 import boto3_tag_list_to_ansible_dict, camel_dict_to_snake_dict, AWSRetry
-from ansible.module_utils.ec2 import boto3_tag_list_to_ansible_dict, camel_dict_to_snake_dict
 
 
 @AWSRetry.exponential_backoff()
@@ -239,11 +238,10 @@ def main():
     """
      Module action handler
     """
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(dict(
         name=dict(aliases=['role_name']),
         path_prefix=dict(),
-    ))
+    )
 
     module = AnsibleAWSModule(argument_spec=argument_spec,
                               supports_check_mode=True,
@@ -251,9 +249,7 @@ def main():
     if module._name == 'iam_role_facts':
         module.deprecate("The 'iam_role_facts' module has been renamed to 'iam_role_info'", version='2.13')
 
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
+    client = module.client('iam')
-    client = boto3_conn(module, conn_type='client', resource='iam',
-                        region=region, endpoint=ec2_url, **aws_connect_params)
 
     module.exit_json(changed=False, iam_roles=describe_iam_roles(module, client))
 

lib/ansible/modules/cloud/amazon/iam_user.py

@@ -109,15 +109,14 @@ user:
 
 from ansible.module_utils._text import to_native
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import camel_dict_to_snake_dict, ec2_argument_spec, get_aws_connection_info, boto3_conn
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
-from ansible.module_utils.ec2 import HAS_BOTO3
 
 import traceback
 
 try:
     from botocore.exceptions import ClientError, ParamValidationError, BotoCoreError
 except ImportError:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def compare_attached_policies(current_attached_policies, new_attached_policies):

lib/ansible/modules/cloud/amazon/lambda_info.py

@@ -84,7 +84,7 @@ function.TheName:
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import camel_dict_to_snake_dict, get_aws_connection_info, boto3_conn
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
 import json
 import datetime
 import re
@@ -93,7 +93,7 @@ import re
 try:
     from botocore.exceptions import ClientError
 except ImportError:
-    pass  # protected by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def fix_return(node):
@@ -354,16 +354,7 @@ def main():
         if len(function_name) > 64:
             module.fail_json(msg='Function name "{0}" exceeds 64 character limit'.format(function_name))
 
-    try:
+    client = module.client('lambda')
-        region, endpoint, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
-        aws_connect_kwargs.update(dict(region=region,
-                                       endpoint=endpoint,
-                                       conn_type='client',
-                                       resource='lambda'
-                                       ))
-        client = boto3_conn(module, **aws_connect_kwargs)
-    except ClientError as e:
-        module.fail_json_aws(e, "trying to set up boto connection")
 
     invocations = dict(
         aliases='alias_details',

lib/ansible/modules/cloud/amazon/lambda_policy.py

@@ -144,12 +144,11 @@ import json
 import re
 from ansible.module_utils._text import to_native
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import get_aws_connection_info, boto3_conn
 
 try:
     from botocore.exceptions import ClientError
 except Exception:
-    pass  # will be protected by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def pc(key):
@@ -398,15 +397,6 @@ def manage_state(module, lambda_client):
     return dict(changed=changed, ansible_facts=dict(lambda_policy_action=action_taken))
 
 
-def setup_client(module):
-    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=True)
-    if region:
-        connection = boto3_conn(module, conn_type='client', resource='lambda', region=region, endpoint=ec2_url, **aws_connect_params)
-    else:
-        module.fail_json(msg="region must be specified")
-    return connection
-
-
 def setup_module_object():
     argument_spec = dict(
         state=dict(default='present', choices=['present', 'absent']),
@@ -438,7 +428,7 @@ def main():
     """
 
     module = setup_module_object()
-    client = setup_client(module)
+    client = module.client('lambda')
     validate_params(module)
     results = manage_state(module, client)
 

lib/ansible/modules/cloud/amazon/rds_snapshot_info.py

@@ -302,7 +302,7 @@ from ansible.module_utils.ec2 import AWSRetry, boto3_tag_list_to_ansible_dict, c
 try:
     import botocore
 except Exception:
-    pass  # caught by imported HAS_BOTO3
+    pass  # caught by AnsibleAWSModule
 
 
 def common_snapshot_info(module, conn, method, prefix, params):

lib/ansible/modules/cloud/amazon/redshift_cross_region_snapshots.py

@@ -92,7 +92,6 @@ EXAMPLES = '''
 RETURN = ''' # '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import ec2_argument_spec
 
 
 class SnapshotController(object):
@@ -148,16 +147,13 @@ def needs_update(actual, requested):
 
 
 def run_module():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        cluster_name=dict(type='str', required=True, aliases=['cluster']),
-        dict(
+        state=dict(type='str', choices=['present', 'absent'], default='present'),
-            cluster_name=dict(type='str', required=True, aliases=['cluster']),
+        region=dict(type='str', required=True, aliases=['source']),
-            state=dict(type='str', choices=['present', 'absent'], default='present'),
+        destination_region=dict(type='str', required=True, aliases=['destination']),
-            region=dict(type='str', required=True, aliases=['source']),
+        snapshot_copy_grant=dict(type='str', aliases=['copy_grant']),
-            destination_region=dict(type='str', required=True, aliases=['destination']),
+        snapshot_retention_period=dict(type='int', required=True, aliases=['retention_period']),
-            snapshot_copy_grant=dict(type='str', aliases=['copy_grant']),
-            snapshot_retention_period=dict(type='int', required=True, aliases=['retention_period']),
-        )
     )
 
     module = AnsibleAWSModule(

lib/ansible/modules/cloud/amazon/route53_zone.py

@@ -126,12 +126,11 @@ delegation_set_id:
 
 import time
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import boto3_conn, ec2_argument_spec, get_aws_connection_info
 
 try:
     from botocore.exceptions import BotoCoreError, ClientError
 except ImportError:
-    pass  # handled by AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def find_zones(module, client, zone_in, private_zone):

lib/ansible/modules/cloud/amazon/sts_assume_role.py

@@ -111,13 +111,12 @@ EXAMPLES = '''
 '''
 
 from ansible.module_utils.aws.core import AnsibleAWSModule
-from ansible.module_utils.ec2 import (boto3_conn, get_aws_connection_info,
+from ansible.module_utils.ec2 import camel_dict_to_snake_dict
-                                      ec2_argument_spec, camel_dict_to_snake_dict)
 
 try:
     from botocore.exceptions import ClientError, ParamValidationError
 except ImportError:
-    pass  # caught by imported AnsibleAWSModule
+    pass  # caught by AnsibleAWSModule
 
 
 def _parse_response(response):
@@ -160,29 +159,19 @@ def assume_role_policy(connection, module):
 
 
 def main():
-    argument_spec = ec2_argument_spec()
+    argument_spec = dict(
-    argument_spec.update(
+        role_arn=dict(required=True),
-        dict(
+        role_session_name=dict(required=True),
-            role_arn=dict(required=True),
+        duration_seconds=dict(required=False, default=None, type='int'),
-            role_session_name=dict(required=True),
+        external_id=dict(required=False, default=None),
-            duration_seconds=dict(required=False, default=None, type='int'),
+        policy=dict(required=False, default=None),
-            external_id=dict(required=False, default=None),
+        mfa_serial_number=dict(required=False, default=None),
-            policy=dict(required=False, default=None),
+        mfa_token=dict(required=False, default=None)
-            mfa_serial_number=dict(required=False, default=None),
-            mfa_token=dict(required=False, default=None)
-        )
     )
 
     module = AnsibleAWSModule(argument_spec=argument_spec)
 
-    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
+    connection = module.client('sts')
-
-    if region:
-        connection = boto3_conn(module, conn_type='client', resource='sts',
-                                region=region, endpoint=ec2_url, **aws_connect_kwargs)
-
-    else:
-        module.fail_json(msg="region must be specified")
 
     assume_role_policy(connection, module)
 

test/integration/targets/lambda_policy/tasks/main.yml

@@ -40,24 +40,7 @@
       assert:
         that:
            - 'result.failed'
-           - '"region must be specified" in result.msg'
+           - '"requires a region and none was found" in result.msg'
-
-    # ============================================================
-    - name: test with all required dummy parameters but no region
-      lambda_policy:
-        statement_id: dummy
-        principal: api_fakeway
-        action: fake:do_something_fake
-        function_name: dummy_fake_function
-        region: null
-      ignore_errors: true
-      register: result
-
-    - name: assert failure and appropriate message when called false region region
-      assert:
-        that:
-           - 'result.failed'
-           - '"region must be specified" in result.msg'
 
     # ============================================================
     - name: test exceptions generated by forcing bad ec2 url