openstack
/
deb-python-os-vif
Code Issues Proposed changes

Adds Windows support for OvsPlugin 

OVS has been ported to Windows since Kilo, and this
patch is necessary in order to bind OVS VIFs on
instances spawned on Hyper-V.

Partially-Implements: blueprint hyper-v-ovs-vif

Change-Id: Ia33e76a28f96fb94e6fdeedc4947b8a353e3d5bc
This commit is contained in:
Claudiu Belu 2016-07-19 22:19:09 +03:00 committed by Sahid Orentino Ferdjaoui
parent b088d21b91
commit 0901bf9c8c
3 changed files with 128 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
vif_plug_ovs/constants.py
View File

@ -14,3 +14,5 @@ OVS_VHOSTUSER_INTERFACE_TYPE = 'dpdkvhostuser'
OVS_DATAPATH_SYSTEM = 'system'
OVS_DATAPATH_NETDEV = 'netdev'
PLATFORM_WIN32 = 'win32'

58
vif_plug_ovs/ovs.py
View File

@ -17,6 +17,8 @@
# License for the specific language governing permissions and limitations
# under the License.
import sys
from os_vif import objects
from os_vif import plugin
from oslo_config import cfg
@ -80,16 +82,22 @@ class OvsPlugin(plugin.PluginBase):
max_version="1.0")
])
def _plug_vhostuser(self, vif, instance_info):
linux_net.ensure_ovs_bridge(vif.network.bridge,
constants.OVS_DATAPATH_NETDEV)
def _create_vif_port(self, vif, vif_name, instance_info, **kwargs):
linux_net.create_ovs_vif_port(
vif.network.bridge,
OvsPlugin.gen_port_name("vhu", vif.id),
vif_name,
vif.port_profile.interface_id,
vif.address, instance_info.uuid,
self.config.network_device_mtu,
timeout=self.config.ovs_vsctl_timeout,
**kwargs)
def _plug_vhostuser(self, vif, instance_info):
linux_net.ensure_ovs_bridge(vif.network.bridge,
constants.OVS_DATAPATH_NETDEV)
vif_name = OvsPlugin.gen_port_name("vhu", vif.id)
self._create_vif_port(
vif, vif_name, instance_info,
interface_type=constants.OVS_VHOSTUSER_INTERFACE_TYPE)
def _plug_bridge(self, vif, instance_info):
@ -111,13 +119,15 @@ class OvsPlugin(plugin.PluginBase):
linux_net.add_bridge_port(vif.bridge_name, v1_name)
linux_net.ensure_ovs_bridge(vif.network.bridge,
constants.OVS_DATAPATH_SYSTEM)
linux_net.create_ovs_vif_port(
vif.network.bridge,
v2_name,
vif.port_profile.interface_id,
vif.address, instance_info.uuid,
self.config.network_device_mtu,
timeout=self.config.ovs_vsctl_timeout)
self._create_vif_port(vif, v2_name, instance_info)
def _plug_vif_windows(self, vif, instance_info):
"""Create a per-VIF OVS port."""
if not linux_net.device_exists(vif.id):
linux_net.ensure_ovs_bridge(vif.network.bridge,
constants.OVS_DATAPATH_SYSTEM)
self._create_vif_port(vif, vif.id, instance_info)
def plug(self, vif, instance_info):
if not hasattr(vif, "port_profile"):
@ -128,10 +138,16 @@ class OvsPlugin(plugin.PluginBase):
profile=vif.port_profile.__class__.__name__)
if isinstance(vif, objects.vif.VIFOpenVSwitch):
linux_net.ensure_ovs_bridge(vif.network.bridge,
constants.OVS_DATAPATH_SYSTEM)
if sys.platform != constants.PLATFORM_WIN32:
linux_net.ensure_ovs_bridge(vif.network.bridge,
constants.OVS_DATAPATH_SYSTEM)
else:
self._plug_vif_windows(vif, instance_info)
elif isinstance(vif, objects.vif.VIFBridge):
self._plug_bridge(vif, instance_info)
if sys.platform != constants.PLATFORM_WIN32:
self._plug_bridge(vif, instance_info)
else:
self._plug_vif_windows(vif, instance_info)
elif isinstance(vif, objects.vif.VIFVHostUser):
self._plug_vhostuser(vif, instance_info)
@ -154,6 +170,12 @@ class OvsPlugin(plugin.PluginBase):
linux_net.delete_ovs_vif_port(vif.network.bridge, v2_name,
timeout=self.config.ovs_vsctl_timeout)
def _unplug_vif_windows(self, vif, instance_info):
"""Remove port from OVS."""
linux_net.delete_ovs_vif_port(vif.network.bridge, vif.id,
timeout=self.config.ovs_vsctl_timeout)
def unplug(self, vif, instance_info):
if not hasattr(vif, "port_profile"):
raise exception.MissingPortProfile()
@ -163,8 +185,12 @@ class OvsPlugin(plugin.PluginBase):
profile=vif.port_profile.__class__.__name__)
if isinstance(vif, objects.vif.VIFOpenVSwitch):
pass # no special unplugging required
if sys.platform == constants.PLATFORM_WIN32:
self._unplug_vif_windows(vif, instance_info)
elif isinstance(vif, objects.vif.VIFBridge):
self._unplug_bridge(vif, instance_info)
if sys.platform != constants.PLATFORM_WIN32:
self._unplug_bridge(vif, instance_info)
else:
self._unplug_vif_windows(vif, instance_info)
elif isinstance(vif, objects.vif.VIFVHostUser):
self._unplug_vhostuser(vif, instance_info)

