def main(): argument_spec = openstack_full_argument_spec( image=dict(required=False), properties=dict(default=None, type='dict'), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) is_old_facts = module._name == 'os_image_facts' if is_old_facts: module.deprecate("The 'os_image_facts' module has been renamed to 'os_image_info', " "and the renamed one no longer returns ansible_facts", version='2.13') sdk, cloud = openstack_cloud_from_module(module) try: if module.params['image']: image = cloud.get_image(module.params['image']) if is_old_facts: module.exit_json(changed=False, ansible_facts=dict( openstack_image=image)) else: module.exit_json(changed=False, openstack_image=image) else: images = cloud.search_images(filters=module.params['properties']) if is_old_facts: module.exit_json(changed=False, ansible_facts=dict( openstack_image=images)) else: module.exit_json(changed=False, openstack_image=images) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( size=dict(default=None, type='int'), volume_type=dict(default=None), display_name=dict(required=True, aliases=['name']), display_description=dict(default=None, aliases=['description']), image=dict(default=None), snapshot_id=dict(default=None), volume=dict(default=None), state=dict(default='present', choices=['absent', 'present']), scheduler_hints=dict(default=None, type='dict'), metadata=dict(default=None, type='dict'), bootable=dict(type='bool', default=False)) module_kwargs = openstack_module_kwargs(mutually_exclusive=[ ['image', 'snapshot_id', 'volume'], ], ) module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True, **module_kwargs) state = module.params['state'] if state == 'present' and not module.params['size']: module.fail_json(msg="Size is required when state is 'present'") sdk, cloud = openstack_cloud_from_module(module) try: if state == 'present': _present_volume(module, cloud) if state == 'absent': _absent_volume(module, cloud, sdk) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
def main(): argument_spec = openstack_full_argument_spec( port=dict(required=False), filters=dict(type='dict', required=False), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) is_old_facts = module._name == 'os_port_facts' if is_old_facts: module.deprecate( "The 'os_port_facts' module has been renamed to 'os_port_info', " "and the renamed one no longer returns ansible_facts", version='2.13') port = module.params.get('port') filters = module.params.get('filters') sdk, cloud = openstack_cloud_from_module(module) try: ports = cloud.search_ports(port, filters) if is_old_facts: module.exit_json(changed=False, ansible_facts=dict(openstack_ports=ports)) else: module.exit_json(changed=False, openstack_ports=ports) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
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) sdk, cloud = openstack_cloud_from_module(module) state = module.params['state'] try: 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 (sdk.exceptions.OpenStackCloudException, sdk.exceptions.ResourceTimeout) as e: module.fail_json(msg=e.message)
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'] sdk, 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 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']), pool=dict(required=True), address=dict(default=None), protocol_port=dict(default=80, type='int'), subnet_id=dict(default=None), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) sdk, cloud = openstack_cloud_from_module(module) name = module.params['name'] pool = module.params['pool'] try: changed = False pool_ret = cloud.load_balancer.find_pool(name_or_id=pool) if not pool_ret: module.fail_json(msg='pool %s is not found' % pool) pool_id = pool_ret.id member = cloud.load_balancer.find_member(name, pool_id) if module.params['state'] == 'present': if not member: member = cloud.load_balancer.create_member( pool_ret, address=module.params['address'], name=name, protocol_port=module.params['protocol_port'], subnet_id=module.params['subnet_id']) changed = True if not module.params['wait']: module.exit_json(changed=changed, member=member.to_dict(), id=member.id) if module.params['wait']: member = _wait_for_member_status(module, cloud, pool_id, member.id, "ACTIVE", ["ERROR"]) module.exit_json(changed=changed, member=member.to_dict(), id=member.id) elif module.params['state'] == 'absent': if member: cloud.load_balancer.delete_member(member, pool_ret) 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=False, default=None), ram=dict(required=False, default=None), vcpus=dict(required=False, default=None), limit=dict(required=False, default=None, type='int'), ephemeral=dict(required=False, default=None), ) module_kwargs = openstack_module_kwargs( mutually_exclusive=[['name', 'ram'], ['name', 'vcpus'], ['name', 'ephemeral']]) module = AnsibleModule(argument_spec, **module_kwargs) is_old_facts = module._name == 'os_flavor_facts' if is_old_facts: module.deprecate( "The 'os_flavor_facts' module has been renamed to 'os_flavor_info', " "and the renamed one no longer returns ansible_facts", version='2.13') name = module.params['name'] vcpus = module.params['vcpus'] ram = module.params['ram'] ephemeral = module.params['ephemeral'] limit = module.params['limit'] filters = {} if vcpus: filters['vcpus'] = vcpus if ram: filters['ram'] = ram if ephemeral: filters['ephemeral'] = ephemeral sdk, cloud = openstack_cloud_from_module(module) try: if name: flavors = cloud.search_flavors(filters={'name': name}) else: flavors = cloud.list_flavors() if filters: flavors = cloud.range_search(flavors, filters) if limit is not None: flavors = flavors[:limit] if is_old_facts: module.exit_json(changed=False, ansible_facts=dict(openstack_flavors=flavors)) else: module.exit_json(changed=False, openstack_flavors=flavors) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
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') sdk, 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 sdk.exceptions.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( 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=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( 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']) sdk, cloud = openstack_cloud_from_module(module) 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 sdk.exceptions.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', default=False), filters=dict(required=False, type='dict', default=None), all_projects=dict(required=False, type='bool', default=False), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) is_old_facts = module._name == 'os_server_facts' if is_old_facts: module.deprecate( "The 'os_server_facts' module has been renamed to 'os_server_info', " "and the renamed one no longer returns ansible_facts", version='2.13') sdk, cloud = openstack_cloud_from_module(module) try: openstack_servers = cloud.search_servers( detailed=module.params['detailed'], filters=module.params['filters'], all_projects=module.params['all_projects']) if module.params['server']: # filter servers by name pattern = module.params['server'] # TODO(mordred) This is handled by sdk now openstack_servers = [ server for server in openstack_servers if fnmatch.fnmatch(server['name'], pattern) or fnmatch.fnmatch(server['id'], pattern) ] if is_old_facts: module.exit_json( changed=False, ansible_facts=dict(openstack_servers=openstack_servers)) else: module.exit_json(changed=False, openstack_servers=openstack_servers) except sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e))
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( 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) is_old_facts = module._name == 'os_keystone_domain_facts' if is_old_facts: module.deprecate( "The 'os_keystone_domain_facts' module has been renamed to 'os_keystone_domain_info', " "and the renamed one no longer returns ansible_facts", version='2.13') sdk, 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 Exception: domains = opcloud.search_domains(filters={'name': name}) else: domains = opcloud.search_domains(filters) if is_old_facts: module.exit_json(changed=False, ansible_facts=dict(openstack_domains=domains)) else: module.exit_json(changed=False, openstack_domains=domains) 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']), ) 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') sdk, 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 sdk.exceptions.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'] sdk, 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 sdk.exceptions.OpenStackCloudException as e: module.fail_json(msg=str(e), extra_data=e.extra_data)
def main(): argument_spec = openstack_full_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), properties=dict(type='dict', default={}), ironic_url=dict(required=False), chassis_uuid=dict(required=False), skip_update_of_masked_password=dict(required=False, type='bool'), state=dict(required=False, default='present')) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, **module_kwargs) if not HAS_JSONPATCH: module.fail_json(msg='jsonpatch is required for this module') 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']) 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( 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))
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 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( 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) changed = False 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( service=dict(type='str', required=True), endpoint_interface=dict(type='str', required=True, choices=['admin', 'public', 'internal']), url=dict(type='str', required=True), region=dict(type='str'), enabled=dict(type='bool', default=True), state=dict(type='str', default='present', choices=['absent', 'present']), ) module_kwargs = openstack_module_kwargs() module = AnsibleModule(argument_spec, supports_check_mode=True, **module_kwargs) service_name_or_id = module.params['service'] interface = module.params['endpoint_interface'] url = module.params['url'] region = module.params['region'] enabled = module.params['enabled'] state = module.params['state'] sdk, cloud = openstack_cloud_from_module(module) try: service = cloud.get_service(service_name_or_id) if service is None: module.fail_json(msg='Service %s does not exist' % service_name_or_id) filters = dict(service_id=service.id, interface=interface) if region is not None: filters['region'] = region endpoints = cloud.search_endpoints(filters=filters) if len(endpoints) > 1: module.fail_json(msg='Service %s, interface %s and region %s are ' 'not unique' % (service_name_or_id, interface, region)) elif len(endpoints) == 1: endpoint = endpoints[0] else: endpoint = None if module.check_mode: module.exit_json(changed=_system_state_change(module, endpoint)) if state == 'present': if endpoint is None: result = cloud.create_endpoint(service_name_or_id=service, url=url, interface=interface, region=region, enabled=enabled) endpoint = result[0] changed = True else: if _needs_update(module, endpoint): endpoint = cloud.update_endpoint(endpoint.id, url=url, enabled=enabled) changed = True else: changed = False module.exit_json(changed=changed, endpoint=endpoint) elif state == 'absent': if endpoint is None: changed = False else: cloud.delete_endpoint(endpoint.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(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( 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 = 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(): 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), allocation_pool_start=dict(type='str'), allocation_pool_end=dict(type='str'), host_routes=dict(type='list', default=None), 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): 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), 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': parameters = module.params['parameters'] if module.params['tag']: parameters['tags'] = module.params['tag'] from distutils.version import StrictVersion min_version = '0.28.0' if StrictVersion(sdk.version.__version__) < StrictVersion( min_version) and stack: module.warn("To update tags using os_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( 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=[]), 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)