def main():

    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(
        name=dict(type='str'),
        tags=dict(type='dict'),
    ))
    module = AnsibleModule(argument_spec=argument_spec)
    if module._name == 'ec2_asg_facts':
        module.deprecate(
            "The 'ec2_asg_facts' module has been renamed to 'ec2_asg_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    asg_name = module.params.get('name')
    asg_tags = module.params.get('tags')

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
            module, boto3=True)
        autoscaling = boto3_conn(module,
                                 conn_type='client',
                                 resource='autoscaling',
                                 region=region,
                                 endpoint=ec2_url,
                                 **aws_connect_kwargs)
    except ClientError as e:
        module.fail_json(msg=e.message, **camel_dict_to_snake_dict(e.response))

    results = find_asgs(autoscaling, module, name=asg_name, tags=asg_tags)
    module.exit_json(results=results)
예제 #2
0
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(
            filters=dict(type='dict', default={}),
            dry_run=dict(type='bool', default=False, aliases=['DryRun']),
            dhcp_options_ids=dict(type='list', aliases=['DhcpOptionIds'])
        )
    )

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'ec2_vpc_dhcp_option_facts':
        module.deprecate("The 'ec2_vpc_dhcp_option_facts' module has been renamed to 'ec2_vpc_dhcp_option_info'", version='2.13')

    # Validate Requirements
    if not HAS_BOTO3:
        module.fail_json(msg='boto3 and botocore are required.')

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
        connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_kwargs)
    except botocore.exceptions.NoCredentialsError as e:
        module.fail_json(msg="Can't authorize connection - " + str(e))

    # call your function here
    results = list_dhcp_options(connection, module)

    module.exit_json(dhcp_options=results)
def main():
    argument_spec = xenserver_common_argument_spec()
    argument_spec.update(
        name=dict(type='str', aliases=['name_label']),
        uuid=dict(type='str'),
    )

    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
        required_one_of=[
            ['name', 'uuid'],
        ],
    )

    if module._name == 'xenserver_guest_facts':
        module.deprecate(
            "The 'xenserver_guest_facts' module has been renamed to 'xenserver_guest_info'",
            version='2.13')

    result = {'failed': False, 'changed': False}

    # Module will exit with an error message if no VM is found.
    vm = XenServerVM(module)

    # Gather facts.
    result['instance'] = vm.gather_facts()

    if result['failed']:
        module.fail_json(**result)
    else:
        module.exit_json(**result)
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(log_group_name=dict(), ))

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'cloudwatchlogs_log_group_facts':
        module.deprecate(
            "The 'cloudwatchlogs_log_group_facts' module has been renamed to 'cloudwatchlogs_log_group_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 is required.')

    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
                                                                  boto3=True)
    logs = boto3_conn(module,
                      conn_type='client',
                      resource='logs',
                      region=region,
                      endpoint=ec2_url,
                      **aws_connect_kwargs)

    desc_log_group = describe_log_group(
        client=logs,
        log_group_name=module.params['log_group_name'],
        module=module)
    final_log_group_snake = []

    for log_group in desc_log_group['logGroups']:
        final_log_group_snake.append(camel_dict_to_snake_dict(log_group))

    desc_log_group_result = dict(changed=False,
                                 log_groups=final_log_group_snake)
    module.exit_json(**desc_log_group_result)
def main():

    argument_spec = openstack_full_argument_spec(name=dict(required=False,
                                                           default=None,
                                                           aliases=['subnet']),
                                                 filters=dict(required=False,
                                                              type='dict',
                                                              default=None))
    module = AnsibleModule(argument_spec)
    is_old_facts = module._name == 'os_subnets_facts'
    if is_old_facts:
        module.deprecate(
            "The 'os_subnets_facts' module has been renamed to 'os_subnets_info', "
            "and the renamed one no longer returns ansible_facts",
            version='2.13')

    sdk, cloud = openstack_cloud_from_module(module)
    try:
        subnets = cloud.search_subnets(module.params['name'],
                                       module.params['filters'])
        if is_old_facts:
            module.exit_json(changed=False,
                             ansible_facts=dict(openstack_subnets=subnets))
        else:
            module.exit_json(changed=False, openstack_subnets=subnets)

    except sdk.exceptions.OpenStackCloudException as e:
        module.fail_json(msg=str(e))