109
vif_plug_ovs/tests/test_plugin.py
View File

@ -88,9 +88,26 @@ class PluginTest(testtools.TestCase):
name='demo',
uuid='f0000000-0000-0000-0000-000000000001')
@mock.patch.object(linux_net, 'create_ovs_vif_port')
def test_create_vif_port(self, mock_create_ovs_vif_port):
plugin = ovs.OvsPlugin.load('ovs')
plugin._create_vif_port(
self.vif_ovs, mock.sentinel.vif_name, self.instance,
interface_type=constants.OVS_VHOSTUSER_INTERFACE_TYPE)
mock_create_ovs_vif_port.assert_called_once_with(
self.vif_ovs.network.bridge, mock.sentinel.vif_name,
self.vif_ovs.port_profile.interface_id,
self.vif_ovs.address, self.instance.uuid,
plugin.config.network_device_mtu,
timeout=plugin.config.ovs_vsctl_timeout,
interface_type=constants.OVS_VHOSTUSER_INTERFACE_TYPE)
def test_plug_ovs(self):
with mock.patch.object(linux_net, 'ensure_ovs_bridge') as (
ensure_ovs_bridge):
with nested(
mock.patch.object(ovs, 'sys'),
mock.patch.object(linux_net, 'ensure_ovs_bridge')
) as (mock_sys, ensure_ovs_bridge):
mock_sys.platform = 'linux'
plug_bridge_mock = mock.Mock()
plugin = ovs.OvsPlugin.load("ovs")
plugin._plug_bridge = plug_bridge_mock
@ -108,36 +125,62 @@ class PluginTest(testtools.TestCase):
'ensure_bridge': [mock.call('qbrvif-xxx-yyy')],
'add_bridge_port': [mock.call('qbrvif-xxx-yyy',
'qvbb679325f-ca')],
'create_ovs_vif_port': [mock.call(
'br0', 'qvob679325f-ca',
'e65867e0-9340-4a7f-a256-09af6eb7a3aa',
'ca:fe:de:ad:be:ef',
'f0000000-0000-0000-0000-000000000001',
1500,
timeout=120)],
'_create_vif_port': [mock.call(
self.vif_ovs_hybrid, 'qvob679325f-ca',
self.instance)],
'ensure_ovs_bridge': [mock.call('br0',
constants.OVS_DATAPATH_SYSTEM)]
}
with nested(
mock.patch.object(ovs, 'sys'),
mock.patch.object(linux_net, 'ensure_bridge'),
mock.patch.object(linux_net, 'device_exists',
return_value=False),
mock.patch.object(linux_net, 'create_veth_pair'),
mock.patch.object(linux_net, 'add_bridge_port'),
mock.patch.object(linux_net, 'create_ovs_vif_port'),
mock.patch.object(ovs.OvsPlugin, '_create_vif_port'),
mock.patch.object(linux_net, 'ensure_ovs_bridge')
) as (ensure_bridge, device_exists, create_veth_pair,
add_bridge_port, create_ovs_vif_port, ensure_ovs_bridge):
) as (mock_sys, ensure_bridge, device_exists, create_veth_pair,
add_bridge_port, _create_vif_port, ensure_ovs_bridge):
mock_sys.platform = 'linux'
plugin = ovs.OvsPlugin.load("ovs")
plugin.plug(self.vif_ovs_hybrid, self.instance)
ensure_bridge.assert_has_calls(calls['ensure_bridge'])
device_exists.assert_has_calls(calls['device_exists'])
create_veth_pair.assert_has_calls(calls['create_veth_pair'])
add_bridge_port.assert_has_calls(calls['add_bridge_port'])
create_ovs_vif_port.assert_has_calls(calls['create_ovs_vif_port'])
_create_vif_port.assert_has_calls(calls['_create_vif_port'])
ensure_ovs_bridge.assert_has_calls(calls['ensure_ovs_bridge'])
def _check_plug_ovs_windows(self, vif):
calls = {
'device_exists': [mock.call(vif.id)],
'_create_vif_port': [mock.call(vif, vif.id, self.instance)],
'ensure_ovs_bridge': [mock.call('br0',
constants.OVS_DATAPATH_SYSTEM)]
}
with nested(
mock.patch.object(ovs, 'sys'),
mock.patch.object(linux_net, 'device_exists',
return_value=False),
mock.patch.object(ovs.OvsPlugin, '_create_vif_port'),
mock.patch.object(linux_net, 'ensure_ovs_bridge')
) as (mock_sys, device_exists, _create_vif_port, ensure_ovs_bridge):
mock_sys.platform = constants.PLATFORM_WIN32
plugin = ovs.OvsPlugin.load("ovs")
plugin.plug(vif, self.instance)
device_exists.assert_has_calls(calls['device_exists'])
_create_vif_port.assert_has_calls(calls['_create_vif_port'])
ensure_ovs_bridge.assert_has_calls(calls['ensure_ovs_bridge'])
def test_plug_ovs_windows(self):
self._check_plug_ovs_windows(self.vif_ovs)
def test_plug_ovs_bridge_windows(self):
self._check_plug_ovs_windows(self.vif_ovs_hybrid)
def test_unplug_ovs(self):
unplug_bridge_mock = mock.Mock()
plugin = ovs.OvsPlugin.load("ovs")
@ -152,35 +195,51 @@ class PluginTest(testtools.TestCase):
timeout=120)]
}
with nested(
mock.patch.object(ovs, 'sys'),
mock.patch.object(linux_net, 'delete_bridge'),
mock.patch.object(linux_net, 'delete_ovs_vif_port')
) as (delete_bridge, delete_ovs_vif_port):
) as (mock_sys, delete_bridge, delete_ovs_vif_port):
mock_sys.platform = 'linux'
plugin = ovs.OvsPlugin.load("ovs")
plugin.unplug(self.vif_ovs_hybrid, self.instance)
delete_bridge.assert_has_calls(calls['delete_bridge'])
delete_ovs_vif_port.assert_has_calls(calls['delete_ovs_vif_port'])
def _check_unplug_ovs_windows(self, vif):
with nested(
mock.patch.object(ovs, 'sys'),
mock.patch.object(linux_net, 'delete_ovs_vif_port')
) as (mock_sys, delete_ovs_vif_port):
mock_sys.platform = constants.PLATFORM_WIN32
plugin = ovs.OvsPlugin.load("ovs")
plugin.unplug(vif, self.instance)
delete_ovs_vif_port.assert_called_once_with(
'br0', vif.id, timeout=120)
def test_unplug_ovs_windows(self):
self._check_unplug_ovs_windows(self.vif_ovs)
def test_unplug_ovs_bridge_windows(self):
self._check_unplug_ovs_windows(self.vif_ovs_hybrid)
def test_plug_ovs_vhostuser(self):
calls = {
'create_ovs_vif_port': [mock.call(
'br0', 'vhub679325f-ca',
'e65867e0-9340-4a7f-a256-09af6eb7a3aa',
'ca:fe:de:ad:be:ef',
'f0000000-0000-0000-0000-000000000001',
1500,
interface_type='dpdkvhostuser',
timeout=120)],
'_create_vif_port': [mock.call(
self.vif_vhostuser, 'vhub679325f-ca',
self.instance,
interface_type='dpdkvhostuser')],
'ensure_ovs_bridge': [mock.call('br0',
constants.OVS_DATAPATH_NETDEV)]
}
with nested(
mock.patch.object(linux_net, 'create_ovs_vif_port'),
mock.patch.object(ovs.OvsPlugin, '_create_vif_port'),
mock.patch.object(linux_net, 'ensure_ovs_bridge')
) as (create_ovs_vif_port, ensure_ovs_bridge):
) as (_create_vif_port, ensure_ovs_bridge):
plugin = ovs.OvsPlugin.load("ovs")
plugin.plug(self.vif_vhostuser, self.instance)
create_ovs_vif_port.assert_has_calls(calls['create_ovs_vif_port'])
_create_vif_port.assert_has_calls(calls['_create_vif_port'])
ensure_ovs_bridge.assert_has_calls(calls['ensure_ovs_bridge'])
def test_unplug_ovs_vhostuser(self):