class NetnsMonitor(object):
def __init__(self, project, vm_obj, vmi_obj, ifname, **kwargs):
self.project = project
self.vm = vm_obj
self.vmi = vmi_obj
self.ifname = ifname
self.vmi_out = kwargs.get('vmi_out', None)
self.ifname_out = kwargs.get('ifname_out', None)
vrouter_semaphore = gevent.lock.Semaphore()
self.vrouter_client = ContrailVRouterApi(doconnect=True,
semaphore=vrouter_semaphore)
self.vrouter_client.connect()
self.vrouter_agent_connection = self.vrouter_client._client
def keepalive(self):
self.vrouter_client.periodic_connection_check()
current_agent_connection = self.vrouter_client._client
if not current_agent_connection:
# vrouter agent is down, Try checking...
return
if self.vrouter_agent_connection != current_agent_connection:
# Initial connection object to vrouter agent is different from
# the current object, vrouter agent is restarted, plug the netns
# vif's again.
interface_register(self.vm,
self.vmi,
self.ifname,
project=self.project)
if self.vmi_out:
interface_register(self.vm,
self.vmi_out,
self.ifname_out,
project=self.project)
self.vrouter_agent_connection = current_agent_connection
def monitor(self):
while True:
gevent.sleep(INTERVAL)
self.keepalive()
class NetnsMonitor(object):
def __init__(self, project, vm_obj, vmi_obj, ifname, **kwargs):
self.project = project
self.vm = vm_obj
self.vmi = vmi_obj
self.ifname = ifname
self.vmi_out = kwargs.get('vmi_out', None)
self.ifname_out = kwargs.get('ifname_out', None)
vrouter_semaphore = gevent.lock.Semaphore()
self.vrouter_client = ContrailVRouterApi(doconnect=True,
semaphore=vrouter_semaphore)
self.vrouter_client.connect()
self.vrouter_agent_connection = self.vrouter_client._client
def keepalive(self):
self.vrouter_client.periodic_connection_check()
current_agent_connection = self.vrouter_client._client
if not current_agent_connection:
# vrouter agent is down, Try checking...
return
if self.vrouter_agent_connection != current_agent_connection:
# Initial connection object to vrouter agent is different from
# the current object, vrouter agent is restarted, plug the netns
# vif's again.
interface_register(self.vm, self.vmi, self.ifname,
project=self.project)
if self.vmi_out:
interface_register(self.vm, self.vmi_out, self.ifname_out,
project=self.project)
self.vrouter_agent_connection = current_agent_connection
def monitor(self):
while True:
gevent.sleep(INTERVAL)
self.keepalive()
class VRouterVIFDriver(LibvirtBaseVIFDriver):
"""VIF driver for VRouter when running Neutron."""
PORT_TYPE = 'NovaVMPort'
def __init__(self, get_connection):
super(VRouterVIFDriver, self).__init__(get_connection)
self._vrouter_client = ContrailVRouterApi()
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
def get_config(self, instance, vif, image_meta, inst_type):
conf = super(VRouterVIFDriver, self).get_config(instance, vif,
image_meta, inst_type)
dev = self.get_vif_devname(vif)
designer.set_vif_host_backend_ethernet_config(conf, dev)
designer.set_vif_bandwidth_config(conf, inst_type)
return conf
def plug(self, instance, vif):
dev = self.get_vif_devname(vif)
try:
linux_net.create_tap_dev(dev)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
kwargs = {
'ip_address': vif['network']['subnets'][0]['ips'][0]['address'],
'vn_id': vif['network']['id'],
'display_name': instance['display_name'],
'hostname': instance['hostname'],
'host': instance['host'],
'vm_project_id': instance['project_id'],
'port_type': self.PORT_TYPE,
}
try:
result = self._vrouter_client.add_port(instance['uuid'],
vif['id'],
dev,
vif['address'],
**kwargs)
if not result:
LOG.exception(_LE("Failed while plugging vif"),
instance=instance)
except TApplicationException:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
def unplug(self, instance, vif):
dev = self.get_vif_devname(vif)
try:
self._vrouter_client.delete_port(vif['id'])
linux_net.delete_net_dev(dev)
except (TApplicationException, processutils.ProcessExecutionError):
LOG.exception(_LE("Failed while unplugging vif"),
instance=instance)
class OpenContrailVIFDriver(object):
def __init__(self):
self._vrouter_semaphore = eventlet.semaphore.Semaphore()
self._vrouter_client = ContrailVRouterApi(
doconnect=True, semaphore=self._vrouter_semaphore)
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
def plug(self, instance, vif):
vif_type = vif['type']
LOG.debug('Plug vif_type=%(vif_type)s instance=%(instance)s '
'vif=%(vif)s',
{'vif_type': vif_type, 'instance': instance,
'vif': vif})
if_local_name = 'veth%s' % vif['id'][:8]
if_remote_name = 'ns%s' % vif['id'][:8]
# Device already exists so return.
if linux_net.device_exists(if_local_name):
return
undo_mgr = utils.UndoManager()
try:
utils.execute('ip', 'link', 'add', if_local_name, 'type', 'veth',
'peer', 'name', if_remote_name, run_as_root=True)
undo_mgr.undo_with(lambda: utils.execute(
'ip', 'link', 'delete', if_local_name, run_as_root=True))
utils.execute('ip', 'link', 'set', if_remote_name, 'address',
vif['address'], run_as_root=True)
except Exception:
LOG.exception("Failed to configure network")
msg = _('Failed to setup the network, rolling back')
undo_mgr.rollback_and_reraise(msg=msg, instance=instance)
def attach(self, instance, vif, container_id):
vif_type = vif['type']
LOG.debug('Attach vif_type=%(vif_type)s instance=%(instance)s '
'vif=%(vif)s',
{'vif_type': vif_type, 'instance': instance,
'vif': vif})
if_local_name = 'veth%s' % vif['id'][:8]
if_remote_name = 'ns%s' % vif['id'][:8]
undo_mgr = utils.UndoManager()
undo_mgr.undo_with(lambda: utils.execute(
'ip', 'link', 'delete', if_local_name, run_as_root=True))
ipv4_address, ipv4_netmask, ipv4_gateway = self._retrieve_ip_address(
vif, 4)
ipv6_address, ipv6_netmask, ipv6_gateway = self._retrieve_ip_address(
vif, 6)
ipv4_address = ipv4_address or '0.0.0.0'
params = {
'ip_address': ipv4_address,
'vn_id': vif['network']['id'],
'display_name': instance['display_name'],
'hostname': instance['hostname'],
'host': instance['host'],
'vm_project_id': instance['project_id'],
'port_type': 'NovaVMPort',
'ip6_address': ipv6_address,
}
try:
utils.execute('ip', 'link', 'set', if_remote_name, 'netns',
container_id, run_as_root=True)
result = self._vrouter_client.add_port(
instance['uuid'], vif['id'],
if_local_name, vif['address'], **params)
if not result:
# follow the exception path
raise RuntimeError('add_port returned %s' % str(result))
utils.execute('ip', 'link', 'set', if_local_name, 'up',
run_as_root=True)
except Exception:
LOG.exception("Failed to attach the network")
msg = _('Failed to attach the network, rolling back')
undo_mgr.rollback_and_reraise(msg=msg, instance=instance)
try:
utils.execute('ip', 'netns', 'exec', container_id, 'ip', 'link',
'set', if_remote_name, 'address', vif['address'],
run_as_root=True)
if ipv6_address:
ip = ipv6_address + "/" + ipv6_netmask
gateway = ipv6_gateway
utils.execute('ip', 'netns', 'exec', container_id, 'ifconfig',
if_remote_name, 'inet6', 'add', ip,
run_as_root=True)
utils.execute('ip', 'netns', 'exec', container_id, 'ip', '-6',
'route', 'replace', 'default', 'via', gateway,
'dev', if_remote_name, run_as_root=True)
if ipv4_address != '0.0.0.0':
ip = ipv4_address + "/" + ipv4_netmask
gateway = ipv4_gateway
utils.execute('ip', 'netns', 'exec', container_id, 'ifconfig',
if_remote_name, ip, run_as_root=True)
utils.execute('ip', 'netns', 'exec', container_id, 'ip',
'route', 'replace', 'default', 'via', gateway,
'dev', if_remote_name, run_as_root=True)
utils.execute('ip', 'netns', 'exec', container_id, 'ip', 'link',
'set', if_remote_name, 'up', run_as_root=True)
except Exception:
LOG.exception("Failed to attach vif", instance=instance)
def _retrieve_ip_address(self, vif, version):
address = None
netmask = None
gateway = None
if 'subnets' in vif['network']:
subnets = vif['network']['subnets']
for subnet in subnets:
ips = subnet['ips'][0]
if (ips['version'] == version):
if ips['address'] is not None:
address = ips['address']
netmask = subnet['cidr'].split('/')[1]
gateway = subnet['gateway']['address']
return address, netmask, gateway
def unplug(self, instance, vif):
vif_type = vif['type']
if_local_name = 'veth%s' % vif['id'][:8]
LOG.debug('Unplug vif_type=%(vif_type)s instance=%(instance)s '
'vif=%(vif)s',
{'vif_type': vif_type, 'instance': instance,
'vif': vif})
try:
self._vrouter_client.delete_port(vif['id'])
if linux_net.device_exists(if_local_name):
utils.execute('ip', 'link', 'delete', if_local_name,
run_as_root=True)
except Exception:
LOG.exception("Delete port failed", instance=instance)
class VRouterApiTest(unittest.TestCase):
def setUp(self):
self._api = ContrailVRouterApi()
def test_create_port(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
self._api.add_port(str(uuid.uuid1()), str(uuid.uuid1()), 'tapX',
'aa:bb:cc:ee:ff:00')
self.assertTrue(mock_client.AddPort.called)
def test_delete_port(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
vm_uuid = uuid.uuid1()
vif_uuid = uuid.uuid1()
self._api.add_port(str(vm_uuid), str(vif_uuid), 'tapX',
'aa:bb:cc:ee:ff:00')
self.assertTrue(mock_client.AddPort.called)
self.assertTrue(self._api._ports[vif_uuid])
self._api.delete_port(str(vif_uuid))
self.assertTrue(mock_client.DeletePort.called)
def test_resynchronize(self):
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = None
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
port1 = ttypes.Port(self._api._uuid_string_to_hex(vif_uuid),
self._api._uuid_string_to_hex(vm_uuid),
'tapX', '0.0.0.0', [0] * 16, 'aa:bb:cc:ee:ff:00')
self._api.add_port(vm_uuid, vif_uuid, 'tapX', 'aa:bb:cc:ee:ff:00')
mock_client = mock.Mock()
self._api._rpc_client_instance.return_value = mock_client
self._api.periodic_connection_check()
mock_client.AddPort.assert_called_with([port1])
def test_resynchronize_multi_ports(self):
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = None
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
port1 = ttypes.Port(self._api._uuid_string_to_hex(vif_uuid),
self._api._uuid_string_to_hex(vm_uuid),
'tapX', '0.0.0.0', [0] * 16, 'aa:bb:cc:ee:ff:00')
self._api.add_port(vm_uuid, vif_uuid, 'tapX', 'aa:bb:cc:ee:ff:00')
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
port2 = ttypes.Port(self._api._uuid_string_to_hex(vif_uuid),
self._api._uuid_string_to_hex(vm_uuid),
'tapY', '0.0.0.0', [0] * 16, '11:22:33:44:55:66')
self._api.add_port(vm_uuid, vif_uuid, 'tapY', '11:22:33:44:55:66')
mock_client = mock.Mock()
self._api._rpc_client_instance.return_value = mock_client
self._api.connect()
self._api._resynchronize()
mock_client.AddPort.assert_called_with([port1, port2])
def test_additional_arguments(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
vif_uuid = uuid.uuid1()
network_uuid = uuid.uuid1()
project_id = uuid.uuid1().hex
self._api.add_port(str(uuid.uuid1()), str(vif_uuid), 'tapX',
'aa:bb:cc:ee:ff:00',
network_uuid=str(network_uuid),
vm_project_id=project_id)
self.assertTrue(mock_client.AddPort.called)
port = self._api._ports[vif_uuid]
self.assertEqual(self._api._uuid_to_hex(network_uuid),
port.vn_id)
self.assertEqual(self._api._uuid_string_to_hex(project_id),
port.vm_project_id)
class OpenContrailVIFDriver(object):
def __init__(self):
self._vrouter_semaphore = eventlet.semaphore.Semaphore()
self._vrouter_client = ContrailVRouterApi(
doconnect=True, semaphore=self._vrouter_semaphore)
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
def plug(self, instance, vif):
vif_type = vif['type']
LOG.debug(
'Plug vif_type=%(vif_type)s instance=%(instance)s '
'vif=%(vif)s', {
'vif_type': vif_type,
'instance': instance,
'vif': vif
})
if_local_name = 'veth%s' % vif['id'][:8]
if_remote_name = 'ns%s' % vif['id'][:8]
# Device already exists so return.
if linux_net.device_exists(if_local_name):
return
undo_mgr = utils.UndoManager()
try:
utils.execute('ip',
'link',
'add',
if_local_name,
'type',
'veth',
'peer',
'name',
if_remote_name,
run_as_root=True)
undo_mgr.undo_with(lambda: utils.execute(
'ip', 'link', 'delete', if_local_name, run_as_root=True))
utils.execute('ip',
'link',
'set',
if_remote_name,
'address',
vif['address'],
run_as_root=True)
except Exception:
LOG.exception("Failed to configure network")
msg = _('Failed to setup the network, rolling back')
undo_mgr.rollback_and_reraise(msg=msg, instance=instance)
def attach(self, instance, vif, container_id):
vif_type = vif['type']
LOG.debug(
'Attach vif_type=%(vif_type)s instance=%(instance)s '
'vif=%(vif)s', {
'vif_type': vif_type,
'instance': instance,
'vif': vif
})
if_local_name = 'veth%s' % vif['id'][:8]
if_remote_name = 'ns%s' % vif['id'][:8]
undo_mgr = utils.UndoManager()
undo_mgr.undo_with(lambda: utils.execute(
'ip', 'link', 'delete', if_local_name, run_as_root=True))
ipv4_address = '0.0.0.0'
ipv6_address = None
if 'subnets' in vif['network']:
subnets = vif['network']['subnets']
for subnet in subnets:
ips = subnet['ips'][0]
if (ips['version'] == 4):
if ips['address'] is not None:
ipv4_address = ips['address']
ipv4_netmask = subnet['cidr'].split('/')[1]
ipv4_gateway = subnet['gateway']['address']
if (ips['version'] == 6):
if ips['address'] is not None:
ipv6_address = ips['address']
ipv6_netmask = subnet['cidr'].split('/')[1]
ipv6_gateway = subnet['gateway']['address']
params = {
'ip_address': ipv4_address,
'vn_id': vif['network']['id'],
'display_name': instance['display_name'],
'hostname': instance['hostname'],
'host': instance['host'],
'vm_project_id': instance['project_id'],
'port_type': 'NovaVMPort',
'ip6_address': ipv6_address,
}
try:
utils.execute('ip',
'link',
'set',
if_remote_name,
'netns',
container_id,
run_as_root=True)
result = self._vrouter_client.add_port(instance['uuid'], vif['id'],
if_local_name,
vif['address'], **params)
if not result:
# follow the exception path
raise RuntimeError('add_port returned %s' % str(result))
utils.execute('ip',
'link',
'set',
if_local_name,
'up',
run_as_root=True)
except Exception:
LOG.exception("Failed to attach the network")
msg = _('Failed to attach the network, rolling back')
undo_mgr.rollback_and_reraise(msg=msg, instance=instance)
try:
utils.execute('ip',
'netns',
'exec',
container_id,
'ip',
'link',
'set',
if_remote_name,
'address',
vif['address'],
run_as_root=True)
if ipv6_address:
ip = ipv6_address + "/" + ipv6_netmask
gateway = ipv6_gateway
utils.execute('ip',
'netns',
'exec',
container_id,
'ifconfig',
if_remote_name,
'inet6',
'add',
ip,
run_as_root=True)
utils.execute('ip',
'netns',
'exec',
container_id,
'ip',
'-6',
'route',
'replace',
'default',
'via',
gateway,
'dev',
if_remote_name,
run_as_root=True)
if ipv4_address != '0.0.0.0':
ip = ipv4_address + "/" + ipv4_netmask
gateway = ipv4_gateway
utils.execute('ip',
'netns',
'exec',
container_id,
'ifconfig',
if_remote_name,
ip,
run_as_root=True)
utils.execute('ip',
'netns',
'exec',
container_id,
'ip',
'route',
'replace',
'default',
'via',
gateway,
'dev',
if_remote_name,
run_as_root=True)
utils.execute('ip',
'netns',
'exec',
container_id,
'ip',
'link',
'set',
if_remote_name,
'up',
run_as_root=True)
except Exception:
LOG.exception(_("Failed to attach vif"), instance=instance)
def unplug(self, instance, vif):
vif_type = vif['type']
if_local_name = 'veth%s' % vif['id'][:8]
LOG.debug(
'Unplug vif_type=%(vif_type)s instance=%(instance)s '
'vif=%(vif)s', {
'vif_type': vif_type,
'instance': instance,
'vif': vif
})
try:
self._vrouter_client.delete_port(vif['id'])
if linux_net.device_exists(if_local_name):
utils.execute('ip',
'link',
'delete',
if_local_name,
run_as_root=True)
except Exception:
LOG.exception(_("Delete port failed"), instance=instance)
class ContrailInterfaceDriver(interface.LinuxInterfaceDriver):
""" Opencontrail VIF driver for neutron."""
@classmethod
def _parse_class_args(cls, cfg_parser):
cfg_parser.read(CONTRAIL_CFG_FILE)
cls._api_server_ip = _read_cfg(cfg_parser, 'APISERVER',
'api_server_ip', '127.0.0.1')
cls._api_server_port = _read_cfg(cfg_parser, 'APISERVER',
'api_server_port', '8082')
cls._api_server_use_ssl = _read_cfg(cfg_parser, 'APISERVER',
'use_ssl', False)
def __init__(self, conf):
super(ContrailInterfaceDriver, self).__init__(conf)
self._port_dict = {}
self._client = self._connect_to_api_server()
self._vrouter_client = ContrailVRouterApi()
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _connect_to_api_server(self):
cfg_parser = ConfigParser.ConfigParser()
ContrailInterfaceDriver._parse_class_args(cfg_parser)
try:
client = VncApi(api_server_host=self._api_server_ip,
api_server_port=self._api_server_port,
api_server_use_ssl=self._api_server_use_ssl)
return client
except:
pass
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
def _delete_port(self, port_id):
self._vrouter_client.delete_port(port_id)
def _instance_locate(self, port_obj):
""" lookup the instance associated with the port object.
Create the vm instance if port object is not associated
with a vm instance
"""
if port_obj.get_virtual_machine_refs() is not None:
try:
vm_uuid = port_obj.get_virtual_machine_refs()[0]['uuid']
instance_obj = self._client.virtual_machine_read(id=vm_uuid)
return instance_obj
except NoIdError:
pass
vm_uuid = str(uuid.uuid4())
instance_obj = VirtualMachine(vm_uuid)
instance_obj.uuid = vm_uuid
self._client.virtual_machine_create(instance_obj)
port_obj.set_virtual_machine(instance_obj)
self._client.virtual_machine_interface_update(port_obj)
return instance_obj
def _add_port_to_agent(self, port_id, net_id, iface_name, mac_address):
port_obj = self._client.virtual_machine_interface_read(id=port_id)
if port_obj is None:
LOG.debug(_("Invalid port_id : %s"), port_id)
return
ips = port_obj.get_instance_ip_back_refs()
ip_addr = '0.0.0.0'
# get the ip address of the port if associated
if ips and len(ips):
ip_uuid = ips[0]['uuid']
ip = self._client.instance_ip_read(id=ip_uuid)
ip_addr = ip.get_instance_ip_address()
net_obj = self._client.virtual_network_read(id=net_id)
if net_obj is None:
LOG.debug(_("Invalid net_id : %s"), net_id)
return
# get the instance object the port is attached to
instance_obj = self._instance_locate(port_obj)
if instance_obj is None:
return
kwargs = {}
kwargs['ip_address'] = ip_addr
kwargs['network_uuid'] = net_id
kwargs['vm_project_uuid'] = net_obj.parent_uuid
self._vrouter_client.add_port(instance_obj.uuid, port_id, iface_name,
mac_address, **kwargs)
def plug(self, network_id, port_id, device_name, mac_address,
bridge=None, namespace=None, prefix=None):
if not ip_lib.device_exists(device_name, self.root_helper, namespace):
ip = ip_lib.IPWrapper(self.root_helper)
tap_name = device_name.replace(prefix or 'veth', 'veth')
# Create ns_dev in a namespace if one is configured.
root_dev, ns_dev = ip.add_veth(tap_name,
device_name,
namespace2=namespace)
ns_dev.link.set_address(mac_address)
namespace_obj = ip.ensure_namespace(namespace)
namespace_obj.add_device_to_namespace(ns_dev)
ns_dev.link.set_up()
root_dev.link.set_up()
self._add_port_to_agent(port_id, network_id,
tap_name, mac_address)
self._port_dict[tap_name] = port_id
else:
LOG.warn(_("Device %s already exists"), device_name)
def unplug(self, device_name, bridge=None, namespace=None, prefix=None):
tap_name = device_name.replace(prefix or 'veth', 'veth')
if tap_name in self._port_dict:
self._delete_port(self._port_dict[tap_name])
del self._port_dict[tap_name]
device = ip_lib.IPDevice(device_name, self.root_helper, namespace)
device.link.delete()
LOG.debug(_("Unplugged interface '%s'"), device_name)
ip_lib.IPWrapper(
self.root_helper, namespace).garbage_collect_namespace()
class ContrailInterfaceDriver(interface.LinuxInterfaceDriver):
""" Opencontrail VIF driver for neutron."""
@classmethod
def _parse_class_args(cls, cfg_parser):
cfg_parser.read(CONTRAIL_CFG_FILE)
cls._api_server_ip = _read_cfg(cfg_parser, 'APISERVER',
'api_server_ip', '127.0.0.1')
cls._api_server_port = _read_cfg(cfg_parser, 'APISERVER',
'api_server_port', '8082')
cls._api_server_use_ssl = _read_cfg(cfg_parser, 'APISERVER', 'use_ssl',
False)
cls._auth_token_url = _read_cfg(cfg_parser, 'APISERVER',
'auth_token_url', None)
def __init__(self, conf):
super(ContrailInterfaceDriver, self).__init__(conf)
self._port_dict = {}
self._client = self._connect_to_api_server()
self._vrouter_client = ContrailVRouterApi()
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _connect_to_api_server(self):
cfg_parser = ConfigParser.ConfigParser()
ContrailInterfaceDriver._parse_class_args(cfg_parser)
try:
client = VncApi(api_server_host=self._api_server_ip,
api_server_port=self._api_server_port,
api_server_use_ssl=self._api_server_use_ssl,
auth_token_url=self._auth_token_url)
return client
except:
pass
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
def _delete_port(self, port_id):
self._vrouter_client.delete_port(port_id)
def _instance_locate(self, port_obj):
""" lookup the instance associated with the port object.
Create the vm instance if port object is not associated
with a vm instance
"""
if port_obj.get_virtual_machine_refs() is not None:
try:
vm_uuid = port_obj.get_virtual_machine_refs()[0]['uuid']
instance_obj = self._client.virtual_machine_read(id=vm_uuid)
return instance_obj
except NoIdError:
pass
vm_uuid = str(uuid.uuid4())
instance_obj = VirtualMachine(vm_uuid)
instance_obj.uuid = vm_uuid
self._client.virtual_machine_create(instance_obj)
port_obj.set_virtual_machine(instance_obj)
self._client.virtual_machine_interface_update(port_obj)
return instance_obj
def _add_port_to_agent(self, port_id, net_id, iface_name, mac_address):
port_obj = self._client.virtual_machine_interface_read(id=port_id)
if port_obj is None:
LOG.debug(_("Invalid port_id : %s"), port_id)
return
ips = port_obj.get_instance_ip_back_refs()
ip_addr = '0.0.0.0'
# get the ip address of the port if associated
if ips and len(ips):
ip_uuid = ips[0]['uuid']
ip = self._client.instance_ip_read(id=ip_uuid)
ip_addr = ip.get_instance_ip_address()
net_obj = self._client.virtual_network_read(id=net_id)
if net_obj is None:
LOG.debug(_("Invalid net_id : %s"), net_id)
return
# get the instance object the port is attached to
instance_obj = self._instance_locate(port_obj)
if instance_obj is None:
return
kwargs = {}
kwargs['ip_address'] = ip_addr
kwargs['network_uuid'] = net_id
kwargs['vm_project_uuid'] = net_obj.parent_uuid
self._vrouter_client.add_port(instance_obj.uuid, port_id, iface_name,
mac_address, **kwargs)
def plug(self,
network_id,
port_id,
device_name,
mac_address,
bridge=None,
namespace=None,
prefix=None):
if not ip_lib.device_exists(device_name, self.root_helper, namespace):
ip = ip_lib.IPWrapper(self.root_helper)
tap_name = device_name.replace(prefix or 'veth', 'veth')
# Create ns_dev in a namespace if one is configured.
root_dev, ns_dev = ip.add_veth(tap_name,
device_name,
namespace2=namespace)
ns_dev.link.set_address(mac_address)
namespace_obj = ip.ensure_namespace(namespace)
namespace_obj.add_device_to_namespace(ns_dev)
ns_dev.link.set_up()
root_dev.link.set_up()
self._add_port_to_agent(port_id, network_id, tap_name, mac_address)
self._port_dict[tap_name] = port_id
else:
LOG.warn(_("Device %s already exists"), device_name)
def unplug(self, device_name, bridge=None, namespace=None, prefix=None):
tap_name = device_name.replace(prefix or 'veth', 'veth')
if tap_name in self._port_dict:
self._delete_port(self._port_dict[tap_name])
del self._port_dict[tap_name]
device = ip_lib.IPDevice(device_name, self.root_helper, namespace)
device.link.delete()
LOG.debug(_("Unplugged interface '%s'"), device_name)
ip_lib.IPWrapper(self.root_helper,
namespace).garbage_collect_namespace()
class VRouterVIFDriver(LibvirtBaseVIFDriver):
"""VIF driver for VRouter when running Neutron."""
PORT_TYPE = 'NovaVMPort'
def __init__(self, get_connection):
super(VRouterVIFDriver, self).__init__(get_connection)
self._vrouter_client = ContrailVRouterApi()
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
@staticmethod
def _get_br_name(dev):
"""Returns the bridge name for a tap device.
This is lxc related stuff. To work around the fact, that libvirt does
not support direct passthrough of devices to LXC."""
return 'br%s' % dev[3:]
def _create_bridge(self, dev, instance):
"""Creating a bridge and returning its name"""
br_name = self._get_br_name(dev)
try:
linux_net.LinuxBridgeInterfaceDriver.ensure_bridge(br_name, dev)
linux_net._execute('ip',
'link',
'set',
br_name,
'promisc',
'on',
run_as_root=True)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
return br_name
def get_config(self, instance, vif, image_meta, inst_type):
conf = super(VRouterVIFDriver,
self).get_config(instance, vif, image_meta, inst_type)
dev = self.get_vif_devname(vif)
if cfg.CONF.libvirt.virt_type == 'lxc':
# for lxc we need to pass a bridge to libvirt
br_name = self._get_br_name(dev)
designer.set_vif_host_backend_bridge_config(conf, br_name)
else:
designer.set_vif_host_backend_ethernet_config(conf, dev)
designer.set_vif_bandwidth_config(conf, inst_type)
return conf
def plug(self, instance, vif):
dev = self.get_vif_devname(vif)
try:
linux_net.create_tap_dev(dev)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
if cfg.CONF.libvirt.virt_type == 'lxc':
dev = self._create_bridge(dev, instance)
kwargs = {
'ip_address': vif['network']['subnets'][0]['ips'][0]['address'],
'vn_id': vif['network']['id'],
'display_name': instance['display_name'],
'hostname': instance['hostname'],
'host': instance['host'],
'vm_project_id': instance['project_id'],
'port_type': self.PORT_TYPE,
}
try:
result = self._vrouter_client.add_port(instance['uuid'], vif['id'],
dev, vif['address'],
**kwargs)
if not result:
LOG.exception(_LE("Failed while plugging vif"),
instance=instance)
except TApplicationException:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
def unplug(self, instance, vif):
dev = self.get_vif_devname(vif)
try:
self._vrouter_client.delete_port(vif['id'])
#delegate the deletion of tap device to a deffered thread
worker_thread = threading.Thread(target=self.delete_device, \
name='contrailvif', args=(dev,))
worker_thread.start()
except (TApplicationException, processutils.ProcessExecutionError,\
RuntimeError):
LOG.exception(_LE("Failed while unplugging vif"),
instance=instance)
def delete_device(self, dev):
time.sleep(2)
LOG.debug(dev)
if cfg.CONF.libvirt.virt_type == 'lxc':
linux_net.LinuxBridgeInterfaceDriver.remove_bridge(
self._get_br_name(dev))
linux_net.delete_net_dev(dev)
class VRouterApiTest(unittest.TestCase):
def setUp(self):
self._api = ContrailVRouterApi()
def test_create_port(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
self._api.add_port(str(uuid.uuid1()), str(uuid.uuid1()), 'tapX',
'aa:bb:cc:ee:ff:00')
self.assertTrue(mock_client.AddPort.called)
def test_delete_port(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
vm_uuid = uuid.uuid1()
vif_uuid = uuid.uuid1()
self._api.add_port(str(vm_uuid), str(vif_uuid), 'tapX',
'aa:bb:cc:ee:ff:00')
self.assertTrue(mock_client.AddPort.called)
self.assertTrue(self._api._ports[vif_uuid])
self._api.delete_port(str(vif_uuid))
self.assertTrue(mock_client.DeletePort.called)
def test_resynchronize(self):
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = None
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
port1 = ttypes.Port(self._api._uuid_string_to_hex(vif_uuid),
self._api._uuid_string_to_hex(vm_uuid), 'tapX',
'0.0.0.0', [0] * 16, 'aa:bb:cc:ee:ff:00')
self._api.add_port(vm_uuid, vif_uuid, 'tapX', 'aa:bb:cc:ee:ff:00')
mock_client = mock.Mock()
self._api._rpc_client_instance.return_value = mock_client
self._api.periodic_connection_check()
mock_client.AddPort.assert_called_with([port1])
def test_resynchronize_multi_ports(self):
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = None
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
port1 = ttypes.Port(self._api._uuid_string_to_hex(vif_uuid),
self._api._uuid_string_to_hex(vm_uuid), 'tapX',
'0.0.0.0', [0] * 16, 'aa:bb:cc:ee:ff:00')
self._api.add_port(vm_uuid, vif_uuid, 'tapX', 'aa:bb:cc:ee:ff:00')
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
port2 = ttypes.Port(self._api._uuid_string_to_hex(vif_uuid),
self._api._uuid_string_to_hex(vm_uuid), 'tapY',
'0.0.0.0', [0] * 16, '11:22:33:44:55:66')
self._api.add_port(vm_uuid, vif_uuid, 'tapY', '11:22:33:44:55:66')
mock_client = mock.Mock()
self._api._rpc_client_instance.return_value = mock_client
self._api.connect()
self._api._resynchronize()
mock_client.AddPort.assert_called_with([port1, port2])
def test_additional_arguments(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
vif_uuid = uuid.uuid1()
network_uuid = uuid.uuid1()
project_id = uuid.uuid1().hex
self._api.add_port(str(uuid.uuid1()),
str(vif_uuid),
'tapX',
'aa:bb:cc:ee:ff:00',
vn_id=str(network_uuid),
vm_project_id=project_id)
self.assertTrue(mock_client.AddPort.called)
port = self._api._ports[vif_uuid]
self.assertEqual(self._api._uuid_to_hex(network_uuid), port.vn_id)
self.assertEqual(self._api._uuid_string_to_hex(project_id),
port.vm_project_id)
class VRouterVIFDriver(LibVirtVIFDriver):
"""VIF driver for VRouter when running Neutron."""
PORT_TYPE = 'NovaVMPort'
def __init__(self, get_connection):
super(VRouterVIFDriver, self).__init__(get_connection)
self._vrouter_semaphore = eventlet.semaphore.Semaphore()
self._vrouter_client = ContrailVRouterApi(doconnect=True, semaphore=self._vrouter_semaphore)
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
@staticmethod
def _get_br_name(dev):
"""Returns the bridge name for a tap device.
This is lxc related stuff. To work around the fact, that libvirt does
not support direct passthrough of devices to LXC."""
return 'br%s' % dev[3:]
def _create_bridge(self, dev, instance):
"""Creating a bridge and returning its name"""
br_name = self._get_br_name(dev)
try:
linux_net.LinuxBridgeInterfaceDriver.ensure_bridge(br_name, dev)
linux_net._execute('ip', 'link', 'set', br_name, 'promisc', 'on',
run_as_root=True)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
return br_name
def get_config(self, instance, vif, image_meta, inst_type, virt_type=None):
try:
conf = super(VRouterVIFDriver, self).get_config(instance, vif,
image_meta, inst_type)
except TypeError:
conf = super(VRouterVIFDriver, self).get_base_config(instance, vif,
image_meta, inst_type, virt_type)
dev = self.get_vif_devname(vif)
if not virt_type:
try:
virt_type = cfg.CONF.libvirt.virt_type
except cfg.NoSuchOptError:
virt_type = cfg.CONF.libvirt_type
if virt_type == 'lxc':
# for lxc we need to pass a bridge to libvirt
br_name = self._get_br_name(dev)
designer.set_vif_host_backend_bridge_config(conf, br_name)
else:
if CONF.contrail.use_userspace_vhost:
dev = path.join(CONF.contrail.userspace_vhost_socket_dir,
'uvh_vif_' + dev)
designer.set_vif_host_backend_vhostuser_config(conf, 'client',
dev)
else:
designer.set_vif_host_backend_ethernet_config(conf, dev)
designer.set_vif_bandwidth_config(conf, inst_type)
return conf
def plug(self, instance, vif):
try:
dev = self.get_vif_devname(vif)
try:
if not CONF.contrail.use_userspace_vhost:
linux_net.create_tap_dev(dev)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
try:
virt_type = cfg.CONF.libvirt.virt_type
except cfg.NoSuchOptError:
virt_type = cfg.CONF.libvirt_type
if virt_type == 'lxc':
dev = self._create_bridge(dev, instance)
ipv4_address = '0.0.0.0'
ipv6_address = None
subnets = vif['network']['subnets']
for subnet in subnets:
ips = subnet['ips'][0]
if (ips['version'] == 4):
if ips['address'] is not None:
ipv4_address = ips['address']
if (ips['version'] == 6):
if ips['address'] is not None:
ipv6_address = ips['address']
kwargs = {
'ip_address': ipv4_address,
'vn_id': vif['network']['id'],
'display_name': instance['display_name'],
'hostname': instance['hostname'],
'host': instance['host'],
'vm_project_id': instance['project_id'],
'port_type': self.PORT_TYPE,
'ip6_address': ipv6_address,
}
try:
result = self._vrouter_client.add_port(instance['uuid'],
vif['id'],
dev,
vif['address'],
**kwargs)
if not result:
LOG.exception(_LE("Failed while plugging vif"),
instance=instance)
except TApplicationException:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
except Exception as e:
from pprint import pformat
LOG.error(_("Error in plug: %s locals: %s instance %s"
%(str(e), pformat(locals()),
pformat(instance) if isinstance(instance, dict) else pformat(instance.__dict__))))
def unplug(self, instance, vif):
try:
dev = self.get_vif_devname(vif)
if isinstance(instance, dict):
task_state = instance['task_state']
else:
task_state = instance._task_state
try:
self._vrouter_client.delete_port(vif['id'])
if task_state == 'rebuilding':
self.delete_device(dev)
else:
# delegate the deletion of tap device to a deffered thread
worker_thread = threading.Thread(
target=self.delete_device,
name='contrailvif',
args=(dev,), kwargs={'timeout': 2})
worker_thread.start()
except (TApplicationException, processutils.ProcessExecutionError,
RuntimeError):
LOG.exception(_LE("Failed while unplugging vif"),
instance=instance)
except Exception as e:
from pprint import pformat
LOG.error(_("Error in unplug: %s locals: %s instance %s"
%(str(e), pformat(locals()),
pformat(instance) if isinstance(instance, dict) else pformat(instance.__dict__))))
def delete_device(self, dev, timeout=None):
if timeout is not None:
time.sleep(timeout)
LOG.debug(dev)
try:
virt_type = cfg.CONF.libvirt.virt_type
except cfg.NoSuchOptError:
virt_type = cfg.CONF.libvirt_type
if virt_type == 'lxc':
linux_net.LinuxBridgeInterfaceDriver.remove_bridge(
self._get_br_name(dev))
if not CONF.contrail.use_userspace_vhost:
linux_net.delete_net_dev(dev)
class VRouterVIFDriver(LibvirtBaseVIFDriver):
"""VIF driver for VRouter when running Neutron."""
PORT_TYPE = 'NovaVMPort'
def __init__(self, get_connection):
super(VRouterVIFDriver, self).__init__(get_connection)
self._vrouter_client = ContrailVRouterApi()
timer = loopingcall.FixedIntervalLoopingCall(self._keep_alive)
timer.start(interval=2)
def _keep_alive(self):
self._vrouter_client.periodic_connection_check()
@staticmethod
def _get_br_name(dev):
"""Returns the bridge name for a tap device.
This is lxc related stuff. To work around the fact, that libvirt does
not support direct passthrough of devices to LXC."""
return 'br%s' % dev[3:]
def _create_bridge(self, dev, instance):
"""Creating a bridge and returning its name"""
br_name = self._get_br_name(dev)
try:
linux_net.LinuxBridgeInterfaceDriver.ensure_bridge(br_name, dev)
linux_net._execute('ip', 'link', 'set', br_name, 'promisc', 'on',
run_as_root=True)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
return br_name
def get_config(self, instance, vif, image_meta, inst_type):
conf = super(VRouterVIFDriver, self).get_config(instance, vif,
image_meta, inst_type)
dev = self.get_vif_devname(vif)
if cfg.CONF.libvirt.virt_type == 'lxc':
# for lxc we need to pass a bridge to libvirt
br_name = self._get_br_name(dev)
designer.set_vif_host_backend_bridge_config(conf, br_name)
else:
designer.set_vif_host_backend_ethernet_config(conf, dev)
designer.set_vif_bandwidth_config(conf, inst_type)
return conf
def plug(self, instance, vif):
dev = self.get_vif_devname(vif)
try:
linux_net.create_tap_dev(dev)
except processutils.ProcessExecutionError:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
if cfg.CONF.libvirt.virt_type == 'lxc':
dev = self._create_bridge(dev, instance)
kwargs = {
'ip_address': vif['network']['subnets'][0]['ips'][0]['address'],
'vn_id': vif['network']['id'],
'display_name': instance['display_name'],
'hostname': instance['hostname'],
'host': instance['host'],
'vm_project_id': instance['project_id'],
'port_type': self.PORT_TYPE,
}
try:
result = self._vrouter_client.add_port(instance['uuid'],
vif['id'],
dev,
vif['address'],
**kwargs)
if not result:
LOG.exception(_LE("Failed while plugging vif"),
instance=instance)
except TApplicationException:
LOG.exception(_LE("Failed while plugging vif"), instance=instance)
def unplug(self, instance, vif):
dev = self.get_vif_devname(vif)
try:
self._vrouter_client.delete_port(vif['id'])
#delegate the deletion of tap device to a deffered thread
worker_thread = threading.Thread(target=self.delete_device, \
name='contrailvif', args=(dev,))
worker_thread.start()
except (TApplicationException, processutils.ProcessExecutionError,\
RuntimeError):
LOG.exception(_LE("Failed while unplugging vif"),
instance=instance)
def delete_device(self, dev):
time.sleep(2)
LOG.debug(dev)
if cfg.CONF.libvirt.virt_type == 'lxc':
linux_net.LinuxBridgeInterfaceDriver.remove_bridge(
self._get_br_name(dev))
linux_net.delete_net_dev(dev)
class VRouterApiTest(unittest.TestCase):
def setUp(self):
self._api = ContrailVRouterApi()
def test_create_port(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
self._api.add_port(str(uuid.uuid1()), str(uuid.uuid1()), 'tapX',
'aa:bb:cc:ee:ff:00')
self.assertTrue(mock_client.AddPort.called)
def test_delete_port(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
vm_uuid = uuid.uuid1()
vif_uuid = uuid.uuid1()
self._api.add_port(str(vm_uuid), str(vif_uuid), 'tapX',
'aa:bb:cc:ee:ff:00')
self.assertTrue(mock_client.AddPort.called)
self.assertTrue(self._api._ports[vif_uuid])
self._api.delete_port(str(vif_uuid))
self.assertTrue(mock_client.DeletePort.called)
def test_resynchronize(self):
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = None
vm_uuid = str(uuid.uuid1())
vif_uuid = str(uuid.uuid1())
self._api.add_port(vm_uuid, vif_uuid, 'tapX', 'aa:bb:cc:ee:ff:00')
mock_client = mock.Mock()
self._api._rpc_client_instance.return_value = mock_client
self._api.periodic_connection_check()
self.assertTrue(mock_client.AddPort.called)
def test_additional_arguments(self):
mock_client = mock.Mock()
self._api._rpc_client_instance = mock.MagicMock(
name='rpc_client_instance')
self._api._rpc_client_instance.return_value = mock_client
vif_uuid = uuid.uuid1()
network_uuid = uuid.uuid1()
project_uuid = uuid.uuid1()
self._api.add_port(str(uuid.uuid1()), str(vif_uuid), 'tapX',
'aa:bb:cc:ee:ff:00',
network_uuid=str(network_uuid),
vm_project_uuid=str(project_uuid))
self.assertTrue(mock_client.AddPort.called)
port = self._api._ports[vif_uuid]
self.assertEqual(self._api._uuid_to_hex(network_uuid),
port.vn_id)
self.assertEqual(self._api._uuid_to_hex(project_uuid),
port.vm_project_uuid)