def main():

    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(load_balancer_arns=dict(type='list'), names=dict(type='list')))

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=[['load_balancer_arns',
                                                'names']],
                           supports_check_mode=True)
    if module._name == 'elb_application_lb_facts':
        module.deprecate(
            "The 'elb_application_lb_facts' module has been renamed to 'elb_application_lb_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    region, ec2_url, aws_connect_params = get_aws_connection_info(module,
                                                                  boto3=True)

    if region:
        connection = boto3_conn(module,
                                conn_type='client',
                                resource='elbv2',
                                region=region,
                                endpoint=ec2_url,
                                **aws_connect_params)
    else:
        module.fail_json(msg="region must be specified")

    list_load_balancers(connection, module)
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(user_name=dict(required=False, default=None)))

    module = AnsibleModule(argument_spec=argument_spec)
    if module._name == 'iam_mfa_device_facts':
        module.deprecate(
            "The 'iam_mfa_device_facts' module has been renamed to 'iam_mfa_device_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module,
                                                                  boto3=True)
    if region:
        connection = boto3_conn(module,
                                conn_type='client',
                                resource='iam',
                                region=region,
                                endpoint=ec2_url,
                                **aws_connect_kwargs)
    else:
        module.fail_json(msg="region must be specified")

    list_mfa_devices(connection, module)
예제 #8
0
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(filters=dict(type='dict'),
             pending_deletion=dict(type='bool', default=False)))

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'aws_kms_facts':
        module.deprecate(
            "The 'aws_kms_facts' module has been renamed to 'aws_kms_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 and botocore are required for this module')

    region, ec2_url, aws_connect_params = get_aws_connection_info(module,
                                                                  boto3=True)

    if region:
        connection = boto3_conn(module,
                                conn_type='client',
                                resource='kms',
                                region=region,
                                endpoint=ec2_url,
                                **aws_connect_params)
    else:
        module.fail_json(msg="region must be specified")

    all_keys = get_kms_info(connection, module)
    module.exit_json(keys=[
        key for key in all_keys
        if key_matches_filters(key, module.params['filters'])
    ])
예제 #9
0
def main():
    argument_spec = ovirt_info_full_argument_spec(pattern=dict(
        default='', required=False), )
    module = AnsibleModule(argument_spec)
    is_old_facts = module._name == 'ovirt_user_facts'
    if is_old_facts:
        module.deprecate(
            "The 'ovirt_user_facts' module has been renamed to 'ovirt_user_info', "
            "and the renamed one no longer returns ansible_facts",
            version='2.13')

    check_sdk(module)

    try:
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        users_service = connection.system_service().users_service()
        users = users_service.list(search=module.params['pattern'])
        result = dict(ovirt_users=[
            get_dict_of_struct(
                struct=c,
                connection=connection,
                fetch_nested=module.params.get('fetch_nested'),
                attributes=module.params.get('nested_attributes'),
            ) for c in users
        ], )
        if is_old_facts:
            module.exit_json(changed=False, ansible_facts=result)
        else:
            module.exit_json(changed=False, **result)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)
def main():
    argument_spec = openstack_full_argument_spec(
        port=dict(required=False),
        filters=dict(type='dict', required=False),
    )
    module_kwargs = openstack_module_kwargs()
    module = AnsibleModule(argument_spec, **module_kwargs)
    is_old_facts = module._name == 'os_port_facts'
    if is_old_facts:
        module.deprecate(
            "The 'os_port_facts' module has been renamed to 'os_port_info', "
            "and the renamed one no longer returns ansible_facts",
            version='2.13')

    port = module.params.get('port')
    filters = module.params.get('filters')

    sdk, cloud = openstack_cloud_from_module(module)
    try:
        ports = cloud.search_ports(port, filters)
        if is_old_facts:
            module.exit_json(changed=False,
                             ansible_facts=dict(openstack_ports=ports))
        else:
            module.exit_json(changed=False, openstack_ports=ports)

    except sdk.exceptions.OpenStackCloudException as e:
        module.fail_json(msg=str(e))
예제 #11
0
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(filters=dict(default=None, type='dict')))

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'ec2_vpc_route_table_facts':
        module.deprecate(
            "The 'ec2_vpc_route_table_facts' module has been renamed to 'ec2_vpc_route_table_info'",
            version='2.13')

    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    region, ec2_url, aws_connect_params = get_aws_connection_info(module)

    if region:
        try:
            connection = connect_to_aws(boto.vpc, region, **aws_connect_params)
        except (boto.exception.NoAuthHandlerFound, AnsibleAWSError) as e:
            module.fail_json(msg=str(e))
    else:
        module.fail_json(msg="region must be specified")

    list_ec2_vpc_route_tables(connection, module)
