def _generate_port_list(self, context, method, seg_id,
interface, pp_dict,
logical_switch_uuid, gw_connection=None):
port_list = []
vlan_bindings = db.get_all_vlan_bindings_by_physical_port(
context, pp_dict)
if method == "CREATE":
if not seg_id:
vlan_id = interface.get('segmentation_id')
else:
vlan_id = int(seg_id)
vlan_dict = {'vlan': vlan_id,
'logical_switch_uuid': logical_switch_uuid}
port_list.append(vlan_dict)
for vlan_binding in vlan_bindings:
if vlan_binding.get('vlan') == vlan_id:
msg = _('Duplicate segmentation ID for the interface '
'name=%(name)s uuid=%(uuid)s'
) % {'name': pp_dict['name'],
'uuid': pp_dict['uuid']}
raise l2gw_exc.L2GatewayDuplicateSegmentationID(message=msg
)
vlan_dict = {'vlan': vlan_binding.get('vlan'),
'logical_switch_uuid': vlan_binding.get(
'logical_switch_uuid')}
port_list.append(vlan_dict)
physical_port = self._get_dict(
ovsdb_schema.PhysicalPort(
uuid=pp_dict.get('uuid'),
name=pp_dict.get('interface_name'),
phys_switch_id=pp_dict.get('physical_switch_id'),
vlan_binding_dicts=None,
port_fault_status=None))
physical_port['vlan_bindings'] = port_list
else:
vlan_id = gw_connection.get('segmentation_id')
if not vlan_id:
vlan_id = interface.get('segmentation_id')
for vlan_binding in vlan_bindings:
if ((vlan_binding.get('vlan') == vlan_id) and (
vlan_binding.get(
'logical_switch_uuid') == logical_switch_uuid)):
continue
else:
vlan_dict = {
'vlan': vlan_binding.get('vlan'),
'logical_switch_uuid':
vlan_binding.get('logical_switch_uuid')}
port_list.append(vlan_dict)
physical_port = self._get_dict(
ovsdb_schema.PhysicalPort(
uuid=pp_dict.get('uuid'),
name=pp_dict.get('interface_name'),
phys_switch_id=pp_dict.get('physical_switch_id'),
vlan_binding_dicts=None,
port_fault_status=None))
physical_port['vlan_bindings'] = port_list
return physical_port
def _process_physical_port(self, uuid, uuid_dict, port_map, data_dict):
"""Processes Physical_Port record from the OVSDB event."""
new_row = uuid_dict.get('new', None)
old_row = uuid_dict.get('old', None)
if new_row:
port_fault_status = new_row.get('port_fault_status')
if type(port_fault_status) is list:
port_fault_status = None
port = ovsdb_schema.PhysicalPort(uuid, new_row.get('name'), None,
None,
port_fault_status)
switch_id = port_map.get(uuid, None)
if switch_id:
port.physical_switch_id = switch_id
# Update the vlan bindings
outer_binding_list = new_row.get('vlan_bindings')
# First element is "map"
outer_binding_list.remove(outer_binding_list[0])
vlan_bindings = []
if len(outer_binding_list) > 0:
for binding in outer_binding_list:
if len(binding) > 0:
for element in binding:
vlan = element[0]
inner_most_list = element[1]
ls_id = inner_most_list[1]
vb = ovsdb_schema.VlanBinding(vlan, ls_id).__dict__
vlan_bindings.append(vb)
port.vlan_bindings = vlan_bindings
if old_row:
modified_physical_ports = data_dict.get(
'modified_physical_ports')
modified_physical_ports.append(port)
else:
new_physical_ports = data_dict.get(
'new_physical_ports')
new_physical_ports.append(port)
elif old_row:
# Port is deleted permanently from OVSDB server
port_fault_status = old_row.get('port_fault_status')
if type(port_fault_status) is list:
port_fault_status = None
port = ovsdb_schema.PhysicalPort(uuid, old_row.get('name'), None,
None,
port_fault_status)
deleted_physical_ports = data_dict.get('deleted_physical_ports')
deleted_physical_ports.append(port)
def test_get_bindings_to_update1(self):
"""Test case to test _get_bindings_to_update."""
fake_op_method = 'CREATE'
with mock.patch.object(
ovsdb_writer.OVSDBWriter,
'_form_logical_switch') as form_ls, \
mock.patch.object(
ovsdb_writer.OVSDBWriter,
'_form_physical_locators') as form_pl, \
mock.patch.object(
ovsdb_writer.OVSDBWriter, '_form_ports') as form_pp, \
mock.patch.object(
ovsdb_schema, 'LogicalSwitch') as mock_ls, \
mock.patch.object(
ovsdb_schema, 'PhysicalLocator') as mock_pl, \
mock.patch.object(
ovsdb_schema, 'UcastMacsRemote') as mock_ucmr, \
mock.patch.object(ovsdb_schema, 'PhysicalPort') as mock_pp:
ls = mock_ls.return_value = ovsdb_schema.LogicalSwitch(
'ls_uuid', 'ls_name', 'ls_key', 'ls_desc')
pl = mock_pl.return_value = ovsdb_schema.PhysicalLocator(
'pl_uuid', 'pl_dst_ip')
mock_ucmr.return_value = ovsdb_schema.UcastMacsRemote(
'ucmr_uuid', 'ucmr_mac', 'ucmr_ls_id', 'ucmr_pl_id', 'ucmr_ip')
pp = mock_pp.return_value = ovsdb_schema.PhysicalPort(
'pp_uuid', 'pp_name', 'pp_ps_id', 'pp_vlan_bindings')
form_ls.return_value = ['uuid', ls.uuid]
self.l2gw_ovsdb._get_bindings_to_update(
mock.MagicMock(), [{
'uuid': 'uuid',
'dst_ip': 'dst_ip'
}], mock.MagicMock(), [{
'uuid': 'uuid',
'name': 'name',
'physical_switch_id': 'physical_switch_id',
'vlan_bindings': 'vlan_bindings',
'port_fault_status': 'port_fault_status'
}], fake_op_method)
form_ls.assert_called_with(ls, mock.ANY)
form_pl.assert_called_with(['uuid', ls.uuid], [pl], mock.ANY,
mock.ANY)
form_pp.assert_called_with(['uuid', ls.uuid], [pp], mock.ANY,
fake_op_method)
def _get_bindings_to_update(self, l_switch_dict, locator_dicts, mac_dicts,
port_dicts):
# For connection-create, there are two cases to be handled
# Case 1: VMs exist in a network on compute nodes.
# Connection request will contain locators, ports, MACs and
# network.
# Case 2: VMs do not exist in a network on compute nodes.
# Connection request will contain only ports and network
#
# For connection-delete, we do not need logical_switch and locators
# information, we just need ports.
locator_list = []
port_list = []
ls_list = []
logical_switch = None
# Convert logical switch dict to a class object
if l_switch_dict:
logical_switch = ovsdb_schema.LogicalSwitch(
l_switch_dict['uuid'], l_switch_dict['name'],
l_switch_dict['key'], l_switch_dict['description'])
# Convert locator dicts into class objects
for locator in locator_dicts:
locator_list.append(
ovsdb_schema.PhysicalLocator(locator['uuid'],
locator['dst_ip']))
# Convert MAC dicts into class objects. mac_dicts is a dictionary with
# locator VTEP IP as the key and list of MACs as the value.
locator_macs = {}
for locator_ip, mac_list in mac_dicts.items():
mac_object_list = []
for mac_dict in mac_list:
mac_object = ovsdb_schema.UcastMacsRemote(
mac_dict['uuid'], mac_dict['mac'],
mac_dict['logical_switch_id'],
mac_dict['physical_locator_id'], mac_dict['ip_address'])
mac_object_list.append(mac_object)
locator_macs[locator_ip] = mac_object_list
# Convert port dicts into class objects
for port in port_dicts:
phys_port = ovsdb_schema.PhysicalPort(port['uuid'], port['name'],
port['physical_switch_id'],
port['vlan_bindings'],
port['port_fault_status'])
port_list.append(phys_port)
bindings = []
bindings.append(n_const.OVSDB_SCHEMA_NAME)
# Form the query.
commit_dict = {"op": "commit", "durable": True}
params = [n_const.OVSDB_SCHEMA_NAME]
# Use logical switch
if logical_switch:
ls_list = self._form_logical_switch(logical_switch, params)
# Use physical locators
if locator_list:
self._form_physical_locators(ls_list, locator_list, locator_macs,
params)
# Use ports
self._form_ports(ls_list, port_list, params)
params.append(commit_dict)
return params
