def main(): argument_spec = openstack_full_argument_spec( cluster_template_id=dict(required=True), discovery_url=dict(default=None), docker_volume_size=dict(type='int'), flavor_id=dict(default=None), keypair=dict(default=None), labels=dict(default=None, type='raw'), master_count=dict(type='int', default=1), master_flavor_id=dict(default=None), name=dict(required=True), node_count=dict(type='int', default=1), state=dict(default='present', choices=['absent', 'present']), timeout=dict(type='int', default=60), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) params = module.params.copy() state = module.params['state'] name = module.params['name'] cluster_template_id = module.params['cluster_template_id'] kwargs = dict( discovery_url=module.params['discovery_url'], docker_volume_size=module.params['docker_volume_size'], flavor_id=module.params['flavor_id'], keypair=module.params['keypair'], labels=_parse_labels(params['labels']), master_count=module.params['master_count'], master_flavor_id=module.params['master_flavor_id'], node_count=module.params['node_count'], create_timeout=module.params['timeout'], ) sdk, cloud = openstack_cloud_from_module(module) try: changed = False cluster = cloud.get_coe_cluster( name_or_id=name, filters={'cluster_template_id': cluster_template_id}) if state == 'present': if not cluster: cluster = cloud.create_coe_cluster( name, cluster_template_id=cluster_template_id, **kwargs) changed = True else: changed = False module.exit_json(changed=changed, cluster=cluster, id=cluster['uuid']) elif state == 'absent': if not cluster: module.exit_json(changed=False) else: cloud.delete_coe_cluster(name) module.exit_json(changed=True) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def run_module(): result = dict( success=False, changed=False, error="", ) argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options'] ) module = AnsibleModule( argument_spec, supports_check_mode=False, **openstack_module_kwargs() ) default_network = module.params.get('default_network', DEFAULT_NETWORK) net_data = module.params['net_data'] idx = module.params['idx'] error_messages = network_data_v2.validate_json_schema(net_data) if error_messages: module.fail_json(msg='\n\n'.join(error_messages)) try: _, conn = openstack_cloud_from_module(module) ipv6_enabled = net_data.get('ipv6', False) # Create or update the network net_spec = create_net_spec( net_data, get_overcloud_domain_name(conn, default_network), idx) changed, network = create_or_update_network(conn, module, net_spec) result['changed'] = changed if changed else result['changed'] # Get current segments and subnets on the network segments = list(conn.network.segments(network_id=network.id)) subnets = list(conn.network.subnets(network_id=network.id)) changed = adopt_the_implicit_segment(conn, module, segments, subnets, network) result['changed'] = changed if changed else result['changed'] for subnet_name, subnet_data in net_data.get('subnets', {}).items(): segment_spec = create_segment_spec( network.id, network.name, subnet_name, physical_network=subnet_data.get('physical_network')) subnet_v4_spec, subnet_v6_spec = create_subnet_spec( network.id, subnet_name, subnet_data, ipv6_enabled) changed, segment = create_or_update_segment( conn, module, segment_spec) result['changed'] = changed if changed else result['changed'] if subnet_v4_spec: subnet_v4_spec.update({'segment_id': segment.id}) changed = create_or_update_subnet(conn, module, subnet_v4_spec) result['changed'] = changed if changed else result['changed'] if subnet_v6_spec: subnet_v6_spec.update({'segment_id': segment.id}) changed = create_or_update_subnet(conn, module, subnet_v6_spec) result['changed'] = changed if changed else result['changed'] result['success'] = True module.exit_json(**result) except Exception as err: result['error'] = str(err) result['msg'] = ("Error overcloud network provision failed!") module.fail_json(**result)
def main(): argument_spec = openstack_full_argument_spec( role=dict(required=True), user=dict(required=False), group=dict(required=False), project=dict(required=False), domain=dict(required=False), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs( required_one_of=[['user', 'group']]) module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) role = module.params.get('role') user = module.params.get('user') group = module.params.get('group') project = module.params.get('project') domain = module.params.get('domain') state = module.params.get('state') sdk, cloud = openstack_cloud_from_module(module) try: filters = {} domain_id = None r = cloud.get_role(role) if r is None: module.fail_json(msg="Role %s is not valid" % role) filters['role'] = r['id'] if domain: d = cloud.get_domain(name_or_id=domain) if d is None: module.fail_json(msg="Domain %s is not valid" % domain) filters['domain'] = d['id'] domain_id = d['id'] if user: if domain: u = cloud.get_user(user, domain_id=filters['domain']) else: u = cloud.get_user(user) if u is None: module.fail_json(msg="User %s is not valid" % user) filters['user'] = u['id'] if group: if domain: g = cloud.get_group(group, domain_id=filters['domain']) else: g = cloud.get_group(group) if g is None: module.fail_json(msg="Group %s is not valid" % group) filters['group'] = g['id'] if project: if domain: p = cloud.get_project(project, domain_id=filters['domain']) # OpenStack won't allow us to use both a domain and project as # filter. Once we identified the project (using the domain as # a filter criteria), we need to remove the domain itself from # the filters list. domain_id = filters.pop('domain') else: p = cloud.get_project(project) if p is None: module.fail_json(msg="Project %s is not valid" % project) filters['project'] = p['id'] assignment = cloud.list_role_assignments(filters=filters) if module.check_mode: module.exit_json(changed=_system_state_change(state, assignment)) changed = False if state == 'present': if not assignment: kwargs = _build_kwargs(user, group, project, domain_id) cloud.grant_role(role, **kwargs) changed = True elif state == 'absent': if assignment: kwargs = _build_kwargs(user, group, project, domain_id) cloud.revoke_role(role, **kwargs) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), password=dict(required=False, default=None, no_log=True), email=dict(required=False, default=None), default_project=dict(required=False, default=None), description=dict(type='str'), domain=dict(required=False, default=None), enabled=dict(default=True, type='bool'), state=dict(default='present', choices=['absent', 'present']), update_password=dict(default=None, choices=['always', 'on_create']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) name = module.params['name'] password = module.params.get('password') email = module.params['email'] default_project = module.params['default_project'] domain = module.params['domain'] enabled = module.params['enabled'] state = module.params['state'] update_password = module.params['update_password'] description = module.params['description'] sdk, cloud = openstack_cloud_from_module(module) try: domain_id = None if domain: domain_id = _get_domain_id(cloud, domain) user = cloud.get_user(name, domain_id=domain_id) else: user = cloud.get_user(name) if state == 'present': if update_password in ('always', 'on_create'): if not password: msg = "update_password is %s but a password value is missing" % update_password module.fail_json(msg=msg) default_project_id = None if default_project: default_project_id = _get_default_project_id( cloud, default_project, domain_id, module) if user is None: if description is not None: user = cloud.create_user( name=name, password=password, email=email, default_project=default_project_id, domain_id=domain_id, enabled=enabled, description=description) else: user = cloud.create_user( name=name, password=password, email=email, default_project=default_project_id, domain_id=domain_id, enabled=enabled) changed = True else: params_dict = { 'email': email, 'enabled': enabled, 'password': password, 'update_password': update_password } if description is not None: params_dict['description'] = description if domain_id is not None: params_dict['domain_id'] = domain_id if default_project_id is not None: params_dict['default_project_id'] = default_project_id if _needs_update(params_dict, user): if update_password == 'always': if description is not None: user = cloud.update_user( user['id'], password=password, email=email, default_project=default_project_id, domain_id=domain_id, enabled=enabled, description=description) else: user = cloud.update_user( user['id'], password=password, email=email, default_project=default_project_id, domain_id=domain_id, enabled=enabled) else: if description is not None: user = cloud.update_user( user['id'], email=email, default_project=default_project_id, domain_id=domain_id, enabled=enabled, description=description) else: user = cloud.update_user( user['id'], email=email, default_project=default_project_id, domain_id=domain_id, enabled=enabled) changed = True else: changed = False module.exit_json(changed=changed, user=user) elif state == 'absent': if user is None: changed = False else: if domain: cloud.delete_user(user['id'], domain_id=domain_id) else: cloud.delete_user(user['id']) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( network=dict(required=False), name=dict(required=False), fixed_ips=dict(type='list', default=None, elements='dict'), admin_state_up=dict(type='bool', default=None), mac_address=dict(default=None), security_groups=dict(default=None, type='list', elements='str'), no_security_groups=dict(default=False, type='bool'), allowed_address_pairs=dict(type='list', default=None, elements='dict'), extra_dhcp_opts=dict(type='list', default=None, elements='dict'), device_owner=dict(default=None), device_id=dict(default=None), state=dict(default='present', choices=['absent', 'present']), vnic_type=dict(default=None, choices=[ 'normal', 'direct', 'direct-physical', 'macvtap', 'baremetal', 'virtio-forwarder' ]), port_security_enabled=dict(default=None, type='bool')) module_kwargs = openstack_module_kwargs(mutually_exclusive=[ ['no_security_groups', 'security_groups'], ]) module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) if not HAS_ORDEREDDICT: module.fail_json(msg=missing_required_lib('ordereddict')) name = module.params['name'] state = module.params['state'] sdk, cloud = openstack_cloud_from_module(module) try: if module.params['security_groups']: # translate security_groups to UUID's if names where provided module.params['security_groups'] = [ get_security_group_id(module, cloud, v) for v in module.params['security_groups'] ] # Neutron API accept 'binding:vnic_type' as an argument # for the port type. module.params['binding:vnic_type'] = module.params.pop('vnic_type') port = None network_id = None if name: port = cloud.get_port(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, port, cloud)) changed = False if state == 'present': if not port: network = module.params['network'] if not network: module.fail_json( msg="Parameter 'network' is required in Port Create") port_kwargs = _compose_port_args(module, cloud) network_object = cloud.get_network(network) if network_object: network_id = network_object['id'] else: module.fail_json(msg="Specified network was not found.") port = cloud.create_port(network_id, **port_kwargs) changed = True else: if _needs_update(module, port, cloud): port_kwargs = _compose_port_args(module, cloud) port = cloud.update_port(port['id'], **port_kwargs) changed = True module.exit_json(changed=changed, id=port['id'], port=port) if state == 'absent': if port: cloud.delete_port(port['id']) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( server=dict(required=True), action=dict(required=True, choices=[ 'stop', 'start', 'pause', 'unpause', 'lock', 'unlock', 'suspend', 'resume', 'rebuild' ]), image=dict(required=False), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, required_if=[('action', 'rebuild', ['image'])], **module_kwargs) action = module.params['action'] wait = module.params['wait'] timeout = module.params['timeout'] image = module.params['image'] sdk, cloud = openstack_cloud_from_module(module) try: server = cloud.get_server(module.params['server']) if not server: module.fail_json(msg='Could not find server %s' % server) status = server.status if module.check_mode: module.exit_json(changed=_system_state_change(action, status)) if action == 'stop': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.compute.post(_action_url(server.id), json={'os-stop': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) if action == 'start': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.compute.post(_action_url(server.id), json={'os-start': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) if action == 'pause': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.compute.post(_action_url(server.id), json={'pause': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) elif action == 'unpause': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.compute.post(_action_url(server.id), json={'unpause': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) elif action == 'lock': # lock doesn't set a state, just do it cloud.compute.post(_action_url(server.id), json={'lock': None}) module.exit_json(changed=True) elif action == 'unlock': # unlock doesn't set a state, just do it cloud.compute.post(_action_url(server.id), json={'unlock': None}) module.exit_json(changed=True) elif action == 'suspend': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.compute.post(_action_url(server.id), json={'suspend': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) elif action == 'resume': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.compute.post(_action_url(server.id), json={'resume': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) elif action == 'rebuild': image = cloud.get_image(image) if image is None: module.fail_json(msg="Image does not exist") # rebuild doesn't set a state, just do it cloud.compute.post(_action_url(server.id), json={'rebuild': None}) if wait: _wait(timeout, cloud, server, action, module, sdk) module.exit_json(changed=True) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), state=dict(default='present', choices=['absent', 'present']), backup_gigabytes=dict(required=False, type='int', default=None), backups=dict(required=False, type='int', default=None), cores=dict(required=False, type='int', default=None), fixed_ips=dict(required=False, type='int', default=None), floating_ips=dict(required=False, type='int', default=None, aliases=['compute_floating_ips']), floatingip=dict(required=False, type='int', default=None, aliases=['network_floating_ips']), gigabytes=dict(required=False, type='int', default=None), gigabytes_types=dict(required=False, type='dict', default={}), injected_file_size=dict(required=False, type='int', default=None), injected_files=dict(required=False, type='int', default=None), injected_path_size=dict(required=False, type='int', default=None), instances=dict(required=False, type='int', default=None), key_pairs=dict(required=False, type='int', default=None), loadbalancer=dict(required=False, type='int', default=None), network=dict(required=False, type='int', default=None), per_volume_gigabytes=dict(required=False, type='int', default=None), pool=dict(required=False, type='int', default=None), port=dict(required=False, type='int', default=None), project=dict(required=False, type='int', default=None), properties=dict(required=False, type='int', default=None), ram=dict(required=False, type='int', default=None), rbac_policy=dict(required=False, type='int', default=None), router=dict(required=False, type='int', default=None), security_group_rule=dict(required=False, type='int', default=None), security_group=dict(required=False, type='int', default=None), server_group_members=dict(required=False, type='int', default=None), server_groups=dict(required=False, type='int', default=None), snapshots=dict(required=False, type='int', default=None), snapshots_types=dict(required=False, type='dict', default={}), subnet=dict(required=False, type='int', default=None), subnetpool=dict(required=False, type='int', default=None), volumes=dict(required=False, type='int', default=None), volumes_types=dict(required=False, type='dict', default={})) module = AnsibleModule(argument_spec, supports_check_mode=True) if not HAS_KEYSTONEAUTH1: module.fail_json(msg=missing_required_lib("keystoneauth1"), exception=KEYSTONEAUTH1_IMP_ERR) sdk, cloud = openstack_cloud_from_module(module) try: cloud_params = dict(module.params) # In order to handle the different volume types we update module params after. dynamic_types = [ 'gigabytes_types', 'snapshots_types', 'volumes_types', ] for dynamic_type in dynamic_types: for k, v in module.params[dynamic_type].items(): module.params[k] = int(v) # Get current quota values project_quota_output = _get_quotas(sdk, module, cloud, cloud_params['name']) changes_required = False if module.params['state'] == "absent": # If a quota state is set to absent we should assume there will be changes. # The default quota values are not accessible so we can not determine if # no changes will occur or not. if module.check_mode: module.exit_json(changed=True) # Calling delete_network_quotas when a quota has not been set results # in an error, according to the sdk docs it should return the # current quota. # The following error string is returned: # network client call failed: Quota for tenant 69dd91d217e949f1a0b35a4b901741dc could not be found. neutron_msg1 = "network client call failed: Quota for tenant" neutron_msg2 = "could not be found" for quota_type in project_quota_output.keys(): quota_call = getattr(cloud, 'delete_%s_quotas' % (quota_type)) try: quota_call(cloud_params['name']) except sdk.exceptions.OpenStackCloudException as e: error_msg = str(e) if error_msg.find(neutron_msg1) > -1 and error_msg.find( neutron_msg2) > -1: pass else: module.fail_json(msg=str(e), extra_data=e.extra_data) project_quota_output = _get_quotas(sdk, module, cloud, cloud_params['name']) changes_required = True elif module.params['state'] == "present": if module.check_mode: module.exit_json( changed=_system_state_change(module, project_quota_output)) changes_required, quota_change_request = _system_state_change_details( module, project_quota_output) if changes_required: for quota_type in quota_change_request.keys(): quota_call = getattr(cloud, 'set_%s_quotas' % (quota_type)) quota_call(cloud_params['name'], **quota_change_request[quota_type]) # Get quota state post changes for validation project_quota_update = _get_quotas(sdk, module, cloud, cloud_params['name']) if project_quota_output == project_quota_update: module.fail_json(msg='Could not apply quota update') project_quota_output = project_quota_update module.exit_json(changed=changes_required, openstack_quotas=project_quota_output) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( server=dict(required=True), state=dict(default='present', choices=['absent', 'present']), network=dict(required=False, default=None), floating_ip_address=dict(required=False, default=None), reuse=dict(required=False, type='bool', default=False), fixed_address=dict(required=False, default=None), nat_destination=dict(required=False, default=None, aliases=['fixed_network', 'internal_network']), wait=dict(required=False, type='bool', default=False), timeout=dict(required=False, type='int', default=60), purge=dict(required=False, type='bool', default=False), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) server_name_or_id = module.params['server'] state = module.params['state'] network = module.params['network'] floating_ip_address = module.params['floating_ip_address'] reuse = module.params['reuse'] fixed_address = module.params['fixed_address'] nat_destination = module.params['nat_destination'] wait = module.params['wait'] timeout = module.params['timeout'] purge = module.params['purge'] sdk, cloud = openstack_cloud_from_module(module) try: server = cloud.get_server(server_name_or_id) if server is None: module.fail_json( msg="server {0} not found".format(server_name_or_id)) if state == 'present': # If f_ip already assigned to server, check that it matches # requirements. public_ip = cloud.get_server_public_ip(server) f_ip = _get_floating_ip(cloud, public_ip) if public_ip else public_ip if f_ip: if network: network_id = cloud.get_network(name_or_id=network)["id"] else: network_id = None # check if we have floating ip on given nat_destination network if nat_destination: nat_floating_addrs = [ addr for addr in server.addresses.get( cloud.get_network(nat_destination)['name'], []) if addr['addr'] == public_ip and addr['OS-EXT-IPS:type'] == 'floating' ] if len(nat_floating_addrs) == 0: module.fail_json( msg="server {server} already has a " "floating-ip on a different " "nat-destination than '{nat_destination}'".format( server=server_name_or_id, nat_destination=nat_destination)) if all([ fixed_address, f_ip.fixed_ip_address == fixed_address, network, f_ip.network != network_id ]): # Current state definitely conflicts with requirements module.fail_json( msg="server {server} already has a " "floating-ip on requested " "interface but it doesn't match " "requested network {network}: {fip}".format( server=server_name_or_id, network=network, fip=remove_values(f_ip, module.no_log_values))) if not network or f_ip.network == network_id: # Requirements are met module.exit_json(changed=False, floating_ip=f_ip) # Requirements are vague enough to ignore existing f_ip and try # to create a new f_ip to the server. server = cloud.add_ips_to_server(server=server, ips=floating_ip_address, ip_pool=network, reuse=reuse, fixed_address=fixed_address, wait=wait, timeout=timeout, nat_destination=nat_destination) fip_address = cloud.get_server_public_ip(server) # Update the floating IP status f_ip = _get_floating_ip(cloud, fip_address) module.exit_json(changed=True, floating_ip=f_ip) elif state == 'absent': if floating_ip_address is None: if not server_name_or_id: module.fail_json( msg="either server or floating_ip_address are required" ) server = cloud.get_server(server_name_or_id) floating_ip_address = cloud.get_server_public_ip(server) f_ip = _get_floating_ip(cloud, floating_ip_address) if not f_ip: # Nothing to detach module.exit_json(changed=False) changed = False if f_ip["fixed_ip_address"]: cloud.detach_ip_from_server(server_id=server['id'], floating_ip_id=f_ip['id']) # Update the floating IP status f_ip = cloud.get_floating_ip(id=f_ip['id']) changed = True if purge: cloud.delete_floating_ip(f_ip['id']) module.exit_json(changed=True) module.exit_json(changed=changed, floating_ip=f_ip) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), metadata=dict(required=False, default=None, type='dict'), availability_zone=dict(required=False, default=None), hosts=dict(required=False, default=None, type='list', elements='str'), purge_hosts=dict(default=True, type='bool'), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) name = module.params['name'] metadata = module.params['metadata'] availability_zone = module.params['availability_zone'] hosts = module.params['hosts'] purge_hosts = module.params['purge_hosts'] state = module.params['state'] if metadata is not None: metadata.pop('availability_zone', None) sdk, cloud = openstack_cloud_from_module(module) try: aggregates = cloud.search_aggregates(name_or_id=name) if len(aggregates) == 1: aggregate = aggregates[0] elif len(aggregates) == 0: aggregate = None else: raise Exception("Should not happen") if module.check_mode: module.exit_json(changed=_system_state_change(module, aggregate)) if state == 'present': if aggregate is None: aggregate = cloud.create_aggregate( name=name, availability_zone=availability_zone) _update_hosts(cloud, aggregate, hosts, False) if metadata: cloud.set_aggregate_metadata(aggregate.id, metadata) changed = True else: if _needs_update(module, aggregate): if availability_zone is not None: aggregate = cloud.update_aggregate( aggregate.id, name=name, availability_zone=availability_zone) if metadata is not None: metas = metadata for i in (set(aggregate.metadata.keys()) - set(metadata.keys())): if i != 'availability_zone': metas[i] = None cloud.set_aggregate_metadata(aggregate.id, metas) _update_hosts(cloud, aggregate, hosts, purge_hosts) changed = True else: changed = False module.exit_json(changed=changed) elif state == 'absent': if aggregate is None: changed = False else: _update_hosts(cloud, aggregate, [], True) cloud.delete_aggregate(aggregate.id) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( zone=dict(required=True), name=dict(required=True), recordset_type=dict(required=False, choices=[ 'a', 'aaaa', 'mx', 'cname', 'txt', 'ns', 'srv', 'ptr', 'caa' ]), records=dict(required=False, type='list', elements='str'), description=dict(required=False, default=None), ttl=dict(required=False, type='int'), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, required_if=[('state', 'present', ['recordset_type', 'records'])], supports_check_mode=True, **module_kwargs) module.module_min_sdk_version = '0.28.0' zone = module.params.get('zone') name = module.params.get('name') state = module.params.get('state') sdk, cloud = openstack_cloud_from_module(module) recordsets = cloud.search_recordsets(zone, name_or_id=name) if recordsets: recordset = recordsets[0] try: recordset_id = recordset['id'] except KeyError as e: module.fail_json(msg=str(e)) else: # recordsets is filtered by type and should never be more than 1 return recordset = None if state == 'present': recordset_type = module.params.get('recordset_type').upper() records = module.params.get('records') description = module.params.get('description') ttl = module.params.get('ttl') kwargs = {} if description: kwargs['description'] = description kwargs['records'] = records if module.check_mode: module.exit_json(changed=_system_state_change( state, records, description, ttl, recordset)) if recordset is None: if ttl: kwargs['ttl'] = ttl else: kwargs['ttl'] = 300 recordset = cloud.create_recordset(zone=zone, name=name, recordset_type=recordset_type, **kwargs) changed = True else: if ttl: kwargs['ttl'] = ttl pre_update_recordset = recordset changed = _system_state_change(state, records, description, ttl, pre_update_recordset) if changed: recordset = cloud.update_recordset(zone=zone, name_or_id=recordset_id, **kwargs) module.exit_json(changed=changed, recordset=recordset) elif state == 'absent': if module.check_mode: module.exit_json(changed=_system_state_change( state, None, None, None, recordset)) if recordset is None: changed = False else: cloud.delete_recordset(zone, recordset_id) changed = True module.exit_json(changed=changed)
def main(): argument_spec = openstack_full_argument_spec( coe=dict(required=True, choices=['kubernetes', 'swarm', 'mesos']), dns_nameserver=dict(default='8.8.8.8'), docker_storage_driver=dict( choices=['devicemapper', 'overlay', 'overlay2']), docker_volume_size=dict(type='int'), external_network_id=dict(default=None), fixed_network=dict(default=None), fixed_subnet=dict(default=None), flavor_id=dict(default=None), floating_ip_enabled=dict(type='bool', default=True), keypair_id=dict(default=None), image_id=dict(required=True), labels=dict(default=None, type='raw'), http_proxy=dict(default=None), https_proxy=dict(default=None), master_lb_enabled=dict(type='bool', default=False), master_flavor_id=dict(default=None), name=dict(required=True), network_driver=dict(choices=['flannel', 'calico', 'docker']), no_proxy=dict(default=None), public=dict(type='bool', default=False), registry_enabled=dict(type='bool', default=False), server_type=dict(default="vm", choices=['vm', 'bm']), state=dict(default='present', choices=['absent', 'present']), tls_disabled=dict(type='bool', default=False), volume_driver=dict(choices=['cinder', 'rexray']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) params = module.params.copy() state = module.params['state'] name = module.params['name'] coe = module.params['coe'] image_id = module.params['image_id'] kwargs = dict( dns_nameserver=module.params['dns_nameserver'], docker_storage_driver=module.params['docker_storage_driver'], docker_volume_size=module.params['docker_volume_size'], external_network_id=module.params['external_network_id'], fixed_network=module.params['fixed_network'], fixed_subnet=module.params['fixed_subnet'], flavor_id=module.params['flavor_id'], floating_ip_enabled=module.params['floating_ip_enabled'], keypair_id=module.params['keypair_id'], labels=_parse_labels(params['labels']), http_proxy=module.params['http_proxy'], https_proxy=module.params['https_proxy'], master_lb_enabled=module.params['master_lb_enabled'], master_flavor_id=module.params['master_flavor_id'], network_driver=module.params['network_driver'], no_proxy=module.params['no_proxy'], public=module.params['public'], registry_enabled=module.params['registry_enabled'], server_type=module.params['server_type'], tls_disabled=module.params['tls_disabled'], volume_driver=module.params['volume_driver'], ) sdk, cloud = openstack_cloud_from_module(module) try: changed = False template = cloud.get_coe_cluster_template(name_or_id=name, filters={ 'coe': coe, 'image_id': image_id }) if state == 'present': if not template: template = cloud.create_coe_cluster_template(name, coe=coe, image_id=image_id, **kwargs) changed = True else: changed = False module.exit_json(changed=changed, cluster_template=template, id=template['uuid']) elif state == 'absent': if not template: module.exit_json(changed=False) else: cloud.delete_coe_cluster_template(name) module.exit_json(changed=True) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( security_group=dict(required=True), # NOTE(Shrews): None is an acceptable protocol value for # Neutron, but Nova will balk at this. protocol=dict(default=None, choices=[None, 'any', 'tcp', 'udp', 'icmp', '112', '132']), port_range_min=dict(required=False, type='int'), port_range_max=dict(required=False, type='int'), remote_ip_prefix=dict(required=False, default=None), remote_group=dict(required=False, default=None), ethertype=dict(default='IPv4', choices=['IPv4', 'IPv6']), direction=dict(default='ingress', choices=['egress', 'ingress']), state=dict(default='present', choices=['absent', 'present']), project=dict(default=None), ) module_kwargs = openstack_module_kwargs( mutually_exclusive=[ ['remote_ip_prefix', 'remote_group'], ] ) module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] security_group = module.params['security_group'] remote_group = module.params['remote_group'] project = module.params['project'] changed = False sdk, cloud = openstack_cloud_from_module(module) try: if project is not None: proj = cloud.get_project(project) if proj is None: module.fail_json(msg='Project %s could not be found' % project) project_id = proj['id'] else: project_id = cloud.current_project_id if project_id: filters = {'tenant_id': project_id} else: filters = None secgroup = cloud.get_security_group(security_group, filters=filters) if remote_group: remotegroup = cloud.get_security_group(remote_group, filters=filters) else: remotegroup = {'id': None} if module.check_mode: module.exit_json(changed=_system_state_change(module, secgroup, remotegroup)) if state == 'present': if module.params['protocol'] == 'any': module.params['protocol'] = None if not secgroup: module.fail_json(msg='Could not find security group %s' % security_group) rule = _find_matching_rule(module, secgroup, remotegroup) if not rule: kwargs = {} if project_id: kwargs['project_id'] = project_id rule = cloud.create_security_group_rule( secgroup['id'], port_range_min=module.params['port_range_min'], port_range_max=module.params['port_range_max'], protocol=module.params['protocol'], remote_ip_prefix=module.params['remote_ip_prefix'], remote_group_id=remotegroup['id'], direction=module.params['direction'], ethertype=module.params['ethertype'], **kwargs ) changed = True module.exit_json(changed=changed, rule=rule, id=rule['id']) if state == 'absent' and secgroup: rule = _find_matching_rule(module, secgroup, remotegroup) if rule: cloud.delete_security_group_rule(rule['id']) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), shared=dict(default=False, type='bool'), admin_state_up=dict(default=True, type='bool'), external=dict(default=False, type='bool'), provider_physical_network=dict(required=False), provider_network_type=dict(required=False), provider_segmentation_id=dict(required=False, type='int'), state=dict(default='present', choices=['absent', 'present']), project=dict(default=None), port_security_enabled=dict(type='bool'), mtu=dict(required=False, type='int'), dns_domain=dict(required=False) ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) state = module.params['state'] name = module.params['name'] shared = module.params['shared'] admin_state_up = module.params['admin_state_up'] external = module.params['external'] provider_physical_network = module.params['provider_physical_network'] provider_network_type = module.params['provider_network_type'] provider_segmentation_id = module.params['provider_segmentation_id'] project = module.params.get('project') port_security_enabled = module.params.get('port_security_enabled') mtu = module.params.get('mtu') dns_domain = module.params.get('dns_domain') sdk, cloud = openstack_cloud_from_module(module) try: if project is not None: proj = cloud.get_project(project) if proj is None: module.fail_json(msg='Project %s could not be found' % project) project_id = proj['id'] filters = {'tenant_id': project_id} else: project_id = None filters = None net = cloud.get_network(name, filters=filters) if state == 'present': if not net: provider = {} if provider_physical_network: provider['physical_network'] = provider_physical_network if provider_network_type: provider['network_type'] = provider_network_type if provider_segmentation_id: provider['segmentation_id'] = provider_segmentation_id if project_id is not None: net = cloud.create_network(name, shared, admin_state_up, external, provider, project_id, port_security_enabled=port_security_enabled, mtu_size=mtu, dns_domain=dns_domain) else: net = cloud.create_network(name, shared, admin_state_up, external, provider, port_security_enabled=port_security_enabled, mtu_size=mtu, dns_domain=dns_domain) changed = True else: changed = False module.exit_json(changed=changed, network=net, id=net['id']) elif state == 'absent': if not net: module.exit_json(changed=False) else: cloud.delete_network(name) module.exit_json(changed=True) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), state=dict(default='present', choices=['absent', 'present']), loadbalancer=dict(required=True), protocol=dict(default='HTTP', choices=['HTTP', 'HTTPS', 'TCP', 'TERMINATED_HTTPS']), protocol_port=dict(default=80, type='int', required=False), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) loadbalancer = module.params['loadbalancer'] loadbalancer_id = None try: changed = False listener = cloud.load_balancer.find_listener( name_or_id=module.params['name']) if module.params['state'] == 'present': if not listener: lb = cloud.load_balancer.find_load_balancer(loadbalancer) if not lb: module.fail_json(msg='load balancer %s is not found' % loadbalancer) loadbalancer_id = lb.id listener = cloud.load_balancer.create_listener( name=module.params['name'], loadbalancer_id=loadbalancer_id, protocol=module.params['protocol'], protocol_port=module.params['protocol_port'], ) changed = True if not module.params['wait']: module.exit_json(changed=changed, listener=listener.to_dict(), id=listener.id) if module.params['wait']: # Check in case the listener already exists. lb = cloud.load_balancer.find_load_balancer(loadbalancer) if not lb: module.fail_json(msg='load balancer %s is not found' % loadbalancer) _lb_wait_for_status(module, cloud, lb, "ACTIVE", ["ERROR"]) module.exit_json(changed=changed, listener=listener.to_dict(), id=listener.id) elif module.params['state'] == 'absent': if not listener: changed = False else: cloud.load_balancer.delete_listener(listener) changed = True if module.params['wait']: # Wait for the load balancer to be active after deleting # the listener. lb = cloud.load_balancer.find_load_balancer(loadbalancer) if not lb: module.fail_json(msg='load balancer %s is not found' % loadbalancer) _lb_wait_for_status(module, cloud, lb, "ACTIVE", ["ERROR"]) module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( state=dict(required=False, default='present', choices=['absent', 'present']), target_project_id=dict(required=True, type='str'), resource_type=dict(required=True, type='str'), resource_name=dict(required=True, type='str'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, required_if=[('state', 'present', ['target_project_id'])], **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) state = module.params['state'] resource_name = module.params['resource_name'] resource_type = module.params['resource_type'] target_project_id = module.params['target_project_id'] try: if resource_type == 'nova_flavor': # returns Munch({'NAME_ATTR': 'name', # 'tenant_id': u'37e55da59ec842649d84230f3a24eed5', # 'HUMAN_ID': False, # 'flavor_id': u'6d4d37b9-0480-4a8c-b8c9-f77deaad73f9', # 'request_ids': [], 'human_id': None}), _get_resource = cloud.get_flavor _list_resource_access = cloud.list_flavor_access _add_resource_access = cloud.add_flavor_access _remove_resource_access = cloud.remove_flavor_access elif resource_type == 'cinder_volume_type': # returns [Munch({ # 'project_id': u'178cdb9955b047eea7afbe582038dc94', # 'properties': {'request_ids': [], 'NAME_ATTR': 'name', # 'human_id': None, # 'HUMAN_ID': False}, # 'id': u'd5573023-b290-42c8-b232-7c5ca493667f'}), _get_resource = cloud.get_volume_type _list_resource_access = cloud.get_volume_type_access _add_resource_access = cloud.add_volume_type_access _remove_resource_access = cloud.remove_volume_type_access else: module.exit_json(changed=False, resource_name=resource_name, resource_type=resource_type, error="Not implemented.") resource = _get_resource(resource_name) if not resource: module.exit_json(changed=False, resource_name=resource_name, resource_type=resource_type, error="Not found.") resource_id = getattr(resource, 'id', resource['id']) # _list_resource_access returns a list of dicts containing 'project_id' acls = _list_resource_access(resource_id) if not all(acl.get('project_id') for acl in acls): module.exit_json(changed=False, resource_name=resource_name, resource_type=resource_type, error="Missing project_id in resource output.") allowed_tenants = [acl['project_id'] for acl in acls] changed_access = any( (state == 'present' and target_project_id not in allowed_tenants, state == 'absent' and target_project_id in allowed_tenants)) if module.check_mode or not changed_access: module.exit_json(changed=changed_access, resource=resource, id=resource_id) if state == 'present': _add_resource_access(resource_id, target_project_id) elif state == 'absent': _remove_resource_access(resource_id, target_project_id) module.exit_json(changed=True, resource=resource, id=resource_id) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), **module.params)
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), id=dict(default=None), checksum=dict(default=None), disk_format=dict(default='qcow2', choices=['ami', 'ari', 'aki', 'vhd', 'vmdk', 'raw', 'qcow2', 'vdi', 'iso', 'vhdx', 'ploop']), container_format=dict(default='bare', choices=['ami', 'aki', 'ari', 'bare', 'ovf', 'ova', 'docker']), owner=dict(default=None), min_disk=dict(type='int', default=0), min_ram=dict(type='int', default=0), is_public=dict(type='bool', default=False), protected=dict(type='bool', default=False), filename=dict(default=None), ramdisk=dict(default=None), kernel=dict(default=None), properties=dict(type='dict', default={}), volume=dict(default=None), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs( mutually_exclusive=[['filename', 'volume']], ) module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: changed = False if module.params['id']: image = cloud.get_image(name_or_id=module.params['id']) elif module.params['checksum']: image = cloud.get_image(name_or_id=module.params['name'], filters={'checksum': module.params['checksum']}) else: image = cloud.get_image(name_or_id=module.params['name']) if module.params['state'] == 'present': if not image: kwargs = {} if module.params['id'] is not None: kwargs['id'] = module.params['id'] image = cloud.create_image( name=module.params['name'], filename=module.params['filename'], disk_format=module.params['disk_format'], container_format=module.params['container_format'], wait=module.params['wait'], timeout=module.params['timeout'], is_public=module.params['is_public'], protected=module.params['protected'], min_disk=module.params['min_disk'], min_ram=module.params['min_ram'], volume=module.params['volume'], **kwargs ) changed = True if not module.params['wait']: module.exit_json(changed=changed, image=image, id=image.id) cloud.update_image_properties( image=image, kernel=module.params['kernel'], ramdisk=module.params['ramdisk'], protected=module.params['protected'], **module.params['properties']) image = cloud.get_image(name_or_id=image.id) module.exit_json(changed=changed, image=image, id=image.id) elif module.params['state'] == 'absent': if not image: changed = False else: cloud.delete_image( name_or_id=module.params['name'], wait=module.params['wait'], timeout=module.params['timeout']) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), image=dict(default=None), image_exclude=dict(default='(deprecated)'), flavor=dict(default=None), flavor_ram=dict(default=None, type='int'), flavor_include=dict(default=None), key_name=dict(default=None), security_groups=dict(default=['default'], type='list'), network=dict(default=None), nics=dict(default=[], type='list'), meta=dict(default=None, type='raw'), userdata=dict(default=None, aliases=['user_data']), config_drive=dict(default=False, type='bool'), auto_ip=dict(default=True, type='bool', aliases=['auto_floating_ip', 'public_ip']), floating_ips=dict(default=None, type='list'), floating_ip_pools=dict(default=None, type='list'), volume_size=dict(default=False, type='int'), boot_from_volume=dict(default=False, type='bool'), boot_volume=dict(default=None, aliases=['root_volume']), terminate_volume=dict(default=False, type='bool'), volumes=dict(default=[], type='list'), scheduler_hints=dict(default=None, type='dict'), state=dict(default='present', choices=['absent', 'present']), delete_fip=dict(default=False, type='bool'), reuse_ips=dict(default=True, type='bool'), ) module_kwargs = openstack_module_kwargs( mutually_exclusive=[ ['auto_ip', 'floating_ips'], ['auto_ip', 'floating_ip_pools'], ['floating_ips', 'floating_ip_pools'], ['flavor', 'flavor_ram'], ['image', 'boot_volume'], ['boot_from_volume', 'boot_volume'], ['nics', 'network'], ], required_if=[ ('boot_from_volume', True, ['volume_size', 'image']), ], ) module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] image = module.params['image'] boot_volume = module.params['boot_volume'] flavor = module.params['flavor'] flavor_ram = module.params['flavor_ram'] if state == 'present': if not (image or boot_volume): module.fail_json( msg= 'Parameter image or boot_volume is required if state == present' ) if not flavor and not flavor_ram: module.fail_json( msg= 'Parameter flavor or flavor_ram is required if state == present' ) sdk, cloud = openstack_cloud_from_module(module) try: if state == 'present': _present_server(module, cloud) if state == 'absent': _absent_server(module, cloud) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = ironic_argument_spec( uuid=dict(required=False), name=dict(required=False), driver=dict(required=False), driver_info=dict(type='dict', required=True), nics=dict(type='list', required=True, elements="dict"), properties=dict(type='dict', default={}), chassis_uuid=dict(required=False), skip_update_of_masked_password=dict( required=False, type='bool', aliases=['skip_update_of_driver_password'], deprecated_aliases=[ dict(name='skip_update_of_driver_password', version='2.0.0') ]), state=dict(required=False, default='present', choices=['present', 'absent'])) module_kwargs = openstack_module_kwargs() module = IronicModule(argument_spec, **module_kwargs) if not HAS_JSONPATCH: module.fail_json(msg='jsonpatch is required for this module') node_id = _choose_id_value(module) sdk, cloud = openstack_cloud_from_module(module) try: server = cloud.get_machine(node_id) if module.params['state'] == 'present': if module.params['driver'] is None: module.fail_json(msg="A driver must be defined in order " "to set a node to present.") properties = _parse_properties(module) driver_info = _parse_driver_info(sdk, module) kwargs = dict( driver=module.params['driver'], properties=properties, driver_info=driver_info, name=module.params['name'], ) if module.params['chassis_uuid']: kwargs['chassis_uuid'] = module.params['chassis_uuid'] if server is None: # Note(TheJulia): Add a specific UUID to the request if # present in order to be able to re-use kwargs for if # the node already exists logic, since uuid cannot be # updated. if module.params['uuid']: kwargs['uuid'] = module.params['uuid'] server = cloud.register_machine(module.params['nics'], **kwargs) module.exit_json(changed=True, uuid=server['uuid'], provision_state=server['provision_state']) else: # TODO(TheJulia): Presently this does not support updating # nics. Support needs to be added. # # Note(TheJulia): This message should never get logged # however we cannot realistically proceed if neither a # name or uuid was supplied to begin with. if not node_id: module.fail_json(msg="A uuid or name value " "must be defined") # Note(TheJulia): Constructing the configuration to compare # against. The items listed in the server_config block can # be updated via the API. server_config = dict( driver=server['driver'], properties=server['properties'], driver_info=server['driver_info'], name=server['name'], ) # Add the pre-existing chassis_uuid only if # it is present in the server configuration. if hasattr(server, 'chassis_uuid'): server_config['chassis_uuid'] = server['chassis_uuid'] # Note(TheJulia): If a password is defined and concealed, a # patch will always be generated and re-asserted. patch = jsonpatch.JsonPatch.from_diff(server_config, kwargs) if not patch: _exit_node_not_updated(module, server) elif _choose_if_password_only(module, list(patch)): # Note(TheJulia): Normally we would allow the general # exception catch below, however this allows a specific # message. try: server = cloud.patch_machine(server['uuid'], list(patch)) except Exception as e: module.fail_json(msg="Failed to update node, " "Error: %s" % e.message) # Enumerate out a list of changed paths. change_list = [] for change in list(patch): change_list.append(change['path']) module.exit_json(changed=True, result="Node Updated", changes=change_list, uuid=server['uuid'], provision_state=server['provision_state']) # Return not updated by default as the conditions were not met # to update. _exit_node_not_updated(module, server) if module.params['state'] == 'absent': if not node_id: module.fail_json(msg="A uuid or name value must be defined " "in order to remove a node.") if server is not None: cloud.unregister_machine(module.params['nics'], server['uuid']) module.exit_json(changed=True, result="deleted") else: module.exit_json(changed=False, result="Server not found") except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), description=dict(default=''), state=dict(default='present', choices=['absent', 'present']), project=dict(default=None), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) name = module.params['name'] state = module.params['state'] description = module.params['description'] project = module.params['project'] sdk, cloud = openstack_cloud_from_module(module) try: if project is not None: proj = cloud.get_project(project) if proj is None: module.fail_json(msg='Project %s could not be found' % project) project_id = proj['id'] else: project_id = cloud.current_project_id if project_id: filters = {'tenant_id': project_id} else: filters = None secgroup = cloud.get_security_group(name, filters=filters) if module.check_mode: module.exit_json(changed=_system_state_change(module, secgroup)) changed = False if state == 'present': if not secgroup: kwargs = {} if project_id: kwargs['project_id'] = project_id secgroup = cloud.create_security_group(name, description, **kwargs) changed = True else: if _needs_update(module, secgroup): secgroup = cloud.update_security_group( secgroup['id'], description=description) changed = True module.exit_json(changed=changed, id=secgroup['id'], secgroup=secgroup) if state == 'absent': if secgroup: cloud.delete_security_group(secgroup['id']) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( server=dict(required=True), volume=dict(required=True), device=dict(default=None), # None == auto choose device name state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] wait = module.params['wait'] timeout = module.params['timeout'] sdk, cloud = openstack_cloud_from_module(module) try: server = cloud.get_server(module.params['server']) volume = cloud.get_volume(module.params['volume']) if not volume: module.fail_json(msg='volume %s is not found' % module.params['volume']) dev = cloud.get_volume_attach_device(volume, server.id) if module.check_mode: module.exit_json(changed=_system_state_change(state, dev)) if state == 'present': changed = False if not dev: changed = True cloud.attach_volume(server, volume, module.params['device'], wait=wait, timeout=timeout) server = cloud.get_server(module.params['server']) # refresh volume = cloud.get_volume(module.params['volume']) # refresh hostvars = cloud.get_openstack_vars(server) module.exit_json(changed=changed, id=volume['id'], attachments=volume['attachments'], openstack=hostvars) elif state == 'absent': if not dev: # Volume is not attached to this server module.exit_json(changed=False) cloud.detach_volume(server, volume, wait=wait, timeout=timeout) module.exit_json(changed=True, result='Detached volume from server') except (sdk.exceptions.OpenStackCloudException, sdk.exceptions.ResourceTimeout) as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), public_key=dict(default=None), public_key_file=dict(default=None), state=dict(default='present', choices=['absent', 'present', 'replace']), ) module_kwargs = openstack_module_kwargs( mutually_exclusive=[['public_key', 'public_key_file']]) module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] name = module.params['name'] public_key = module.params['public_key'] if module.params['public_key_file']: with open(module.params['public_key_file']) as public_key_fh: public_key = public_key_fh.read().rstrip() sdk, cloud = openstack_cloud_from_module(module) try: keypair = cloud.get_keypair(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, keypair)) if state in ('present', 'replace'): if keypair and keypair['name'] == name: if public_key and (public_key != keypair['public_key']): if state == 'present': module.fail_json( msg="Key name %s present but key hash not the same" " as offered. Delete key first." % name ) else: cloud.delete_keypair(name) keypair = cloud.create_keypair(name, public_key) changed = True else: changed = False else: keypair = cloud.create_keypair(name, public_key) changed = True module.exit_json(changed=changed, key=keypair, id=keypair['id']) elif state == 'absent': if keypair: cloud.delete_keypair(name) module.exit_json(changed=True) module.exit_json(changed=False) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( uuid=dict(required=False), name=dict(required=False), instance_info=dict(type='dict', required=False), config_drive=dict(type='raw', required=False), ironic_url=dict(required=False), state=dict(required=False, default='present'), maintenance=dict(required=False), maintenance_reason=dict(required=False), power=dict(required=False, default='present'), deploy=dict(required=False, default='yes'), wait=dict(type='bool', required=False, default=False), timeout=dict(required=False, type='int', default=1800), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) if (module.params['auth_type'] in [None, 'None'] and module.params['ironic_url'] is None): module.fail_json(msg="Authentication appears disabled, Please " "define an ironic_url parameter") if (module.params['ironic_url'] and module.params['auth_type'] in [None, 'None']): module.params['auth'] = dict(endpoint=module.params['ironic_url']) if (module.params['config_drive'] and not isinstance(module.params['config_drive'], (str, dict))): config_drive_type = type(module.params['config_drive']) msg = ('argument config_drive is of type %s and we expected' ' str or dict') % config_drive_type module.fail_json(msg=msg) node_id = _choose_id_value(module) if not node_id: module.fail_json(msg="A uuid or name value must be defined " "to use this module.") sdk, cloud = openstack_cloud_from_module(module) try: node = cloud.get_machine(node_id) if node is None: module.fail_json(msg="node not found") uuid = node['uuid'] instance_info = module.params['instance_info'] changed = False wait = module.params['wait'] timeout = module.params['timeout'] # User has requested desired state to be in maintenance state. if module.params['state'] == 'maintenance': module.params['maintenance'] = True if node['provision_state'] in [ 'cleaning', 'deleting', 'wait call-back' ]: module.fail_json(msg="Node is in %s state, cannot act upon the " "request as the node is in a transition " "state" % node['provision_state']) # TODO(TheJulia) This is in-development code, that requires # code in the shade library that is still in development. if _check_set_maintenance(module, cloud, node): if node['provision_state'] in 'active': module.exit_json(changed=True, result="Maintenance state changed") changed = True node = cloud.get_machine(node_id) if _check_set_power_state(module, cloud, node): changed = True node = cloud.get_machine(node_id) if _is_true(module.params['state']): if _is_false(module.params['deploy']): module.exit_json(changed=changed, result="User request has explicitly disabled " "deployment logic") if 'active' in node['provision_state']: module.exit_json(changed=changed, result="Node already in an active state.") if instance_info is None: module.fail_json(changed=changed, msg="When setting an instance to present, " "instance_info is a required variable.") # TODO(TheJulia): Update instance info, however info is # deployment specific. Perhaps consider adding rebuild # support, although there is a known desire to remove # rebuild support from Ironic at some point in the future. cloud.update_machine(uuid, instance_info=instance_info) cloud.validate_node(uuid) if not wait: cloud.activate_node(uuid, module.params['config_drive']) else: cloud.activate_node(uuid, configdrive=module.params['config_drive'], wait=wait, timeout=timeout) # TODO(TheJulia): Add more error checking.. module.exit_json(changed=changed, result="node activated") elif _is_false(module.params['state']): if node['provision_state'] not in "deleted": cloud.update_machine(uuid, instance_info={}) if not wait: cloud.deactivate_node(uuid) else: cloud.deactivate_node(uuid, wait=wait, timeout=timeout) module.exit_json(changed=True, result="deleted") else: module.exit_json(changed=False, result="node not found") else: module.fail_json(msg="State must be present, absent, " "maintenance, off") except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), state=dict(default='present', choices=['absent', 'present']), vip_network=dict(required=False), vip_subnet=dict(required=False), vip_port=dict(required=False), vip_address=dict(required=False), listeners=dict(type='list', default=[], elements='dict'), public_ip_address=dict(required=False, default=None), auto_public_ip=dict(required=False, default=False, type='bool'), public_network=dict(required=False), delete_public_ip=dict(required=False, default=False, type='bool'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) vip_network = module.params['vip_network'] vip_subnet = module.params['vip_subnet'] vip_port = module.params['vip_port'] listeners = module.params['listeners'] public_vip_address = module.params['public_ip_address'] allocate_fip = module.params['auto_public_ip'] delete_fip = module.params['delete_public_ip'] public_network = module.params['public_network'] vip_network_id = None vip_subnet_id = None vip_port_id = None try: changed = False lb = cloud.load_balancer.find_load_balancer( name_or_id=module.params['name']) if module.params['state'] == 'present': if not lb: if not (vip_network or vip_subnet or vip_port): module.fail_json( msg="One of vip_network, vip_subnet, or vip_port must " "be specified for load balancer creation") if vip_network: network = cloud.get_network(vip_network) if not network: module.fail_json(msg='network %s is not found' % vip_network) vip_network_id = network.id if vip_subnet: subnet = cloud.get_subnet(vip_subnet) if not subnet: module.fail_json(msg='subnet %s is not found' % vip_subnet) vip_subnet_id = subnet.id if vip_port: port = cloud.get_port(vip_port) if not port: module.fail_json(msg='port %s is not found' % vip_port) vip_port_id = port.id lb = cloud.load_balancer.create_load_balancer( name=module.params['name'], vip_network_id=vip_network_id, vip_subnet_id=vip_subnet_id, vip_port_id=vip_port_id, vip_address=module.params['vip_address'], ) changed = True if not listeners and not module.params['wait']: module.exit_json(changed=changed, loadbalancer=lb.to_dict(), id=lb.id) _wait_for_lb(module, cloud, lb, "ACTIVE", ["ERROR"]) for listener_def in listeners: listener_name = listener_def.get("name") pool_def = listener_def.get("pool") if not listener_name: module.fail_json(msg='listener name is required') listener = cloud.load_balancer.find_listener( name_or_id=listener_name) if not listener: _wait_for_lb(module, cloud, lb, "ACTIVE", ["ERROR"]) protocol = listener_def.get("protocol", "HTTP") protocol_port = listener_def.get("protocol_port", 80) listener = cloud.load_balancer.create_listener( name=listener_name, loadbalancer_id=lb.id, protocol=protocol, protocol_port=protocol_port, ) changed = True # Ensure pool in the listener. if pool_def: pool_name = pool_def.get("name") members = pool_def.get('members', []) if not pool_name: module.fail_json(msg='pool name is required') pool = cloud.load_balancer.find_pool(name_or_id=pool_name) if not pool: _wait_for_lb(module, cloud, lb, "ACTIVE", ["ERROR"]) protocol = pool_def.get("protocol", "HTTP") lb_algorithm = pool_def.get("lb_algorithm", "ROUND_ROBIN") pool = cloud.load_balancer.create_pool( name=pool_name, listener_id=listener.id, protocol=protocol, lb_algorithm=lb_algorithm) changed = True # Ensure members in the pool for member_def in members: member_name = member_def.get("name") if not member_name: module.fail_json(msg='member name is required') member = cloud.load_balancer.find_member( member_name, pool.id) if not member: _wait_for_lb(module, cloud, lb, "ACTIVE", ["ERROR"]) address = member_def.get("address") if not address: module.fail_json( msg='member address for member %s is ' 'required' % member_name) subnet_id = member_def.get("subnet") if subnet_id: subnet = cloud.get_subnet(subnet_id) if not subnet: module.fail_json( msg='subnet %s for member %s is not ' 'found' % (subnet_id, member_name)) subnet_id = subnet.id protocol_port = member_def.get("protocol_port", 80) member = cloud.load_balancer.create_member( pool, name=member_name, address=address, protocol_port=protocol_port, subnet_id=subnet_id) changed = True # Associate public ip to the load balancer VIP. If # public_vip_address is provided, use that IP, otherwise, either # find an available public ip or create a new one. fip = None orig_public_ip = None new_public_ip = None if public_vip_address or allocate_fip: ips = cloud.network.ips(port_id=lb.vip_port_id, fixed_ip_address=lb.vip_address) ips = list(ips) if ips: orig_public_ip = ips[0] new_public_ip = orig_public_ip.floating_ip_address if public_vip_address and public_vip_address != orig_public_ip: fip = cloud.network.find_ip(public_vip_address) if not fip: module.fail_json(msg='Public IP %s is unavailable' % public_vip_address) # Release origin public ip first cloud.network.update_ip(orig_public_ip, fixed_ip_address=None, port_id=None) # Associate new public ip cloud.network.update_ip(fip, fixed_ip_address=lb.vip_address, port_id=lb.vip_port_id) new_public_ip = public_vip_address changed = True elif allocate_fip and not orig_public_ip: fip = cloud.network.find_available_ip() if not fip: if not public_network: module.fail_json(msg="Public network is not provided") pub_net = cloud.network.find_network(public_network) if not pub_net: module.fail_json(msg='Public network %s not found' % public_network) fip = cloud.network.create_ip( floating_network_id=pub_net.id) cloud.network.update_ip(fip, fixed_ip_address=lb.vip_address, port_id=lb.vip_port_id) new_public_ip = fip.floating_ip_address changed = True # Include public_vip_address in the result. lb = cloud.load_balancer.find_load_balancer(name_or_id=lb.id) lb_dict = lb.to_dict() lb_dict.update({"public_vip_address": new_public_ip}) module.exit_json(changed=changed, loadbalancer=lb_dict, id=lb.id) elif module.params['state'] == 'absent': changed = False public_vip_address = None if lb: if delete_fip: ips = cloud.network.ips(port_id=lb.vip_port_id, fixed_ip_address=lb.vip_address) ips = list(ips) if ips: public_vip_address = ips[0] # Deleting load balancer with `cascade=False` does not make # sense because the deletion will always fail if there are # sub-resources. cloud.load_balancer.delete_load_balancer(lb, cascade=True) changed = True if module.params['wait']: _wait_for_lb(module, cloud, lb, "DELETED", ["ERROR"]) if delete_fip and public_vip_address: cloud.network.delete_ip(public_vip_address) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), tag=dict(required=False, default=None), template=dict(default=None), environment=dict(default=None, type='list', elements='str'), parameters=dict(default={}, type='dict'), rollback=dict(default=False, type='bool'), timeout=dict(default=3600, type='int'), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] name = module.params['name'] # Check for required parameters when state == 'present' if state == 'present': for p in ['template']: if not module.params[p]: module.fail_json(msg='%s required with present state' % p) sdk, cloud = openstack_cloud_from_module(module) try: stack = cloud.get_stack(name) if module.check_mode: module.exit_json( changed=_system_state_change(module, stack, cloud)) if state == 'present': parameters = module.params['parameters'] if module.params['tag']: parameters['tags'] = module.params['tag'] min_version = '0.28.0' if StrictVersion(sdk.version.__version__) < StrictVersion( min_version) and stack: module.warn( "To update tags using openstack.cloud.stack module, the" "installed version of the openstacksdk" "library MUST be >={min_version}" "".format(min_version=min_version)) if not stack: stack = _create_stack(module, stack, cloud, sdk, parameters) else: stack = _update_stack(module, stack, cloud, sdk, parameters) module.exit_json(changed=True, stack=stack, id=stack.id) elif state == 'absent': if not stack: changed = False else: changed = True if not cloud.delete_stack(name, wait=module.params['wait']): module.fail_json(msg='delete stack failed for stack: %s' % name) module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=to_native(e))
def main(): argument_spec = openstack_full_argument_spec( description=dict(default=None), enabled=dict(default=True, type='bool'), name=dict(required=True), service_type=dict(required=True), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) description = module.params['description'] enabled = module.params['enabled'] name = module.params['name'] state = module.params['state'] service_type = module.params['service_type'] sdk, cloud = openstack_cloud_from_module(module) try: services = cloud.search_services(name_or_id=name, filters=dict(type=service_type)) if len(services) > 1: module.fail_json(msg='Service name %s and type %s are not unique' % (name, service_type)) elif len(services) == 1: service = services[0] else: service = None if module.check_mode: module.exit_json(changed=_system_state_change(module, service)) if state == 'present': if service is None: service = cloud.create_service(name=name, description=description, type=service_type, enabled=True) changed = True else: if _needs_update(module, service): service = cloud.update_service(service.id, name=name, type=service_type, enabled=enabled, description=description) changed = True else: changed = False module.exit_json(changed=changed, service=service, id=service.id) elif state == 'absent': if service is None: changed = False else: cloud.delete_service(service.id) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): ipv6_mode_choices = ['dhcpv6-stateful', 'dhcpv6-stateless', 'slaac'] argument_spec = openstack_full_argument_spec( name=dict(type='str', required=True), network_name=dict(type='str'), cidr=dict(type='str'), ip_version=dict(type='str', default='4', choices=['4', '6']), enable_dhcp=dict(type='bool', default=True), gateway_ip=dict(type='str'), no_gateway_ip=dict(type='bool', default=False), dns_nameservers=dict(type='list', default=None, elements='str'), allocation_pool_start=dict(type='str'), allocation_pool_end=dict(type='str'), host_routes=dict(type='list', default=None, elements='dict'), ipv6_ra_mode=dict(type='str', choices=ipv6_mode_choices), ipv6_address_mode=dict(type='str', choices=ipv6_mode_choices), use_default_subnetpool=dict(type='bool', default=False), extra_specs=dict(type='dict', default=dict()), state=dict(type='str', default='present', choices=['absent', 'present']), project=dict(type='str'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule( argument_spec, supports_check_mode=True, required_together=[ ['allocation_pool_end', 'allocation_pool_start'], ], **module_kwargs) state = module.params['state'] network_name = module.params['network_name'] cidr = module.params['cidr'] ip_version = module.params['ip_version'] enable_dhcp = module.params['enable_dhcp'] subnet_name = module.params['name'] gateway_ip = module.params['gateway_ip'] no_gateway_ip = module.params['no_gateway_ip'] dns = module.params['dns_nameservers'] pool_start = module.params['allocation_pool_start'] pool_end = module.params['allocation_pool_end'] host_routes = module.params['host_routes'] ipv6_ra_mode = module.params['ipv6_ra_mode'] ipv6_a_mode = module.params['ipv6_address_mode'] use_default_subnetpool = module.params['use_default_subnetpool'] project = module.params.pop('project') extra_specs = module.params['extra_specs'] # Check for required parameters when state == 'present' if state == 'present': if not module.params['network_name']: module.fail_json(msg='network_name required with present state') if (not module.params['cidr'] and not use_default_subnetpool and not extra_specs.get('subnetpool_id', False)): module.fail_json(msg='cidr or use_default_subnetpool or ' 'subnetpool_id required with present state') if pool_start and pool_end: pool = [dict(start=pool_start, end=pool_end)] else: pool = None if no_gateway_ip and gateway_ip: module.fail_json(msg='no_gateway_ip is not allowed with gateway_ip') sdk, cloud = openstack_cloud_from_module(module) try: if project is not None: proj = cloud.get_project(project) if proj is None: module.fail_json(msg='Project %s could not be found' % project) project_id = proj['id'] filters = {'tenant_id': project_id} else: project_id = None filters = None subnet = cloud.get_subnet(subnet_name, filters=filters) if module.check_mode: module.exit_json( changed=_system_state_change(module, subnet, cloud, filters)) if state == 'present': if not subnet: kwargs = dict(cidr=cidr, ip_version=ip_version, enable_dhcp=enable_dhcp, subnet_name=subnet_name, gateway_ip=gateway_ip, disable_gateway_ip=no_gateway_ip, dns_nameservers=dns, allocation_pools=pool, host_routes=host_routes, ipv6_ra_mode=ipv6_ra_mode, ipv6_address_mode=ipv6_a_mode, tenant_id=project_id) dup_args = set(kwargs.keys()) & set(extra_specs.keys()) if dup_args: raise ValueError( 'Duplicate key(s) {0} in extra_specs'.format( list(dup_args))) if use_default_subnetpool: kwargs['use_default_subnetpool'] = use_default_subnetpool kwargs = dict(kwargs, **extra_specs) subnet = cloud.create_subnet(network_name, **kwargs) changed = True else: if _needs_update(subnet, module, cloud, filters): subnet = cloud.update_subnet( subnet['id'], subnet_name=subnet_name, enable_dhcp=enable_dhcp, gateway_ip=gateway_ip, disable_gateway_ip=no_gateway_ip, dns_nameservers=dns, allocation_pools=pool, host_routes=host_routes) changed = True else: changed = False module.exit_json(changed=changed, subnet=subnet, id=subnet['id']) elif state == 'absent': if not subnet: changed = False else: changed = True cloud.delete_subnet(subnet_name) module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), state=dict(default='present', choices=['absent', 'present']), loadbalancer=dict(default=None), listener=dict(default=None), protocol=dict(default='HTTP', choices=['HTTP', 'HTTPS', 'TCP', 'UDP', 'PROXY']), lb_algorithm=dict( default='ROUND_ROBIN', choices=['ROUND_ROBIN', 'LEAST_CONNECTIONS', 'SOURCE_IP'])) module_kwargs = openstack_module_kwargs( mutually_exclusive=[['loadbalancer', 'listener']]) module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) loadbalancer = module.params['loadbalancer'] listener = module.params['listener'] try: changed = False pool = cloud.load_balancer.find_pool(name_or_id=module.params['name']) if module.params['state'] == 'present': if not pool: loadbalancer_id = None if not (loadbalancer or listener): module.fail_json( msg="either loadbalancer or listener must be provided") if loadbalancer: lb = cloud.load_balancer.find_load_balancer(loadbalancer) if not lb: module.fail_json(msg='load balancer %s is not ' 'found' % loadbalancer) loadbalancer_id = lb.id listener_id = None if listener: listener_ret = cloud.load_balancer.find_listener(listener) if not listener_ret: module.fail_json(msg='listener %s is not found' % listener) listener_id = listener_ret.id pool = cloud.load_balancer.create_pool( name=module.params['name'], loadbalancer_id=loadbalancer_id, listener_id=listener_id, protocol=module.params['protocol'], lb_algorithm=module.params['lb_algorithm']) changed = True if not module.params['wait']: module.exit_json(changed=changed, pool=pool.to_dict(), id=pool.id) if module.params['wait']: pool = _wait_for_pool_status(module, cloud, pool.id, "ACTIVE", ["ERROR"]) module.exit_json(changed=changed, pool=pool.to_dict(), id=pool.id) elif module.params['state'] == 'absent': if pool: cloud.load_balancer.delete_pool(pool) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( state=dict(default='present', choices=['absent', 'present']), name=dict(required=True), admin_state_up=dict(type='bool', default=True), enable_snat=dict(type='bool'), network=dict(default=None), interfaces=dict(type='list', default=None, elements='raw'), external_fixed_ips=dict(type='list', default=None, elements='dict'), project=dict(default=None)) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] name = module.params['name'] network = module.params['network'] project = module.params['project'] if module.params['external_fixed_ips'] and not network: module.fail_json( msg='network is required when supplying external_fixed_ips') sdk, cloud = openstack_cloud_from_module(module) try: if project is not None: proj = cloud.get_project(project) if proj is None: module.fail_json(msg='Project %s could not be found' % project) project_id = proj['id'] filters = {'tenant_id': project_id} else: project_id = None filters = None router = cloud.get_router(name, filters=filters) net = None if network: net = cloud.get_network(network) if not net: module.fail_json(msg='network %s not found' % network) # Validate and cache the subnet IDs so we can avoid duplicate checks # and expensive API calls. external_ids, subnet_internal_ids, internal_portids = _validate_subnets( module, cloud, filters) if module.check_mode: module.exit_json(changed=_system_state_change( cloud, module, router, net, subnet_internal_ids, internal_portids, filters)) if state == 'present': changed = False if not router: kwargs = _build_kwargs(cloud, module, router, net) if project_id: kwargs['project_id'] = project_id router = cloud.create_router(**kwargs) for int_s_id in subnet_internal_ids: cloud.add_router_interface(router, subnet_id=int_s_id) changed = True # add interface by port id as well for int_p_id in internal_portids: cloud.add_router_interface(router, port_id=int_p_id) changed = True else: if _needs_update(cloud, module, router, net, subnet_internal_ids, internal_portids, filters): kwargs = _build_kwargs(cloud, module, router, net) updated_router = cloud.update_router(**kwargs) # Protect against update_router() not actually # updating the router. if not updated_router: changed = False # On a router update, if any internal interfaces were supplied, # just detach all existing internal interfaces and attach the new. if internal_portids or subnet_internal_ids: router = updated_router ports = _router_internal_interfaces(cloud, router) for port in ports: cloud.remove_router_interface(router, port_id=port['id']) if internal_portids: external_ids, subnet_internal_ids, internal_portids = _validate_subnets( module, cloud, filters) for int_p_id in internal_portids: cloud.add_router_interface(router, port_id=int_p_id) changed = True if subnet_internal_ids: for s_id in subnet_internal_ids: cloud.add_router_interface(router, subnet_id=s_id) changed = True module.exit_json(changed=changed, router=router, id=router['id']) elif state == 'absent': if not router: module.exit_json(changed=False) else: # We need to detach all internal interfaces on a router before # we will be allowed to delete it. ports = _router_internal_interfaces(cloud, router) router_id = router['id'] for port in ports: cloud.remove_router_interface(router, port_id=port['id']) cloud.delete_router(router_id) module.exit_json(changed=True) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), description=dict(required=False, default=None), domain_id=dict(required=False, default=None, aliases=['domain']), enabled=dict(default=True, type='bool'), state=dict(default='present', choices=['absent', 'present'])) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) name = module.params['name'] description = module.params['description'] domain = module.params.get('domain_id') enabled = module.params['enabled'] state = module.params['state'] sdk, cloud = openstack_cloud_from_module(module) try: if domain: try: # We assume admin is passing domain id dom = cloud.get_domain(domain)['id'] domain = dom except Exception: # If we fail, maybe admin is passing a domain name. # Note that domains have unique names, just like id. try: dom = cloud.search_domains( filters={'name': domain})[0]['id'] domain = dom except Exception: # Ok, let's hope the user is non-admin and passing a sane id pass if domain: project = cloud.get_project(name, domain_id=domain) else: project = cloud.get_project(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, project)) if state == 'present': if project is None: project = cloud.create_project(name=name, description=description, domain_id=domain, enabled=enabled) changed = True else: if _needs_update(module, project): project = cloud.update_project(project['id'], description=description, enabled=enabled) changed = True else: changed = False module.exit_json(changed=changed, project=project) elif state == 'absent': if project is None: changed = False else: cloud.delete_project(project['id']) changed = True module.exit_json(changed=changed) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=e.message, extra_data=e.extra_data)
def main(): argument_spec = openstack_full_argument_spec( state=dict(required=False, default='present', choices=['absent', 'present']), name=dict(required=False), # required when state is 'present' ram=dict(required=False, type='int'), vcpus=dict(required=False, type='int'), disk=dict(required=False, default=0, type='int'), ephemeral=dict(required=False, default=0, type='int'), swap=dict(required=False, default=0, type='int'), rxtx_factor=dict(required=False, default=1.0, type='float'), is_public=dict(required=False, default=True, type='bool'), flavorid=dict(required=False, default="auto"), extra_specs=dict(required=False, default=None, type='dict'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, required_if=[('state', 'present', ['ram', 'vcpus', 'disk'])], **module_kwargs) state = module.params['state'] name = module.params['name'] extra_specs = module.params['extra_specs'] or {} sdk, cloud = openstack_cloud_from_module(module) try: flavor = cloud.get_flavor(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, flavor)) if state == 'present': old_extra_specs = {} require_update = False if flavor: old_extra_specs = flavor['extra_specs'] for param_key in [ 'ram', 'vcpus', 'disk', 'ephemeral', 'swap', 'rxtx_factor', 'is_public' ]: if module.params[param_key] != flavor[param_key]: require_update = True break if flavor and require_update: cloud.delete_flavor(name) flavor = None if not flavor: flavor = cloud.create_flavor( name=name, ram=module.params['ram'], vcpus=module.params['vcpus'], disk=module.params['disk'], flavorid=module.params['flavorid'], ephemeral=module.params['ephemeral'], swap=module.params['swap'], rxtx_factor=module.params['rxtx_factor'], is_public=module.params['is_public']) changed = True else: changed = False new_extra_specs = dict([(k, str(v)) for k, v in extra_specs.items()]) unset_keys = set(old_extra_specs.keys()) - set(extra_specs.keys()) if unset_keys and not require_update: cloud.unset_flavor_specs(flavor['id'], unset_keys) if old_extra_specs != new_extra_specs: cloud.set_flavor_specs(flavor['id'], extra_specs) changed = (changed or old_extra_specs != new_extra_specs) module.exit_json(changed=changed, flavor=flavor, id=flavor['id']) elif state == 'absent': if flavor: cloud.delete_flavor(name) module.exit_json(changed=True) module.exit_json(changed=False) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))