예제 #12
0
def main():

    argument_spec = openstack_full_argument_spec(
        image=dict(required=False),
        properties=dict(default=None, type='dict'),
    )
    module_kwargs = openstack_module_kwargs()
    module = AnsibleModule(argument_spec, **module_kwargs)
    is_old_facts = module._name == 'os_image_facts'
    if is_old_facts:
        module.deprecate("The 'os_image_facts' module has been renamed to 'os_image_info', "
                         "and the renamed one no longer returns ansible_facts", version='2.13')

    sdk, cloud = openstack_cloud_from_module(module)
    try:
        if module.params['image']:
            image = cloud.get_image(module.params['image'])
            if is_old_facts:
                module.exit_json(changed=False, ansible_facts=dict(
                    openstack_image=image))
            else:
                module.exit_json(changed=False, openstack_image=image)
        else:
            images = cloud.search_images(filters=module.params['properties'])
            if is_old_facts:
                module.exit_json(changed=False, ansible_facts=dict(
                    openstack_image=images))
            else:
                module.exit_json(changed=False, openstack_image=images)

    except sdk.exceptions.OpenStackCloudException as e:
        module.fail_json(msg=str(e))
def main():
    """
    Get list of S3 buckets
    :return:
    """

    # Ensure we have an empty dict
    result = {}

    # Including ec2 argument spec
    module = AnsibleModule(argument_spec=ec2_argument_spec(), supports_check_mode=True)
    is_old_facts = module._name == 'aws_s3_bucket_facts'
    if is_old_facts:
        module.deprecate("The 'aws_s3_bucket_facts' module has been renamed to 'aws_s3_bucket_info', "
                         "and the renamed one no longer returns ansible_facts", version='2.13')

    # Verify Boto3 is used
    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    # Set up connection
    region, ec2_url, aws_connect_params = get_aws_connection_info(module, boto3=HAS_BOTO3)
    connection = boto3_conn(module, conn_type='client', resource='s3', region=region, endpoint=ec2_url,
                            **aws_connect_params)

    # Gather results
    result['buckets'] = get_bucket_list(module, connection)

    # Send exit
    if is_old_facts:
        module.exit_json(msg="Retrieved s3 facts.", ansible_facts=result)
    else:
        module.exit_json(msg="Retrieved s3 info.", **result)
def main():
    argument_spec = vmware_argument_spec()
    argument_spec.update(
        cluster_name=dict(type='str', required=False),
        esxi_hostname=dict(type='str', required=False),
        rules=dict(type='list', default=list(), required=False),
    )

    module = AnsibleModule(argument_spec=argument_spec,
                           required_one_of=[
                               ['cluster_name', 'esxi_hostname'],
                           ],
                           supports_check_mode=True)

    for rule_option in module.params.get("rules", []):
        if 'allowed_hosts' in rule_option:
            if isinstance(rule_option['allowed_hosts'], list):
                if len(rule_option['allowed_hosts']) == 1:
                    allowed_hosts = rule_option['allowed_hosts'][0]
                    rule_option['allowed_hosts'] = allowed_hosts
                    module.deprecate(
                        'allowed_hosts should be a dict, not a list', '2.13')

    vmware_firewall_manager = VmwareFirewallManager(module)
    vmware_firewall_manager.check_params()
    vmware_firewall_manager.ensure()
예제 #15
0
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(
            filters=dict(type='dict', default=dict()),
            vpn_gateway_ids=dict(type='list', default=None)
        )
    )

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
    if module._name == 'ec2_vpc_vgw_facts':
        module.deprecate("The 'ec2_vpc_vgw_facts' module has been renamed to 'ec2_vpc_vgw_info'", version='2.13')

    # Validate Requirements
    if not HAS_BOTO3:
        module.fail_json(msg='json and boto3 is required.')

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(module, boto3=True)
        connection = boto3_conn(module, conn_type='client', resource='ec2', region=region, endpoint=ec2_url, **aws_connect_kwargs)
    except botocore.exceptions.NoCredentialsError as e:
        module.fail_json(msg="Can't authorize connection - " + str(e))

    # call your function here
    results = list_virtual_gateways(connection, module)

    module.exit_json(virtual_gateways=results)
