149 lines
5.5 KiB
Python
149 lines
5.5 KiB
Python
# Copyright 2016 Red Hat, Inc
|
|
# All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
from collections import defaultdict
|
|
|
|
from neutron_lib import exceptions
|
|
|
|
from neutron._i18n import _
|
|
|
|
|
|
class VifIdNotFound(exceptions.NeutronException):
|
|
message = _('VIF ID %(vif_id)s not found in any network managed by '
|
|
'VLAN Manager')
|
|
|
|
|
|
class MappingAlreadyExists(exceptions.NeutronException):
|
|
message = _('VLAN mapping for network with id %(net_id)s and '
|
|
'segmentation id %(seg_id)s already exists')
|
|
|
|
|
|
class MappingNotFound(exceptions.NeutronException):
|
|
message = _('Mapping VLAN for network %(net_id)s with segmentation id '
|
|
'%(seg_id)s not found.')
|
|
|
|
|
|
class NotUniqMapping(exceptions.NeutronException):
|
|
message = _('Mapping VLAN for network %(net_id)s should be unique.')
|
|
|
|
|
|
class LocalVLANMapping(object):
|
|
def __init__(self, vlan, network_type, physical_network, segmentation_id,
|
|
vif_ports=None):
|
|
self.vlan = vlan
|
|
self.network_type = network_type
|
|
self.physical_network = physical_network
|
|
self.segmentation_id = segmentation_id
|
|
self.vif_ports = vif_ports or {}
|
|
# set of tunnel ports on which packets should be flooded
|
|
self.tun_ofports = set()
|
|
|
|
def __str__(self):
|
|
return ("lv-id = %s type = %s phys-net = %s phys-id = %s" %
|
|
(self.vlan, self.network_type, self.physical_network,
|
|
self.segmentation_id))
|
|
|
|
def __eq__(self, other):
|
|
return all(hasattr(other, a) and getattr(self, a) == getattr(other, a)
|
|
for a in ['vlan',
|
|
'network_type',
|
|
'physical_network',
|
|
'segmentation_id',
|
|
'vif_ports'])
|
|
|
|
def __hash__(self):
|
|
return id(self)
|
|
|
|
|
|
class LocalVlanManager(object):
|
|
"""Singleton manager that maps internal VLAN mapping to external network
|
|
segmentation ids.
|
|
"""
|
|
|
|
def __new__(cls):
|
|
if not hasattr(cls, '_instance'):
|
|
cls._instance = super(LocalVlanManager, cls).__new__(cls)
|
|
return cls._instance
|
|
|
|
def __init__(self):
|
|
if not hasattr(self, 'mapping'):
|
|
self.mapping = defaultdict(dict)
|
|
|
|
def __contains__(self, key):
|
|
return key in self.mapping
|
|
|
|
def __iter__(self):
|
|
for value in list(self.mapping.values()):
|
|
yield value
|
|
|
|
def items(self):
|
|
for item in self.mapping.items():
|
|
yield item
|
|
|
|
def add(self, net_id, vlan, network_type, physical_network,
|
|
segmentation_id, vif_ports=None):
|
|
try:
|
|
if self.get(net_id, segmentation_id):
|
|
raise MappingAlreadyExists(
|
|
net_id=net_id, seg_id=segmentation_id)
|
|
except MappingNotFound:
|
|
pass
|
|
self.mapping[net_id][segmentation_id] = LocalVLANMapping(
|
|
vlan, network_type, physical_network, segmentation_id, vif_ports)
|
|
|
|
def get_net_and_segmentation_id(self, vif_id, net_uuid=None):
|
|
# TODO(sahid): We should improve algorithm if net_uuid is passed.
|
|
for network_id, vlan_mappings in self.mapping.items():
|
|
for segmentation_id, vlan_mapping in vlan_mappings.items():
|
|
if vif_id in vlan_mapping.vif_ports:
|
|
return network_id, segmentation_id
|
|
raise VifIdNotFound(vif_id=vif_id)
|
|
|
|
def get(self, net_id, segmentation_id):
|
|
if net_id in self.mapping and segmentation_id in self.mapping[net_id]:
|
|
return self.mapping[net_id][segmentation_id]
|
|
raise MappingNotFound(net_id=net_id, seg_id=segmentation_id)
|
|
|
|
def get_segments(self, net_id):
|
|
if net_id not in self.mapping:
|
|
raise MappingNotFound(net_id=net_id, seg_id="<all>")
|
|
return self.mapping[net_id]
|
|
|
|
def pop(self, net_id, segmentation_id):
|
|
if self.get(net_id, segmentation_id):
|
|
ret = self.mapping[net_id].pop(segmentation_id)
|
|
# if it's the last seg id for a network, let's removed the network
|
|
# entry as-well.
|
|
if len(self.mapping[net_id]) == 0:
|
|
del self.mapping[net_id]
|
|
return ret
|
|
|
|
def update_segmentation_id(self, net_id, segmentation_id):
|
|
"""Returns tuple with segmentation id, lvm in success or None, None"""
|
|
if len(self.get_segments(net_id)) != 1:
|
|
# Update of segmentation id can work only if network has one
|
|
# segment. This is a design issue that should be fixed in
|
|
# future. We should not accept segmentation update for a network.
|
|
raise NotUniqMapping(net_id=net_id)
|
|
mapping = list(self.mapping[net_id].values())[0]
|
|
if mapping.segmentation_id == segmentation_id:
|
|
# No need to update
|
|
return None, None
|
|
old = mapping.segmentation_id
|
|
del self.mapping[net_id][old]
|
|
mapping.segmentation_id = segmentation_id
|
|
self.mapping[net_id][segmentation_id] = mapping
|
|
return old, mapping
|