def main(): argument_spec = openstack_full_argument_spec( display_name=dict(required=True, aliases=['name']), display_description=dict(default=None, aliases=['description']), volume=dict(required=True), force=dict(required=False, default=False, type='bool'), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) if not HAS_SHADE: module.fail_json(msg='shade is required for this module') state = module.params['state'] try: cloud = shade.openstack_cloud(**module.params) if cloud.volume_exists(module.params['volume']): if module.check_mode: module.exit_json(changed=_system_state_change(module, cloud)) if state == 'present': _present_volume_snapshot(module, cloud) if state == 'absent': _absent_volume_snapshot(module, cloud) else: module.fail_json( msg="No volume with name or id '{0}' was found.".format( module.params['volume'])) except (shade.OpenStackCloudException, shade.OpenStackCloudTimeout) as e: module.fail_json(msg=e.message)
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=False, default=None), filters=dict(required=False, type='dict', default=None), ) module_kwargs = openstack_module_kwargs( mutually_exclusive=[ ['name', 'filters'], ] ) module = AnsibleModule(argument_spec, **module_kwargs) shade, opcloud = openstack_cloud_from_module(module) try: name = module.params['name'] filters = module.params['filters'] if name: # Let's suppose user is passing domain ID try: domains = opcloud.get_domain(name) except: domains = opcloud.search_domains(filters={'name': name}) else: domains = opcloud.search_domains(filters) module.exit_json(changed=False, ansible_facts=dict( openstack_domains=domains)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( server=dict(required=False), detailed=dict(required=False, type='bool'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) shade, cloud = openstack_cloud_from_module(module) try: openstack_servers = cloud.list_servers( detailed=module.params['detailed']) if module.params['server']: # filter servers by name pattern = module.params['server'] # TODO(mordred) This is handled by shade now openstack_servers = [server for server in openstack_servers if fnmatch.fnmatch(server['name'], pattern) or fnmatch.fnmatch(server['id'], pattern)] module.exit_json(changed=False, ansible_facts=dict( openstack_servers=openstack_servers)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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'), 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) # stack API introduced in 1.8.0 min_version = '1.8.0' tag = module.params['tag'] if tag is not None: # stack tag API was introduced in 1.26.0 min_version = '1.26.0' 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) shade, cloud = openstack_cloud_from_module(module, min_version='1.26.0') try: stack = cloud.get_stack(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, stack, cloud)) if state == 'present': if not stack: stack = _create_stack(module, stack, cloud, shade) else: stack = _update_stack(module, stack, cloud, shade) changed = True module.exit_json(changed=changed, 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 shade.OpenStackCloudException as e: module.fail_json(msg=to_native(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'] shade, cloud = openstack_cloud_from_module(module) try: server = cloud.get_server(module.params['server']) volume = cloud.get_volume(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': if dev: # Volume is already attached to this server module.exit_json(changed=False) 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=True, 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 (shade.OpenStackCloudException, shade.OpenStackCloudTimeout) as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), description=dict(default=None), 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'] enabled = module.params['enabled'] state = module.params['state'] shade, cloud = openstack_cloud_from_module(module) try: domains = cloud.search_domains(filters=dict(name=name)) if len(domains) > 1: module.fail_json(msg='Domain name %s is not unique' % name) elif len(domains) == 1: domain = domains[0] else: domain = None if module.check_mode: module.exit_json(changed=_system_state_change(module, domain)) if state == 'present': if domain is None: domain = cloud.create_domain( name=name, description=description, enabled=enabled) changed = True else: if _needs_update(module, domain): domain = cloud.update_domain( domain.id, name=name, description=description, enabled=enabled) changed = True else: changed = False module.exit_json(changed=changed, domain=domain, id=domain.id) elif state == 'absent': if domain is None: changed = False else: cloud.delete_domain(domain.id) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException 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']), ) 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']: public_key = open(module.params['public_key_file']).read() public_key = public_key.rstrip() shade, 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 == 'present': if keypair and keypair['name'] == name: if public_key and (public_key != keypair['public_key']): module.fail_json( msg="Key name %s present but key hash not the same" " as offered. Delete key first." % name ) 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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) 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 if filters: # Range search added in 1.5.0 min_version = '1.5.0' else: min_version = None shade, cloud = openstack_cloud_from_module(module, min_version=min_version) 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] module.exit_json(changed=False, ansible_facts=dict(openstack_flavors=flavors)) except shade.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), 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.get('name') description = module.params.get('description') state = module.params.get('state') domain_id = module.params.pop('domain_id') shade, cloud = openstack_cloud_from_module(module) try: if domain_id: group = cloud.get_group(name, filters={'domain_id': domain_id}) else: group = cloud.get_group(name) if module.check_mode: module.exit_json(changed=_system_state_change(state, description, group)) if state == 'present': if group is None: group = cloud.create_group( name=name, description=description, domain=domain_id) changed = True else: if description is not None and group.description != description: group = cloud.update_group( group.id, description=description) changed = True else: changed = False module.exit_json(changed=changed, group=group) elif state == 'absent': if group is None: changed = False else: cloud.delete_group(group.id) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException 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']), ) 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']: public_key = open(module.params['public_key_file']).read() public_key = public_key.rstrip() shade, 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 == 'present': if keypair and keypair['name'] == name: if public_key and (public_key != keypair['public_key']): module.fail_json( msg="Key name %s present but key hash not the same" " as offered. Delete key first." % name) 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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'), 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': if not stack: stack = _create_stack(module, stack, cloud, sdk) else: stack = _update_stack(module, stack, cloud, sdk) changed = True module.exit_json(changed=changed, 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( 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) 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 if filters: # Range search added in 1.5.0 min_version = '1.5.0' else: min_version = None shade, cloud = openstack_cloud_from_module(module, min_version=min_version) 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] module.exit_json(changed=False, ansible_facts=dict(openstack_flavors=flavors)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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) if not HAS_SHADE: module.fail_json(msg='shade is required for this module') name = module.params['name'] vcpus = module.params['vcpus'] ram = module.params['ram'] ephemeral = module.params['ephemeral'] limit = module.params['limit'] try: cloud = shade.openstack_cloud(**module.params) if name: flavors = cloud.search_flavors(filters={'name': name}) else: flavors = cloud.list_flavors() filters = {} if vcpus: filters['vcpus'] = vcpus if ram: filters['ram'] = ram if ephemeral: filters['ephemeral'] = ephemeral if filters: # Range search added in 1.5.0 if StrictVersion(shade.__version__) < StrictVersion('1.5.0'): module.fail_json( msg="Shade >= 1.5.0 needed for this functionality") flavors = cloud.range_search(flavors, filters) if limit is not None: flavors = flavors[:limit] module.exit_json(changed=False, ansible_facts=dict(openstack_flavors=flavors)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec() module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: module.exit_json(changed=False, ansible_facts=dict( auth_token=cloud.auth_token, service_catalog=cloud.service_catalog)) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc())
def main(): argument_spec = openstack_full_argument_spec(image=dict(required=True), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) shade, cloud = openstack_cloud_from_module(module) try: image = cloud.get_image(module.params['image']) module.exit_json(changed=False, ansible_facts=dict(openstack_image=image)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( auth_type=dict(required=False), uuid=dict(required=False), name=dict(required=False), mac=dict(required=False), ironic_url=dict(required=False), timeout=dict(default=1200, type='int', required=False), ) 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 to be 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'] ) shade, cloud = openstack_cloud_from_module( module, min_version='1.0.0') try: if module.params['name'] or module.params['uuid']: server = cloud.get_machine(_choose_id_value(module)) elif module.params['mac']: server = cloud.get_machine_by_mac(module.params['mac']) else: module.fail_json(msg="The worlds did not align, " "the host was not found as " "no name, uuid, or mac was " "defined.") if server: cloud.inspect_machine(server['uuid'], module.params['wait']) # TODO(TheJulia): diff properties, ?and ports? and determine # if a change occurred. In theory, the node is always changed # if introspection is able to update the record. module.exit_json(changed=True, ansible_facts=server['properties']) else: module.fail_json(msg="node not found.") except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( auth_type=dict(required=False), uuid=dict(required=False), name=dict(required=False), mac=dict(required=False), ironic_url=dict(required=False), timeout=dict(default=1200, type='int', required=False), ) 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 to be 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'] ) shade, cloud = openstack_cloud_from_module( module, min_version='1.0.0') try: if module.params['name'] or module.params['uuid']: server = cloud.get_machine(_choose_id_value(module)) elif module.params['mac']: server = cloud.get_machine_by_mac(module.params['mac']) else: module.fail_json(msg="The worlds did not align, " "the host was not found as " "no name, uuid, or mac was " "defined.") if server: cloud.inspect_machine(server['uuid'], module.params['wait']) # TODO(TheJulia): diff properties, ?and ports? and determine # if a change occurred. In theory, the node is always changed # if introspection is able to update the record. module.exit_json(changed=True, ansible_facts=server['properties']) else: module.fail_json(msg="node not found.") except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec(server=dict(type='str', required=True), wait=dict(type='bool', default=True), timeout=dict(type='int', default=180), name=dict(tyep='str', required=True), metadata=dict(type='dict', default={})) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=False, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) name = module.params['name'] metadata = module.params['metadata'] wait = module.params['wait'] timeout = module.params['timeout'] try: server = cloud.get_server(module.params['server']) if not server: module.fail_json(msg='Could not find server %s' % server) action = {'name': name} if metadata is not None: action['metadata'] = metadata body = {'createImage': action} response = cloud.compute.post(_action_url(server.id), json=body) if not response or 'image_id' not in response: module.fail_json(msg='Could not capture the server %s' % server) else: image_id = response['image_id'] image = cloud.get_image(image_id) if wait: image = cloud.wait_for_image(image, timeout=timeout) module.exit_json(changed=False, server_id=server.id, image=image) 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), policies=dict(required=False, type='list'), 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'] policies = module.params['policies'] state = module.params['state'] shade, cloud = openstack_cloud_from_module(module) try: server_group = cloud.get_server_group(name) if module.check_mode: module.exit_json( changed=_system_state_change(state, server_group) ) changed = False if state == 'present': if not server_group: if not policies: module.fail_json( msg="Parameter 'policies' is required in Server Group " "Create" ) server_group = cloud.create_server_group(name, policies) changed = True module.exit_json( changed=changed, id=server_group['id'], server_group=server_group ) if state == 'absent': if server_group: cloud.delete_server_group(server_group['id']) changed = True module.exit_json(changed=changed) except shade.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), policies=dict(required=False, type='list'), 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'] policies = module.params['policies'] state = module.params['state'] sdk, cloud = openstack_cloud_from_module(module) try: server_group = cloud.get_server_group(name) if module.check_mode: module.exit_json( changed=_system_state_change(state, server_group) ) changed = False if state == 'present': if not server_group: if not policies: module.fail_json( msg="Parameter 'policies' is required in Server Group " "Create" ) server_group = cloud.create_server_group(name, policies) changed = True module.exit_json( changed=changed, id=server_group['id'], server_group=server_group ) if state == 'absent': if server_group: cloud.delete_server_group(server_group['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() module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) shade, cloud = openstack_cloud_from_module(module) try: module.exit_json( changed=False, ansible_facts=dict( auth_token=cloud.auth_token, service_catalog=cloud.service_catalog)) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc())
def main(): argument_spec = openstack_full_argument_spec(key=dict(required=True, type='str'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) secret_key = module.params['key'] secret = cloud.key_manager.find_secret(secret_key) if secret: module.exit_json(changed=False, secret=secret.payload) else: msg = "Failed to retrieve secret with key '%s'".format(secret_key) module.fail_json(msg=msg)
def main(): argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options']) module = AnsibleModule(argument_spec, **openstack_module_kwargs()) _, conn = openstack_cloud_from_module(module) tripleo = tc.TripleOCommon(session=conn.session) if hasattr(tripleo, module.params["action"]): action = getattr(tripleo, module.params["action"]) result = action(kwargs=module.params["args"]) module.exit_json(result=result) else: module.fail_json( msg="Unknown action name {}".format(module.params["action"]))
def main(): argument_spec = openstack_full_argument_spec( server=dict(required=True, aliases=['name']), meta=dict(required=True, type='dict'), 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'] server_param = module.params['server'] meta_param = module.params['meta'] changed = False sdk, cloud = openstack_cloud_from_module(module) try: server = cloud.get_server(server_param) if not server: module.fail_json( msg='Could not find server {0}'.format(server_param)) if state == 'present': # check if it needs update if _needs_update(server_metadata=server.metadata, metadata=meta_param): if not module.check_mode: cloud.set_server_metadata(server_param, meta_param) changed = True elif state == 'absent': # remove from params the keys that do not exist in the server keys_to_delete = _get_keys_to_delete(server.metadata.keys(), meta_param.keys()) if len(keys_to_delete) > 0: if not module.check_mode: cloud.delete_server_metadata(server_param, keys_to_delete) changed = True if changed: server = cloud.get_server(server_param) module.exit_json(changed=changed, server_id=server.id, metadata=server.metadata) 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( name=dict(required=True), description=dict(default=''), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) if not HAS_SHADE: module.fail_json(msg='shade is required for this module') name = module.params['name'] state = module.params['state'] description = module.params['description'] try: cloud = shade.openstack_cloud(**module.params) secgroup = cloud.get_security_group(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, secgroup)) changed = False if state == 'present': if not secgroup: secgroup = cloud.create_security_group(name, description) 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( image=dict(required=True), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) shade, cloud = openstack_cloud_from_module(module) try: image = cloud.get_image(module.params['image']) module.exit_json(changed=False, ansible_facts=dict( openstack_image=image)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec(image_name=dict(required=True, type='str'), volume_id=dict(required=True, type='str'), force=dict(default=False, type='bool'), container_format=dict( default=None, type='str'), disk_format=dict(default=None, type='str'), wait=dict(default=True, type='bool'), timeout=dict(default=120, type='int')) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: wait = module.params['wait'] timeout = module.params['timeout'] image = cloud.block_storage.create_image( module.params['image_name'], module.params['volume_id'], module.params['force'], module.params['container_format'], module.params['disk_format'], # These variables are not used by the openstacksdk implementation as of 09/04/2019 wait, timeout) # Wait for the image to become active and the volume to become available again volume_id = module.params['volume_id'] if wait: start = time.time() while time.time() < start + timeout: image = cloud.image.get_image(image.id) volume = cloud.block_storage.get_volume(volume_id) if image.status.lower() == 'active' and volume.status.lower( ) == 'available': break else: raise TimeoutError('Timed out waiting for image.') module.exit_json(changed=True, image_id=image.id) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc())
def main(): argument_spec = openstack_full_argument_spec( cluster=dict(type='str', required=True), node_ids=dict(type=list), wait_status=dict(type='str', choices=['active', 'deleted'])) # redefine wait default behavior, wait must be enabled expicitly here argument_spec['wait']['default'] = False module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=False, **module_kwargs) clustername_id = module.params['cluster'] cloud = connect_from_ansible(module) try: # temporary fix for the fact that the new RDS service is not yet in catalog cloud.add_service(cce_service.CceService("ccev2.0", aliases=["cce2"])) cluster = cloud.cce2.find_cluster(clustername_id) if cluster: if not module.params['wait']: if 'node_ids' in module.params: nodes = filter( lambda res: res.id in module.params['node_ids'], cloud.cce2.cluster_nodes(cluster.id)) else: nodes = cloud.cce2.cluster_nodes(cluster.id) module.exit_json(changed=False, ansible_facts=dict(cluster_nodes=list(nodes))) elif module.params['wait_status'] == 'active': nodes = cloud.cce2.wait_for_status_nodes( cluster.id, module.params['node_ids']) module.exit_json(changed=False, ansible_facts=dict(cluster_nodes=list(nodes))) elif module.params['wait_status'] == 'deleted': nodes = cloud.cce2.wait_for_delete_nodes( cluster.id, module.params['node_ids']) module.exit_json(changed=False, ansible_facts=dict(cluster_nodes=list(nodes))) module.exit_json(changed=False, ansible_facts={}) except exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options']) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=False, **module_kwargs) auth_type = module.params.get('auth_type') ironic_url = module.params.get('ironic_url') if auth_type in (None, 'None'): if not ironic_url: module.fail_json(msg="Authentication appears to be disabled," " Please define an ironic_url parameter") else: module.params['auth'] = {'endpoint': ironic_url} _, cloud = openstack_cloud_from_module(module) introspector = IntrospectionManagement(cloud, module, module.params["concurrency"], module.params["max_retries"], module.params["node_timeout"], module.params["retry_timeout"]) module_results = {"changed": True} result = introspector.introspect(module.params["node_uuids"]) failed_nodes = [k for k, v in result.items() if v['failed']] passed_nodes = [k for k, v in result.items() if not v['failed']] failed = len(failed_nodes) if failed > 0: message = ( "Introspection completed with failures. %s node(s) failed." % failed) module.log("os_tripleo_baremetal_node_introspection ERROR %s" % message) module_results.update({'failed': True}) else: message = "Introspection completed successfully: %s nodes" % len( module.params["node_uuids"]) module.log("os_tripleo_baremetal_node_introspection INFO %s" % message) module_results.update({ "introspection_data": result if not module.params['quiet'] else {}, "failed_nodes": failed_nodes, "passed_nodes": passed_nodes, "msg": message }) module.exit_json(**module_results)
def main(): argument_spec = openstack_full_argument_spec( name=dict(type='str', required=True), cidr=dict(type='str'), enable_shared_snat=dict(default=False, type='bool'), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) state = module.params['state'] name = module.params['name'] cloud = connect_from_ansible(module) try: cloud.add_service( vpc_service.VpcService("vpc", aliases=['vpc1'] )) cloud.add_service( vpc_service.VpcService("vpc2.0", aliases=['vpc2'] )) v = cloud.vpc.find_vpc(name) if state == 'present': if not v: v = cloud.vpc.create_vpc(name=name, cidr=module.params['cidr'], enable_shared_snat=module.params['enable_shared_snat']) changed = True elif _needs_update(module, cloud, v): v = cloud.vpc.update_vpc(vpc=v, name=name, cidr=module.params['cidr'], enable_shared_snat=module.params['enable_shared_snat']) changed = True else: changed = False module.exit_json(changed=changed, vpc=v.copy(), id=v.id ) elif state == 'absent': if not v: module.exit_json(changed=False) else: cloud.vpc.delete_vpc(v) module.exit_json(changed=True) except exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def run_module(): result = dict(success=False, changed=False, error="", params={}) argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options']) module = AnsibleModule(argument_spec, supports_check_mode=False, **openstack_module_kwargs()) log_file = module.params.get('log_file') debug = module.params.get('debug') if not module.no_log: log = setup_logging(log_file, debug) cleanup = module.params.get('cleanup') dry_run = module.params.get('dry_run') if cleanup not in image_uploader.CLEANUP: raise RuntimeError('--cleanup must be one of: %s' % ', '.join(image_uploader.CLEANUP)) roles_data = module.params.get('roles_data') env = module.params.get('environment') try: lock = processlock.ProcessLock() params = kolla_builder.container_images_prepare_multi(env, roles_data, cleanup=cleanup, dry_run=dry_run, lock=lock) if not module.no_log: output = yaml.safe_dump(params, default_flow_style=False) log.info(output) result['success'] = True result['changed'] = True result['params'] = {"parameter_defaults": params} except Exception as err: result['error'] = str(err) result['msg'] = ("Error running container image prepare: %s" % (err)) module.fail_json(**result) # in the event of a successful module execution, you will want to # simple AnsibleModule.exit_json(), passing the key/value results module.exit_json(**result)
def run_module(): module_args = dict( ibm_endpoint=dict(type='str', required=True), ibm_api_key=dict(type='str', required=True, no_log=True), ibm_auth_endpoint=dict( type='str', default='https://iam.cloud.ibm.com/identity/token'), ibm_resource_id=dict(type='str', required=True), project=dict(aliases=['blueprint'], type='str', required=True), bucket=dict(required=True), mode=dict(choices=['upload', 'download', 'update', 'delete'], default='upload'), output_dir=dict(default="/images/import"), glance_pool=dict(required=False), images=dict(type=list), overwrite=dict(aliases=['force'], default=False, type=bool), chunk_file_size=dict(default=5, type='int'), threshold_file_size=dict(default=15, type='int'), retries=dict(default=5, type=int)) argument_spec = openstack_full_argument_spec(image=dict(required=False), ) module_args.update(argument_spec) module_kwargs = openstack_module_kwargs() module = AnsibleModule(module_args, **module_kwargs) # if the user is working with this module in only check mode we do not # want to make any changes to the environment, just return the current # state with no modifications if module.check_mode: module.exit_json(msg="Operation skipped - running in check mode", changed=True) mode = module.params.get("mode") if mode == "upload": convert_to_qcow(module) if mode == "download": convert_to_raw(module) if mode == "update": update_image(module) if mode == "delete": delete_image(module) module.exit_json(failed=False)
def main(): argument_spec = openstack_full_argument_spec( peering=dict(type='str', required=True, aliases=['peering_id']), state=dict(default='accept', choices=['accept', 'reject']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) state = module.params['state'] peering_name = module.params['peering'] cloud = connect_from_ansible(module) try: cloud.add_service(vpc_service.VpcService("vpc", aliases=['vpc1'])) # need to use the artificial endpoint without project-id cloud.add_service(vpc_service.VpcService("peervpc")) v = cloud.peervpc.find_peering(peering_name, ignore_missing=False) if state == 'accept': if v.status == "PENDING_ACCEPTANCE": cloud.peervpc.accept_peering(v) if module.params['wait']: v = cloud.peervpc.wait_for_status(v, "ACTIVE") changed = True elif v.status == "ACTIVE": changed = False else: module.fail_json(msg="Peering in wrong state " + v.status) elif state == 'reject': if v.status == "PENDING_ACCEPTANCE": cloud.peervpc.reject_peering(v) if module.params['wait']: v = cloud.peervpc.wait_for_status(v, "REJECTED") changed = True elif v.status == "REJECTED": changed = False else: module.fail_json(msg="Peering in wrong state " + v.status) else: changed = False module.exit_json(changed=changed, peering=v.copy(), id=v.id) except exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=False, default=None), container=dict(required=True), filename=dict(required=False, default=None), container_access=dict(default='private', choices=['private', 'public']), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: changed = process_object(cloud, **module.params) 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=False, default=None), container=dict(required=True), filename=dict(required=False, default=None), container_access=dict(default='private', choices=['private', 'public']), state=dict(default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) shade, cloud = openstack_cloud_from_module(module) try: changed = process_object(cloud, **module.params) module.exit_json(changed=changed) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec() module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) if not HAS_SHADE: module.fail_json(msg='shade is required for this module') try: cloud = shade.openstack_cloud(**module.params) module.exit_json( changed=False, ansible_facts=dict( auth_token=cloud.auth_token, service_catalog=cloud.service_catalog)) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc())
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), filters=dict(default={}, type='dict'), max_depth=dict(default=2, type='int'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: filters = module.params['filters'] max_depth = module.params['max_depth'] def get_children(name, depth): resources = [] if depth > max_depth: return resources try: for r in cloud.orchestration.resources(name): if r: r = r.to_dict() meets_all_conds = True for key, value in filters.iteritems(): meets_all_conds = meets_all_conds and r.get( key) == value if meets_all_conds: resources.append(r) resources.extend( get_children(r.get('physical_resource_id'), depth + 1)) return resources except sdk.exceptions.ResourceNotFound as e: return resources resources = get_children(name=module.params['name'], depth=0) module.exit_json( changed=False, ansible_facts=dict(openstack_stack_resources=resources)) 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']), ) 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'] shade, cloud = openstack_cloud_from_module(module) try: secgroup = cloud.get_security_group(name) if module.check_mode: module.exit_json(changed=_system_state_change(module, secgroup)) changed = False if state == 'present': if not secgroup: secgroup = cloud.create_security_group(name, description) 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), server=dict(required=True), wait=dict(default=True, type='bool'), timeout=dict(default=180, type='int'), meta=dict(default=None, type='raw'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: _create_server_snapshot(module, cloud) 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( port=dict(required=False), filters=dict(type='dict', required=False), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) port = module.params.get('port') filters = module.params.get('filters') shade, cloud = openstack_cloud_from_module(module) try: ports = cloud.search_ports(port, filters) module.exit_json(changed=False, ansible_facts=dict( openstack_ports=ports)) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def run_module(): argument_spec = openstack_full_argument_spec( key_pair=dict(required=False), properties=dict(default=None, type='dict'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) try: if module.params['key_pair']: key_pair = cloud.get_key_pair(module.params['key_pair']) module.exit_json(changed=False, openstack_key_pair=key_pair) else: key_pairs = cloud.search_keypairs() module.exit_json(changed=False, openstack_key_pair=key_pairs) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options'] ) module_kwargs = openstack_module_kwargs() module = AnsibleModule( argument_spec, supports_check_mode=False, **module_kwargs ) if not module.params['node_uuid'] and not module.params['node_name']: module.fail_json(msg="Provide either UUID or names of nodes!") sdk, cloud = openstack_cloud_from_module(module) try: result = parallel_nodes_cleaning(cloud, module) module_results = {"changed": True} failed_nodes = [k for k, v in result.items() if v['failed']] passed_nodes = [k for k, v in result.items() if not v['failed']] infos = [{k: v['info']} for k, v in result.items()] all_errors = "\n".join( [v['msg'] for k, v in result.items() if v['failed']]) failed = len(failed_nodes) if failed > 0: message = ("Cleaning completed with failures. %s node(s) failed." "Errors: %s" % (failed, all_errors)) module_results.update({'failed': True}) else: message = "Cleaning completed successfully: %s nodes" % len( module.params["node_uuid"]) module_results.update({ "baremetal_data": infos if not module.params['quiet'] else {}, "failed_nodes": failed_nodes, "passed_nodes": passed_nodes, "msg": message }) module.exit_json(**module_results) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options']) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=False, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) provisioner = metalsmith.Provisioner(cloud_region=cloud.config) instances = module.params['instances'] state = module.params['state'] concurrency = module.params['concurrency'] timeout = module.params['timeout'] wait = module.params['wait'] clean_up = module.params['clean_up'] if state == 'present': changed, nodes = provision(provisioner, instances, timeout, concurrency, clean_up, wait) instances = [{ 'name': i.node.name or i.uuid, 'hostname': i.hostname, 'id': i.uuid, } for i in nodes] module.exit_json( changed=changed, msg="{} instances provisioned".format(len(nodes)), instances=instances, ) if state == 'reserved': changed, nodes = reserve(provisioner, instances, clean_up) module.exit_json(changed=changed, msg="{} instances reserved".format(len(nodes)), ids=[node.id for node in nodes], instances=instances) if state == 'absent': changed = unprovision(provisioner, instances) module.exit_json(changed=changed, msg="{} nodes unprovisioned".format(len(instances)))
def main(): argument_spec = openstack_full_argument_spec( name=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) if not HAS_SHADE: module.fail_json(msg='shade is required for this module') name = module.params.pop('name') state = module.params.pop('state') try: cloud = shade.operator_cloud(**module.params) role = cloud.get_role(name) if module.check_mode: module.exit_json(changed=_system_state_change(state, role)) if state == 'present': if role is None: role = cloud.create_role(name) changed = True else: changed = False module.exit_json(changed=changed, role=role) elif state == 'absent': if role is None: changed = False else: cloud.delete_role(name) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def run_module(): result = dict( success=False, changed=False, error="", passwords={} ) argument_spec = openstack_full_argument_spec( **yaml.safe_load(DOCUMENTATION)['options'] ) module = AnsibleModule( argument_spec, supports_check_mode=False, **openstack_module_kwargs() ) try: container = module.params.get('container') rotate_passwords = module.params.get('rotate_passwords') password_list = module.params.get('password_list') _, conn = openstack_cloud_from_module(module) tripleo = tc.TripleOCommon(session=conn.session) swift = tripleo.get_object_client() heat = tripleo.get_orchestration_client() rotated_passwords = plan_utils.generate_passwords( swift, heat, container=container, rotate_passwords=rotate_passwords, rotate_pw_list=password_list) result['success'] = True result['passwords'] = rotated_passwords result['changed'] = True except Exception as err: result['error'] = str(err) result['msg'] = ("Error rotating passwords for plan %s: %s" % ( container, err)) module.fail_json(**result) # in the event of a successful module execution, you will want to # simple AnsibleModule.exit_json(), passing the key/value results module.exit_json(**result)
def main(): argument_spec = openstack_full_argument_spec( name=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) name = module.params.get('name') state = module.params.get('state') shade, cloud = openstack_cloud_from_module(module) try: role = cloud.get_role(name) if module.check_mode: module.exit_json(changed=_system_state_change(state, role)) if state == 'present': if role is None: role = cloud.create_role(name) changed = True else: changed = False module.exit_json(changed=changed, role=role) elif state == 'absent': if role is None: changed = False else: cloud.delete_role(name) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( user=dict(required=True), group=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) user = module.params['user'] group = module.params['group'] state = module.params['state'] shade, cloud = openstack_cloud_from_module(module) try: in_group = cloud.is_user_in_group(user, group) if module.check_mode: module.exit_json(changed=_system_state_change(state, in_group)) changed = False if state == 'present': if not in_group: cloud.add_user_to_group(user, group) changed = True elif state == 'absent': if in_group: cloud.remove_user_from_group(user, group) changed = True module.exit_json(changed=changed) except shade.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), 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), state=dict(default='present', choices=['absent', 'present']), project=dict(default=None) ) 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') shade, cloud = openstack_cloud_from_module(module, min_version='1.6.0') 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) else: net = cloud.create_network(name, shared, admin_state_up, external, provider) 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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'), 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'] state = module.params['state'] if metadata is not None: metadata.pop('availability_zone', None) shade, cloud = openstack_cloud_from_module(module, min_version='1.9.0') 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) if hosts: for h in hosts: cloud.add_host_to_aggregate(aggregate.id, h) 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) if hosts is not None: for i in (set(aggregate.hosts) - set(hosts)): cloud.remove_host_from_aggregate(aggregate.id, i) for i in (set(hosts) - set(aggregate.hosts)): cloud.add_host_to_aggregate(aggregate.id, i) changed = True else: changed = False module.exit_json(changed=changed) elif state == 'absent': if aggregate is None: changed = False else: cloud.delete_aggregate(aggregate.id) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException as e: module.fail_json(msg=str(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'] shade, cloud = openstack_cloud_from_module(module, min_version='1.6.0') 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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, 'tcp', 'udp', 'icmp', '112']), 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']), ) 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'] changed = False shade, cloud = openstack_cloud_from_module(module) try: secgroup = cloud.get_security_group(security_group) if remote_group: remotegroup = cloud.get_security_group(remote_group) else: remotegroup = {'id': None} if module.check_mode: module.exit_json(changed=_system_state_change(module, secgroup, remotegroup)) if state == 'present': 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: 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'] ) 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( name=dict(required=True), zone_type=dict(required=False, choice=['primary', 'secondary']), email=dict(required=False, default=None), description=dict(required=False, default=None), ttl=dict(required=False, default=None, type='int'), masters=dict(required=False, default=None, type='list'), 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.get('name') state = module.params.get('state') shade, cloud = openstack_cloud_from_module(module, min_version='1.8.0') try: zone = cloud.get_zone(name) if state == 'present': zone_type = module.params.get('zone_type') email = module.params.get('email') description = module.params.get('description') ttl = module.params.get('ttl') masters = module.params.get('masters') if module.check_mode: module.exit_json(changed=_system_state_change(state, email, description, ttl, masters, zone)) if zone is None: zone = cloud.create_zone( name=name, zone_type=zone_type, email=email, description=description, ttl=ttl, masters=masters) changed = True else: if masters is None: masters = [] pre_update_zone = zone changed = _system_state_change(state, email, description, ttl, masters, pre_update_zone) if changed: zone = cloud.update_zone( name, email=email, description=description, ttl=ttl, masters=masters) module.exit_json(changed=changed, zone=zone) elif state == 'absent': if module.check_mode: module.exit_json(changed=_system_state_change(state, None, None, None, None, zone)) if zone is None: changed = False else: cloud.delete_zone(name) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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) if module.params['nat_destination']: min_version = '1.8.0' else: min_version = None 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'] shade, cloud = openstack_cloud_from_module(module, min_version=min_version) 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 floting 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 shade.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, **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'" ) shade, cloud = openstack_cloud_from_module(module) try: if state == 'present': _get_server_state(module, cloud) _create_server(module, cloud) elif state == 'absent': _get_server_state(module, cloud) _delete_server(module, cloud) except shade.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), 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) if module._name == 'os_server_actions': module.deprecate("The 'os_server_actions' module is being renamed 'os_server_action'", version=2.8) action = module.params['action'] wait = module.params['wait'] timeout = module.params['timeout'] image = module.params['image'] if action in _admin_actions: shade, cloud = openstack_cloud_from_module(module) else: shade, 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.nova_client.servers.stop(server=server.id) if wait: _wait(timeout, cloud, server, action, module, shade) module.exit_json(changed=True) if action == 'start': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.nova_client.servers.start(server=server.id) if wait: _wait(timeout, cloud, server, action, module, shade) module.exit_json(changed=True) if action == 'pause': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.nova_client.servers.pause(server=server.id) if wait: _wait(timeout, cloud, server, action, module, shade) module.exit_json(changed=True) elif action == 'unpause': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.nova_client.servers.unpause(server=server.id) if wait: _wait(timeout, cloud, server, action, module, shade) module.exit_json(changed=True) elif action == 'lock': # lock doesn't set a state, just do it cloud.nova_client.servers.lock(server=server.id) module.exit_json(changed=True) elif action == 'unlock': # unlock doesn't set a state, just do it cloud.nova_client.servers.unlock(server=server.id) module.exit_json(changed=True) elif action == 'suspend': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.nova_client.servers.suspend(server=server.id) if wait: _wait(timeout, cloud, server, action, module, shade) module.exit_json(changed=True) elif action == 'resume': if not _system_state_change(action, status): module.exit_json(changed=False) cloud.nova_client.servers.resume(server=server.id) if wait: _wait(timeout, cloud, server, action, module, shade) 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.nova_client.servers.rebuild(server=server.id, image=image.id) if wait: _wait(timeout, cloud, server, action, module, shade) module.exit_json(changed=True) except shade.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), 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='always', choices=['always', 'on_create']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule( argument_spec, **module_kwargs) if not HAS_SHADE: module.fail_json(msg='shade is required for this module') name = module.params['name'] password = module.params.pop('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'] if description and StrictVersion(shade.__version__) < StrictVersion('1.13.0'): module.fail_json(msg="To utilize description, the installed version of the shade library MUST be >=1.13.0") try: cloud = shade.openstack_cloud(**module.params) user = cloud.get_user(name) domain_id = None if domain: opcloud = shade.operator_cloud(**module.params) domain_id = _get_domain_id(opcloud, domain) 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, 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: cloud.delete_user(user['id']) changed = True module.exit_json(changed=changed) except shade.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']), 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, 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 {} shade, 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': 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 old_extra_specs = flavor['extra_specs'] new_extra_specs = dict([(k, str(v)) for k, v in extra_specs.items()]) unset_keys = set(flavor['extra_specs'].keys()) - set(extra_specs.keys()) if unset_keys: 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 shade.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'] if domain: min_version = '1.8.0' else: min_version = None shade, cloud = openstack_cloud_from_module( module, min_version=min_version) try: if domain: try: # We assume admin is passing domain id dom = cloud.get_domain(domain)['id'] domain = dom except: # 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: # 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 shade.OpenStackCloudException as e: module.fail_json(msg=e.message, extra_data=e.extra_data)
def main(): ipv6_mode_choices = ['dhcpv6-stateful', 'dhcpv6-stateless', 'slaac'] argument_spec = openstack_full_argument_spec( name=dict(required=True), network_name=dict(default=None), cidr=dict(default=None), ip_version=dict(default='4', choices=['4', '6']), enable_dhcp=dict(default='true', type='bool'), gateway_ip=dict(default=None), no_gateway_ip=dict(default=False, type='bool'), dns_nameservers=dict(default=None, type='list'), allocation_pool_start=dict(default=None), allocation_pool_end=dict(default=None), host_routes=dict(default=None, type='list'), ipv6_ra_mode=dict(default=None, choice=ipv6_mode_choices), ipv6_address_mode=dict(default=None, choice=ipv6_mode_choices), use_default_subnetpool=dict(default=False, type='bool'), 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) 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') min_version = None if use_default_subnetpool: min_version = '1.16.0' # 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: module.fail_json(msg='cidr or use_default_subnetpool required ' 'with present state') if pool_start and pool_end: pool = [dict(start=pool_start, end=pool_end)] elif pool_start or pool_end: module.fail_json(msg='allocation pool requires start and end values') else: pool = None if no_gateway_ip and gateway_ip: module.fail_json(msg='no_gateway_ip is not allowed with gateway_ip') shade, cloud = openstack_cloud_from_module(module, min_version=min_version) 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)) if state == 'present': if not subnet: kwargs = dict( 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) if use_default_subnetpool: kwargs['use_default_subnetpool'] = use_default_subnetpool subnet = cloud.create_subnet(network_name, cidr, **kwargs) changed = True else: if _needs_update(subnet, module, cloud): 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 shade.OpenStackCloudException as e: module.fail_json(msg=str(e))
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') # role grant/revoke API introduced in 1.5.0 shade, cloud = openstack_cloud_from_module( module, min_version='1.5.0') try: filters = {} r = cloud.get_role(role) if r is None: module.fail_json(msg="Role %s is not valid" % role) filters['role'] = r['id'] if user: 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: g = cloud.get_group(group) if g is None: module.fail_json(msg="Group %s is not valid" % group) filters['group'] = g['id'] if domain: d = cloud.get_domain(domain) if d is None: module.fail_json(msg="Domain %s is not valid" % domain) filters['domain'] = d['id'] if project: if domain: p = cloud.get_project(project, domain_id=filters['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) cloud.grant_role(role, **kwargs) changed = True elif state == 'absent': if assignment: kwargs = _build_kwargs(user, group, project, domain) cloud.revoke_role(role, **kwargs) changed = True module.exit_json(changed=changed) except shade.OpenStackCloudException as e: module.fail_json(msg=str(e))