def main():

    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(instance_ids=dict(default=[], type='list'),
             filters=dict(default={}, type='dict')))

    module = AnsibleModule(argument_spec=argument_spec,
                           mutually_exclusive=[['instance_ids', 'filters']],
                           supports_check_mode=True)
    if module._name == 'ec2_instance_facts':
        module.deprecate(
            "The 'ec2_instance_facts' module has been renamed to 'ec2_instance_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    region, ec2_url, aws_connect_params = get_aws_connection_info(module,
                                                                  boto3=True)

    if region:
        connection = boto3_conn(module,
                                conn_type='client',
                                resource='ec2',
                                region=region,
                                endpoint=ec2_url,
                                **aws_connect_params)
    else:
        module.fail_json(msg="region must be specified")

    list_ec2_instances(connection, module)
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(names={'default': [], 'type': 'list'}))
    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'ec2_elb_facts':
        module.deprecate(
            "The 'ec2_elb_facts' module has been renamed to 'ec2_elb_info'",
            version='2.13')

    if not HAS_BOTO:
        module.fail_json(msg='boto required for this module')

    try:
        region, ec2_url, aws_connect_params = get_aws_connection_info(module)
        if not region:
            module.fail_json(msg="region must be specified")

        names = module.params['names']
        elb_information = ElbInformation(module, names, region,
                                         **aws_connect_params)

        ec2_info_result = dict(changed=False, elbs=elb_information.list_elbs())

    except BotoServerError as err:
        module.fail_json(msg="{0}: {1}".format(err.error_code,
                                               err.error_message),
                         exception=traceback.format_exc())

    module.exit_json(**ec2_info_result)
예제 #18
0
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(vpc_ids=dict(type='list', default=[]),
             filters=dict(type='dict', default={})))

    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'ec2_vpc_net_facts':
        module.deprecate(
            "The 'ec2_vpc_net_facts' module has been renamed to 'ec2_vpc_net_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 and botocore are required for this module')

    region, ec2_url, aws_connect_params = get_aws_connection_info(module,
                                                                  boto3=True)
    connection = boto3_conn(module,
                            conn_type='client',
                            resource='ec2',
                            region=region,
                            endpoint=ec2_url,
                            **aws_connect_params)

    describe_vpcs(connection, module)
def main():
    global module
    module = AnsibleModule(argument_spec=dict(
        cli_path=dict(type='path', default='op'),
        auto_login=dict(type='dict',
                        options=dict(
                            subdomain=dict(type='str'),
                            username=dict(type='str'),
                            master_password=dict(required=True,
                                                 type='str',
                                                 no_log=True),
                            secret_key=dict(type='str', no_log=True),
                        ),
                        default=None),
        search_terms=dict(required=True, type='list')),
                           supports_check_mode=True)

    results = {'onepassword': OnePasswordInfo().run()}

    if module._name == 'onepassword_facts':
        module.deprecate(
            "The 'onepassword_facts' module has been renamed to 'onepassword_info'. "
            "When called with the new name it no longer returns 'ansible_facts'",
            version='2.13')
        module.exit_json(changed=False, ansible_facts=results)
    else:
        module.exit_json(changed=False, **results)
예제 #20
0
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(dict(name=dict(type='str'), ))

    module = AnsibleModule(argument_spec=argument_spec, )
    if module._name == 'iam_server_certificate_facts':
        module.deprecate(
            "The 'iam_server_certificate_facts' module has been renamed to 'iam_server_certificate_info'",
            version='2.13')

    if not HAS_BOTO3:
        module.fail_json(msg='boto3 required for this module')

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
            module, boto3=True)
        iam = boto3_conn(module,
                         conn_type='client',
                         resource='iam',
                         region=region,
                         endpoint=ec2_url,
                         **aws_connect_kwargs)
    except botocore.exceptions.ClientError as e:
        module.fail_json(msg="Boto3 Client Error - " + str(e.msg))

    cert_name = module.params.get('name')
    results = get_server_certs(iam, cert_name)
    module.exit_json(results=results)
