From 2dc2806c578029bce1b75317f62770b054c1e62c Mon Sep 17 00:00:00 2001 From: Artem Goncharov Date: Thu, 20 May 2021 16:38:38 +0200 Subject: [PATCH] Switch floating_ip module to OpenStackModule Change-Id: I0d406b527a2389d5299ab4e5f5c557737fe2ad99 --- plugins/modules/floating_ip.py | 127 ++++++++++++++++----------------- 1 file changed, 62 insertions(+), 65 deletions(-) diff --git a/plugins/modules/floating_ip.py b/plugins/modules/floating_ip.py index dbf6ee0d..16222445 100644 --- a/plugins/modules/floating_ip.py +++ b/plugins/modules/floating_ip.py @@ -118,23 +118,12 @@ EXAMPLES = ''' server: cattle001 ''' -from ansible.module_utils.basic import AnsibleModule, remove_values -from ansible_collections.openstack.cloud.plugins.module_utils.openstack import (openstack_full_argument_spec, - openstack_module_kwargs, - openstack_cloud_from_module) +from ansible.module_utils.basic import remove_values +from ansible_collections.openstack.cloud.plugins.module_utils.openstack import OpenStackModule -def _get_floating_ip(cloud, floating_ip_address): - f_ips = cloud.search_floating_ips( - filters={'floating_ip_address': floating_ip_address}) - if not f_ips: - return None - - return f_ips[0] - - -def main(): - argument_spec = openstack_full_argument_spec( +class NetworkingFloatingIPModule(OpenStackModule): + argument_spec = dict( server=dict(required=True), state=dict(default='present', choices=['absent', 'present']), network=dict(required=False, default=None), @@ -148,107 +137,115 @@ def main(): purge=dict(required=False, type='bool', default=False), ) - module_kwargs = openstack_module_kwargs() - module = AnsibleModule(argument_spec, **module_kwargs) + module_kwargs = dict() - 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'] + def _get_floating_ip(self, floating_ip_address): + f_ips = self.conn.search_floating_ips( + filters={'floating_ip_address': floating_ip_address}) + if not f_ips: + return None - sdk, cloud = openstack_cloud_from_module(module) - try: + return f_ips[0] - server = cloud.get_server(server_name_or_id) + def run(self): + server_name_or_id = self.params['server'] + state = self.params['state'] + network = self.params['network'] + floating_ip_address = self.params['floating_ip_address'] + reuse = self.params['reuse'] + fixed_address = self.params['fixed_address'] + nat_destination = self.params['nat_destination'] + wait = self.params['wait'] + timeout = self.params['timeout'] + purge = self.params['purge'] + + server = self.conn.get_server(server_name_or_id) if server is None: - module.fail_json( + self.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 + public_ip = self.conn.get_server_public_ip(server) + f_ip = self._get_floating_ip(public_ip) if public_ip else public_ip if f_ip: if network: - network_id = cloud.get_network(name_or_id=network)["id"] + network_id = self.conn.get_network(name_or_id=network)["id"] else: network_id = None # check if we have floating ip on given nat_destination network if nat_destination: nat_floating_addrs = [ addr for addr in server.addresses.get( - cloud.get_network(nat_destination)['name'], []) + self.conn.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)) + self.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))) + self.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, self.no_log_values))) if not network or f_ip.network == network_id: # Requirements are met - module.exit_json(changed=False, floating_ip=f_ip) + self.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 = self.conn.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) + fip_address = self.conn.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) + f_ip = self._get_floating_ip(fip_address) + self.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) + self.fail_json(msg="either server or floating_ip_address are required") + server = self.conn.get_server(server_name_or_id) + floating_ip_address = self.conn.get_server_public_ip(server) - f_ip = _get_floating_ip(cloud, floating_ip_address) + f_ip = self._get_floating_ip(floating_ip_address) if not f_ip: # Nothing to detach - module.exit_json(changed=False) + self.exit_json(changed=False) changed = False if f_ip["fixed_ip_address"]: - cloud.detach_ip_from_server( + self.conn.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']) + f_ip = self.conn.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) + self.conn.delete_floating_ip(f_ip['id']) + self.exit_json(changed=True) + self.exit_json(changed=changed, floating_ip=f_ip) - except sdk.exceptions.OpenStackCloudException as e: - module.fail_json(msg=str(e), extra_data=e.extra_data) + +def main(): + module = NetworkingFloatingIPModule() + module() if __name__ == '__main__':