def test_delete_default_network_group(self):
net_name = "storage"
node_group = objects.Cluster.get_default_group(self.cluster)
# delete one of default network group
storage_net = objects.NetworkGroup.get_from_node_group_by_name(
node_group.id, net_name)
objects.NetworkGroup.delete(storage_net)
# download default template and fix it
net_template = self.env.read_fixtures(['network_template'])[0]
template_meta = net_template["adv_net_template"]["default"]
# wide out network from template
del(template_meta["network_assignments"][net_name])
for k, v in template_meta["templates_for_node_role"].iteritems():
if net_name in v:
v.remove(net_name)
del(template_meta["network_scheme"][net_name])
# apply updated template to the cluster
objects.Cluster.set_network_template(
self.cluster,
net_template
)
serializer = get_serializer_for_cluster(self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
# serializer should not fail if we delete one of default network
# what is not used in template
net_serializer.generate_network_metadata(self.cluster)
def check_selective_gateway(self, use_net_template=False):
node = self.env.create_node(cluster_id=self.cluster.id, roles=["controller"], primary_roles=["controller"])
objects.Cluster.set_network_template(self.cluster, self.net_template if use_net_template else None)
objects.Cluster.prepare_for_deployment(self.cluster)
serializer = deployment_serializers.get_serializer_for_cluster(self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
networks_list = nm.get_node_networks(node)
networks = {net["name"]: net for net in networks_list}
endpoints = net_serializer.generate_network_scheme(node, networks_list)["endpoints"]
na = self.net_template["adv_net_template"]["default"]["network_assignments"]
ep_net_map = {na[net_name]["ep"]: net_name for net_name in na}
for name in endpoints:
if name not in ep_net_map:
self.assertNotIn("vendor_specific", endpoints[name])
continue
if networks[ep_net_map[name]].get("gateway") is None:
self.assertNotIn("vendor_specific", endpoints[name])
else:
self.assertIn("vendor_specific", endpoints[name])
self.assertEqual(
endpoints[name]["vendor_specific"]["provider_gateway"], networks[ep_net_map[name]]["gateway"]
)
def check_selective_gateway(self, use_net_template=False):
node = self.env.create_node(cluster_id=self.cluster.id,
roles=['controller'],
primary_roles=['controller'])
objects.Cluster.set_network_template(
self.cluster, self.net_template if use_net_template else None)
objects.Cluster.prepare_for_deployment(self.cluster)
serializer = deployment_serializers.get_serializer_for_cluster(
self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
networks_list = nm.get_node_networks(node)
networks = {net['name']: net for net in networks_list}
endpoints = net_serializer.generate_network_scheme(
node, networks_list)['endpoints']
na = self.net_template['adv_net_template']['default'][
'network_assignments']
ep_net_map = {na[net_name]['ep']: net_name for net_name in na}
for name in endpoints:
if name not in ep_net_map:
self.assertNotIn('vendor_specific', endpoints[name])
continue
if networks[ep_net_map[name]].get('gateway') is None:
self.assertNotIn('vendor_specific', endpoints[name])
else:
self.assertIn('vendor_specific', endpoints[name])
self.assertEqual(
endpoints[name]['vendor_specific']['provider_gateway'],
networks[ep_net_map[name]]['gateway'])
def check_selective_gateway(self, use_net_template=False):
node = self.env.create_node(
cluster_id=self.cluster.id,
roles=['controller'], primary_roles=['controller']
)
objects.Cluster.set_network_template(
self.cluster,
self.net_template if use_net_template else None)
objects.Cluster.prepare_for_deployment(self.cluster)
serializer = deployment_serializers.get_serializer_for_cluster(
self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
networks_list = nm.get_node_networks(node)
networks = {net['name']: net for net in networks_list}
endpoints = net_serializer.generate_network_scheme(
node, networks_list)['endpoints']
na = self.net_template[
'adv_net_template']['default']['network_assignments']
ep_net_map = {na[net_name]['ep']: net_name for net_name in na}
for name in endpoints:
if name not in ep_net_map:
self.assertNotIn('vendor_specific', endpoints[name])
continue
if networks[ep_net_map[name]].get('gateway') is None:
self.assertNotIn('vendor_specific', endpoints[name])
else:
self.assertIn('vendor_specific', endpoints[name])
self.assertEqual(
endpoints[name]['vendor_specific']['provider_gateway'],
networks[ep_net_map[name]]['gateway'])
def test_multiple_node_roles_transformations(self):
node = self.cluster.nodes[1]
serializer = get_serializer_for_cluster(self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
transformations = net_serializer.generate_transformations(node)
# Two node roles with the same template should only generate one
# transformation.
admin_brs = filter(lambda t: t.get('name') == 'br-fw-admin',
transformations)
self.assertEqual(1, len(admin_brs))
# Templates are applied in the order as defined in the template.
# storage network template is applied after the 4 transformations
# in common
self.assertEqual('br-storage', transformations[4]['name'])
# Ensure all ports connected to br-mgmt happen after the bridge
# has been created
port_seen = False
for tx in transformations:
if tx.get('name') == 'br-mgmt' and tx['action'] == 'add-br' \
and port_seen:
self.fail('Port was added to br-mgmt prior to the bridge '
'being created')
if tx.get('bridge') == 'br-mgmt' and tx['action'] == 'add-port':
port_seen = True
def test_baremetal_neutron_attrs(self):
brmtl_template = deepcopy(
self.net_template['adv_net_template']['default'])
brmtl_template['network_assignments']['baremetal'] = {
'ep': 'br-baremetal'
}
brmtl_template['templates_for_node_role']['controller'].append(
'baremetal')
brmtl_template['nic_mapping']['default']['if8'] = 'eth7'
brmtl_template['network_scheme']['baremetal'] = {
'endpoints': ['br-baremetal'],
'transformations': [],
'roles': {
'baremetal': 'br-baremetal'
}
}
self.cluster.network_config.configuration_template = {
'adv_net_template': {
'default': brmtl_template
},
'pk': 1
}
serializer_type = get_serializer_for_cluster(self.cluster)
self.serializer = serializer_type(AstuteGraph(self.cluster))
self._check_baremetal_neutron_attrs(self.cluster)
def test_process_skipped_task(self):
self.prepare_plugins_for_cluster(
self.cluster,
[
{
'name': 'task_with_skipped_plugin',
'deployment_tasks': [
{
'id': 'skipped_task',
'type': 'skipped',
},
],
},
]
)
graph = AstuteGraph(self.cluster)
objects.NodeCollection.prepare_for_deployment(self.cluster.nodes)
serializer = \
get_serializer_for_cluster(self.cluster)(graph)
serialized = serializer.serialize(self.cluster, self.cluster.nodes)
tasks = serialized[0]['tasks']
release_depl_tasks_ids = ('first-fake-depl-task',
'second-fake-depl-task')
serialized_tasks_ids = (t['parameters']['puppet_manifest']
for t in tasks)
self.assertItemsEqual(release_depl_tasks_ids, serialized_tasks_ids)
def serialize_node(cls, node, data, **kwargs):
if objects.Release.is_lcm_supported(node.cluster.release):
return data
else:
serializer = get_serializer_for_cluster(node.cluster)()
serializer.initialize(node.cluster)
role = objects.Node.all_roles(node)[0]
real_data = serializer.serialize_node(node, role)
return real_data
def _serialize_nodes(self, nodes):
serializer = deployment_serializers.get_serializer_for_cluster(
self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
serialized_nodes = serializer.node_list(nodes)
serialized_nodes = net_serializer.update_nodes_net_info(
self.cluster, serialized_nodes)
return serialized_nodes
def _serialize_nodes(self, nodes):
serializer = deployment_serializers.get_serializer_for_cluster(
self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
serialized_nodes = serializer.node_list(nodes)
serialized_nodes = net_serializer.update_nodes_net_info(
self.cluster, serialized_nodes)
return serialized_nodes
def setUp(self, *args):
super(TestDeploymentAttributesSerialization70, self).setUp()
self.cluster = self.create_env('ha_compact')
# NOTE: 'prepare_for_deployment' is going to be changed for 7.0
objects.NodeCollection.prepare_for_deployment(self.env.nodes, 'vlan')
cluster_db = self.db.query(Cluster).get(self.cluster['id'])
serializer = get_serializer_for_cluster(cluster_db)
self.serialized_for_astute = serializer(
AstuteGraph(cluster_db)).serialize(cluster_db, cluster_db.nodes)
def setUp(self, *args):
super(TestDeploymentAttributesSerialization70, self).setUp()
self.cluster = self.create_env('ha_compact')
# NOTE: 'prepare_for_deployment' is going to be changed for 7.0
objects.NodeCollection.prepare_for_deployment(self.env.nodes, 'vlan')
cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
serializer = get_serializer_for_cluster(cluster_db)
self.serialized_for_astute = serializer(
AstuteGraph(cluster_db)).serialize(cluster_db, cluster_db.nodes)
def test_get_net_provider_serializer(self):
serializer = get_serializer_for_cluster(self.cluster)
self.cluster.network_config.configuration_template = None
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, self.legacy_serializer)
self.cluster.network_config.configuration_template = \
self.net_template
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, self.template_serializer)
def setUp(self):
super(BaseTestDeploymentAttributesSerialization70, self).setUp()
self.cluster = self.create_env('ha_compact')
self.prepare_for_deployment(self.env.nodes)
self.cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
serializer_type = get_serializer_for_cluster(self.cluster_db)
self.serializer = serializer_type(AstuteGraph(self.cluster_db))
self.serialized_for_astute = self.serializer.serialize(
self.cluster_db, self.cluster_db.nodes)
self.vm_data = self.env.read_fixtures(['vmware_attributes'])
def test_get_net_provider_serializer(self):
serializer = get_serializer_for_cluster(self.cluster)
self.cluster.network_config.configuration_template = None
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, self.legacy_serializer)
self.cluster.network_config.configuration_template = \
self.net_template
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, self.template_serializer)
def test_get_net_provider_serializer(self):
serializer = get_serializer_for_cluster(self.cluster)
self.cluster.network_config.configuration_template = None
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, NeutronNetworkDeploymentSerializer80)
self.cluster.network_config.configuration_template = \
self.net_template
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, NeutronNetworkTemplateSerializer80)
def test_get_net_provider_serializer(self):
serializer = get_serializer_for_cluster(self.cluster)
self.cluster.network_config.configuration_template = None
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, NeutronNetworkDeploymentSerializer80)
self.cluster.network_config.configuration_template = \
self.net_template
net_serializer = serializer.get_net_provider_serializer(self.cluster)
self.assertIs(net_serializer, NeutronNetworkTemplateSerializer80)
def setUp(self):
super(TestBlockDeviceDevicesSerialization80, self).setUp()
self.cluster = self.env.create(
release_kwargs={'version': self.env_version},
cluster_kwargs={
'mode': consts.CLUSTER_MODES.ha_compact,
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.vlan})
self.cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
serializer_type = get_serializer_for_cluster(self.cluster_db)
self.serializer = serializer_type(AstuteGraph(self.cluster_db))
def setUp(self, *args):
super(TestDeploymentSerializationForNovaNetwork70, self).setUp()
self.cluster = self.create_env('ha_compact')
# NOTE: 'prepare_for_deployment' is going to be changed for 7.0
objects.NodeCollection.prepare_for_deployment(self.env.nodes)
cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
serializer_type = get_serializer_for_cluster(cluster_db)
self.serializer = serializer_type(AstuteGraph(cluster_db))
self.serialized_for_astute = self.serializer.serialize(
cluster_db, cluster_db.nodes)
self.vm_data = self.env.read_fixtures(['vmware_attributes'])
def serialize_cluster(cls, cluster, data, **kwargs):
if objects.Release.is_lcm_supported(cluster.release):
return data
else:
serializer = get_serializer_for_cluster(cluster)()
serializer.initialize(cluster)
common_attrs = serializer.get_common_attrs(cluster)
if cluster.replaced_deployment_info:
# patch common attributes with custom deployment info
utils.dict_update(common_attrs,
cluster.replaced_deployment_info)
return common_attrs
def test_network_schemes_priorities(self):
expected = [{
"action": "add-br",
"name": "br-prv",
"provider": "ovs"
}, {
"action": "add-br",
"name": "br-aux"
}, {
"action": "add-patch",
"bridges": ["br-prv", "br-aux"],
"provider": "ovs",
"mtu": 65000
}, {
"action": "add-port",
"bridge": "br-aux",
"name": "eth3.101"
}, {
"action": "add-br",
"name": "br-fw-admin"
}, {
"action": "add-port",
"bridge": "br-fw-admin",
"name": "eth0"
}, {
"action": "add-br",
"name": "br-mgmt"
}, {
"action": "add-port",
"bridge": "br-mgmt",
"name": "eth1.104"
}, {
"action": "add-br",
"name": "br-storage"
}, {
"action": "add-port",
"bridge": "br-storage",
"name": "eth2"
}]
objects.Cluster.set_network_template(self.cluster, self.net_template)
node = self.env.create_nodes_w_interfaces_count(
1, 8, roles=['compute', 'cinder'], cluster_id=self.cluster.id)[0]
self.serializer = get_serializer_for_cluster(self.cluster)
net_serializer = self.serializer.get_net_provider_serializer(
self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
network_scheme = net_serializer.generate_network_scheme(
node, nm.get_node_networks(node))
self.assertEqual(expected, network_scheme['transformations'])
def check_vendor_specific_is_not_set(self, use_net_template=False):
node = self.env.create_node(cluster_id=self.cluster.id, roles=["controller"], primary_roles=["controller"])
objects.Cluster.set_network_template(self.cluster, self.net_template if use_net_template else None)
objects.Cluster.prepare_for_deployment(self.cluster)
serializer = deployment_serializers.get_serializer_for_cluster(self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
networks = nm.get_node_networks(node)
endpoints = net_serializer.generate_network_scheme(node, networks)["endpoints"]
for name in endpoints:
# Just 'provider_gateway' can be in 'vendor_specific'
if endpoints[name].get("vendor_specific"):
self.assertItemsEqual(["provider_gateway"], endpoints[name]["vendor_specific"])
def setUp(self, *args):
super(TestNetworkTemplateSerializer70, self).setUp()
self.cluster = self.create_env('ha_compact')
self.net_template = self.env.read_fixtures(['network_template'])[0]
objects.Cluster.set_network_template(
self.cluster,
self.net_template
)
self.prepare_for_deployment(self.env.nodes)
cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
serializer = get_serializer_for_cluster(self.cluster)
self.serialized_for_astute = serializer(
AstuteGraph(cluster_db)).serialize(self.cluster, cluster_db.nodes)
def setUp(self):
super(TestMultiNodeGroupsSerialization80, self).setUp()
cluster = self.env.create(
release_kwargs={'version': self.env_version},
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.vlan}
)
self.env.create_nodes_w_interfaces_count(
nodes_count=3,
if_count=2,
roles=['controller', 'cinder'],
pending_addition=True,
cluster_id=cluster['id'])
self.cluster_db = self.db.query(models.Cluster).get(cluster['id'])
serializer_type = get_serializer_for_cluster(self.cluster_db)
self.serializer = serializer_type(AstuteGraph(self.cluster_db))
def test_baremetal_neutron_attrs(self):
brmtl_template = deepcopy(
self.net_template['adv_net_template']['default'])
brmtl_template['network_assignments']['baremetal'] = {
'ep': 'br-baremetal'}
brmtl_template['templates_for_node_role']['controller'].append(
'baremetal')
brmtl_template['nic_mapping']['default']['if8'] = 'eth7'
brmtl_template['network_scheme']['baremetal'] = {
'endpoints': ['br-baremetal'],
'transformations': [],
'roles': {'baremetal': 'br-baremetal'}}
self.cluster.network_config.configuration_template = {
'adv_net_template': {'default': brmtl_template}, 'pk': 1}
serializer_type = get_serializer_for_cluster(self.cluster)
self.serializer = serializer_type(AstuteGraph(self.cluster))
self._check_baremetal_neutron_attrs(self.cluster)
def setUp(self):
super(TestMultiNodeGroupsSerialization80, self).setUp()
cluster = self.env.create(
release_kwargs={'version': self.env_version},
cluster_kwargs={
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
'net_segment_type': consts.NEUTRON_SEGMENT_TYPES.vlan}
)
self.env.create_nodes_w_interfaces_count(
nodes_count=3,
if_count=2,
roles=['controller', 'cinder'],
pending_addition=True,
cluster_id=cluster['id'])
self.cluster_db = self.db.query(models.Cluster).get(cluster['id'])
serializer_type = get_serializer_for_cluster(self.cluster_db)
self.serializer = serializer_type(AstuteGraph(self.cluster_db))
def test_plugin_depl_tasks_proper_injections(self):
self.prepare_plugins_for_cluster(
self.cluster,
[
{
'name': 'between_rel_tasks',
'deployment_tasks': [
{
'id': 'between-rel-tasks',
'type': 'puppet',
'groups': ['primary-controller'],
'requires': ['first-fake-depl-task'],
'required_for': ['second-fake-depl-task'],
'parameters': {
'puppet_manifest': 'between-rel-tasks',
'puppet_modules': 'test',
'timeout': 0,
}
},
],
},
]
)
graph = AstuteGraph(self.cluster)
objects.NodeCollection.prepare_for_deployment(self.cluster.nodes)
serializer = \
get_serializer_for_cluster(self.cluster)(graph)
serialized = serializer.serialize(self.cluster, self.cluster.nodes)
serialized_tasks = serialized[0]['tasks']
expected_priority = {
100: 'first-fake-depl-task',
200: 'between-rel-tasks',
300: 'second-fake-depl-task',
}
for task in serialized_tasks:
task_identificator = task['parameters']['puppet_manifest']
self.assertEqual(
task_identificator, expected_priority[task['priority']]
)
def check_vendor_specific_is_not_set(self, use_net_template=False):
node = self.env.create_node(cluster_id=self.cluster.id,
roles=['controller'],
primary_roles=['controller'])
objects.Cluster.set_network_template(
self.cluster, self.net_template if use_net_template else None)
objects.Cluster.prepare_for_deployment(self.cluster)
serializer = deployment_serializers.get_serializer_for_cluster(
self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
networks = nm.get_node_networks(node)
endpoints = net_serializer.generate_network_scheme(
node, networks)['endpoints']
for name in endpoints:
# Just 'provider_gateway' can be in 'vendor_specific'
if endpoints[name].get('vendor_specific'):
self.assertItemsEqual(['provider_gateway'],
endpoints[name]['vendor_specific'])
def test_plugin_depl_task_overwrite_from_rel(self):
self.prepare_plugins_for_cluster(
self.cluster,
[
{
'name': 'between_rel_tasks',
'deployment_tasks': [
{
'id': 'first-fake-depl-task',
'type': 'puppet',
'groups': ['primary-controller'],
'requires': ['deploy_start'],
'required_for': ['second-fake-depl-task'],
'parameters': {
'puppet_manifest': 'plugin_task',
'puppet_modules': 'test',
'timeout': 0,
}
},
],
},
]
)
graph = AstuteGraph(self.cluster)
objects.NodeCollection.prepare_for_deployment(self.cluster.nodes)
serializer = \
get_serializer_for_cluster(self.cluster)(graph)
serialized = serializer.serialize(self.cluster, self.cluster.nodes)
serialized_tasks = serialized[0]['tasks']
needed_task_priority = next(
t['priority'] for t in serialized_tasks
if t['parameters']['puppet_manifest'] == 'plugin_task'
)
# first task in graph has priority equal 100
self.assertEqual(needed_task_priority, 100)
def test_floating_role_belongs_to_public_bridge(self):
# download default template and assign floating role to public bridge
net_template = self.env.read_fixtures(['network_template'])[0]
schemes = net_template["adv_net_template"]["default"]["network_scheme"]
schemes["public"]["roles"]["neutron/floating"] = "br-ex"
# apply updated template to the cluster
objects.Cluster.set_network_template(
self.cluster,
net_template
)
cluster_db = self.db.query(models.Cluster).get(self.cluster['id'])
nm = objects.Cluster.get_network_manager(self.env.clusters[0])
serializer = get_serializer_for_cluster(self.cluster)
self.serialized_for_astute = serializer(
AstuteGraph(cluster_db)).serialize(self.cluster, cluster_db.nodes)
for node_data in self.serialized_for_astute:
node = objects.Node.get_by_uid(node_data['uid'])
# check nodes with assigned public ip
if objects.Node.should_have_public_with_ip(node):
nets = nm.get_node_networks(node)
ng = nm.get_network_by_netname('public', nets)
endpoints = node_data["network_scheme"]["endpoints"]
self.assertEqual(endpoints["br-ex"]["IP"], [ng.get('ip')])
def test_usage_of_latest_serializer_in_case_of_new_release(self):
cluster = mock.MagicMock(is_ha_mode=True)
cluster.release.environment_version = '9999.0'
self.assertIs(ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer90)
def test_retreiving_ha_for_8_0(self):
cluster = mock.MagicMock(is_ha_mode=True)
cluster.release.environment_version = '8.0'
self.assertIs(ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer80)
def test_retreiving_multinode_for_6_1(self):
cluster = mock.MagicMock(is_ha_mode=False)
cluster.release.environment_version = '6.1'
self.assertIs(ds.get_serializer_for_cluster(cluster),
ds.DeploymentMultinodeSerializer61)
def test_retreiving_ha_for_5_1(self, _):
cluster = mock.MagicMock(is_ha_mode=True)
self.assertIs(ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer51)
def create_serializer(cls, cluster):
serializer_type = deployment_serializers.get_serializer_for_cluster(
cluster)
return serializer_type(None)
def test_usage_of_latest_serializer_in_case_of_new_release(self, _):
cluster = mock.MagicMock(is_ha_mode=False)
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentMultinodeSerializer61)
def test_unsupported_serializer(self, _):
cluster = mock.MagicMock(is_ha_mode=True)
with self.assertRaises(errors.UnsupportedSerializer):
ds.get_serializer_for_cluster(cluster)
def test_retreiving_ha_for_5_1(self, _):
cluster = mock.MagicMock(is_ha_mode=True)
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer51)
def create_serializer(cls, cluster):
serializer_type = deployment_serializers.get_serializer_for_cluster(
cluster
)
return serializer_type(None)
def test_retreiving_multinode_for_5_1(self, _):
cluster = mock.MagicMock(is_ha_mode=False)
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentMultinodeSerializer51)
def test_usage_of_latest_serializer_in_case_of_new_release_ha(self, _):
cluster = mock.MagicMock(is_ha_mode=True)
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer70)
def create_serializer(cls, cluster):
serializer_type = get_serializer_for_cluster(cluster)
return serializer_type(AstuteGraph(cluster))
def _get_serializer(self, cluster):
return get_serializer_for_cluster(cluster)(AstuteGraph(cluster))
def test_network_schemes_priorities(self):
expected = [
{
"action": "add-br",
"name": "br-prv",
"provider": "ovs"
},
{
"action": "add-br",
"name": "br-aux"
},
{
"action": "add-patch",
"bridges": [
"br-prv",
"br-aux"
],
"provider": "ovs",
"mtu": 65000
},
{
"action": "add-port",
"bridge": "br-aux",
"name": "eth3.101"
},
{
"action": "add-br",
"name": "br-fw-admin"
},
{
"action": "add-port",
"bridge": "br-fw-admin",
"name": "eth0"
},
{
"action": "add-br",
"name": "br-mgmt"
},
{
"action": "add-port",
"bridge": "br-mgmt",
"name": "eth1.104"
},
{
"action": "add-br",
"name": "br-storage"
},
{
"action": "add-port",
"bridge": "br-storage",
"name": "eth2"
}
]
objects.Cluster.set_network_template(
self.cluster,
self.net_template
)
node = self.env.create_nodes_w_interfaces_count(
1, 8, roles=['compute', 'cinder'],
cluster_id=self.cluster.id
)[0]
serializer = get_serializer_for_cluster(self.cluster)
net_serializer = serializer.get_net_provider_serializer(self.cluster)
nm = objects.Cluster.get_network_manager(self.cluster)
network_scheme = net_serializer.generate_network_scheme(
node, nm.get_node_networks(node))
self.assertEqual(expected, network_scheme['transformations'])
def test_retreiving_ha_for_5_0(self):
cluster = mock.MagicMock(is_ha_mode=True)
cluster.release.environment_version = '5.0'
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer50)
def create_serializer(cls, cluster):
serializer_type = get_serializer_for_cluster(cluster)
return serializer_type(AstuteGraph(cluster))
def test_retreiving_multinode_for_5_1(self):
cluster = mock.MagicMock(is_ha_mode=False)
cluster.release.environment_version = '5.1'
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentMultinodeSerializer51)
def test_usage_of_latest_serializer_in_case_of_new_release(self):
cluster = mock.MagicMock(is_ha_mode=True)
cluster.release.environment_version = '9999.0'
self.assertIs(
ds.get_serializer_for_cluster(cluster),
ds.DeploymentHASerializer70)
def test_retreiving_multinode_for_5_1(self, _):
cluster = mock.MagicMock(is_ha_mode=False)
self.assertIs(ds.get_serializer_for_cluster(cluster),
ds.DeploymentMultinodeSerializer51)