def main():
    argument_spec = openstack_full_argument_spec(
        name=dict(required=False, default=None),
        ram=dict(required=False, default=None),
        vcpus=dict(required=False, default=None),
        limit=dict(required=False, default=None, type='int'),
        ephemeral=dict(required=False, default=None),
    )
    module_kwargs = openstack_module_kwargs(
        mutually_exclusive=[
            ['name', 'ram'],
            ['name', 'vcpus'],
            ['name', 'ephemeral']
        ]
    )
    module = AnsibleModule(argument_spec, **module_kwargs)
    is_old_facts = module._name == 'os_flavor_facts'
    if is_old_facts:
        module.deprecate("The 'os_flavor_facts' module has been renamed to 'os_flavor_info', "
                         "and the renamed one no longer returns ansible_facts", version='2.13')

    name = module.params['name']
    vcpus = module.params['vcpus']
    ram = module.params['ram']
    ephemeral = module.params['ephemeral']
    limit = module.params['limit']

    filters = {}
    if vcpus:
        filters['vcpus'] = vcpus
    if ram:
        filters['ram'] = ram
    if ephemeral:
        filters['ephemeral'] = ephemeral

    sdk, cloud = openstack_cloud_from_module(module)
    try:
        if name:
            flavors = cloud.search_flavors(filters={'name': name})

        else:
            flavors = cloud.list_flavors()
            if filters:
                flavors = cloud.range_search(flavors, filters)

        if limit is not None:
            flavors = flavors[:limit]

        if is_old_facts:
            module.exit_json(changed=False,
                             ansible_facts=dict(openstack_flavors=flavors))
        else:
            module.exit_json(changed=False,
                             openstack_flavors=flavors)

    except sdk.exceptions.OpenStackCloudException as e:
        module.fail_json(msg=str(e))
예제 #22
0
def main():
    argument_spec = DigitalOceanHelper.digital_ocean_argument_spec()
    module = AnsibleModule(argument_spec=argument_spec)
    if module._name == 'digital_ocean_account_facts':
        module.deprecate("The 'digital_ocean_account_facts' module has been renamed to 'digital_ocean_account_info'", version='2.13')
    try:
        core(module)
    except Exception as e:
        module.fail_json(msg=to_native(e), exception=format_exc())
예제 #23
0
def main():
    argument_spec = ovirt_info_full_argument_spec(
        name=dict(default=None, required=False),
        type=dict(
            default=None,
            required=True,
            choices=[
                'os_image',
                'os_network',
                'os_volume',
                'foreman',
            ],
            aliases=['provider'],
        ),
    )
    module = AnsibleModule(argument_spec)
    is_old_facts = module._name == 'ovirt_external_provider_facts'
    if is_old_facts:
        module.deprecate(
            "The 'ovirt_external_provider_facts' module has been renamed to 'ovirt_external_provider_info', "
            "and the renamed one no longer returns ansible_facts",
            version='2.13')

    check_sdk(module)

    try:
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        external_providers_service = _external_provider_service(
            provider_type=module.params.pop('type'),
            system_service=connection.system_service(),
        )
        if module.params['name']:
            external_providers = [
                e for e in external_providers_service.list()
                if fnmatch.fnmatch(e.name, module.params['name'])
            ]
        else:
            external_providers = external_providers_service.list()

        result = dict(ovirt_external_providers=[
            get_dict_of_struct(
                struct=c,
                connection=connection,
                fetch_nested=module.params.get('fetch_nested'),
                attributes=module.params.get('nested_attributes'),
            ) for c in external_providers
        ], )
        if is_old_facts:
            module.exit_json(changed=False, ansible_facts=result)
        else:
            module.exit_json(changed=False, **result)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)
