openstack
/
zun
Code Issues Proposed changes

Merge "Rename network_api to network_driver"

This commit is contained in:
Zuul 2020-07-19 05:09:50 +00:00 committed by Gerrit Code Review
parent 52427d612b 7f5d147c0f
commit c2a72d8900
3 changed files with 92 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
zun/container/docker/driver.py
View File

@ -248,11 +248,13 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
def create(self, context, container, image, requested_networks,
requested_volumes):
with docker_utils.docker_client() as docker:
network_api = zun_network.api(context=context, docker_api=docker)
network_driver = zun_network.driver(context=context,
docker_api=docker)
name = container.name
LOG.debug('Creating container with image %(image)s name %(name)s',
{'image': image['image'], 'name': name})
self._provision_network(context, network_api, requested_networks)
self._provision_network(context, network_driver,
requested_networks)
volmaps = requested_volumes.get(container.uuid, [])
binds = self._get_binds(context, volmaps)
kwargs = {
@ -280,7 +282,7 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
host_config['runtime'] = runtime
host_config['binds'] = binds
kwargs['volumes'] = [b['bind'] for b in binds.values()]
self._process_exposed_ports(network_api.neutron_api, container,
self._process_exposed_ports(network_driver.neutron_api, container,
kwargs)
self._process_networking_config(
context, container, requested_networks, host_config,
@ -325,7 +327,7 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
container.container_id = response['Id']
addresses = self._setup_network_for_container(
context, container, requested_networks, network_api)
context, container, requested_networks, network_driver)
container.addresses = addresses
response = docker.inspect_container(container.container_id)
@ -378,8 +380,8 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
def _process_networking_config(self, context, container,
requested_networks, host_config,
container_kwargs, docker):
network_api = zun_network.api(context=context, docker_api=docker)
neutron_api = network_api.neutron_api
network_driver = zun_network.driver(context=context, docker_api=docker)
neutron_api = network_driver.neutron_api
# Process the first requested network at create time. The rest
# will be processed after create.
@ -388,8 +390,8 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
context, requested_network['network'])
security_group_ids = utils.get_security_group_ids(
context, container.security_groups)
docker_network = network_api.inspect_network(docker_net_name)
device_owner = network_api.get_device_owner()
docker_network = network_driver.inspect_network(docker_net_name)
device_owner = network_driver.get_device_owner()
neutron_net_id = docker_network['Options']['neutron.net.uuid']
addresses, port = neutron_api.create_or_update_port(
container, neutron_net_id, requested_network, device_owner,
@ -413,10 +415,10 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
container_kwargs['networking_config'] = network_config
container_kwargs['mac_address'] = port['mac_address']
def _provision_network(self, context, network_api, requested_networks):
def _provision_network(self, context, network_driver, requested_networks):
for rq_network in requested_networks:
self._get_or_create_docker_network(
context, network_api, rq_network['network'])
context, network_driver, rq_network['network'])
def _get_secgorup_name(self, container_uuid):
return consts.NAME_PREFIX + container_uuid
@ -430,7 +432,7 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
return binds
def _setup_network_for_container(self, context, container,
requested_networks, network_api):
requested_networks, network_driver):
security_group_ids = utils.get_security_group_ids(
context, container.security_groups)
addresses = {}
@ -443,7 +445,7 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
docker_net_name = self._get_docker_network_name(
context, network['network'])
addrs = network_api.connect_container_to_network(
addrs = network_driver.connect_container_to_network(
container, docker_net_name, network,
security_groups=security_group_ids)
addresses[network['network']] = addrs
@ -453,10 +455,10 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
def delete(self, context, container, force):
with docker_utils.docker_client() as docker:
try:
network_api = zun_network.api(context=context,
docker_api=docker)
self._cleanup_network_for_container(container, network_api)
self._cleanup_exposed_ports(network_api.neutron_api,
network_driver = zun_network.driver(context=context,
docker_api=docker)
self._cleanup_network_for_container(container, network_driver)
self._cleanup_exposed_ports(network_driver.neutron_api,
container)
if container.container_id:
docker.remove_container(container.container_id,
@ -469,12 +471,12 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
raise
@wrap_docker_error
def _cleanup_network_for_container(self, container, network_api):
def _cleanup_network_for_container(self, container, network_driver):
if not container.addresses:
return
for neutron_net in container.addresses:
docker_net = neutron_net
network_api.disconnect_container_from_network(
network_driver.disconnect_container_from_network(
container, docker_net, neutron_network_id=neutron_net)
def _cleanup_exposed_ports(self, neutron_api, container):
@ -1029,14 +1031,14 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
def _encode_utf8(self, value):
return value.encode('utf-8')
def _get_or_create_docker_network(self, context, network_api,
def _get_or_create_docker_network(self, context, network_driver,
neutron_net_id):
docker_net_name = self._get_docker_network_name(context,
neutron_net_id)
docker_networks = network_api.list_networks(names=[docker_net_name])
docker_networks = network_driver.list_networks(names=[docker_net_name])
if not docker_networks:
network_api.create_network(neutron_net_id=neutron_net_id,
name=docker_net_name)
network_driver.create_network(neutron_net_id=neutron_net_id,
name=docker_net_name)
def _get_docker_network_name(self, context, neutron_net_id):
# Note(kiseok7): neutron_net_id is a unique ID in neutron networks and
@ -1105,18 +1107,18 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
def add_security_group(self, context, container, security_group):
with docker_utils.docker_client() as docker:
network_api = zun_network.api(context=context,
docker_api=docker)
network_api.add_security_groups_to_ports(container,
[security_group])
network_driver = zun_network.driver(context=context,
docker_api=docker)
network_driver.add_security_groups_to_ports(container,
[security_group])
def remove_security_group(self, context, container, security_group):
with docker_utils.docker_client() as docker:
network_api = zun_network.api(context=context,
docker_api=docker)
network_api.remove_security_groups_from_ports(container,
[security_group])
network_driver = zun_network.driver(context=context,
docker_api=docker)
network_driver.remove_security_groups_from_ports(container,
[security_group])
def get_available_nodes(self):
return [self._host.get_hostname()]
@ -1142,11 +1144,11 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
@wrap_docker_error
def network_detach(self, context, container, network):
with docker_utils.docker_client() as docker:
network_api = zun_network.api(context,
docker_api=docker)
network_driver = zun_network.driver(context,
docker_api=docker)
docker_net = self._get_docker_network_name(context, network)
network_api.disconnect_container_from_network(container,
docker_net, network)
network_driver.disconnect_container_from_network(
container, docker_net, network)
# Only clear network info related to this network
# Cannot del container.address directly which will not update
@ -1163,8 +1165,8 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
if container.security_groups:
security_group_ids = utils.get_security_group_ids(
context, container.security_groups)
network_api = zun_network.api(context,
docker_api=docker)
network_driver = zun_network.driver(context,
docker_api=docker)
network = requested_network['network']
if network in container.addresses:
raise exception.ZunException('Container %(container)s has '
@ -1172,9 +1174,10 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
'network %(network)s.'
% {'container': container.uuid,
'network': network})
self._get_or_create_docker_network(context, network_api, network)
self._get_or_create_docker_network(context, network_driver,
network)
docker_net_name = self._get_docker_network_name(context, network)
addrs = network_api.connect_container_to_network(
addrs = network_driver.connect_container_to_network(
container, docker_net_name, requested_network,
security_groups=security_group_ids)
if addrs is None:
@ -1189,19 +1192,19 @@ class DockerDriver(driver.BaseDriver, driver.ContainerDriver,
def create_network(self, context, neutron_net_id):
with docker_utils.docker_client() as docker:
network_api = zun_network.api(context,
docker_api=docker)
network_driver = zun_network.driver(context,
docker_api=docker)
docker_net_name = self._get_docker_network_name(
context, neutron_net_id)
return network_api.create_network(
return network_driver.create_network(
neutron_net_id=neutron_net_id,
name=docker_net_name)
def delete_network(self, context, network):
with docker_utils.docker_client() as docker:
network_api = zun_network.api(context,
docker_api=docker)
network_api.remove_network(network)
network_driver = zun_network.driver(context,
docker_api=docker)
network_driver.remove_network(network)
def create_capsule(self, context, capsule, image, requested_networks,
requested_volumes):

14
zun/network/network.py
View File

@ -12,7 +12,7 @@
import abc
from stevedore import driver
from stevedore import driver as stevedore_driver
import zun.conf
@ -20,15 +20,15 @@ import zun.conf
CONF = zun.conf.CONF
def api(*args, **kwargs):
network_driver = CONF.network.driver
network_api = driver.DriverManager(
def driver(*args, **kwargs):
driver_name = CONF.network.driver
network_driver = stevedore_driver.DriverManager(
"zun.network.driver",
network_driver,
driver_name,
invoke_on_load=True).driver
network_api.init(*args, **kwargs)
return network_api
network_driver.init(*args, **kwargs)
return network_driver
class Network(object, metaclass=abc.ABCMeta):

76
zun/tests/unit/network/test_kuryr_network.py
View File

@ -180,23 +180,23 @@ class KuryrNetworkTestCase(base.TestCase):
def setUp(self):
super(KuryrNetworkTestCase, self).setUp()
self.docker_api = FakeDockerClient()
self.network_api = kuryr_network.KuryrNetwork()
self.network_api.init(self.context, self.docker_api)
self.network_api.neutron_api = FakeNeutronClient()
self.network_driver = kuryr_network.KuryrNetwork()
self.network_driver.init(self.context, self.docker_api)
self.network_driver.neutron_api = FakeNeutronClient()
@mock.patch.object(ZunNetwork, 'create')
@mock.patch.object(ZunNetwork, 'save')
@mock.patch('zun.network.neutron.NeutronAPI')
def test_create_network_without_subnetpool(
self, mock_neutron_api_cls, mock_save, mock_create):
self.network_api.neutron_api.subnets[0].pop('subnetpool_id')
mock_neutron_api_cls.return_value = self.network_api.neutron_api
self.network_driver.neutron_api.subnets[0].pop('subnetpool_id')
mock_neutron_api_cls.return_value = self.network_driver.neutron_api
name = 'test_kuryr_network'
neutron_net_id = 'fake-net-id'
with mock.patch.object(self.network_api.docker, 'create_network',
with mock.patch.object(self.network_driver.docker, 'create_network',
return_value={'Id': 'docker-net'}
) as mock_create_network:
network = self.network_api.create_network(name, neutron_net_id)
network = self.network_driver.create_network(name, neutron_net_id)
self.assertEqual('docker-net', network.network_id)
mock_create_network.assert_called_once_with(
name=name,
@ -215,13 +215,13 @@ class KuryrNetworkTestCase(base.TestCase):
@mock.patch('zun.network.neutron.NeutronAPI')
def test_create_network_with_subnetpool(
self, mock_neutron_api_cls, mock_save, mock_create):
mock_neutron_api_cls.return_value = self.network_api.neutron_api
mock_neutron_api_cls.return_value = self.network_driver.neutron_api
name = 'test_kuryr_network'
neutron_net_id = 'fake-net-id'
with mock.patch.object(self.network_api.docker, 'create_network',
with mock.patch.object(self.network_driver.docker, 'create_network',
return_value={'Id': 'docker-net'}
) as mock_create_network:
network = self.network_api.create_network(name, neutron_net_id)
network = self.network_driver.create_network(name, neutron_net_id)
self.assertEqual('docker-net', network.network_id)
mock_create_network.assert_called_once_with(
name=name,
@ -241,7 +241,7 @@ class KuryrNetworkTestCase(base.TestCase):
@mock.patch('zun.network.neutron.NeutronAPI')
def test_create_network_already_exist(
self, mock_neutron_api_cls, mock_list, mock_save, mock_create):
mock_neutron_api_cls.return_value = self.network_api.neutron_api
mock_neutron_api_cls.return_value = self.network_driver.neutron_api
name = 'test_kuryr_network'
neutron_net_id = 'fake-net-id'
docker_net_id = 'docker-net'
@ -250,10 +250,10 @@ class KuryrNetworkTestCase(base.TestCase):
mock_list.return_value = [fake_network]
mock_create.side_effect = exception.NetworkAlreadyExists(
field='neutron_net_id', value=neutron_net_id)
with mock.patch.object(self.network_api.docker, 'networks',
with mock.patch.object(self.network_driver.docker, 'networks',
return_value=[{'Id': docker_net_id}]
) as mock_list_network:
network = self.network_api.create_network(name, neutron_net_id)
network = self.network_driver.create_network(name, neutron_net_id)
self.assertEqual(docker_net_id, network.network_id)
mock_list.assert_called_once_with(
self.context, filters={'neutron_net_id': neutron_net_id})
@ -261,19 +261,19 @@ class KuryrNetworkTestCase(base.TestCase):
def test_remove_network(self):
network = mock.Mock(name='c02afe4e-8350-4263-8078')
self.network_api.remove_network(network)
self.network_driver.remove_network(network)
network.destroy.assert_called_once_with()
def test_inspect_network(self):
network_name = 'c02afe4e-8350-4263-8078'
expected = {'Name': 'c02afe4e-8350-4263-8078',
'Options': {'neutron.net.uuid': '1234567'}}
info = self.network_api.inspect_network(network_name)
info = self.network_driver.inspect_network(network_name)
self.assertEqual(expected, info)
def test_list_networks(self):
expected = [{'Name': 'test_network'}]
networks = self.network_api.list_networks()
networks = self.network_driver.list_networks()
self.assertEqual(expected, networks)
def test_connect_container_to_network(self):
@ -286,18 +286,18 @@ class KuryrNetworkTestCase(base.TestCase):
'port': 'fake-port-id',
'subnet_id': 'fake-subnet-id',
'preserve_on_delete': True}]
old_port = self.network_api.neutron_api.list_ports(
old_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', old_port['device_id'])
with mock.patch.object(self.network_api.docker,
with mock.patch.object(self.network_driver.docker,
'connect_container_to_network') as mock_connect:
address = self.network_api.connect_container_to_network(
address = self.network_driver.connect_container_to_network(
container, network_name, requested_net)
self.assertEqual(expected_address, address)
mock_connect.assert_called_once_with(
container.container_id, network_name, ipv4_address='10.5.0.22')
new_port = self.network_api.neutron_api.list_ports(
new_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual(container.uuid, new_port['device_id'])
@ -308,17 +308,17 @@ class KuryrNetworkTestCase(base.TestCase):
requested_net = {'ipv4_address': '10.5.0.22',
'port': 'fake-port-id',
'preserve_on_delete': True}
mock_neutron_api_cls.return_value = self.network_api.neutron_api
old_port = self.network_api.neutron_api.list_ports(
mock_neutron_api_cls.return_value = self.network_driver.neutron_api
old_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', old_port['device_id'])
self.network_api.docker = mock.MagicMock()
self.network_api.docker.connect_container_to_network = \
self.network_driver.docker = mock.MagicMock()
self.network_driver.docker.connect_container_to_network = \
mock.Mock(side_effect=exception.DockerError)
self.assertRaises(exception.DockerError,
self.network_api.connect_container_to_network,
self.network_driver.connect_container_to_network,
container, network_name, requested_net)
new_port = self.network_api.neutron_api.list_ports(
new_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
self.assertEqual('', new_port['device_id'])
@ -328,18 +328,18 @@ class KuryrNetworkTestCase(base.TestCase):
container = Container(self.context, **utils.get_test_container(
addresses=addresses))
network_name = 'c02afe4e-8350-4263-8078'
ports = self.network_api.neutron_api.list_ports(
ports = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports']
self.assertEqual(1, len(ports))
with mock.patch.object(self.network_api.docker,
with mock.patch.object(self.network_driver.docker,
'disconnect_container_from_network'
) as mock_disconnect:
self.network_api.disconnect_container_from_network(
self.network_driver.disconnect_container_from_network(
container, network_name, 'fake-net-id')
mock_disconnect.assert_called_once_with(
container.container_id, network_name)
# assert the neutron port is deleted
ports = self.network_api.neutron_api.list_ports(
ports = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports']
self.assertEqual(0, len(ports))
@ -348,13 +348,13 @@ class KuryrNetworkTestCase(base.TestCase):
addresses = {'fake-net-id': [{'port': 'fake-port-id'}]}
container = Container(self.context, **utils.get_test_container(
addresses=addresses))
mock_neutron_api_cls.return_value = self.network_api.neutron_api
old_port = self.network_api.neutron_api.list_ports(
mock_neutron_api_cls.return_value = self.network_driver.neutron_api
old_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
security_group_ids = ['sg2']
self.network_api.add_security_groups_to_ports(container,
security_group_ids)
new_port = self.network_api.neutron_api.list_ports(
self.network_driver.add_security_groups_to_ports(container,
security_group_ids)
new_port = self.network_driver.neutron_api.list_ports(
id='fake-port-id')['ports'][0]
old_secgroups = old_port.pop('security_groups')
new_secgroups = new_port.pop('security_groups')
@ -368,14 +368,14 @@ class KuryrNetworkTestCase(base.TestCase):
addresses = {'fake-net-id': [{'port': 'fake-port-id'}]}
container = Container(self.context, **utils.get_test_container(
addresses=addresses))
mock_neutron_api_cls.return_value = self.network_api.neutron_api
mock_neutron_api_cls.return_value = self.network_driver.neutron_api
security_group_ids = ['sg2']
with mock.patch.object(self.network_api.neutron_api,
with mock.patch.object(self.network_driver.neutron_api,
'update_port') as mock_update_port:
mock_update_port.side_effect = n_exc.BadRequest(
message='error')
self.assertRaises(exception.SecurityGroupCannotBeApplied,
self.network_api.add_security_groups_to_ports,
self.network_driver.add_security_groups_to_ports,
container, security_group_ids)
mock_update_port.assert_called_once_with(