Check network roles after node reassigning.

Checks that network roles mapping from an original cluster is a subset
of network roles mapping of a new cluster. Use info from network
templates if any.

Partial-Bug: #1619162
Depends-On: I5f26c77ad94f9469f4cc743afe1b82231ad0081a
Change-Id: Ibf79976278ea84b149d56d37535e1bd8fd1e836e

cluster_upgrade/objects/adapters.py

@@ -16,6 +16,8 @@
 
 from nailgun.extensions.volume_manager import extension as volume_ext
 from nailgun import objects
+from nailgun.orchestrator.deployment_serializers import \
+    get_serializer_for_cluster
 
 
 class NailgunClusterAdapter(object):
@@ -94,6 +96,19 @@ class NailgunClusterAdapter(object):
     def get_admin_network_group(self):
         return objects.NetworkGroup.get_admin_network_group()
 
+    def get_network_roles(self):
+        return objects.Cluster.get_network_roles(self.cluster)
+
+    def get_network_serializer(self):
+        serializer = get_serializer_for_cluster(self.cluster)
+        return serializer.get_net_provider_serializer(self.cluster)
+
+    def prepare_for_deployment(self, nodes=None):
+        objects.Cluster.prepare_for_deployment(
+            self.cluster,
+            [n.node for n in nodes] if nodes is not None else None
+        )
+
 
 class NailgunReleaseAdapter(object):
     def __init__(self, release):
@@ -155,6 +170,9 @@ class NailgunNetworkManager(object):
         return objects.Node.set_bond_assignment_netgroups_ids(
             node.node, mapping)
 
+    def get_node_networks(self, node, default_admin_net=None):
+        return self.net_manager.get_node_networks(node.node, default_admin_net)
+
 
 class NailgunNodeAdapter(object):
 

cluster_upgrade/tests/test_handlers.py

@@ -97,21 +97,45 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
         provisioned_uids = [int(n['uid']) for n in nodes]
         self.assertEqual([node_id], provisioned_uids)
 
-    @mock.patch('nailgun.task.task.rpc.cast')
+    @mock.patch('nailgun.rpc.cast')
     def test_node_reassign_handler_with_roles(self, mcast):
         cluster = self.env.create(
             cluster_kwargs={'api': False},
             nodes_kwargs=[{'status': consts.NODE_STATUSES.ready,
-                           'roles': ['controller']}])
+                           'roles': ['role_a']}],
+            release_kwargs={
+                'version': 'liberty-9.0',
+                'roles_metadata': {
+                    'role_a': {
+                        'name': 'Role A',
+                        'description': 'Role A is ...',
+                        'public_ip_required': True,
+                    },
+                },
+            },
+        )
         node = cluster.nodes[0]
-        seed_cluster = self.env.create_cluster(api=False)
+        seed_cluster = self.env.create(
+            cluster_kwargs={'api': False},
+            release_kwargs=dict(
+                version='mitaka-9.0',
+                roles_metadata={
+                    'role_b': {
+                        'name': 'Role B',
+                        'description': 'Role B is ...',
+                        'public_ip_required': True,
+                        'conflicts': ['role_a'],
+                    },
+                },
+            )
+        )
 
         # NOTE(akscram): reprovision=True means that the node will be
         #                re-provisioned during the reassigning. This is
         #                a default behavior.
         data = {'nodes_ids': [node.id],
                 'reprovision': True,
-                'roles': ['compute']}
+                'roles': ['role_b']}
         resp = self.app.post(
             reverse('NodeReassignHandler',
                     kwargs={'cluster_id': seed_cluster.id}),
@@ -119,7 +143,7 @@ class TestNodeReassignHandler(base.BaseIntegrationTest):
             headers=self.default_headers)
         self.assertEqual(202, resp.status_code)
         self.assertEqual(node.roles, [])
-        self.assertEqual(node.pending_roles, ['compute'])
+        self.assertEqual(node.pending_roles, ['role_b'])
         self.assertTrue(mcast.called)
 
     @mock.patch('nailgun.task.task.rpc.cast')

cluster_upgrade/upgrade.py

@@ -18,6 +18,8 @@ import copy
 import six
 
 from nailgun import consts
+from nailgun.db import db
+from nailgun import errors
 from nailgun.extensions.network_manager.objects.serializers import \
     network_configuration
 from nailgun import objects
@@ -180,8 +182,31 @@ class UpgradeHelper(object):
     @classmethod
     def assign_node_to_cluster(cls, node, seed_cluster, roles, pending_roles):
         orig_cluster = adapters.NailgunClusterAdapter.get_by_uid(
-            node.cluster_id)
+            node.cluster_id
+        )
 
+        orig_cluster.prepare_for_deployment([node])
+        orig_roles_mapping = cls._get_node_roles_mapping(node, orig_cluster)
+
+        cls._assign_node_to_cluster(
+            node, orig_cluster, seed_cluster, roles, pending_roles
+        )
+        db().flush()
+        db().refresh(node.node)
+
+        seed_cluster.prepare_for_deployment([node])
+        new_roles_mapping = cls._get_node_roles_mapping(node, seed_cluster)
+
+        if not set(orig_roles_mapping.items()).issubset(
+                set(new_roles_mapping.items())):
+            raise errors.ValidationException(
+                "Network changes during upgrade is not supported."
+            )
+
+    @classmethod
+    def _assign_node_to_cluster(cls, node,
+                                orig_cluster, seed_cluster,
+                                roles, pending_roles):
         volumes = cls.volumes_transformations.apply(
             orig_cluster.release.environment_version,
             seed_cluster.release.environment_version,
@@ -205,6 +230,15 @@ class UpgradeHelper(object):
 
         node.add_pending_change(consts.CLUSTER_CHANGES.interfaces)
 
+    @staticmethod
+    def _get_node_roles_mapping(node, cluster):
+        nm = cluster.get_network_manager()
+        serializer = cluster.get_network_serializer()
+
+        networks = nm.get_node_networks(node)
+        scheme = serializer.generate_network_scheme(node.node, networks)
+        return scheme['roles']
+
     @classmethod
     def get_netgroups_id_mapping(self, orig_cluster, seed_cluster):
         orig_ng = orig_cluster.get_network_groups()