def main():
    module = AnsibleModule(argument_spec=dict(
        repository=dict(type='str', required=True, aliases=["repo"]),
        user=dict(type='str', required=True),
        password=dict(type='str', required=False, no_log=True),
        token=dict(type='str', required=False, no_log=True),
        github_url=dict(type='str',
                        required=False,
                        default="https://api.github.com")),
                           mutually_exclusive=(('password', 'token'), ),
                           required_one_of=(("password", "token"), ),
                           supports_check_mode=True)
    if module._name == 'github_webhook_facts':
        module.deprecate(
            "The 'github_webhook_facts' module has been renamed to 'github_webhook_info'",
            version='2.13')

    if not HAS_GITHUB:
        module.fail_json(msg=missing_required_lib('PyGithub'),
                         exception=GITHUB_IMP_ERR)

    try:
        github_conn = github.Github(module.params["user"],
                                    module.params.get("password")
                                    or module.params.get("token"),
                                    base_url=module.params["github_url"])
    except github.GithubException as err:
        module.fail_json(msg="Could not connect to GitHub at %s: %s" %
                         (module.params["github_url"], to_native(err)))

    try:
        repo = github_conn.get_repo(module.params["repository"])
    except github.BadCredentialsException as err:
        module.fail_json(msg="Could not authenticate to GitHub at %s: %s" %
                         (module.params["github_url"], to_native(err)))
    except github.UnknownObjectException as err:
        module.fail_json(
            msg="Could not find repository %s in GitHub at %s: %s" %
            (module.params["repository"], module.params["github_url"],
             to_native(err)))
    except Exception as err:
        module.fail_json(
            msg="Could not fetch repository %s from GitHub at %s: %s" %
            (module.params["repository"], module.params["github_url"],
             to_native(err)),
            exception=traceback.format_exc())

    try:
        hooks = [_munge_hook(h) for h in repo.get_hooks()]
    except github.GithubException as err:
        module.fail_json(msg="Unable to get hooks from repository %s: %s" %
                         (module.params["repository"], to_native(err)),
                         exception=traceback.format_exc())

    module.exit_json(changed=False, hooks=hooks)
def main():
    argument_spec = ovirt_info_full_argument_spec(
        vm=dict(required=True),
        description=dict(default=None),
        snapshot_id=dict(default=None),
    )
    module = AnsibleModule(argument_spec)
    is_old_facts = module._name == 'ovirt_snapshot_facts'
    if is_old_facts:
        module.deprecate(
            "The 'ovirt_snapshot_facts' module has been renamed to 'ovirt_snapshot_info', "
            "and the renamed one no longer returns ansible_facts",
            version='2.13')

    check_sdk(module)

    try:
        auth = module.params.pop('auth')
        connection = create_connection(auth)
        vms_service = connection.system_service().vms_service()
        vm_name = module.params['vm']
        vm = search_by_name(vms_service, vm_name)
        if vm is None:
            raise Exception("VM '%s' was not found." % vm_name)

        snapshots_service = vms_service.service(vm.id).snapshots_service()
        if module.params['description']:
            snapshots = [
                e for e in snapshots_service.list()
                if fnmatch.fnmatch(e.description, module.params['description'])
            ]
        elif module.params['snapshot_id']:
            snapshots = [
                snapshots_service.snapshot_service(
                    module.params['snapshot_id']).get()
            ]
        else:
            snapshots = snapshots_service.list()

        result = dict(ovirt_snapshots=[
            get_dict_of_struct(
                struct=c,
                connection=connection,
                fetch_nested=module.params.get('fetch_nested'),
                attributes=module.params.get('nested_attributes'),
            ) for c in snapshots
        ], )
        if is_old_facts:
            module.exit_json(changed=False, ansible_facts=result)
        else:
            module.exit_json(changed=False, **result)
    except Exception as e:
        module.fail_json(msg=str(e), exception=traceback.format_exc())
    finally:
        connection.close(logout=auth.get('token') is None)
def main():
    argument_spec = ec2_argument_spec()
    argument_spec.update(
        dict(
            filters=dict(default=dict(), type='dict'),
            peer_connection_ids=dict(default=None, type='list'),
        ))

    module = AnsibleModule(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'",
            version='2.13')

    # Validate Requirements
    if not HAS_BOTO3:
        module.fail_json(msg='botocore and boto3 are required.')

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
            module, boto3=True)
    except NameError as e:
        # Getting around the get_aws_connection_info boto reliance for region
        if "global name 'boto' is not defined" in e.message:
            module.params['region'] = botocore.session.get_session(
            ).get_config_variable('region')
            if not module.params['region']:
                module.fail_json(msg="Error - no region provided")
        else:
            module.fail_json(msg="Can't retrieve connection information - " +
                             str(e))

    try:
        region, ec2_url, aws_connect_kwargs = get_aws_connection_info(
            module, boto3=True)
        ec2 = boto3_conn(module,
                         conn_type='client',
                         resource='ec2',
                         region=region,
                         endpoint=ec2_url,
                         **aws_connect_kwargs)
    except botocore.exceptions.NoCredentialsError as e:
        module.fail_json(msg=str(e))

    # 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)
def main():
    module = AnsibleModule(
        argument_spec=DigitalOceanHelper.digital_ocean_argument_spec(),
        supports_check_mode=False,
    )

    module.deprecate(
        "The 'digital_ocean_sshkey_facts' module has been deprecated, use the new 'digital_ocean_sshkey_info' module",
        version='2.13')

    core(module)
