#!/usr/bin/python # -*- coding: utf-8 -*- # Copyright: Ansible Project # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) DOCUMENTATION = ''' --- module: router short_description: Create or delete routers from OpenStack author: OpenStack Ansible SIG description: - Create or Delete routers from OpenStack. Although Neutron allows routers to share the same name, this module enforces name uniqueness to be more user friendly. options: state: description: - Indicate desired state of the resource choices: ['present', 'absent'] default: present type: str name: description: - Name to be give to the router required: true type: str enable_snat: description: - Enable Source NAT (SNAT) attribute. type: bool is_admin_state_up: description: - Desired admin state of the created or existing router. type: bool default: 'yes' aliases: [admin_state_up] network: description: - Unique name or ID of the external gateway network. - required I(interfaces) or I(enable_snat) are provided. type: str project: description: - Unique name or ID of the project. type: str external_gateway_info: description: - Information about the router's external gateway type: dict suboptions: network: description: - Unique name or ID of the external gateway network. - required I(interfaces) or I(enable_snat) are provided. type: str enable_snat: description: - Unique name or ID of the external gateway network. - required I(interfaces) or I(enable_snat) are provided. type: bool external_fixed_ips: description: - The IP address parameters for the external gateway network. Each is a dictionary with the subnet name or ID (subnet) and the IP address to assign on the subnet (ip). If no IP is specified, one is automatically assigned from that subnet. type: list elements: dict suboptions: ip_address: description: The fixed IP address to attempt to allocate. type: str aliases: [ip] subnet_id: description: The subnet to attach the IP address to. required: true type: str aliases: [subnet] external_fixed_ips: description: - The IP address parameters for the external gateway network. Each is a dictionary with the subnet name or ID (subnet) and the IP address to assign on the subnet (ip). If no IP is specified, one is automatically assigned from that subnet. type: list elements: dict suboptions: ip_address: description: The fixed IP address to attempt to allocate. type: str aliases: [ip] subnet_id: description: The subnet to attach the IP address to. required: true type: str aliases: [subnet] interfaces: description: - List of subnets to attach to the router internal interface. Default gateway associated with the subnet will be automatically attached with the router's internal interface. In order to provide an ip address different from the default gateway,parameters are passed as dictionary with keys as network name or ID (I(net)), subnet name or ID (I(subnet)) and the IP of port (I(portip)) from the network. User defined portip is often required when a multiple router need to be connected to a single subnet for which the default gateway has been already used. type: list elements: raw requirements: - "python >= 3.6" - "openstacksdk" extends_documentation_fragment: - openstack.cloud.openstack ''' EXAMPLES = ''' # Create a simple router, not attached to a gateway or subnets. - openstack.cloud.router: cloud: mycloud state: present name: simple_router # Create a simple router, not attached to a gateway or subnets for a given project. - openstack.cloud.router: cloud: mycloud state: present name: simple_router project: myproj # Creates a router attached to ext_network1 on an IPv4 subnet and one # internal subnet interface. - openstack.cloud.router: cloud: mycloud state: present name: router1 network: ext_network1 external_fixed_ips: - subnet: public-subnet ip: 172.24.4.2 interfaces: - private-subnet # Create another router with two internal subnet interfaces.One with user defined port # ip and another with default gateway. - openstack.cloud.router: cloud: mycloud state: present name: router2 network: ext_network1 interfaces: - net: private-net subnet: private-subnet portip: 10.1.1.10 - project-subnet # Create another router with two internal subnet interface.One with user defined port # ip and and another with default gateway. - openstack.cloud.router: cloud: mycloud state: present name: router2 network: ext_network1 interfaces: - net: private-net subnet: private-subnet portip: 10.1.1.10 - project-subnet # Create another router with two internal subnet interface. one with user defined port # ip and and another with default gateway. - openstack.cloud.router: cloud: mycloud state: present name: router2 network: ext_network1 interfaces: - net: private-net subnet: private-subnet portip: 10.1.1.10 - project-subnet # Update existing router1 external gateway to include the IPv6 subnet. # Note that since 'interfaces' is not provided, any existing internal # interfaces on an existing router will be left intact. - openstack.cloud.router: cloud: mycloud state: present name: router1 network: ext_network1 external_fixed_ips: - subnet: public-subnet ip: 172.24.4.2 - subnet: ipv6-public-subnet ip: 2001:db8::3 # Delete router1 - openstack.cloud.router: cloud: mycloud state: absent name: router1 ''' RETURN = ''' router: description: Dictionary describing the router. returned: On success when I(state) is 'present' type: dict contains: id: description: Router ID. type: str sample: "474acfe5-be34-494c-b339-50f06aa143e4" name: description: Router name. type: str sample: "router1" admin_state_up: description: Administrative state of the router. type: bool sample: true status: description: The router status. type: str sample: "ACTIVE" tenant_id: description: The tenant ID. type: str sample: "861174b82b43463c9edc5202aadc60ef" external_gateway_info: description: The external gateway parameters. type: dict sample: { "enable_snat": true, "external_fixed_ips": [ { "ip_address": "10.6.6.99", "subnet_id": "4272cb52-a456-4c20-8f3c-c26024ecfa81" } ] } routes: description: The extra routes configuration for L3 router. type: list ''' from ansible_collections.openstack.cloud.plugins.module_utils.openstack import OpenStackModule from collections import defaultdict ext_ips_spec = dict(type='list', elements='dict', options=dict( ip_address=dict(aliases=["ip"]), subnet_id=dict(required=True, aliases=["subnet"]), )) class RouterModule(OpenStackModule): argument_spec = dict( state=dict(default='present', choices=['absent', 'present']), name=dict(required=True), is_admin_state_up=dict(type='bool', default=True, aliases=['admin_state_up']), enable_snat=dict(type='bool'), network=dict(), interfaces=dict(type='list', elements='raw'), external_fixed_ips=ext_ips_spec, external_gateway_info=dict(type='dict', options=dict( network=dict(), enable_snat=dict(type='bool'), external_fixed_ips=ext_ips_spec, )), project=dict() ) module_kwargs = dict( mutually_exclusive=[ ('external_gateway_info', 'network'), ('external_gateway_info', 'external_fixed_ips'), ('external_gateway_info', 'enable_snat'), ], required_by=dict( external_fixed_ips='network', ), ) def _needs_update(self, router, kwargs, external_fixed_ips, to_add, to_remove, missing_port_ids): """Decide if the given router needs an update.""" if router['is_admin_state_up'] != self.params['is_admin_state_up']: return True cur_ext_gw_info = router['external_gateway_info'] if 'external_gateway_info' in kwargs: if cur_ext_gw_info is None: return True update = kwargs['external_gateway_info'] for attr in ('enable_snat', 'network_id'): if attr in update and cur_ext_gw_info[attr] != update[attr]: return True cur_ext_gw_info = router['external_gateway_info'] cur_ext_fips = (cur_ext_gw_info or {}) \ .get('external_fixed_ips', []) # map of external fixed ip subnets to addresses cur_fip_map = defaultdict(set) for p in cur_ext_fips: if 'ip_address' in p: cur_fip_map[p['subnet_id']].add(p['ip_address']) req_fip_map = defaultdict(set) for p in external_fixed_ips: if 'ip_address' in p: req_fip_map[p['subnet_id']].add(p['ip_address']) # Check if external ip addresses need to be added for fip in external_fixed_ips: subnet = fip['subnet_id'] ip = fip.get('ip_address', None) if subnet in cur_fip_map: if ip is not None and ip not in cur_fip_map[subnet]: return True else: return True # Check if external ip addresses need to be removed for fip in cur_ext_fips: subnet = fip['subnet_id'] ip = fip['ip_address'] if subnet in req_fip_map: if ip not in req_fip_map[subnet]: return True else: return True if not external_fixed_ips and len(cur_ext_fips) > 1: # no external fixed ips requested but router has several external # fixed ips return True # check if internal interfaces need update if to_add or to_remove or missing_port_ids: return True return False def _build_kwargs(self, router, network, ext_fixed_ips): kwargs = { 'is_admin_state_up': self.params['is_admin_state_up'], } if not router: kwargs['name'] = self.params['name'] curr_ext_gw_info = None if router: curr_ext_gw_info = router['external_gateway_info'] curr_ext_fixed_ips = [] if curr_ext_gw_info: curr_ext_fixed_ips = curr_ext_gw_info.get('external_fixed_ips', []) external_gateway_info = {} if network: external_gateway_info['network_id'] = network.id # can't send enable_snat unless we have a network if self.params['enable_snat'] is not None: external_gateway_info['enable_snat'] = \ self.params['enable_snat'] if ext_fixed_ips: external_gateway_info['external_fixed_ips'] = ext_fixed_ips if external_gateway_info: kwargs['external_gateway_info'] = external_gateway_info if 'external_fixed_ips' not in external_gateway_info: if len(curr_ext_fixed_ips) > 1: fip = curr_ext_fixed_ips[0] external_gateway_info['external_fixed_ips'] = [fip] return kwargs def _build_router_interface_config(self, filters=None): if filters is None: filters = {} external_fixed_ips = [] internal_ports_missing = [] internal_ifaces = [] # Build external interface configuration ext_fixed_ips = None if self.params['external_gateway_info']: ext_fixed_ips = self.params['external_gateway_info'] \ .get('external_fixed_ips') ext_fixed_ips = ext_fixed_ips or self.params['external_fixed_ips'] if ext_fixed_ips: for iface in ext_fixed_ips: subnet = self.conn.network.find_subnet( iface['subnet'], **filters) if not subnet: self.fail(msg='subnet %s not found' % iface['subnet']) fip = dict(subnet_id=subnet.id) if 'ip_address' in iface: fip['ip_address'] = iface['ip_address'] external_fixed_ips.append(fip) # Build internal interface configuration if self.params['interfaces']: internal_ips = [] for iface in self.params['interfaces']: if isinstance(iface, str): subnet = self.conn.network.find_subnet(iface, **filters) if not subnet: self.fail(msg='subnet %s not found' % iface) internal_ifaces.append(dict(subnet_id=subnet.id)) elif isinstance(iface, dict): subnet = self.conn.network.find_subnet(iface['subnet'], **filters) if not subnet: self.fail(msg='subnet %s not found' % iface['subnet']) # TODO: We allow passing a subnet without specifing a # network in case iface is a string, hence we # should allow to omit the network here as well. if 'net' not in iface: self.fail( "Network name missing from interface definition") net = self.conn.network.find_network(iface['net']) if 'portip' not in iface: # portip not set, add any ip from subnet internal_ifaces.append(dict(subnet_id=subnet.id)) elif not iface['portip']: # portip is set but has invalid value self.fail(msg='put an ip in portip or remove it' 'from list to assign default port to router') else: # portip has valid value # look for ports whose fixed_ips.ip_address matchs # portip portip = iface['portip'] port_kwargs = ({'network_id': net.id} if net is not None else {}) existing_ports = self.conn.network.ports(**port_kwargs) for port in existing_ports: for fip in port['fixed_ips']: if (fip['subnet_id'] != subnet.id or fip['ip_address'] != portip): continue internal_ips.append(fip['ip_address']) internal_ifaces.append( dict(port_id=port.id, subnet_id=subnet.id, ip_address=portip)) if portip not in internal_ips: # no port with portip exists hence create a new port internal_ports_missing.append({ 'network_id': subnet.network_id, 'fixed_ips': [{'ip_address': portip, 'subnet_id': subnet.id}] }) return { 'external_fixed_ips': external_fixed_ips, 'internal_ports_missing': internal_ports_missing, 'internal_ifaces': internal_ifaces, } def _update_ifaces(self, router, to_add, to_remove, missing_ports): for port in to_remove: self.conn.network.remove_interface_from_router(router, port_id=port.id) # create ports that are missing for port in missing_ports: p = self.conn.network.create_port(**port) if p: to_add.append(dict(port_id=p.id)) for iface in to_add: self.conn.network.add_interface_to_router(router, **iface) def _get_external_gateway_network_name(self): network_name_or_id = self.params['network'] if self.params['external_gateway_info']: network_name_or_id = \ self.params['external_gateway_info']['network'] return network_name_or_id def _get_port_changes(self, router, ifs_cfg): requested_subnet_ids = [iface['subnet_id'] for iface in ifs_cfg['internal_ifaces']] router_ifs_internal = [] if router: router_ifs_internal = self.conn.list_router_interfaces( router, 'internal') existing_subnet_ips = {} for iface in router_ifs_internal: if 'fixed_ips' not in iface: continue for fip in iface['fixed_ips']: existing_subnet_ips[fip['subnet_id']] = (fip['ip_address'], iface) obsolete_subnet_ids = (set(existing_subnet_ips.keys()) - set(requested_subnet_ids)) internal_ifaces = ifs_cfg['internal_ifaces'] to_add = [] to_remove = [] for iface in internal_ifaces: subnet_id = iface['subnet_id'] if subnet_id not in existing_subnet_ips: iface.pop('ip_address', None) to_add.append(iface) continue ip, existing_port = existing_subnet_ips[subnet_id] if 'ip_address' in iface and ip != iface['ip_address']: # Port exists for subnet but has the wrong ip. Schedule it for # deletion to_remove.append(existing_port) for port in router_ifs_internal: if 'fixed_ips' not in port: continue if any(fip['subnet_id'] in obsolete_subnet_ids for fip in port['fixed_ips']): to_remove.append(port) return dict(to_add=to_add, to_remove=to_remove, router_ifs_internal=router_ifs_internal) def run(self): state = self.params['state'] name = self.params['name'] network_name_or_id = self._get_external_gateway_network_name() project_name_or_id = self.params['project'] if self.params['external_fixed_ips'] and not network_name_or_id: self.fail( msg='network is required when supplying external_fixed_ips') query_filters = {} project = None project_id = None if project_name_or_id is not None: project = self.conn.identity.find_project(project_name_or_id) if project is None: self.fail( msg='Project %s could not be found' % project_name_or_id) project_id = project['id'] query_filters['project_id'] = project_id router = self.conn.network.find_router(name, **query_filters) network = None if network_name_or_id: network = self.conn.network.find_network(network_name_or_id, **query_filters) if not network: self.fail(msg='network %s not found' % network_name_or_id) # Validate and cache the subnet IDs so we can avoid duplicate checks # and expensive API calls. router_ifs_cfg = self._build_router_interface_config(query_filters) missing_internal_ports = router_ifs_cfg['internal_ports_missing'] port_changes = self._get_port_changes(router, router_ifs_cfg) to_add = port_changes['to_add'] to_remove = port_changes['to_remove'] router_ifs_internal = port_changes['router_ifs_internal'] external_fixed_ips = router_ifs_cfg['external_fixed_ips'] if self.ansible.check_mode: # Check if the system state would be changed if state == 'absent' and router: changed = True elif state == 'absent' and not router: changed = False elif state == 'present' and not router: changed = True else: # if state == 'present' and router kwargs = self._build_kwargs(router, network, external_fixed_ips) changed = self._needs_update( router, kwargs, external_fixed_ips, to_add, to_remove, missing_internal_ports) self.exit_json(changed=changed) if state == 'present': changed = False external_fixed_ips = router_ifs_cfg['external_fixed_ips'] internal_ifaces = router_ifs_cfg['internal_ifaces'] kwargs = self._build_kwargs(router, network, external_fixed_ips) if not router: changed = True if project_id: kwargs['project_id'] = project_id router = self.conn.network.create_router(**kwargs) self._update_ifaces(router, internal_ifaces, [], missing_internal_ports) else: if self._needs_update(router, kwargs, external_fixed_ips, to_add, to_remove, missing_internal_ports): changed = True router = self.conn.network.update_router(router, **kwargs) if to_add or to_remove or missing_internal_ports: self._update_ifaces(router, to_add, to_remove, missing_internal_ports) self.exit_json(changed=changed, router=router.to_dict(computed=False)) elif state == 'absent': if not router: self.exit_json(changed=False) else: # We need to detach all internal interfaces on a router # before we will be allowed to delete it. Deletion can # still fail if e.g. floating ips are attached to the # router. for port in router_ifs_internal: self.conn.network.remove_interface_from_router(router, port_id=port['id']) self.conn.network.delete_router(router) self.exit_json(changed=True, router=router) def main(): module = RouterModule() module() if __name__ == '__main__': main()