Cesar77RR's picture
download
raw
41.3 kB
import collections
import netaddr
from neutron_lib import constants as lib_constants
from neutron_lib.utils import helpers
from oslo_log import log as logging
from neutron._i18n import _
from neutron.agent.l3 import namespaces
from neutron.agent.linux import ip_lib
from neutron.agent.linux import iptables_manager
from neutron.agent.linux import ra
from neutron.common import constants as n_const
from neutron.common import exceptions as n_exc
from neutron.common import ipv6_utils
from neutron.common import utils as common_utils
from neutron.ipam import utils as ipam_utils
LOG = logging.getLogger(__name__)
INTERNAL_DEV_PREFIX = namespaces.INTERNAL_DEV_PREFIX
EXTERNAL_DEV_PREFIX = namespaces.EXTERNAL_DEV_PREFIX
FLOATINGIP_STATUS_NOCHANGE = object()
ADDRESS_SCOPE_MARK_MASK = '0xffff0000'
ADDRESS_SCOPE_MARK_ID_MIN = 1024
ADDRESS_SCOPE_MARK_ID_MAX = 2048
DEFAULT_ADDRESS_SCOPE = 'noscope'
class RouterInfo(object, ):
def __init__(self, agent, router_id, router, agent_conf, interface_driver, use_ipv6=False):
self.agent = agent
self.router_id = router_id
self.ex_gw_port = None
self._snat_enabled = None
self.fip_map = {}
self.internal_ports = []
self.pd_subnets = {}
self.floating_ips = set()
self.router = router
self.use_ipv6 = use_ipv6
ns = self.create_router_namespace_object(router_id, agent_conf, interface_driver, use_ipv6)
self.router_namespace = ns
self.ns_name = ns.name
self.available_mark_ids = set(range(ADDRESS_SCOPE_MARK_ID_MIN, ADDRESS_SCOPE_MARK_ID_MAX))
self._address_scope_to_mark_id = {DEFAULT_ADDRESS_SCOPE: self.available_mark_ids.pop()}
self.iptables_manager = iptables_manager.IptablesManager(use_ipv6=use_ipv6, namespace=self.ns_name)
self.initialize_address_scope_iptables()
self.routes = []
self.agent_conf = agent_conf
self.driver = interface_driver
self.process_monitor = None
self.radvd = None
def initialize(self, process_monitor):
"Initialize the router on the system.\n\n This differs from __init__ in that this method actually affects the\n system creating namespaces, starting processes, etc. The other merely\n initializes the python object. This separates in-memory object\n initialization from methods that actually go do stuff to the system.\n\n :param process_monitor: The agent's process monitor instance.\n "
self.process_monitor = process_monitor
self.radvd = ra.DaemonMonitor(self.router_id, self.ns_name, process_monitor, self.get_internal_device_name, self.agent_conf)
self.router_namespace.create()
def create_router_namespace_object(self, router_id, agent_conf, iface_driver, use_ipv6):
return namespaces.RouterNamespace(router_id, agent_conf, iface_driver, use_ipv6)
@property
def router(self):
return self._router
@router.setter
def router(self, value):
self._router = value
if (not self._router):
return
self._snat_enabled = self._router.get('enable_snat', True)
def is_router_master(self):
return True
def get_internal_device_name(self, port_id):
return (INTERNAL_DEV_PREFIX + port_id)[:self.driver.DEV_NAME_LEN]
def get_external_device_name(self, port_id):
return (EXTERNAL_DEV_PREFIX + port_id)[:self.driver.DEV_NAME_LEN]
def get_external_device_interface_name(self, ex_gw_port):
return self.get_external_device_name(ex_gw_port['id'])
def get_gw_ns_name(self):
return self.ns_name
def _update_routing_table(self, operation, route, namespace):
cmd = ['ip', 'route', operation, 'to', route['destination'], 'via', route['nexthop']]
ip_wrapper = ip_lib.IPWrapper(namespace=namespace)
ip_wrapper.netns.execute(cmd, check_exit_code=False)
def update_routing_table(self, operation, route):
self._update_routing_table(operation, route, self.ns_name)
def routes_updated(self, old_routes, new_routes):
(adds, removes) = helpers.diff_list_of_dict(old_routes, new_routes)
for route in adds:
LOG.debug("Added route entry is '%s'", route)
for del_route in removes:
if (route['destination'] == del_route['destination']):
removes.remove(del_route)
self.update_routing_table('replace', route)
for route in removes:
LOG.debug("Removed route entry is '%s'", route)
self.update_routing_table('delete', route)
def get_ex_gw_port(self):
return self.router.get('gw_port')
def get_floating_ips(self):
'Filter Floating IPs to be hosted on this agent.'
return self.router.get(lib_constants.FLOATINGIP_KEY, [])
def floating_forward_rules(self, fip):
fixed_ip = fip['fixed_ip_address']
floating_ip = fip['floating_ip_address']
return [('PREROUTING', ('-d %s/32 -j DNAT --to-destination %s' % (floating_ip, fixed_ip))), ('OUTPUT', ('-d %s/32 -j DNAT --to-destination %s' % (floating_ip, fixed_ip))), ('float-snat', ('-s %s/32 -j SNAT --to-source %s' % (fixed_ip, floating_ip)))]
def floating_mangle_rules(self, floating_ip, fixed_ip, internal_mark):
mark_traffic_to_floating_ip = ('floatingip', ('-d %s/32 -j MARK --set-xmark %s' % (floating_ip, internal_mark)))
mark_traffic_from_fixed_ip = ('FORWARD', ('-s %s/32 -j $float-snat' % fixed_ip))
return [mark_traffic_to_floating_ip, mark_traffic_from_fixed_ip]
def get_address_scope_mark_mask(self, address_scope=None):
if (not address_scope):
address_scope = DEFAULT_ADDRESS_SCOPE
if (address_scope not in self._address_scope_to_mark_id):
self._address_scope_to_mark_id[address_scope] = self.available_mark_ids.pop()
mark_id = self._address_scope_to_mark_id[address_scope]
return ('%s/%s' % (hex((mark_id << 16)), ADDRESS_SCOPE_MARK_MASK))
def get_port_address_scope_mark(self, port):
'Get the IP version 4 and 6 address scope mark for the port\n\n :param port: A port dict from the RPC call\n :returns: A dict mapping the address family to the address scope mark\n '
port_scopes = port.get('address_scopes', {})
address_scope_mark_masks = ((int(k), self.get_address_scope_mark_mask(v)) for (k, v) in port_scopes.items())
return collections.defaultdict(self.get_address_scope_mark_mask, address_scope_mark_masks)
def process_floating_ip_nat_rules(self):
"Configure NAT rules for the router's floating IPs.\n\n Configures iptables rules for the floating ips of the given router\n "
self.iptables_manager.ipv4['nat'].clear_rules_by_tag('floating_ip')
floating_ips = self.get_floating_ips()
for fip in floating_ips:
for (chain, rule) in self.floating_forward_rules(fip):
self.iptables_manager.ipv4['nat'].add_rule(chain, rule, tag='floating_ip')
self.iptables_manager.apply()
def _process_pd_iptables_rules(self, prefix, subnet_id):
'Configure iptables rules for prefix delegated subnets'
ext_scope = self._get_external_address_scope()
ext_scope_mark = self.get_address_scope_mark_mask(ext_scope)
ex_gw_device = self.get_external_device_name(self.get_ex_gw_port()['id'])
scope_rule = self.address_scope_mangle_rule(ex_gw_device, ext_scope_mark)
self.iptables_manager.ipv6['mangle'].add_rule('scope', (('-d %s ' % prefix) + scope_rule), tag=('prefix_delegation_%s' % subnet_id))
def process_floating_ip_address_scope_rules(self):
"Configure address scope related iptables rules for the router's\n floating IPs.\n "
self.iptables_manager.ipv4['mangle'].clear_rules_by_tag('floating_ip')
all_floating_ips = self.get_floating_ips()
ext_scope = self._get_external_address_scope()
floating_ips = [fip for fip in all_floating_ips if (fip.get('fixed_ip_address_scope') != ext_scope)]
if floating_ips:
ext_scope_mark = self.get_address_scope_mark_mask(ext_scope)
ports_scopemark = self._get_address_scope_mark()
devices_in_ext_scope = {device for (device, mark) in ports_scopemark[lib_constants.IP_VERSION_4].items() if (mark == ext_scope_mark)}
for device in devices_in_ext_scope:
self.iptables_manager.ipv4['mangle'].add_rule('float-snat', ('-o %s -j MARK --set-xmark %s' % (device, ext_scope_mark)), tag='floating_ip')
for fip in floating_ips:
fip_ip = fip['floating_ip_address']
fixed_ip = fip['fixed_ip_address']
fixed_scope = fip.get('fixed_ip_address_scope')
internal_mark = self.get_address_scope_mark_mask(fixed_scope)
mangle_rules = self.floating_mangle_rules(fip_ip, fixed_ip, internal_mark)
for (chain, rule) in mangle_rules:
self.iptables_manager.ipv4['mangle'].add_rule(chain, rule, tag='floating_ip')
def process_snat_dnat_for_fip(self):
try:
self.process_floating_ip_nat_rules()
except Exception:
msg = _('L3 agent failure to setup NAT for floating IPs')
LOG.exception(msg)
raise n_exc.FloatingIpSetupException(msg)
def _add_fip_addr_to_device(self, fip, device):
'Configures the floating ip address on the device.\n '
try:
ip_cidr = common_utils.ip_to_cidr(fip['floating_ip_address'])
device.addr.add(ip_cidr)
return True
except RuntimeError:
LOG.warning('Unable to configure IP address for floating IP: %s', fip['id'])
def add_floating_ip(self, fip, interface_name, device):
raise NotImplementedError()
def migrate_centralized_floating_ip(self, fip, interface_name, device):
pass
def gateway_redirect_cleanup(self, rtr_interface):
pass
def remove_floating_ip(self, device, ip_cidr):
device.delete_addr_and_conntrack_state(ip_cidr)
def move_floating_ip(self, fip):
return lib_constants.FLOATINGIP_STATUS_ACTIVE
def remove_external_gateway_ip(self, device, ip_cidr):
device.delete_addr_and_conntrack_state(ip_cidr)
def get_router_cidrs(self, device):
return set([addr['cidr'] for addr in device.addr.list()])
def get_centralized_router_cidrs(self):
return set()
def process_floating_ip_addresses(self, interface_name):
"Configure IP addresses on router's external gateway interface.\n\n Ensures addresses for existing floating IPs and cleans up\n those that should not longer be configured.\n "
fip_statuses = {}
if (interface_name is None):
LOG.debug('No Interface for floating IPs router: %s', self.router['id'])
return fip_statuses
device = ip_lib.IPDevice(interface_name, namespace=self.ns_name)
existing_cidrs = self.get_router_cidrs(device)
new_cidrs = set()
gw_cidrs = self._get_gw_ips_cidr()
floating_ips = self.get_floating_ips()
for fip in floating_ips:
fip_ip = fip['floating_ip_address']
ip_cidr = common_utils.ip_to_cidr(fip_ip)
new_cidrs.add(ip_cidr)
fip_statuses[fip['id']] = lib_constants.FLOATINGIP_STATUS_ACTIVE
cent_router_cidrs = self.get_centralized_router_cidrs()
if (ip_cidr not in existing_cidrs):
fip_statuses[fip['id']] = self.add_floating_ip(fip, interface_name, device)
LOG.debug('Floating ip %(id)s added, status %(status)s', {'id': fip['id'], 'status': fip_statuses.get(fip['id'])})
elif ((fip_ip in self.fip_map) and (self.fip_map[fip_ip] != fip['fixed_ip_address'])):
LOG.debug('Floating IP was moved from fixed IP %(old)s to %(new)s', {'old': self.fip_map[fip_ip], 'new': fip['fixed_ip_address']})
fip_statuses[fip['id']] = self.move_floating_ip(fip)
elif ((ip_cidr in cent_router_cidrs) and (fip.get('host') == self.host)):
LOG.debug('Floating IP is migrating from centralized to distributed: %s', fip)
fip_statuses[fip['id']] = self.migrate_centralized_floating_ip(fip, interface_name, device)
elif (fip_statuses[fip['id']] == fip['status']):
fip_statuses[fip['id']] = FLOATINGIP_STATUS_NOCHANGE
fips_to_remove = (ip_cidr for ip_cidr in ((existing_cidrs - new_cidrs) - gw_cidrs) if common_utils.is_cidr_host(ip_cidr))
for ip_cidr in fips_to_remove:
LOG.debug('Removing floating ip %s from interface %s in namespace %s', ip_cidr, interface_name, self.ns_name)
self.remove_floating_ip(device, ip_cidr)
return fip_statuses
def _get_gw_ips_cidr(self):
gw_cidrs = set()
ex_gw_port = self.get_ex_gw_port()
if ex_gw_port:
for ip_addr in ex_gw_port['fixed_ips']:
ex_gw_ip = ip_addr['ip_address']
addr = netaddr.IPAddress(ex_gw_ip)
if (addr.version == lib_constants.IP_VERSION_4):
gw_cidrs.add(common_utils.ip_to_cidr(ex_gw_ip))
return gw_cidrs
def configure_fip_addresses(self, interface_name):
try:
return self.process_floating_ip_addresses(interface_name)
except Exception:
msg = _('L3 agent failure to setup floating IPs')
LOG.exception(msg)
raise n_exc.FloatingIpSetupException(msg)
def put_fips_in_error_state(self):
fip_statuses = {}
for fip in self.router.get(lib_constants.FLOATINGIP_KEY, []):
fip_statuses[fip['id']] = lib_constants.FLOATINGIP_STATUS_ERROR
return fip_statuses
def delete(self):
self.router['gw_port'] = None
self.router[lib_constants.INTERFACE_KEY] = []
self.router[lib_constants.FLOATINGIP_KEY] = []
self.process_delete()
self.disable_radvd()
self.router_namespace.delete()
def _internal_network_updated(self, port, subnet_id, prefix, old_prefix, updated_cidrs):
interface_name = self.get_internal_device_name(port['id'])
if (prefix != n_const.PROVISIONAL_IPV6_PD_PREFIX):
fixed_ips = port['fixed_ips']
for fixed_ip in fixed_ips:
if (fixed_ip['subnet_id'] == subnet_id):
v6addr = common_utils.ip_to_cidr(fixed_ip['ip_address'], fixed_ip.get('prefixlen'))
if (v6addr not in updated_cidrs):
self.driver.add_ipv6_addr(interface_name, v6addr, self.ns_name)
else:
self.driver.delete_ipv6_addr_with_prefix(interface_name, old_prefix, self.ns_name)
def _internal_network_added(self, ns_name, network_id, port_id, fixed_ips, mac_address, interface_name, prefix, mtu=None):
LOG.debug('adding internal network: prefix(%s), port(%s)', prefix, port_id)
self.driver.plug(network_id, port_id, interface_name, mac_address, namespace=ns_name, prefix=prefix, mtu=mtu)
ip_cidrs = common_utils.fixed_ip_cidrs(fixed_ips)
self.driver.init_router_port(interface_name, ip_cidrs, namespace=ns_name)
for fixed_ip in fixed_ips:
ip_lib.send_ip_addr_adv_notif(ns_name, interface_name, fixed_ip['ip_address'])
def internal_network_added(self, port):
network_id = port['network_id']
port_id = port['id']
fixed_ips = port['fixed_ips']
mac_address = port['mac_address']
interface_name = self.get_internal_device_name(port_id)
self._internal_network_added(self.ns_name, network_id, port_id, fixed_ips, mac_address, interface_name, INTERNAL_DEV_PREFIX, mtu=port.get('mtu'))
def internal_network_removed(self, port):
interface_name = self.get_internal_device_name(port['id'])
LOG.debug('removing internal network: port(%s) interface(%s)', port['id'], interface_name)
if ip_lib.device_exists(interface_name, namespace=self.ns_name):
self.driver.unplug(interface_name, namespace=self.ns_name, prefix=INTERNAL_DEV_PREFIX)
def _get_existing_devices(self):
ip_wrapper = ip_lib.IPWrapper(namespace=self.ns_name)
ip_devs = ip_wrapper.get_devices()
return [ip_dev.name for ip_dev in ip_devs]
@staticmethod
def _get_updated_ports(existing_ports, current_ports):
updated_ports = dict()
current_ports_dict = {p['id']: p for p in current_ports}
for existing_port in existing_ports:
current_port = current_ports_dict.get(existing_port['id'])
if current_port:
fixed_ips_changed = (sorted(existing_port['fixed_ips'], key=helpers.safe_sort_key) != sorted(current_port['fixed_ips'], key=helpers.safe_sort_key))
mtu_changed = (existing_port['mtu'] != current_port['mtu'])
if (fixed_ips_changed or mtu_changed):
updated_ports[current_port['id']] = current_port
return updated_ports
@staticmethod
def _port_has_ipv6_subnet(port):
if ('subnets' in port):
for subnet in port['subnets']:
if ((netaddr.IPNetwork(subnet['cidr']).version == 6) and (subnet['cidr'] != n_const.PROVISIONAL_IPV6_PD_PREFIX)):
return True
def enable_radvd(self, internal_ports=None):
LOG.debug('Spawning radvd daemon in router device: %s', self.router_id)
if (not internal_ports):
internal_ports = self.internal_ports
self.radvd.enable(internal_ports)
def disable_radvd(self):
LOG.debug('Terminating radvd daemon in router device: %s', self.router_id)
self.radvd.disable()
def internal_network_updated(self, interface_name, ip_cidrs, mtu):
self.driver.set_mtu(interface_name, mtu, namespace=self.ns_name, prefix=INTERNAL_DEV_PREFIX)
self.driver.init_router_port(interface_name, ip_cidrs=ip_cidrs, namespace=self.ns_name)
def address_scope_mangle_rule(self, device_name, mark_mask):
return ('-i %s -j MARK --set-xmark %s' % (device_name, mark_mask))
def address_scope_filter_rule(self, device_name, mark_mask):
return ('-o %s -m mark ! --mark %s -j DROP' % (device_name, mark_mask))
def _process_internal_ports(self):
existing_port_ids = set((p['id'] for p in self.internal_ports))
internal_ports = self.router.get(lib_constants.INTERFACE_KEY, [])
current_port_ids = set((p['id'] for p in internal_ports if p['admin_state_up']))
new_port_ids = (current_port_ids - existing_port_ids)
new_ports = [p for p in internal_ports if (p['id'] in new_port_ids)]
old_ports = [p for p in self.internal_ports if (p['id'] not in current_port_ids)]
updated_ports = self._get_updated_ports(self.internal_ports, internal_ports)
enable_ra = False
for p in new_ports:
self.internal_network_added()
LOG.debug('appending port %s to internal_ports cache', p)
self.internal_ports.append(p)
enable_ra = (enable_ra or self._port_has_ipv6_subnet(p))
for subnet in p['subnets']:
if ipv6_utils.is_ipv6_pd_enabled(subnet):
interface_name = self.get_internal_device_name(p['id'])
self.agent.pd.enable_subnet(self.router_id, subnet['id'], subnet['cidr'], interface_name, p['mac_address'])
for p in old_ports:
self.internal_network_removed(p)
LOG.debug('removing port %s from internal_ports cache', p)
self.internal_ports.remove(p)
enable_ra = (enable_ra or self._port_has_ipv6_subnet(p))
for subnet in p['subnets']:
if ipv6_utils.is_ipv6_pd_enabled(subnet):
self.agent.pd.disable_subnet(self.router_id, subnet['id'])
del self.pd_subnets[subnet['id']]
updated_cidrs = []
if updated_ports:
for (index, p) in enumerate(internal_ports):
if (not updated_ports.get(p['id'])):
continue
self.internal_ports[index] = updated_ports[p['id']]
interface_name = self.get_internal_device_name(p['id'])
ip_cidrs = common_utils.fixed_ip_cidrs(p['fixed_ips'])
LOG.debug('updating internal network for port %s', p)
updated_cidrs += ip_cidrs
self.internal_network_updated(interface_name, ip_cidrs, p['mtu'])
enable_ra = (enable_ra or self._port_has_ipv6_subnet(p))
for p in internal_ports:
if (p['id'] in (set(current_port_ids) & set(existing_port_ids))):
for subnet in p.get('subnets', []):
if ipv6_utils.is_ipv6_pd_enabled(subnet):
old_prefix = self.agent.pd.update_subnet(self.router_id, subnet['id'], subnet['cidr'])
if old_prefix:
self._internal_network_updated(p, subnet['id'], subnet['cidr'], old_prefix, updated_cidrs)
self.pd_subnets[subnet['id']] = subnet['cidr']
enable_ra = True
if enable_ra:
self.enable_radvd(internal_ports)
existing_devices = self._get_existing_devices()
current_internal_devs = set((n for n in existing_devices if n.startswith(INTERNAL_DEV_PREFIX)))
current_port_devs = set((self.get_internal_device_name(port_id) for port_id in current_port_ids))
stale_devs = (current_internal_devs - current_port_devs)
for stale_dev in stale_devs:
LOG.debug('Deleting stale internal router device: %s', stale_dev)
self.agent.pd.remove_stale_ri_ifname(self.router_id, stale_dev)
self.driver.unplug(stale_dev, namespace=self.ns_name, prefix=INTERNAL_DEV_PREFIX)
def _list_floating_ip_cidrs(self):
floating_ips = self.get_floating_ips()
return [common_utils.ip_to_cidr(ip['floating_ip_address']) for ip in floating_ips]
def _plug_external_gateway(self, ex_gw_port, interface_name, ns_name):
self.driver.plug(ex_gw_port['network_id'], ex_gw_port['id'], interface_name, ex_gw_port['mac_address'], bridge=self.agent_conf.external_network_bridge, namespace=ns_name, prefix=EXTERNAL_DEV_PREFIX, mtu=ex_gw_port.get('mtu'))
if self.agent_conf.external_network_bridge:
self.driver.remove_vlan_tag(self.agent_conf.external_network_bridge, interface_name)
def _get_external_gw_ips(self, ex_gw_port):
gateway_ips = []
if ('subnets' in ex_gw_port):
gateway_ips = [subnet['gateway_ip'] for subnet in ex_gw_port['subnets'] if subnet['gateway_ip']]
if (self.use_ipv6 and (not self.is_v6_gateway_set(gateway_ips))):
if self.agent_conf.ipv6_gateway:
gateway_ips.append(self.agent_conf.ipv6_gateway)
return gateway_ips
def _add_route_to_gw(self, ex_gw_port, device_name, namespace, preserve_ips):
for subnet in ex_gw_port.get('subnets', []):
is_gateway_not_in_subnet = (subnet['gateway_ip'] and (not ipam_utils.check_subnet_ip(subnet['cidr'], subnet['gateway_ip'])))
if is_gateway_not_in_subnet:
preserve_ips.append(subnet['gateway_ip'])
device = ip_lib.IPDevice(device_name, namespace=namespace)
device.route.add_route(subnet['gateway_ip'], scope='link')
def _configure_ipv6_params_on_gw(self, ex_gw_port, ns_name, interface_name, enabled):
if (not self.use_ipv6):
return
disable_ra = (not enabled)
if enabled:
gateway_ips = self._get_external_gw_ips(ex_gw_port)
if (not self.is_v6_gateway_set(gateway_ips)):
self.driver.configure_ipv6_ra(ns_name, interface_name, n_const.ACCEPT_RA_WITH_FORWARDING)
else:
disable_ra = True
if disable_ra:
self.driver.configure_ipv6_ra(ns_name, interface_name, n_const.ACCEPT_RA_DISABLED)
self.driver.configure_ipv6_forwarding(ns_name, interface_name, enabled)
def _external_gateway_added(self, ex_gw_port, interface_name, ns_name, preserve_ips):
LOG.debug('External gateway added: port(%s), interface(%s), ns(%s)', ex_gw_port, interface_name, ns_name)
self._plug_external_gateway(ex_gw_port, interface_name, ns_name)
ip_cidrs = common_utils.fixed_ip_cidrs(ex_gw_port['fixed_ips'])
gateway_ips = self._get_external_gw_ips(ex_gw_port)
self._add_route_to_gw(ex_gw_port, device_name=interface_name, namespace=ns_name, preserve_ips=preserve_ips)
self.driver.init_router_port(interface_name, ip_cidrs, namespace=ns_name, extra_subnets=ex_gw_port.get('extra_subnets', []), preserve_ips=preserve_ips, clean_connections=True)
device = ip_lib.IPDevice(interface_name, namespace=ns_name)
current_gateways = set()
for ip_version in (lib_constants.IP_VERSION_4, lib_constants.IP_VERSION_6):
gateway = device.route.get_gateway(ip_version=ip_version)
if (gateway and gateway.get('gateway')):
current_gateways.add(gateway.get('gateway'))
for ip in (current_gateways - set(gateway_ips)):
device.route.delete_gateway(ip)
for ip in gateway_ips:
device.route.add_gateway(ip)
self._configure_ipv6_params_on_gw(ex_gw_port, ns_name, interface_name, True)
for fixed_ip in ex_gw_port['fixed_ips']:
ip_lib.send_ip_addr_adv_notif(ns_name, interface_name, fixed_ip['ip_address'])
def is_v6_gateway_set(self, gateway_ips):
'Check to see if list of gateway_ips has an IPv6 gateway.\n '
return any(((netaddr.IPAddress(gw_ip).version == 6) for gw_ip in gateway_ips))
def external_gateway_added(self, ex_gw_port, interface_name):
preserve_ips = self._list_floating_ip_cidrs()
preserve_ips.extend(self.agent.pd.get_preserve_ips(self.router_id))
self._external_gateway_added(ex_gw_port, interface_name, self.ns_name, preserve_ips)
def external_gateway_updated(self, ex_gw_port, interface_name):
preserve_ips = self._list_floating_ip_cidrs()
preserve_ips.extend(self.agent.pd.get_preserve_ips(self.router_id))
self._external_gateway_added(ex_gw_port, interface_name, self.ns_name, preserve_ips)
def external_gateway_removed(self, ex_gw_port, interface_name):
LOG.debug('External gateway removed: port(%s), interface(%s)', ex_gw_port, interface_name)
device = ip_lib.IPDevice(interface_name, namespace=self.ns_name)
for ip_addr in ex_gw_port['fixed_ips']:
prefixlen = ip_addr.get('prefixlen')
self.remove_external_gateway_ip(device, common_utils.ip_to_cidr(ip_addr['ip_address'], prefixlen))
self.driver.unplug(interface_name, bridge=self.agent_conf.external_network_bridge, namespace=self.ns_name, prefix=EXTERNAL_DEV_PREFIX)
@staticmethod
def _gateway_ports_equal(port1, port2):
return (port1 == port2)
def _delete_stale_external_devices(self, interface_name):
existing_devices = self._get_existing_devices()
stale_devs = [dev for dev in existing_devices if (dev.startswith(EXTERNAL_DEV_PREFIX) and (dev != interface_name))]
for stale_dev in stale_devs:
LOG.debug('Deleting stale external router device: %s', stale_dev)
self.agent.pd.remove_gw_interface(self.router['id'])
self.driver.unplug(stale_dev, bridge=self.agent_conf.external_network_bridge, namespace=self.ns_name, prefix=EXTERNAL_DEV_PREFIX)
def _process_external_gateway(self, ex_gw_port):
ex_gw_port_id = ((ex_gw_port and ex_gw_port['id']) or (self.ex_gw_port and self.ex_gw_port['id']))
interface_name = None
if ex_gw_port_id:
interface_name = self.get_external_device_name(ex_gw_port_id)
if ex_gw_port:
if (not self.ex_gw_port):
self.external_gateway_added(ex_gw_port, interface_name)
self.agent.pd.add_gw_interface(self.router['id'], interface_name)
elif (not self._gateway_ports_equal(ex_gw_port, self.ex_gw_port)):
self.external_gateway_updated(ex_gw_port, interface_name)
elif ((not ex_gw_port) and self.ex_gw_port):
self.external_gateway_removed(self.ex_gw_port, interface_name)
self.agent.pd.remove_gw_interface(self.router['id'])
elif ((not ex_gw_port) and (not self.ex_gw_port)):
for p in self.internal_ports:
interface_name = self.get_internal_device_name(p['id'])
self.gateway_redirect_cleanup(interface_name)
self._delete_stale_external_devices(interface_name)
gw_port = self._router.get('gw_port')
self._handle_router_snat_rules(gw_port, interface_name)
def _prevent_snat_for_internal_traffic_rule(self, interface_name):
return ('POSTROUTING', ('! -i %(interface_name)s ! -o %(interface_name)s -m conntrack ! --ctstate DNAT -j ACCEPT' % {'interface_name': interface_name}))
def external_gateway_nat_fip_rules(self, ex_gw_ip, interface_name):
dont_snat_traffic_to_internal_ports_if_not_to_floating_ip = self._prevent_snat_for_internal_traffic_rule(interface_name)
ext_in_mark = self.agent_conf.external_ingress_mark
snat_internal_traffic_to_floating_ip = ('snat', ('-m mark ! --mark %s/%s -m conntrack --ctstate DNAT -j SNAT --to-source %s' % (ext_in_mark, n_const.ROUTER_MARK_MASK, ex_gw_ip)))
return [dont_snat_traffic_to_internal_ports_if_not_to_floating_ip, snat_internal_traffic_to_floating_ip]
def external_gateway_nat_snat_rules(self, ex_gw_ip, interface_name):
snat_normal_external_traffic = ('snat', ('-o %s -j SNAT --to-source %s' % (interface_name, ex_gw_ip)))
return [snat_normal_external_traffic]
def external_gateway_mangle_rules(self, interface_name):
mark = self.agent_conf.external_ingress_mark
mark_packets_entering_external_gateway_port = ('mark', ('-i %s -j MARK --set-xmark %s/%s' % (interface_name, mark, n_const.ROUTER_MARK_MASK)))
return [mark_packets_entering_external_gateway_port]
def _empty_snat_chains(self, iptables_manager):
iptables_manager.ipv4['nat'].empty_chain('POSTROUTING')
iptables_manager.ipv4['nat'].empty_chain('snat')
iptables_manager.ipv4['mangle'].empty_chain('mark')
iptables_manager.ipv4['mangle'].empty_chain('POSTROUTING')
def _add_snat_rules(self, ex_gw_port, iptables_manager, interface_name):
self.process_external_port_address_scope_routing(iptables_manager)
if ex_gw_port:
for ip_addr in ex_gw_port['fixed_ips']:
ex_gw_ip = ip_addr['ip_address']
if (netaddr.IPAddress(ex_gw_ip).version == 4):
if self._snat_enabled:
rules = self.external_gateway_nat_snat_rules(ex_gw_ip, interface_name)
for rule in rules:
iptables_manager.ipv4['nat'].add_rule(*rule)
rules = self.external_gateway_nat_fip_rules(ex_gw_ip, interface_name)
for rule in rules:
iptables_manager.ipv4['nat'].add_rule(*rule)
rules = self.external_gateway_mangle_rules(interface_name)
for rule in rules:
iptables_manager.ipv4['mangle'].add_rule(*rule)
break
def _handle_router_snat_rules(self, ex_gw_port, interface_name):
self._empty_snat_chains(self.iptables_manager)
self.iptables_manager.ipv4['nat'].add_rule('snat', '-j $float-snat')
self._add_snat_rules(ex_gw_port, self.iptables_manager, interface_name)
def _process_external_on_delete(self):
fip_statuses = {}
try:
ex_gw_port = self.get_ex_gw_port()
self._process_external_gateway(ex_gw_port)
if (not ex_gw_port):
return
interface_name = self.get_external_device_interface_name(ex_gw_port)
fip_statuses = self.configure_fip_addresses(interface_name)
except n_exc.FloatingIpSetupException:
LOG.exception('Failed to process floating IPs.')
fip_statuses = self.put_fips_in_error_state()
finally:
self.update_fip_statuses(fip_statuses)
def process_external(self):
fip_statuses = {}
try:
with self.iptables_manager.defer_apply():
ex_gw_port = self.get_ex_gw_port()
self._process_external_gateway(ex_gw_port)
if (not ex_gw_port):
return
self.process_snat_dnat_for_fip()
interface_name = self.get_external_device_interface_name(ex_gw_port)
fip_statuses = self.configure_fip_addresses(interface_name)
except (n_exc.FloatingIpSetupException, n_exc.IpTablesApplyException):
LOG.exception('Failed to process floating IPs.')
fip_statuses = self.put_fips_in_error_state()
finally:
self.update_fip_statuses(fip_statuses)
def update_fip_statuses(self, fip_statuses):
existing_floating_ips = self.floating_ips
self.floating_ips = set(fip_statuses.keys())
for fip_id in (existing_floating_ips - self.floating_ips):
fip_statuses[fip_id] = lib_constants.FLOATINGIP_STATUS_DOWN
fip_statuses = {f: stat for (f, stat) in fip_statuses.items() if (stat != FLOATINGIP_STATUS_NOCHANGE)}
if (not fip_statuses):
return
LOG.debug('Sending floating ip statuses: %s', fip_statuses)
self.agent.plugin_rpc.update_floatingip_statuses(self.agent.context, self.router_id, fip_statuses)
def initialize_address_scope_iptables(self):
self._initialize_address_scope_iptables(self.iptables_manager)
def _initialize_address_scope_iptables(self, iptables_manager):
iptables_manager.ipv4['mangle'].add_chain('scope')
iptables_manager.ipv6['mangle'].add_chain('scope')
iptables_manager.ipv4['mangle'].add_chain('floatingip')
iptables_manager.ipv4['mangle'].add_chain('float-snat')
iptables_manager.ipv4['filter'].add_chain('scope')
iptables_manager.ipv6['filter'].add_chain('scope')
iptables_manager.ipv4['filter'].add_rule('FORWARD', '-j $scope')
iptables_manager.ipv6['filter'].add_rule('FORWARD', '-j $scope')
mark_new_ingress_address_scope_by_interface = '-j $scope'
copy_address_scope_for_existing = '-m connmark ! --mark 0x0/0xffff0000 -j CONNMARK --restore-mark --nfmask 0xffff0000 --ctmask 0xffff0000'
mark_new_ingress_address_scope_by_floatingip = '-j $floatingip'
save_mark_to_connmark = '-m connmark --mark 0x0/0xffff0000 -j CONNMARK --save-mark --nfmask 0xffff0000 --ctmask 0xffff0000'
iptables_manager.ipv4['mangle'].add_rule('PREROUTING', mark_new_ingress_address_scope_by_interface)
iptables_manager.ipv4['mangle'].add_rule('PREROUTING', copy_address_scope_for_existing)
iptables_manager.ipv4['mangle'].add_rule('PREROUTING', mark_new_ingress_address_scope_by_floatingip)
iptables_manager.ipv4['mangle'].add_rule('float-snat', save_mark_to_connmark)
iptables_manager.ipv6['mangle'].add_rule('PREROUTING', mark_new_ingress_address_scope_by_interface)
iptables_manager.ipv6['mangle'].add_rule('PREROUTING', copy_address_scope_for_existing)
def _get_port_devicename_scopemark(self, ports, name_generator):
devicename_scopemark = {lib_constants.IP_VERSION_4: dict(), lib_constants.IP_VERSION_6: dict()}
for p in ports:
device_name = name_generator(p['id'])
ip_cidrs = common_utils.fixed_ip_cidrs(p['fixed_ips'])
port_as_marks = self.get_port_address_scope_mark(p)
for ip_version in {common_utils.get_ip_version(cidr) for cidr in ip_cidrs}:
devicename_scopemark[ip_version][device_name] = port_as_marks[ip_version]
return devicename_scopemark
def _get_address_scope_mark(self):
internal_ports = self.router.get(lib_constants.INTERFACE_KEY, [])
ports_scopemark = self._get_port_devicename_scopemark(internal_ports, self.get_internal_device_name)
external_port = self.get_ex_gw_port()
if external_port:
external_port_scopemark = self._get_port_devicename_scopemark([external_port], self.get_external_device_name)
for ip_version in (lib_constants.IP_VERSION_4, lib_constants.IP_VERSION_6):
ports_scopemark[ip_version].update(external_port_scopemark[ip_version])
return ports_scopemark
def _add_address_scope_mark(self, iptables_manager, ports_scopemark):
external_device_name = None
external_port = self.get_ex_gw_port()
if external_port:
external_device_name = self.get_external_device_name(external_port['id'])
for ip_version in (lib_constants.IP_VERSION_4, lib_constants.IP_VERSION_6):
scopemarks = ports_scopemark[ip_version]
iptables = iptables_manager.get_tables(ip_version)
iptables['mangle'].empty_chain('scope')
iptables['filter'].empty_chain('scope')
dont_block_external = ((ip_version == lib_constants.IP_VERSION_4) and self._snat_enabled and external_port)
for (device_name, mark) in scopemarks.items():
iptables['mangle'].add_rule('scope', self.address_scope_mangle_rule(device_name, mark))
if (dont_block_external and (device_name == external_device_name)):
continue
iptables['filter'].add_rule('scope', self.address_scope_filter_rule(device_name, mark))
for (subnet_id, prefix) in self.pd_subnets.items():
if (prefix != n_const.PROVISIONAL_IPV6_PD_PREFIX):
self._process_pd_iptables_rules(prefix, subnet_id)
def process_ports_address_scope_iptables(self):
ports_scopemark = self._get_address_scope_mark()
self._add_address_scope_mark(self.iptables_manager, ports_scopemark)
def _get_external_address_scope(self):
external_port = self.get_ex_gw_port()
if (not external_port):
return
scopes = external_port.get('address_scopes', {})
return scopes.get(str(lib_constants.IP_VERSION_4))
def process_external_port_address_scope_routing(self, iptables_manager):
if (not self._snat_enabled):
return
external_port = self.get_ex_gw_port()
if (not external_port):
return
external_devicename = self.get_external_device_name(external_port['id'])
rule = ('-o %s -m connmark --mark 0x0/0xffff0000 -j CONNMARK --save-mark --nfmask 0xffff0000 --ctmask 0xffff0000' % external_devicename)
iptables_manager.ipv4['mangle'].add_rule('POSTROUTING', rule)
address_scope = self._get_external_address_scope()
if (not address_scope):
return
rule = ('-o %s -m connmark --mark %s -j ACCEPT' % (external_devicename, self.get_address_scope_mark_mask(address_scope)))
iptables_manager.ipv4['nat'].add_rule('snat', rule)
def process_address_scope(self):
with self.iptables_manager.defer_apply():
self.process_ports_address_scope_iptables()
self.process_floating_ip_address_scope_rules()
@common_utils.exception_logger()
def process_delete(self):
'Process the delete of this router\n\n This method is the point where the agent requests that this router\n be deleted. This is a separate code path from process in that it\n avoids any changes to the qrouter namespace that will be removed\n at the end of the operation.\n\n :param agent: Passes the agent in order to send RPC messages.\n '
LOG.debug('process router delete')
if self.router_namespace.exists():
self._process_internal_ports()
self.agent.pd.sync_router(self.router['id'])
self._process_external_on_delete()
else:
LOG.warning("Can't gracefully delete the router %s: no router namespace found.", self.router['id'])
@common_utils.exception_logger()
def process(self):
'Process updates to this router\n\n This method is the point where the agent requests that updates be\n applied to this router.\n\n :param agent: Passes the agent in order to send RPC messages.\n '
LOG.debug('process router updates')
self._process_internal_ports()
self.agent.pd.sync_router(self.router['id'])
self.process_external()
self.process_address_scope()
self.routes_updated(self.routes, self.router['routes'])
self.routes = self.router['routes']
self.ex_gw_port = self.get_ex_gw_port()
self.fip_map = dict([(fip['floating_ip_address'], fip['fixed_ip_address']) for fip in self.get_floating_ips()])

Xet Storage Details

Size:
41.3 kB
·
Xet hash:
efb776c9e7b820e4d728eed849a87a6f7d0f60157f088bdcd0c44f220287f719

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.