def main():
    argument_spec = get_default_argspec()
    argument_spec.update(
        dict(retrieve_orders=dict(
            type='str',
            default='ignore',
            choices=['ignore', 'url_list', 'object_list']), ))
    module = AnsibleModule(
        argument_spec=argument_spec,
        required_one_of=(['account_key_src', 'account_key_content'], ),
        mutually_exclusive=(['account_key_src', 'account_key_content'], ),
        supports_check_mode=True,
    )
    if module._name == 'acme_account_facts':
        module.deprecate(
            "The 'acme_account_facts' module has been renamed to 'acme_account_info'",
            version='2.12')
    handle_standard_module_arguments(module, needs_acme_v2=True)

    try:
        account = ACMEAccount(module)
        # Check whether account exists
        created, account_data = account.setup_account(
            [],
            allow_creation=False,
            remove_account_uri_if_not_exists=True,
        )
        if created:
            raise AssertionError('Unwanted account creation')
        result = {
            'changed': False,
            'exists': account.uri is not None,
            'account_uri': account.uri,
        }
        if account.uri is not None:
            # Make sure promised data is there
            if 'contact' not in account_data:
                account_data['contact'] = []
            account_data['public_account_key'] = account.key_data['jwk']
            result['account'] = account_data
            # Retrieve orders list
            if account_data.get(
                    'orders') and module.params['retrieve_orders'] != 'ignore':
                orders = get_orders_list(module, account,
                                         account_data['orders'])
                if module.params['retrieve_orders'] == 'url_list':
                    result['orders'] = orders
                else:
                    result['orders'] = [
                        get_order(account, order) for order in orders
                    ]
        module.exit_json(**result)
    except ModuleFailException as e:
        e.do_fail(module)
예제 #29
0
def main():
    argument_spec = VmwareRestClient.vmware_client_argument_spec()
    module = AnsibleModule(argument_spec=argument_spec,
                           supports_check_mode=True)
    if module._name == 'vmware_tag_facts':
        module.deprecate(
            "The 'vmware_tag_facts' module has been renamed to 'vmware_tag_info'",
            version='2.13')

    vmware_tag_info = VmTagInfoManager(module)
    vmware_tag_info.get_all_tags()
예제 #30
0
def main():
    module = AnsibleModule(argument_spec=dict(
        view=dict(choices=['topics', 'subscriptions'], default='topics'),
        topic=dict(required=False),
        state=dict(choices=['list'], default='list'),
        service_account_email=dict(),
        credentials_file=dict(),
        project_id=dict(),
    ), )
    if module._name == 'gcpubsub_facts':
        module.deprecate(
            "The 'gcpubsub_facts' module has been renamed to 'gcpubsub_info'",
            version='2.13')

    if not HAS_PYTHON26:
        module.fail_json(
            msg="GCE module requires python's 'ast' module, python v2.6+")

    if not HAS_GOOGLE_CLOUD_PUBSUB:
        module.fail_json(msg="Please install google-cloud-pubsub library.")

    CLIENT_MINIMUM_VERSION = '0.22.0'
    if not check_min_pkg_version('google-cloud-pubsub',
                                 CLIENT_MINIMUM_VERSION):
        module.fail_json(
            msg="Please install google-cloud-pubsub library version %s" %
            CLIENT_MINIMUM_VERSION)

    mod_params = {}
    mod_params['state'] = module.params.get('state')
    mod_params['topic'] = module.params.get('topic')
    mod_params['view'] = module.params.get('view')

    creds, params = get_google_cloud_credentials(module)
    pubsub_client = pubsub.Client(project=params['project_id'],
                                  credentials=creds,
                                  use_gax=False)
    pubsub_client.user_agent = 'ansible-pubsub-0.1'

    json_output = {}
    if mod_params['view'] == 'topics':
        json_output['topics'] = list_func(pubsub_client.list_topics())
    elif mod_params['view'] == 'subscriptions':
        if mod_params['topic']:
            t = pubsub_client.topic(mod_params['topic'])
            json_output['subscriptions'] = list_func(t.list_subscriptions())
        else:
            json_output['subscriptions'] = list_func(
                pubsub_client.list_subscriptions())

    json_output['changed'] = False
    json_output.update(mod_params)
    module.exit_json(**json_output)