2183 lines
81 KiB
Python
2183 lines
81 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright 2014 Mirantis, Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import copy
|
|
import datetime
|
|
import hashlib
|
|
import mock
|
|
|
|
from itertools import cycle
|
|
from itertools import ifilter
|
|
|
|
from nailgun.db import db
|
|
from nailgun.db.sqlalchemy import models
|
|
import uuid
|
|
|
|
from sqlalchemy import inspect as sqlalchemy_inspect
|
|
from sqlalchemy.orm import Query
|
|
|
|
import jsonschema
|
|
from oslo_serialization import jsonutils
|
|
import six
|
|
from six.moves import range
|
|
|
|
from nailgun.api.v1.validators.json_schema import action_log
|
|
from nailgun.test.base import BaseIntegrationTest
|
|
from nailgun.test.base import BaseTestCase
|
|
from nailgun.utils import reverse
|
|
|
|
from nailgun import errors
|
|
|
|
from nailgun import consts
|
|
from nailgun import plugins
|
|
|
|
from nailgun.db.sqlalchemy.models import NodeGroup
|
|
from nailgun.db.sqlalchemy.models import Task
|
|
|
|
from nailgun.extensions.network_manager.manager import NetworkManager
|
|
from nailgun.extensions.network_manager.managers import neutron
|
|
from nailgun.extensions.network_manager.managers import nova_network
|
|
|
|
from nailgun import objects
|
|
from nailgun.plugins.manager import PluginManager
|
|
from nailgun.settings import settings
|
|
from nailgun.test import base
|
|
from nailgun.utils import dict_merge
|
|
|
|
|
|
class TestObjects(BaseIntegrationTest):
|
|
|
|
def test_filter_by(self):
|
|
names = cycle('ABCD')
|
|
os = cycle([consts.RELEASE_OS.centos, consts.RELEASE_OS.ubuntu])
|
|
for i in range(12):
|
|
self.env.create_release(
|
|
name=names.next(),
|
|
operating_system=os.next()
|
|
)
|
|
|
|
# filtering query - returns query
|
|
query_filtered = objects.ReleaseCollection.filter_by(
|
|
objects.ReleaseCollection.all(),
|
|
name="A",
|
|
operating_system=consts.RELEASE_OS.centos
|
|
)
|
|
self.assertIsInstance(query_filtered, Query)
|
|
self.assertEqual(
|
|
objects.ReleaseCollection.count(query_filtered),
|
|
3
|
|
)
|
|
for r in query_filtered:
|
|
self.assertEqual(r.name, "A")
|
|
self.assertEqual(r.operating_system, consts.RELEASE_OS.centos)
|
|
|
|
# filtering iterable - returns ifilter
|
|
iterable_filtered = objects.ReleaseCollection.filter_by(
|
|
list(objects.ReleaseCollection.all()),
|
|
name="A",
|
|
operating_system=consts.RELEASE_OS.centos
|
|
)
|
|
self.assertIsInstance(iterable_filtered, ifilter)
|
|
self.assertEqual(
|
|
objects.ReleaseCollection.count(iterable_filtered),
|
|
3
|
|
)
|
|
for r in iterable_filtered:
|
|
self.assertEqual(r.name, "A")
|
|
self.assertEqual(r.operating_system, consts.RELEASE_OS.centos)
|
|
|
|
iterable_filtered = objects.ReleaseCollection.filter_by(
|
|
list(),
|
|
name="A",
|
|
)
|
|
self.assertIsInstance(iterable_filtered, ifilter)
|
|
self.assertEquals(0, len(list(iterable_filtered)))
|
|
|
|
def test_filter_by_not(self):
|
|
names = cycle('ABCDE')
|
|
os = cycle([consts.RELEASE_OS.centos, consts.RELEASE_OS.ubuntu])
|
|
|
|
# create releases: we'll have only two releases with both
|
|
# name A and operating_system CentOS
|
|
for i in range(12):
|
|
self.env.create_release(
|
|
name=names.next(),
|
|
operating_system=os.next()
|
|
)
|
|
|
|
# filtering query - returns query
|
|
query_filtered = objects.ReleaseCollection.filter_by_not(
|
|
objects.ReleaseCollection.all(),
|
|
name="A",
|
|
operating_system=consts.RELEASE_OS.centos
|
|
)
|
|
self.assertIsInstance(query_filtered, Query)
|
|
self.assertEqual(
|
|
objects.ReleaseCollection.count(query_filtered),
|
|
10
|
|
)
|
|
for r in query_filtered:
|
|
if r.name == "A":
|
|
self.assertNotEqual(r.operating_system,
|
|
consts.RELEASE_OS.centos)
|
|
elif r.operating_system == consts.RELEASE_OS.centos:
|
|
self.assertNotEqual(r.name, "A")
|
|
|
|
# filtering iterable - returns ifilter
|
|
iterable_filtered = objects.ReleaseCollection.filter_by_not(
|
|
list(objects.ReleaseCollection.all()),
|
|
name="A",
|
|
operating_system=consts.RELEASE_OS.centos
|
|
)
|
|
self.assertIsInstance(iterable_filtered, ifilter)
|
|
self.assertEqual(
|
|
objects.ReleaseCollection.count(iterable_filtered),
|
|
10
|
|
)
|
|
for r in iterable_filtered:
|
|
if r.name == "A":
|
|
self.assertNotEqual(r.operating_system,
|
|
consts.RELEASE_OS.centos)
|
|
elif r.operating_system == consts.RELEASE_OS.centos:
|
|
self.assertNotEqual(r.name, "A")
|
|
|
|
def test_to_list_iterable_none(self):
|
|
nodes_count = 3
|
|
self.env.create_nodes(nodes_count)
|
|
nodes_db = objects.NodeCollection.to_list()
|
|
self.assertEqual(nodes_count, len(nodes_db))
|
|
|
|
def test_to_list_iterable_empty(self):
|
|
nodes_count = 3
|
|
self.env.create_nodes(nodes_count)
|
|
# check that nodes were created
|
|
self.assertEqual(nodes_count, len(self.env.nodes))
|
|
nodes_db = objects.NodeCollection.to_list([])
|
|
self.assertEqual(0, len(nodes_db))
|
|
|
|
|
|
class TestNodeObject(BaseIntegrationTest):
|
|
|
|
@mock.patch('nailgun.objects.node.fire_callback_on_node_delete')
|
|
def test_delete(self, callback_mock):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={'api': False},
|
|
nodes_kwargs=[{'role': 'controller'}])
|
|
node_db = cluster.nodes[0]
|
|
self.assertEqual(len(cluster.nodes), 1)
|
|
objects.Node.delete(node_db)
|
|
callback_mock.assert_called_once_with(node_db)
|
|
self.db.refresh(cluster)
|
|
self.assertEqual(len(cluster.nodes), 0)
|
|
|
|
@mock.patch(
|
|
'nailgun.objects.node.'
|
|
'fire_callback_on_node_collection_delete')
|
|
def test_delete_by_ids(self, callback_mock):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={'api': False},
|
|
nodes_kwargs=[{'role': 'controller'}] * 3)
|
|
ids = [n.id for n in cluster.nodes]
|
|
self.assertEqual(len(ids), 3)
|
|
objects.NodeCollection.delete_by_ids(ids)
|
|
callback_mock.assert_called_once_with(ids)
|
|
self.db.refresh(cluster)
|
|
self.assertEqual(len(cluster.nodes), 0)
|
|
|
|
def test_update_cluster_assignment(self):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={'api': False},
|
|
nodes_kwargs=[{'role': 'controller'}] * 3)
|
|
new_cluster = self.env.create_cluster(api=False)
|
|
new_group = objects.Cluster.get_default_group(new_cluster)
|
|
node = cluster.nodes[0]
|
|
roles = node.roles
|
|
objects.Node.update_cluster_assignment(node, new_cluster, [], roles)
|
|
self.assertEqual(new_cluster.id, node.cluster_id)
|
|
self.assertEqual(new_group.id, node.group_id)
|
|
self.assertEqual([], node.roles)
|
|
self.assertEqual([], node.primary_tags)
|
|
self.assertItemsEqual(roles, node.pending_roles)
|
|
self.assertEqual(node.attributes, cluster.release.node_attributes)
|
|
|
|
def test_assign_group(self):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={'api': False},
|
|
nodes_kwargs=[{'role': 'controller'}] * 3)
|
|
new_cluster = self.env.create_cluster(api=False)
|
|
data = {
|
|
'name': 'custom',
|
|
'cluster_id': new_cluster.id
|
|
}
|
|
new_group = objects.NodeGroup.create(data)
|
|
admin_group_id = db().query(
|
|
models.NetworkGroup.id
|
|
).join(
|
|
models.NetworkGroup.nodegroup
|
|
).filter(
|
|
models.NodeGroup.cluster_id == new_group.cluster_id,
|
|
models.NetworkGroup.name == consts.NETWORKS.fuelweb_admin
|
|
).first()
|
|
admin_group = objects.NetworkGroup.get_by_uid(admin_group_id)
|
|
admin_group.cidr = '10.20.0.0/24'
|
|
node = cluster.nodes[0]
|
|
roles = node.roles
|
|
objects.Node.update_cluster_assignment(node, new_cluster, [], roles)
|
|
self.assertEqual(new_group.id, node.group_id)
|
|
|
|
def test_update_cluster_assignment_with_templates_80(self):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={'api': False},
|
|
nodes_kwargs=[{'role': 'controller'}] * 3)
|
|
new_cluster = self.env.create(
|
|
cluster_kwargs={'api': False},
|
|
release_kwargs={'version': 'liberty-8.0'},
|
|
)
|
|
|
|
net_template = self.env.read_fixtures(['network_template_80'])[0]
|
|
objects.Cluster.set_network_template(new_cluster, net_template)
|
|
|
|
new_group = objects.Cluster.get_default_group(new_cluster)
|
|
node = cluster.nodes[0]
|
|
roles = node.roles
|
|
objects.Node.update_cluster_assignment(node, new_cluster, [], roles)
|
|
self.assertEqual(new_cluster.id, node.cluster_id)
|
|
self.assertEqual(new_group.id, node.group_id)
|
|
self.assertEqual([], node.roles)
|
|
self.assertEqual([], node.primary_tags)
|
|
self.assertItemsEqual(roles, node.pending_roles)
|
|
self.assertIsNotNone(node.network_template)
|
|
endpoints = node.network_template['templates']['common']['endpoints']
|
|
self.assertEqual([u'br-mgmt', u'br-fw-admin'], endpoints)
|
|
|
|
def test_adding_to_cluster_kernel_params_centos(self):
|
|
self.env.create(
|
|
release_kwargs={
|
|
"operating_system": consts.RELEASE_OS.centos
|
|
},
|
|
cluster_kwargs={},
|
|
nodes_kwargs=[
|
|
{"role": "controller"}
|
|
]
|
|
)
|
|
node_db = self.env.nodes[0]
|
|
self.assertEqual(
|
|
objects.Node.get_kernel_params(node_db),
|
|
(
|
|
'console=tty0 '
|
|
'biosdevname=0 '
|
|
'crashkernel=none '
|
|
'rootdelay=90 '
|
|
'nomodeset'
|
|
)
|
|
)
|
|
|
|
def test_adding_to_cluster_kernel_params_ubuntu(self):
|
|
self.env.create(
|
|
release_kwargs={
|
|
"operating_system": consts.RELEASE_OS.ubuntu,
|
|
"attributes_metadata": {
|
|
"editable": {
|
|
"kernel_params": {
|
|
"kernel": {
|
|
"value": (
|
|
"console=tty0 "
|
|
"rootdelay=90 "
|
|
"nomodeset"
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
cluster_kwargs={},
|
|
nodes_kwargs=[
|
|
{"role": "controller"}
|
|
]
|
|
)
|
|
node_db = self.env.nodes[0]
|
|
self.assertEqual(
|
|
objects.Node.get_kernel_params(node_db),
|
|
(
|
|
'console=tty0 '
|
|
'rootdelay=90 '
|
|
'nomodeset'
|
|
)
|
|
)
|
|
|
|
def test_get_kernel_params_overwritten(self):
|
|
"""Test verifies that overwriten kernel params will be returned."""
|
|
cluster = self.env.create(
|
|
nodes_kwargs=[
|
|
{"role": "controller"}
|
|
])
|
|
additional_kernel_params = 'intel_iommu=true'
|
|
default_kernel_params = objects.Cluster.get_default_kernel_params(
|
|
cluster)
|
|
kernel_params = '{0} {1}'.format(default_kernel_params,
|
|
additional_kernel_params)
|
|
self.env.nodes[0].kernel_params = kernel_params
|
|
self.assertNotEqual(
|
|
objects.Node.get_kernel_params(self.env.nodes[0]),
|
|
default_kernel_params)
|
|
self.assertEqual(
|
|
objects.Node.get_kernel_params(self.env.nodes[0]),
|
|
kernel_params)
|
|
|
|
def test_get_kernel_params_w_old_release(self):
|
|
cluster = self.env.create(
|
|
release_kwargs={
|
|
'operating_system': consts.RELEASE_OS.ubuntu,
|
|
'version': '2015.1.0-8.0',
|
|
},
|
|
nodes_kwargs=[
|
|
{"role": "compute"}
|
|
]
|
|
)
|
|
node = cluster.nodes[0]
|
|
del node.meta['numa_topology']
|
|
self.assertNotRaises(KeyError, objects.Node.get_kernel_params, node)
|
|
|
|
def test_should_have_public_with_ip(self):
|
|
nodes = [
|
|
{'roles': ['controller', 'cinder'], 'pending_addition': True},
|
|
{'roles': ['compute', 'cinder'], 'pending_addition': True},
|
|
{'roles': ['compute'], 'pending_addition': True},
|
|
{'roles': ['mongo'], 'pending_addition': True},
|
|
{'roles': [], 'pending_roles': ['cinder'],
|
|
'pending_addition': True},
|
|
{'roles': [], 'pending_roles': ['controller'],
|
|
'pending_addition': True}]
|
|
cluster = self.env.create(
|
|
cluster_kwargs={
|
|
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
},
|
|
nodes_kwargs=nodes)
|
|
|
|
cluster.release.roles_metadata['mongo']['public_ip_required'] = True
|
|
attrs = cluster.attributes.editable
|
|
self.assertFalse(
|
|
attrs['public_network_assignment']['assign_to_all_nodes']['value'])
|
|
self.assertFalse(
|
|
objects.Cluster.should_assign_public_to_all_nodes(cluster))
|
|
|
|
nodes_w_public_count = sum(
|
|
int(objects.Node.should_have_public_with_ip(node))
|
|
for node in self.env.nodes)
|
|
self.assertEqual(nodes_w_public_count, 3)
|
|
|
|
attrs['public_network_assignment']['assign_to_all_nodes']['value'] = \
|
|
True
|
|
|
|
self.assertTrue(
|
|
objects.Cluster.should_assign_public_to_all_nodes(cluster))
|
|
|
|
nodes_w_public_count = sum(
|
|
int(objects.Node.should_have_public_with_ip(node))
|
|
for node in self.env.nodes)
|
|
self.assertEqual(nodes_w_public_count, len(nodes))
|
|
|
|
def test_should_have_public_with_ip_with_given_metadata(self):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={
|
|
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
},
|
|
nodes_kwargs=[{}, {}])
|
|
|
|
node = self.env.nodes[0]
|
|
roles_metadata = objects.Cluster.get_roles(cluster)
|
|
with mock.patch.object(objects.Cluster, 'get_roles') as get_roles_mock:
|
|
get_roles_mock.return_value = roles_metadata
|
|
objects.Node.should_have_public_with_ip(node)
|
|
self.assertEqual(get_roles_mock.call_count, 1)
|
|
|
|
with mock.patch.object(objects.Cluster, 'get_roles') as get_roles_mock:
|
|
objects.Node.should_have_public_with_ip(node, roles_metadata)
|
|
self.assertEqual(get_roles_mock.call_count, 0)
|
|
|
|
def test_should_have_public(self):
|
|
nodes = [
|
|
{'roles': ['controller', 'cinder'], 'pending_addition': True},
|
|
{'roles': ['compute', 'cinder'], 'pending_addition': True},
|
|
{'roles': ['compute'], 'pending_addition': True},
|
|
{'roles': ['mongo'], 'pending_addition': True},
|
|
{'roles': [], 'pending_roles': ['cinder'],
|
|
'pending_addition': True},
|
|
{'roles': [], 'pending_roles': ['controller'],
|
|
'pending_addition': True}]
|
|
cluster = self.env.create(
|
|
cluster_kwargs={
|
|
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
},
|
|
nodes_kwargs=nodes)
|
|
|
|
attrs = copy.deepcopy(cluster.attributes.editable)
|
|
attrs['neutron_advanced_configuration']['neutron_dvr']['value'] = True
|
|
resp = self.app.patch(
|
|
reverse(
|
|
'ClusterAttributesHandler',
|
|
kwargs={'cluster_id': cluster.id}),
|
|
params=jsonutils.dumps({'editable': attrs}),
|
|
headers=self.default_headers
|
|
)
|
|
self.assertEqual(200, resp.status_code)
|
|
self.assertTrue(
|
|
objects.Cluster.neutron_dvr_enabled(cluster))
|
|
self.assertFalse(
|
|
objects.Cluster.should_assign_public_to_all_nodes(cluster))
|
|
|
|
nodes_w_public_count = sum(
|
|
int(objects.Node.should_have_public(node))
|
|
for node in self.env.nodes)
|
|
# only controllers and computes should have public for DVR
|
|
self.assertEqual(4, nodes_w_public_count)
|
|
|
|
nodes_w_public_ip_count = sum(
|
|
int(objects.Node.should_have_public_with_ip(node))
|
|
for node in self.env.nodes)
|
|
# only controllers should have public with IP address for DVR
|
|
self.assertEqual(2, nodes_w_public_ip_count)
|
|
|
|
def test_removing_from_cluster(self):
|
|
cluster = self.env.create(
|
|
cluster_kwargs={},
|
|
nodes_kwargs=[
|
|
{"role": "controller"}
|
|
]
|
|
)
|
|
node_db = self.env.nodes[0]
|
|
config = self.env.create_openstack_config(
|
|
cluster_id=cluster['id'], node_id=node_db.id, configuration={})
|
|
|
|
node2_db = self.env.create_node()
|
|
objects.Node.remove_from_cluster(node_db)
|
|
self.db().refresh(config)
|
|
self.assertEqual(node_db.cluster_id, None)
|
|
self.assertEqual(node_db.roles, [])
|
|
self.assertEqual(node_db.pending_roles, [])
|
|
self.assertFalse(config.is_active)
|
|
self.assertEqual(node_db.attributes, {})
|
|
|
|
exclude_fields = [
|
|
"group_id",
|
|
"id",
|
|
"hostname",
|
|
"fqdn",
|
|
"mac",
|
|
"meta",
|
|
"name",
|
|
"agent_checksum",
|
|
"uuid",
|
|
"timestamp",
|
|
"nic_interfaces",
|
|
"attributes",
|
|
]
|
|
fields = set(
|
|
c.key for c in sqlalchemy_inspect(objects.Node.model).attrs
|
|
) - set(exclude_fields)
|
|
|
|
for f in fields:
|
|
self.assertEqual(
|
|
getattr(node_db, f),
|
|
getattr(node2_db, f)
|
|
)
|
|
|
|
def test_removing_from_cluster_idempotent(self):
|
|
self.env.create(
|
|
cluster_kwargs={},
|
|
nodes_kwargs=[
|
|
{"role": "controller"}
|
|
]
|
|
)
|
|
node_db = self.env.nodes[0]
|
|
objects.Node.remove_from_cluster(node_db)
|
|
|
|
try:
|
|
objects.Node.remove_from_cluster(node_db)
|
|
except Exception as exc:
|
|
self.fail("Node removing is not idempotent: {0}!".format(exc))
|
|
|
|
def test_update_by_agent(self):
|
|
node_db = self.env.create_node()
|
|
data = {
|
|
"status": node_db.status,
|
|
"meta": copy.deepcopy(node_db.meta),
|
|
"mac": node_db.mac,
|
|
}
|
|
|
|
# test empty disks handling
|
|
data["meta"]["disks"] = []
|
|
objects.Node.update_by_agent(node_db, copy.deepcopy(data))
|
|
self.assertNotEqual(node_db.meta["disks"], data["meta"]["disks"])
|
|
|
|
# test status handling
|
|
for status in (consts.NODE_STATUSES.provisioning,
|
|
consts.NODE_STATUSES.error):
|
|
node_db.status = status
|
|
data["status"] = consts.NODE_STATUSES.discover
|
|
objects.Node.update_by_agent(node_db, copy.deepcopy(data))
|
|
|
|
self.assertEqual(node_db.status, status)
|
|
|
|
def test_node_roles_to_pending_roles(self):
|
|
self.env.create(
|
|
cluster_kwargs={},
|
|
nodes_kwargs=[
|
|
{'role': 'controller'}
|
|
]
|
|
)
|
|
node_db = self.env.nodes[0]
|
|
node = objects.Node.get_by_uid(node_db.id, fail_if_not_found=True)
|
|
self.assertEquals(['controller'], node.roles)
|
|
self.assertEquals([], node.pending_roles)
|
|
# Checking roles moved
|
|
objects.Node.move_roles_to_pending_roles(node)
|
|
self.assertEquals([], node.roles)
|
|
self.assertEquals(['controller'], node.pending_roles)
|
|
# Checking second moving has no affect
|
|
objects.Node.move_roles_to_pending_roles(node)
|
|
self.assertEquals([], node.roles)
|
|
self.assertEquals(['controller'], node.pending_roles)
|
|
|
|
def test_objects_order_by(self):
|
|
self.env.create(
|
|
cluster_kwargs={},
|
|
nodes_kwargs=[
|
|
{'role': 'z'},
|
|
{'role': 'a'},
|
|
{'role': 'b'},
|
|
{'role': 'controller'},
|
|
{'role': 'controller'},
|
|
{'role': 'controller'},
|
|
{'role': 'controller'},
|
|
{'role': 'controller'}
|
|
]
|
|
)
|
|
|
|
# Checking nothing to be sorted
|
|
nodes = objects.NodeCollection.order_by(None, 'id')
|
|
self.assertEquals(None, nodes)
|
|
|
|
iterable = ['b', 'a']
|
|
nodes = objects.NodeCollection.order_by(iterable, ())
|
|
self.assertEquals(iterable, nodes)
|
|
|
|
# Checking query ASC ordering applied
|
|
q_nodes = objects.NodeCollection.filter_by(None)
|
|
nodes = objects.NodeCollection.order_by(q_nodes, 'id').all()
|
|
self.assertListEqual(nodes, sorted(nodes, key=lambda x: x.id))
|
|
# Checking query DESC ordering applied
|
|
q_nodes = objects.NodeCollection.filter_by(None)
|
|
nodes = objects.NodeCollection.order_by(q_nodes, '-id').all()
|
|
self.assertListEqual(
|
|
nodes,
|
|
sorted(nodes, key=lambda x: x.id, reverse=True)
|
|
)
|
|
|
|
# Checking iterable ASC ordering applied
|
|
nodes = objects.NodeCollection.filter_by(None).all()
|
|
ordered_nodes = objects.NodeCollection.order_by(nodes, 'role')
|
|
self.assertListEqual(
|
|
ordered_nodes,
|
|
sorted(nodes, key=lambda x: x.role)
|
|
)
|
|
|
|
# Checking iterable DESC ordering applied
|
|
nodes = objects.NodeCollection.filter_by(None).all()
|
|
ordered_nodes = objects.NodeCollection.order_by(nodes, '-id')
|
|
self.assertListEqual(
|
|
ordered_nodes,
|
|
sorted(nodes, key=lambda x: x.id, reverse=True)
|
|
)
|
|
|
|
# Checking order by number of fields
|
|
nodes = objects.NodeCollection.filter_by(None).all()
|
|
ordered_nodes = objects.NodeCollection.order_by(nodes, ('role', '-id'))
|
|
self.assertListEqual(
|
|
ordered_nodes,
|
|
[self.env.nodes[i] for i in [1, 2, 7, 6, 5, 4, 3, 0]]
|
|
)
|
|
|
|
def test_eager_nodes_handlers(self):
|
|
"""Custom handler works and returns correct number of nodes."""
|
|
nodes_count = 10
|
|
self.env.create_nodes(nodes_count)
|
|
nodes_db = objects.NodeCollection.eager_nodes_handlers(None)
|
|
self.assertEqual(nodes_db.count(), nodes_count)
|
|
|
|
def test_make_slave_name(self):
|
|
node = self.env.create_node()
|
|
|
|
node.hostname = 'test-name'
|
|
|
|
self.assertEqual(
|
|
'test-name',
|
|
objects.Node.get_slave_name(node))
|
|
|
|
node.hostname = ''
|
|
|
|
self.assertEqual(
|
|
"node-{0}".format(node.id),
|
|
objects.Node.get_slave_name(node))
|
|
|
|
def test_reset_to_discover(self):
|
|
self.env.create(
|
|
nodes_kwargs=[
|
|
{'role': 'controller'},
|
|
{'role': 'controller'},
|
|
]
|
|
)
|
|
netmanager = objects.Cluster.get_network_manager()
|
|
netmanager.assign_admin_ips(self.env.nodes)
|
|
for node in self.env.nodes:
|
|
networks = [ip.network_data.name for ip in node.ip_addrs]
|
|
prev_roles = node.roles
|
|
self.assertIn(consts.NETWORKS.fuelweb_admin, networks)
|
|
objects.Node.reset_to_discover(node)
|
|
self.db().flush()
|
|
self.db().refresh(node)
|
|
self.assertEqual(node.status, consts.NODE_STATUSES.discover)
|
|
self.assertEqual(node.ip_addrs, [])
|
|
self.assertEqual(node.pending_roles, prev_roles)
|
|
|
|
def _assert_cluster_create_data(self, network_data):
|
|
release = self.env.create_release(api=False)
|
|
expected_data = {
|
|
"name": "cluster-0",
|
|
"mode": consts.CLUSTER_MODES.ha_compact,
|
|
"release_id": release.id,
|
|
}
|
|
expected_data.update(network_data)
|
|
cluster = self.env.create_cluster(api=False, **expected_data)
|
|
create_data = objects.Cluster.get_create_data(cluster)
|
|
self.assertEqual(expected_data, create_data)
|
|
|
|
def test_cluster_get_create_data_neutron(self):
|
|
network_data = {
|
|
"net_provider": consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
"net_segment_type": consts.NEUTRON_SEGMENT_TYPES.vlan,
|
|
"net_l23_provider": consts.NEUTRON_L23_PROVIDERS.ovs,
|
|
}
|
|
self._assert_cluster_create_data(network_data)
|
|
|
|
def test_cluster_get_create_data_nova(self):
|
|
network_data = {
|
|
"net_provider": consts.CLUSTER_NET_PROVIDERS.nova_network,
|
|
}
|
|
self._assert_cluster_create_data(network_data)
|
|
|
|
def test_apply_network_template(self):
|
|
node = self.env.create_node()
|
|
template = self.env.read_fixtures(['network_template_80'])[0]
|
|
|
|
group_name = 'group-custom-1'
|
|
with mock.patch('objects.NodeGroup.get_by_uid',
|
|
return_value=NodeGroup(name=group_name)):
|
|
objects.Node.apply_network_template(node, template)
|
|
self.assertDictEqual(
|
|
node.network_template['templates'],
|
|
base.get_nodegroup_network_schema_template(
|
|
template, group_name)
|
|
)
|
|
|
|
def test_update_w_error(self):
|
|
self.env.create(
|
|
nodes_kwargs=[
|
|
{'roles': ['controller']},
|
|
{'roles': ['compute', 'cinder']}
|
|
]
|
|
)
|
|
cluster_2 = self.env.create_cluster()
|
|
|
|
node_0 = self.env.nodes[0]
|
|
data = {
|
|
'cluster_id': cluster_2['id']
|
|
}
|
|
|
|
self.assertRaises(
|
|
errors.CannotUpdate, objects.Node.update, node_0, data)
|
|
|
|
def test_get_attributes(self):
|
|
fake_attributes = {
|
|
'fake_attributes': {'fake_key_1': 'fake_value_1',
|
|
'fake_key_2': 'fake_value_2'}
|
|
}
|
|
fake_plugin_attributes = {
|
|
'plugin_a_section': {'plugin_attr_key': 'plugin_attr_val'}
|
|
}
|
|
node = self.env.create_node(attributes=fake_attributes)
|
|
|
|
with mock.patch('nailgun.plugins.manager.PluginManager.'
|
|
'get_plugin_node_attributes',
|
|
return_value=fake_plugin_attributes):
|
|
fake_attributes.update(fake_plugin_attributes)
|
|
self.assertDictEqual(fake_attributes,
|
|
objects.Node.get_attributes(node))
|
|
|
|
def test_update_attributes(self):
|
|
node = self.env.create_node()
|
|
node.attributes = {
|
|
'fake_attributes': {'fake_key_1': {'key': 'old_value'},
|
|
'fake_key_2': 'fake_value_2'}
|
|
}
|
|
|
|
objects.Node.update_attributes(
|
|
node,
|
|
{
|
|
'fake_attributes': {
|
|
'fake_key_1': {'key': 'new_value'}
|
|
},
|
|
'plugin_a_section': {
|
|
'plugin_attr_key': {'value': 'new_attr_val'},
|
|
'metadata': {'class': 'plugin', 'node_plugin_id': 1}
|
|
}
|
|
}
|
|
)
|
|
|
|
expected_attributes = {
|
|
'fake_attributes': {'fake_key_1': {'key': 'new_value'},
|
|
'fake_key_2': 'fake_value_2'}
|
|
}
|
|
self.assertDictEqual(expected_attributes, node.attributes)
|
|
|
|
def test_get_default_attributes(self):
|
|
release_node_attributes = {'release_attr_a': 'release_attr_a_val'}
|
|
cluster = self.env.create(
|
|
release_kwargs={
|
|
'version': 'newton-10.0',
|
|
'operating_system': 'Ubuntu',
|
|
'node_attributes': release_node_attributes
|
|
},
|
|
nodes_kwargs=[
|
|
{'role': 'controller'}
|
|
]
|
|
)
|
|
plugin_node_attributes = self.env.get_default_plugin_node_config()
|
|
self.env.create_plugin(
|
|
name='plugin_a',
|
|
cluster=cluster,
|
|
package_version='5.0.0',
|
|
node_attributes_metadata=plugin_node_attributes)
|
|
|
|
node = cluster.nodes[0]
|
|
node.node_cluster_plugins[0].attributes = {}
|
|
node.attributes = {}
|
|
self.db.flush()
|
|
|
|
default_attributes = objects.Node.get_default_attributes(node)
|
|
|
|
expected_attributes = copy.deepcopy(plugin_node_attributes)
|
|
expected_attributes.update(release_node_attributes)
|
|
self.assertDictEqual(expected_attributes, default_attributes)
|
|
|
|
|
|
class TestTaskObject(BaseIntegrationTest):
|
|
|
|
def setUp(self):
|
|
super(TestTaskObject, self).setUp()
|
|
self.cluster = self.env.create(
|
|
nodes_kwargs=[
|
|
{'roles': ['controller']},
|
|
{'roles': ['compute']},
|
|
{'roles': ['cinder']}])
|
|
|
|
def _node_should_be_error_with_type(self, node, error_type):
|
|
self.assertEquals(node.status, consts.NODE_STATUSES.error)
|
|
self.assertEquals(node.error_type, error_type)
|
|
self.assertEquals(node.progress, 0)
|
|
|
|
def _nodes_should_not_be_error(self, nodes):
|
|
for node in nodes:
|
|
self.assertEquals(node.status, consts.NODE_STATUSES.discover)
|
|
|
|
def test_update_nodes_to_error_if_deployment_task_failed(self):
|
|
self.cluster.nodes[0].status = consts.NODE_STATUSES.deploying
|
|
self.cluster.nodes[0].progress = 12
|
|
task = Task(name=consts.TASK_NAMES.deployment,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.error)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
objects.Task._update_cluster_data(task)
|
|
self.db.flush()
|
|
|
|
self.assertEquals(self.cluster.status, consts.CLUSTER_STATUSES.error)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
self._node_should_be_error_with_type(self.cluster.nodes[0],
|
|
consts.NODE_ERRORS.deploy)
|
|
self._nodes_should_not_be_error(self.cluster.nodes[1:])
|
|
|
|
def test_update_cluster_to_error_if_deploy_task_failed(self):
|
|
task = Task(name=consts.TASK_NAMES.deploy,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.error)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
objects.Task._update_cluster_data(task)
|
|
self.db.flush()
|
|
|
|
self.assertEquals(self.cluster.status, consts.CLUSTER_STATUSES.error)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
|
|
def test_update_nodes_to_error_if_provision_task_failed(self):
|
|
self.cluster.nodes[0].status = consts.NODE_STATUSES.provisioning
|
|
self.cluster.nodes[0].progress = 12
|
|
task = Task(name=consts.TASK_NAMES.provision,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.error)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
objects.Task._update_cluster_data(task)
|
|
self.db.flush()
|
|
|
|
self.assertEquals(self.cluster.status, consts.CLUSTER_STATUSES.error)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
self._node_should_be_error_with_type(self.cluster.nodes[0],
|
|
consts.NODE_ERRORS.provision)
|
|
self._nodes_should_not_be_error(self.cluster.nodes[1:])
|
|
|
|
def test_update_cluster_to_operational(self):
|
|
task = Task(name=consts.TASK_NAMES.deployment,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.ready)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
for node in self.env.nodes:
|
|
node.status = consts.NODE_STATUSES.ready
|
|
|
|
objects.Task._update_cluster_data(task)
|
|
self.db.flush()
|
|
|
|
self.assertEqual(self.cluster.status,
|
|
consts.CLUSTER_STATUSES.operational)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
self.assertTrue(
|
|
self.cluster.attributes.generated['deployed_before']['value'])
|
|
|
|
def test_update_vms_conf(self):
|
|
kvm_node = self.cluster.nodes[0]
|
|
kvm_node.roles = [consts.VIRTUAL_NODE_TYPES.virt]
|
|
self.db.flush()
|
|
kvm_node.vms_conf = [{'id': 1, 'cluster_id': self.cluster.id}]
|
|
task = Task(name=consts.TASK_NAMES.spawn_vms,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.ready)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
objects.Task._update_cluster_data(task)
|
|
self.db.flush()
|
|
|
|
for node in self.cluster.nodes:
|
|
if consts.VIRTUAL_NODE_TYPES.virt in node.roles:
|
|
self.assertTrue(node.vms_conf[0].get('created'))
|
|
else:
|
|
self.assertNotEquals(node.status, consts.NODE_STATUSES.ready)
|
|
|
|
def test_update_if_parent_task_is_ready_all_nodes_should_be_ready(self):
|
|
for node in self.cluster.nodes:
|
|
node.status = consts.NODE_STATUSES.ready
|
|
node.progress = 100
|
|
|
|
self.cluster.nodes[0].status = consts.NODE_STATUSES.deploying
|
|
self.cluster.nodes[0].progress = 24
|
|
|
|
task = Task(name=consts.TASK_NAMES.deployment,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.ready)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
objects.Task._update_cluster_data(task)
|
|
self.db.flush()
|
|
|
|
self.assertEquals(self.cluster.status,
|
|
consts.CLUSTER_STATUSES.operational)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
|
|
for node in self.cluster.nodes:
|
|
self.assertEquals(node.status, consts.NODE_STATUSES.ready)
|
|
self.assertEquals(node.progress, 100)
|
|
|
|
def test_update_cluster_status_if_task_was_already_in_error_status(self):
|
|
for node in self.cluster.nodes:
|
|
node.status = consts.NODE_STATUSES.provisioning
|
|
node.progress = 12
|
|
|
|
task = Task(name=consts.TASK_NAMES.provision,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.error)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
data = {'status': consts.TASK_STATUSES.error, 'progress': 100}
|
|
|
|
objects.Task.update(task, data)
|
|
self.db.flush()
|
|
|
|
self.assertEquals(self.cluster.status, consts.CLUSTER_STATUSES.error)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
self.assertEquals(task.status, consts.TASK_STATUSES.error)
|
|
|
|
for node in self.cluster.nodes:
|
|
self.assertEquals(node.status, consts.NODE_STATUSES.error)
|
|
self.assertEquals(node.progress, 0)
|
|
|
|
def test_do_not_set_cluster_to_error_if_validation_failed(self):
|
|
for task_name in [consts.TASK_NAMES.check_before_deployment,
|
|
consts.TASK_NAMES.check_networks]:
|
|
supertask = Task(
|
|
name=consts.TASK_NAMES.deploy,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.error)
|
|
|
|
check_task = Task(
|
|
name=task_name,
|
|
cluster=self.cluster,
|
|
status=consts.TASK_STATUSES.error)
|
|
|
|
supertask.subtasks.append(check_task)
|
|
self.db.add(check_task)
|
|
self.db.flush()
|
|
|
|
objects.Task._update_cluster_data(supertask)
|
|
self.db.flush()
|
|
|
|
self.assertEquals(self.cluster.status, consts.CLUSTER_STATUSES.new)
|
|
self.assertFalse(self.cluster.is_locked)
|
|
|
|
def test_get_task_by_uuid_returns_task(self):
|
|
task = Task(name=consts.TASK_NAMES.deploy)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
task_by_uuid = objects.Task.get_by_uuid(task.uuid)
|
|
self.assertEquals(task.uuid, task_by_uuid.uuid)
|
|
|
|
def test_get_task_by_uuid_raises_error(self):
|
|
self.assertRaises(errors.ObjectNotFound,
|
|
objects.Task.get_by_uuid,
|
|
uuid='not_found_uuid',
|
|
fail_if_not_found=True)
|
|
|
|
def test_task_wrong_status_filtered(self):
|
|
task = Task(name=consts.TASK_NAMES.deploy)
|
|
self.db.add(task)
|
|
self.db.flush()
|
|
|
|
task_obj = objects.Task.get_by_uuid(task.uuid)
|
|
self.assertEquals(consts.TASK_STATUSES.running, task_obj.status)
|
|
|
|
# Checking correct status is set
|
|
objects.Task.update(task, {'status': consts.TASK_STATUSES.ready})
|
|
self.db.flush()
|
|
task_obj = objects.Task.get_by_uuid(task.uuid)
|
|
self.assertEquals(consts.TASK_STATUSES.ready, task_obj.status)
|
|
|
|
# Checking wrong statuses are not set
|
|
objects.Task.update(task, {'status': None})
|
|
self.db.flush()
|
|
task_obj = objects.Task.get_by_uuid(task.uuid)
|
|
self.assertEquals(consts.TASK_STATUSES.ready, task_obj.status)
|
|
|
|
objects.Task.update(task, {'status': 'xxx'})
|
|
self.db.flush()
|
|
task_obj = objects.Task.get_by_uuid(task.uuid)
|
|
self.assertEquals(consts.TASK_STATUSES.ready, task_obj.status)
|
|
|
|
|
|
class TestActionLogObject(BaseIntegrationTest):
|
|
|
|
def _create_log_entry(self, object_data):
|
|
object_data['actor_id'] = hashlib.sha256('actionlog_test').hexdigest()
|
|
object_data['start_timestamp'] = datetime.datetime.now()
|
|
object_data['end_timestamp'] = \
|
|
object_data['start_timestamp'] + datetime.timedelta(hours=1)
|
|
|
|
return objects.ActionLog.create(object_data)
|
|
|
|
def test_validate_json_schema(self):
|
|
object_data = {
|
|
'action_group': 'test_group',
|
|
'action_name': 'test_action_one',
|
|
'action_type': 'http_request',
|
|
'additional_info': {},
|
|
'is_sent': False,
|
|
'cluster_id': 1
|
|
}
|
|
|
|
al = self._create_log_entry(object_data)
|
|
|
|
instance_to_validate = jsonutils.loads(objects.ActionLog.to_json(al))
|
|
self.assertNotRaises(jsonschema.ValidationError, jsonschema.validate,
|
|
instance_to_validate, action_log.schema)
|
|
|
|
def test_validate_json_schema_failure(self):
|
|
object_data = {
|
|
'id': 1,
|
|
'action_group': 'test_group',
|
|
'action_name': 'test_action_one',
|
|
'action_type': consts.ACTION_TYPES.http_request,
|
|
'additional_info': '', # validation should fail because of this
|
|
'is_sent': False,
|
|
'cluster_id': 1
|
|
}
|
|
self.assertRaises(jsonschema.ValidationError, jsonschema.validate,
|
|
object_data, action_log.schema)
|
|
self.assertRaises(ValueError, self._create_log_entry, object_data)
|
|
|
|
def test_get_by_uuid_method(self):
|
|
object_data = {
|
|
'id': 1,
|
|
'action_group': 'test_group',
|
|
'action_name': 'test_action',
|
|
'action_type': consts.ACTION_TYPES.nailgun_task,
|
|
'additional_info': {},
|
|
'is_sent': False,
|
|
'cluster_id': 1,
|
|
'task_uuid': str(uuid.uuid4())
|
|
}
|
|
|
|
al = self._create_log_entry(object_data)
|
|
self.db.add(al)
|
|
self.db.commit()
|
|
|
|
al_db = objects.ActionLog.get_by_kwargs(
|
|
task_uuid=object_data['task_uuid'])
|
|
|
|
self.assertIsNotNone(al_db)
|
|
|
|
self.db.delete(al)
|
|
self.db.commit()
|
|
|
|
def test_update_method(self):
|
|
object_data = {
|
|
'id': 1,
|
|
'action_group': 'test_group',
|
|
'action_name': 'test_action',
|
|
'action_type': consts.ACTION_TYPES.nailgun_task,
|
|
'additional_info': {'already_present_data': None},
|
|
'is_sent': False,
|
|
'cluster_id': 1,
|
|
'task_uuid': str(uuid.uuid4())
|
|
}
|
|
|
|
al = self._create_log_entry(object_data)
|
|
|
|
update_kwargs = {
|
|
'additional_info': {'new_data': []}
|
|
}
|
|
|
|
al = objects.ActionLog.update(al, update_kwargs)
|
|
|
|
self.assertIn('new_data', six.iterkeys(al.additional_info))
|
|
self.assertIn('already_present_data', six.iterkeys(al.additional_info))
|
|
|
|
self.db.rollback()
|
|
|
|
|
|
class TestClusterObject(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(TestClusterObject, self).setUp()
|
|
self.cluster = self.env.create(
|
|
cluster_kwargs={'net_provider': 'neutron'},
|
|
nodes_kwargs=[
|
|
{'roles': ['controller']},
|
|
{'roles': ['controller']},
|
|
{'roles': ['compute']},
|
|
{'roles': ['cinder']}])
|
|
|
|
def _create_cluster_with_plugins(self, plugins_kw_list):
|
|
cluster = self.env.create_cluster(api=False)
|
|
|
|
for kw in plugins_kw_list:
|
|
plugin = objects.Plugin.create(kw)
|
|
cluster.plugins.append(plugin)
|
|
objects.ClusterPlugin.set_attributes(cluster.id,
|
|
plugin.id,
|
|
enabled=True)
|
|
return cluster
|
|
|
|
def _get_network_role_metadata(self, **kwargs):
|
|
network_role = {
|
|
'id': 'test_network_role',
|
|
'default_mapping': consts.NETWORKS.public,
|
|
'properties': {
|
|
'subnet': True,
|
|
'gateway': False,
|
|
'vip': [
|
|
{'name': 'test_vip_a'}
|
|
]
|
|
}
|
|
}
|
|
|
|
return dict_merge(network_role, kwargs)
|
|
|
|
# FIXME(aroma): remove this test when stop action will be reworked for ha
|
|
# cluster. To get more details, please, refer to [1]
|
|
# [1]: https://bugs.launchpad.net/fuel/+bug/1529691
|
|
def test_set_deployed_before_flag(self):
|
|
# for new clusters that are created by Fuel of version >= 8.0
|
|
# the flag is set to False by default
|
|
self.assertFalse(
|
|
self.cluster.attributes.generated['deployed_before']['value'])
|
|
|
|
# check that the flags is set to true if was false
|
|
objects.Cluster.set_deployed_before_flag(self.cluster, value=True)
|
|
self.assertTrue(
|
|
self.cluster.attributes.generated['deployed_before']['value'])
|
|
|
|
# check that flag is set to false if was true
|
|
objects.Cluster.set_deployed_before_flag(self.cluster, value=False)
|
|
self.assertFalse(
|
|
self.cluster.attributes.generated['deployed_before']['value'])
|
|
|
|
# check that flag is not changed when same value is given
|
|
objects.Cluster.set_deployed_before_flag(self.cluster, value=False)
|
|
self.assertFalse(
|
|
self.cluster.attributes.generated['deployed_before']['value'])
|
|
|
|
# FIXME(aroma): remove this test when stop action will be reworked for ha
|
|
# cluster. To get more details, please, refer to [1]
|
|
# [1]: https://bugs.launchpad.net/fuel/+bug/1529691
|
|
def test_set_deployed_before_flag_if_it_is_not_in_generated(self):
|
|
# there will be no 'deployed_before' attribute present in
|
|
# existing clusters' attributes after master node upgrade to Fuel of
|
|
# versions >= 8.0 so it must be set in such case by the method under
|
|
# the test
|
|
|
|
def check_flag_set(value):
|
|
del self.cluster.attributes.generated['deployed_before']
|
|
objects.Cluster.set_deployed_before_flag(self.cluster, value)
|
|
self.assertEqual(
|
|
self.cluster.attributes.generated['deployed_before']['value'],
|
|
value
|
|
)
|
|
|
|
for value in (True, False):
|
|
check_flag_set(value)
|
|
|
|
def test_network_defaults(self):
|
|
cluster = objects.Cluster.get_by_uid(self.env.create(api=True)['id'])
|
|
|
|
self.assertEqual(
|
|
consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
cluster.net_provider)
|
|
self.assertEqual(
|
|
consts.NEUTRON_SEGMENT_TYPES.vlan,
|
|
cluster.network_config.segmentation_type)
|
|
|
|
@mock.patch('nailgun.objects.cluster.fire_callback_on_cluster_delete')
|
|
@mock.patch(
|
|
'nailgun.objects.cluster.'
|
|
'fire_callback_on_node_collection_delete')
|
|
def test_delete(self, mock_node_coll_delete_cb, mock_cluster_delete_cb):
|
|
ids = [node.id for node in self.cluster.nodes]
|
|
objects.Cluster.delete(self.cluster)
|
|
mock_node_coll_delete_cb.assert_called_once_with(ids)
|
|
mock_cluster_delete_cb.assert_called_once_with(self.cluster)
|
|
self.assertEqual(self.db.query(objects.Node.model).count(), 0)
|
|
self.assertEqual(self.db.query(objects.Cluster.model).count(), 0)
|
|
|
|
def test_all_controllers(self):
|
|
self.assertEqual(len(objects.Cluster.get_nodes_by_role(
|
|
self.cluster, 'controller')), 2)
|
|
|
|
def test_put_delete_template_after_deployment(self):
|
|
allowed = [consts.CLUSTER_STATUSES.new,
|
|
consts.CLUSTER_STATUSES.stopped,
|
|
consts.CLUSTER_STATUSES.operational,
|
|
consts.CLUSTER_STATUSES.error,
|
|
consts.CLUSTER_STATUSES.partially_deployed]
|
|
for status in consts.CLUSTER_STATUSES:
|
|
self.cluster.status = status
|
|
self.db.flush()
|
|
self.assertEqual(
|
|
objects.Cluster.is_network_modification_locked(
|
|
self.cluster),
|
|
status not in allowed
|
|
)
|
|
|
|
def test_get_controller_group_id(self):
|
|
controllers = objects.Cluster.get_nodes_by_role(
|
|
self.cluster, 'controller')
|
|
group_id = objects.Cluster.get_controllers_group_id(
|
|
self.cluster)
|
|
self.assertEqual(controllers[0].group_id, group_id)
|
|
|
|
def test_get_node_group(self):
|
|
controller = objects.Cluster.get_nodes_by_role(
|
|
self.cluster, 'controller')[0]
|
|
compute = objects.Cluster.get_nodes_by_role(
|
|
self.cluster, 'compute')[0]
|
|
|
|
group_id = self.env.create_node_group().json_body['id']
|
|
compute.group_id = group_id
|
|
self.db.flush()
|
|
|
|
self.assertEqual(
|
|
group_id,
|
|
objects.Cluster.get_common_node_group(self.cluster,
|
|
['compute']).id)
|
|
self.assertEqual(
|
|
controller.group_id,
|
|
objects.Cluster.get_common_node_group(self.cluster,
|
|
['controller']).id)
|
|
|
|
def test_get_node_group_multiple_return_same_group(self):
|
|
group_id = self.env.create_node_group().json_body['id']
|
|
|
|
compute = objects.Cluster.get_nodes_by_role(self.cluster, 'compute')[0]
|
|
cinder = objects.Cluster.get_nodes_by_role(self.cluster, 'cinder')[0]
|
|
|
|
compute.group_id = group_id
|
|
cinder.group_id = group_id
|
|
self.db.flush()
|
|
|
|
self.assertEqual(
|
|
group_id,
|
|
objects.Cluster.get_common_node_group(
|
|
self.cluster, ['compute', 'cinder']).id)
|
|
|
|
def test_get_node_group_multiple_fail(self):
|
|
group_id = self.env.create_node_group().json_body['id']
|
|
|
|
controller = \
|
|
objects.Cluster.get_nodes_by_role(self.cluster, 'controller')[0]
|
|
cinder = objects.Cluster.get_nodes_by_role(self.cluster, 'cinder')[0]
|
|
|
|
controller.group_id = group_id
|
|
cinder.group_id = group_id
|
|
self.db.flush()
|
|
|
|
# since we have two controllers, and one of them is in another
|
|
# node group, the error will be raised
|
|
self.assertRaisesRegexp(
|
|
errors.CanNotFindCommonNodeGroup,
|
|
'^Node roles \[controller, cinder\] has more than one common '
|
|
'node group$',
|
|
objects.Cluster.get_common_node_group,
|
|
self.cluster,
|
|
['controller', 'cinder'])
|
|
|
|
def test_get_network_roles(self):
|
|
self.assertItemsEqual(
|
|
objects.Cluster.get_network_roles(self.cluster),
|
|
self.cluster.release.network_roles_metadata)
|
|
|
|
def test_get_deployment_tasks(self):
|
|
deployment_tasks = self.env.get_default_plugin_deployment_tasks()
|
|
plugin_metadata = self.env.get_default_plugin_metadata(
|
|
deployment_tasks=deployment_tasks
|
|
)
|
|
|
|
cluster = self._create_cluster_with_plugins([plugin_metadata])
|
|
|
|
cluster_deployment_tasks = \
|
|
objects.Cluster.get_deployment_tasks(cluster)
|
|
|
|
tasks_ids = [t['id'] for t in cluster_deployment_tasks]
|
|
depl_task_id = deployment_tasks[0]['id']
|
|
self.assertIn(depl_task_id, tasks_ids)
|
|
|
|
default_tasks_count = len(objects.Release.get_deployment_tasks(
|
|
cluster.release))
|
|
plugin_tasks_count = len(plugins.wrap_plugin(
|
|
cluster.plugins[0]).get_deployment_tasks())
|
|
|
|
self.assertEqual(
|
|
len(cluster_deployment_tasks),
|
|
default_tasks_count + plugin_tasks_count)
|
|
|
|
def test_get_deployment_tasks_overlapping_error(self):
|
|
deployment_tasks = self.env.get_default_plugin_deployment_tasks()
|
|
plugins_kw_list = [
|
|
self.env.get_default_plugin_metadata(
|
|
name=plugin_name,
|
|
deployment_tasks=deployment_tasks)
|
|
for plugin_name in ('test_plugin_first', 'test_plugin_second')
|
|
]
|
|
|
|
cluster = self._create_cluster_with_plugins(plugins_kw_list)
|
|
|
|
expected_message = (
|
|
'Plugin test_plugin_second-0.1.0 is overlapping with plugin '
|
|
'test_plugin_first-0.1.0 by introducing the same '
|
|
'deployment task with id role-name'
|
|
)
|
|
with self.assertRaisesRegexp(errors.AlreadyExists,
|
|
expected_message):
|
|
objects.Cluster.get_deployment_tasks(cluster)
|
|
|
|
def test_get_refreshable_tasks(self):
|
|
deployment_tasks = [
|
|
self.env.get_default_plugin_deployment_tasks(**{
|
|
'id': 'refreshable_task_on_keystone',
|
|
consts.TASK_REFRESH_FIELD: ['keystone_config']
|
|
})[0],
|
|
self.env.get_default_plugin_deployment_tasks(**{
|
|
'id': 'refreshable_task_on_nova',
|
|
consts.TASK_REFRESH_FIELD: ['nova_config']
|
|
})[0],
|
|
]
|
|
plugin_metadata = self.env.get_default_plugin_metadata(
|
|
deployment_tasks=deployment_tasks
|
|
)
|
|
|
|
cluster = self._create_cluster_with_plugins([plugin_metadata])
|
|
|
|
refreshable_tasks = \
|
|
objects.Cluster.get_refreshable_tasks(cluster)
|
|
|
|
tasks_ids = [t['id'] for t in refreshable_tasks]
|
|
self.assertIn(deployment_tasks[1]['id'], tasks_ids)
|
|
self.assertIn(deployment_tasks[0]['id'], tasks_ids)
|
|
|
|
refreshable_tasks_on_nova = \
|
|
objects.Cluster.get_refreshable_tasks(
|
|
cluster, filter_by_configs=('nova_config',))
|
|
tasks_ids = [t['id'] for t in refreshable_tasks_on_nova]
|
|
self.assertIn(deployment_tasks[1]['id'], tasks_ids)
|
|
self.assertNotIn(deployment_tasks[0]['id'], tasks_ids)
|
|
|
|
def test_get_refreshable_tasks_w_custom_graph(self):
|
|
deployment_tasks = [
|
|
self.env.get_default_plugin_deployment_tasks(**{
|
|
'id': 'refreshable_task_on_keystone',
|
|
consts.TASK_REFRESH_FIELD: ['keystone_config']
|
|
})[0]
|
|
]
|
|
cluster = self.cluster
|
|
release_graph = objects.DeploymentGraph.get_for_model(cluster.release)
|
|
release_tasks = objects.DeploymentGraph.get_tasks(release_graph)
|
|
objects.DeploymentGraph.create_for_model(
|
|
{'tasks': release_tasks}, cluster.release, 'custom-graph')
|
|
objects.DeploymentGraph.create_for_model(
|
|
{'tasks': deployment_tasks}, cluster, 'custom-graph')
|
|
|
|
refreshable_tasks = objects.Cluster.get_refreshable_tasks(
|
|
cluster, None, 'custom-graph')
|
|
tasks_ids = [t['id'] for t in refreshable_tasks]
|
|
self.assertIn(deployment_tasks[0]['id'], tasks_ids)
|
|
|
|
def test_get_plugin_network_roles(self):
|
|
network_roles = [self._get_network_role_metadata()]
|
|
plugin_data = self.env.get_default_plugin_metadata(
|
|
network_roles_metadata=network_roles)
|
|
cluster = self._create_cluster_with_plugins([plugin_data])
|
|
self.assertItemsEqual(
|
|
objects.Cluster.get_network_roles(cluster),
|
|
cluster.release.network_roles_metadata + network_roles)
|
|
|
|
def test_get_plugin_network_roles_fail(self):
|
|
plugins_kw_list = [
|
|
self.env.get_default_plugin_metadata(
|
|
name='test_plugin_{0}'.format(idx),
|
|
network_roles_metadata=[
|
|
self._get_network_role_metadata(
|
|
properties={'gateway': bool(idx)}
|
|
)
|
|
]
|
|
) for idx in six.moves.range(2)
|
|
]
|
|
|
|
cluster = self._create_cluster_with_plugins(plugins_kw_list)
|
|
self.assertRaises(
|
|
errors.NetworkRoleConflict,
|
|
objects.Cluster.get_network_roles, cluster)
|
|
|
|
def test_merge_network_roles(self):
|
|
network_roles = [self._get_network_role_metadata()]
|
|
plugins_kw_list = [
|
|
self.env.get_default_plugin_metadata(
|
|
name=plugin_name,
|
|
network_roles_metadata=network_roles)
|
|
for plugin_name in ('test_plugin_first', 'test_plugin_second')
|
|
]
|
|
|
|
cluster = self._create_cluster_with_plugins(plugins_kw_list)
|
|
self.assertItemsEqual(
|
|
cluster.release.network_roles_metadata + network_roles,
|
|
objects.Cluster.get_network_roles(cluster)
|
|
)
|
|
|
|
def test_get_volumes_metadata_when_no_boot_rules_in_release(self):
|
|
expected_volumes_metadata = {
|
|
'volumes_roles_mapping': {},
|
|
'volumes': [],
|
|
'rule_to_pick_boot_disk': []
|
|
}
|
|
cluster = self.env.create(release_kwargs={
|
|
'volumes_metadata': {
|
|
'volumes_roles_mapping': {},
|
|
'volumes': []
|
|
}
|
|
})
|
|
volumes_metadata = objects.Cluster.get_volumes_metadata(
|
|
cluster)
|
|
self.assertEqual(
|
|
volumes_metadata, expected_volumes_metadata)
|
|
|
|
def test_get_volumes_metadata_when_plugins_are_enabled(self):
|
|
plugin_volumes_metadata = {
|
|
'volumes_roles_mapping': {
|
|
'test_plugin_1': [
|
|
{'allocate_size': 'min', 'id': 'test_plugin_1'}
|
|
],
|
|
'test_plugin_2': [
|
|
{'allocate_size': 'min', 'id': 'test_plugin_2'}
|
|
],
|
|
},
|
|
'volumes': [
|
|
{'id': 'test_plugin_1', 'type': 'vg'},
|
|
{'id': 'test_plugin_2', 'type': 'vg'}
|
|
],
|
|
'rule_to_pick_boot_disk': []
|
|
}
|
|
with mock.patch.object(
|
|
PluginManager, 'get_volumes_metadata') as plugin_volumes:
|
|
plugin_volumes.return_value = plugin_volumes_metadata
|
|
expected_volumes_metadata = copy.deepcopy(
|
|
self.env.releases[0].volumes_metadata)
|
|
expected_volumes_metadata['volumes_roles_mapping'].update(
|
|
plugin_volumes_metadata['volumes_roles_mapping'])
|
|
expected_volumes_metadata['volumes'].extend(
|
|
plugin_volumes_metadata['volumes'])
|
|
|
|
volumes_metadata = objects.Cluster.get_volumes_metadata(
|
|
self.cluster)
|
|
|
|
self.assertDictEqual(
|
|
volumes_metadata, expected_volumes_metadata)
|
|
|
|
def test_cluster_is_component_enabled(self):
|
|
self.assertFalse(objects.Cluster.is_component_enabled(self.cluster,
|
|
'ironic'))
|
|
self.env._set_additional_component(self.cluster, 'ironic', True)
|
|
self.assertTrue(objects.Cluster.is_component_enabled(self.cluster,
|
|
'ironic'))
|
|
|
|
def test_get_cluster_attributes_by_components(self):
|
|
release = self.env.create_release(
|
|
components_metadata=[{
|
|
'name': 'hypervisor:libvirt:test',
|
|
'bind': [['settings:common.libvirt_type.value', 'test'],
|
|
['wrong_model:field.value', 'smth']]
|
|
}, {
|
|
'name': 'additional_service:new',
|
|
'bind': ['settings:additional_components.new.value']
|
|
}, {
|
|
'name': 'network:some_net',
|
|
'bind': [['cluster:net_provider', 'test_provider'],
|
|
'settings:some_net.checkbox']
|
|
}]
|
|
)
|
|
selected_components = ['network:some_net', 'hypervisor:libvirt:test',
|
|
'additional_service:new_plugin_service']
|
|
result_attrs = objects.Cluster.get_cluster_attributes_by_components(
|
|
selected_components, release.id)
|
|
self.assertDictEqual(
|
|
result_attrs,
|
|
{'editable': {u'some_net': {u'checkbox': True},
|
|
u'common': {u'libvirt_type': {u'value': u'test'}}},
|
|
'cluster': {u'net_provider': u'test_provider'}}
|
|
)
|
|
|
|
def test_cluster_has_compute_vmware_changes(self):
|
|
cluster = self.env.create_cluster(api=False)
|
|
ready_compute_vmware_node = self.env.create_node(
|
|
cluster_id=cluster.id,
|
|
roles=['compute-vmware'],
|
|
status=consts.NODE_STATUSES.ready
|
|
)
|
|
self.env.create_node(cluster_id=cluster.id, pending_addition=True,
|
|
pending_roles=['controller'])
|
|
self.assertFalse(objects.Cluster.has_compute_vmware_changes(cluster))
|
|
|
|
pending_compute_vmware_node = self.env.create_node(
|
|
cluster_id=cluster.id,
|
|
pending_roles=["compute-vmware"]
|
|
)
|
|
self.assertTrue(objects.Cluster.has_compute_vmware_changes(cluster))
|
|
objects.Node.delete(pending_compute_vmware_node)
|
|
objects.Node.update(
|
|
ready_compute_vmware_node, {'pending_deletion': True})
|
|
self.assertTrue(objects.Cluster.has_compute_vmware_changes(cluster))
|
|
|
|
def test_enable_settings_by_components(self):
|
|
components = [{
|
|
'name': 'network:neutron:tun',
|
|
'bind': [['cluster:net_provider', 'neutron'],
|
|
['cluster:net_segment_type', 'tun']]
|
|
}, {
|
|
'name': 'hypervisor:libvirt:kvm',
|
|
'bind': [['settings:common.libvirt_type.value', 'kvm']]
|
|
}, {
|
|
'name': 'additional_service:sahara',
|
|
'bind': ['settings:additional_components.sahara.value']
|
|
}]
|
|
default_editable_attributes = {
|
|
'common': {'libvirt_type': {'value': 'qemu'}},
|
|
'additional_components': {'sahara': {'value': False}}
|
|
}
|
|
|
|
release = self.env.create_release(
|
|
version='2015.1-8.0',
|
|
operating_system=consts.RELEASE_OS.ubuntu,
|
|
modes=[consts.CLUSTER_MODES.ha_compact],
|
|
components_metadata=components)
|
|
|
|
self.env.create_plugin(
|
|
name='plugin_with_test_network_for_neutron',
|
|
package_version='4.0.0',
|
|
fuel_version=['8.0'],
|
|
components_metadata=self.env.get_default_components(
|
|
name='network:neutron:test_network',
|
|
bind=[['cluster:net_segment_type', 'tun']]))
|
|
|
|
tests_data = [{
|
|
'selected_components': ['network:neutron:tun',
|
|
'hypervisor:libvirt:kvm',
|
|
'additional_service:sahara'],
|
|
'expected_values': {
|
|
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
'segmentation_type': consts.NEUTRON_SEGMENT_TYPES.tun
|
|
}
|
|
}, {
|
|
'selected_components': ['network:neutron:test_network',
|
|
'hypervisor:libvirt:kvm',
|
|
'additional_service:sahara'],
|
|
'expected_values': {
|
|
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
'segmentation_type': consts.NEUTRON_SEGMENT_TYPES.tun
|
|
}
|
|
}]
|
|
for i, test_data in enumerate(tests_data):
|
|
with mock.patch('objects.Cluster.get_default_editable_attributes',
|
|
return_value=default_editable_attributes):
|
|
cluster = objects.Cluster.create({
|
|
'name': 'test-{0}'.format(i),
|
|
'release_id': release.id,
|
|
'components': test_data.get('selected_components', [])
|
|
})
|
|
editable_attrs = cluster.attributes.editable
|
|
expected_values = test_data['expected_values']
|
|
self.assertEqual(cluster.net_provider,
|
|
expected_values['net_provider'])
|
|
if expected_values['segmentation_type']:
|
|
self.assertEqual(cluster.network_config.segmentation_type,
|
|
expected_values['segmentation_type'])
|
|
self.assertEqual(
|
|
editable_attrs[u'common'][u'libvirt_type'][u'value'], u'kvm')
|
|
self.assertTrue(
|
|
editable_attrs[u'additional_components'][u'sahara'][u'value'])
|
|
|
|
def test_cleanup_openstack_config(self):
|
|
cluster = self.env.create_cluster(
|
|
api=False, nodes=[self.env.nodes[0].id])
|
|
|
|
config = self.env.create_openstack_config(
|
|
cluster_id=cluster.id, node_id=self.env.nodes[0].id,
|
|
configuration={'key': 'value'})
|
|
self.assertTrue(config.is_active)
|
|
|
|
objects.Cluster.update(cluster, {'nodes': []})
|
|
|
|
self.db().refresh(config)
|
|
self.assertFalse(config.is_active)
|
|
|
|
def test_get_nodes_count_unmet_status(self):
|
|
# by default all nodes in discover state
|
|
remaining = objects.Cluster.get_nodes_count_unmet_status(
|
|
self.cluster, consts.NODE_STATUSES.discover
|
|
)
|
|
self.assertEqual(0, remaining)
|
|
remaining = objects.Cluster.get_nodes_count_unmet_status(
|
|
self.cluster, consts.NODE_STATUSES.ready
|
|
)
|
|
self.assertEqual(len(self.env.nodes), remaining)
|
|
self.env.nodes[0].status = consts.NODE_STATUSES.ready
|
|
remaining = objects.Cluster.get_nodes_count_unmet_status(
|
|
self.cluster, consts.NODE_STATUSES.ready
|
|
)
|
|
self.assertEqual(len(self.env.nodes) - 1, remaining)
|
|
|
|
def test_set_netgroups_ids(self):
|
|
cluster = self.env.create_cluster(api=False)
|
|
node = self.env.create_node(cluster_id=cluster.id)
|
|
self.env.network_manager.assign_ips(
|
|
cluster, [node], consts.NETWORKS.management
|
|
)
|
|
admin_ng_id = \
|
|
objects.NetworkGroup.get_admin_network_group(node).id
|
|
node_ng_ids = dict((ip.network, admin_ng_id) for ip in node.ip_addrs)
|
|
objects.Node.set_netgroups_ids(node, node_ng_ids)
|
|
for ip in node.ip_addrs:
|
|
self.assertEquals(admin_ng_id, ip.network)
|
|
|
|
def test_get_updated_editable_attributes_with_plugin(self):
|
|
cluster = self.env.create_cluster(api=False)
|
|
self.env.create_plugin(
|
|
name='test_plugin',
|
|
version='1.0.0',
|
|
package_version='4.0.0',
|
|
cluster=cluster,
|
|
attributes_metadata=self.env.get_default_plugin_env_config()
|
|
)
|
|
self.env.create_plugin(
|
|
name='test_plugin',
|
|
version='3.0.0',
|
|
package_version='4.0.0',
|
|
cluster=cluster,
|
|
attributes_metadata=self.env.get_default_plugin_env_config()
|
|
)
|
|
|
|
attributes = objects.Cluster.get_editable_attributes(cluster, True)
|
|
plugin_attrs = attributes['test_plugin']['metadata']['versions'][1]
|
|
plugin_attrs['plugin_name_text']['value'] = 'test_value_a'
|
|
updated_attributes = objects.Cluster.get_updated_editable_attributes(
|
|
cluster, {'editable': attributes})
|
|
|
|
self.assertEqual(
|
|
'test_value_a',
|
|
updated_attributes['editable']['test_plugin']
|
|
['plugin_name_text']['value'])
|
|
|
|
def test_get_attributes_with_plugin(self):
|
|
cluster = self.env.create_cluster(api=False)
|
|
self.env.create_plugin(
|
|
name='test_plugin',
|
|
version='1.0.0',
|
|
package_version='4.0.0',
|
|
cluster=cluster,
|
|
attributes_metadata=self.env.get_default_plugin_env_config(
|
|
value='{}')
|
|
)
|
|
attr = objects.Cluster.get_attributes(cluster, True)
|
|
plugin_attrs = attr.editable['test_plugin']['metadata']['versions'][0]
|
|
self.assertEqual('{}', plugin_attrs['plugin_name_text']['value'])
|
|
|
|
@mock.patch.object(objects.Cluster, 'get_editable_attributes')
|
|
def test_cluster_get_restrictions_models(self, m_get_attrs):
|
|
attrs = {'some': {'fake': 'attributes'}}
|
|
m_get_attrs.return_value = attrs
|
|
|
|
cluster = mock.Mock()
|
|
|
|
models = objects.Cluster.get_restrictions_models(cluster)
|
|
|
|
self.assertEqual(
|
|
{
|
|
'settings': attrs,
|
|
'cluster': cluster,
|
|
'version': settings.VERSION,
|
|
'networking_parameters': cluster.network_config
|
|
},
|
|
models
|
|
)
|
|
|
|
@mock.patch.object(objects.Cluster, 'get_editable_attributes')
|
|
def test_cluster_get_restrictions_models_with_attrs(self, m_get_attrs):
|
|
attrs = {'some': {'fake': 'attributes'}}
|
|
|
|
cluster = mock.Mock()
|
|
|
|
models = objects.Cluster.get_restrictions_models(cluster, attrs=attrs)
|
|
|
|
self.assertEqual(0, m_get_attrs.call_count)
|
|
self.assertEqual(
|
|
{
|
|
'settings': attrs,
|
|
'cluster': cluster,
|
|
'version': settings.VERSION,
|
|
'networking_parameters': cluster.network_config
|
|
},
|
|
models
|
|
)
|
|
|
|
|
|
class TestClusterObjectVirtRoles(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(TestClusterObjectVirtRoles, self).setUp()
|
|
self.cluster = self.env.create(
|
|
nodes_kwargs=[
|
|
{'roles': ['virt']},
|
|
{'roles': ['virt']},
|
|
{'roles': ['controller']},
|
|
]
|
|
)
|
|
|
|
self.env.nodes[0].vms_conf = [
|
|
{'id': 1, 'cpu': 1, 'mem': 2},
|
|
{'id': 2, 'cpu': 1, 'mem': 2},
|
|
]
|
|
|
|
self.env.nodes[1].vms_conf = [
|
|
{'id': 1, 'cpu': 1, 'mem': 2},
|
|
{'id': 2, 'cpu': 1, 'mem': 2},
|
|
]
|
|
|
|
def test_set_vms_created_state(self):
|
|
objects.Cluster.set_vms_created_state(self.cluster)
|
|
|
|
for node in self.env.nodes:
|
|
for conf in node.vms_conf:
|
|
self.assertTrue(conf['created'])
|
|
|
|
def test_reset_vms_created_state(self):
|
|
objects.Cluster.set_vms_created_state(self.cluster)
|
|
|
|
objects.Node.reset_vms_created_state(self.env.nodes[0])
|
|
|
|
for conf in self.env.nodes[0].vms_conf:
|
|
self.assertFalse(conf['created'])
|
|
|
|
for conf in self.env.nodes[1].vms_conf:
|
|
self.assertTrue(conf['created'])
|
|
|
|
|
|
class TestClusterObjectGetRoles(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(TestClusterObjectGetRoles, self).setUp()
|
|
|
|
self.cluster = self.env.create(
|
|
release_kwargs={
|
|
'roles_metadata': {
|
|
'role_a': {
|
|
'name': 'Role A', 'description': 'Role A is ...', },
|
|
'role_b': {
|
|
'name': 'Role B', 'description': 'Role B is ...', },
|
|
}
|
|
})
|
|
|
|
def create_plugin(self, roles_metadata):
|
|
plugin = objects.Plugin.create(self.env.get_default_plugin_metadata(
|
|
name=uuid.uuid4().get_hex(),
|
|
roles_metadata=roles_metadata,
|
|
))
|
|
self.cluster.plugins.append(plugin)
|
|
objects.ClusterPlugin.set_attributes(self.cluster.id,
|
|
plugin.id,
|
|
enabled=True)
|
|
self.db.refresh(plugin)
|
|
return plugin
|
|
|
|
def test_no_plugins_no_additional_roles(self):
|
|
roles = objects.Cluster.get_roles(self.cluster)
|
|
self.assertItemsEqual(roles.keys(), ['role_a', 'role_b'])
|
|
|
|
def test_plugin_adds_new_roles(self):
|
|
self.create_plugin({
|
|
'role_c': {
|
|
'name': 'Role C', 'description': 'Role C is ...', },
|
|
})
|
|
|
|
roles = objects.Cluster.get_roles(self.cluster)
|
|
self.assertItemsEqual(roles.keys(), ['role_a', 'role_b', 'role_c'])
|
|
|
|
def test_plugin_role_conflict_with_core_roles(self):
|
|
plugin = self.create_plugin({
|
|
'role_a': {
|
|
'name': 'Role X', 'description': 'Role X is ...', },
|
|
})
|
|
|
|
expected_message = (
|
|
"Plugin \(ID={0}\) is unable to register "
|
|
"the following node roles: role_a"
|
|
.format(plugin.id)
|
|
)
|
|
with self.assertRaisesRegexp(errors.AlreadyExists,
|
|
expected_message):
|
|
objects.Cluster.get_roles(self.cluster)
|
|
|
|
def test_plugin_role_conflict_with_other_plugins(self):
|
|
self.create_plugin({
|
|
'role_x': {
|
|
'name': 'Role X', 'description': 'Role X is ...', },
|
|
})
|
|
plugin_in_conflict = self.create_plugin({
|
|
'role_x': {
|
|
'name': 'Role X', 'description': 'Role X is ...', },
|
|
})
|
|
expected_message = (
|
|
"Plugin \(ID={0}\) is unable to register "
|
|
"the following node roles: role_x"
|
|
.format(plugin_in_conflict.id)
|
|
)
|
|
with self.assertRaisesRegexp(errors.AlreadyExists,
|
|
expected_message):
|
|
objects.Cluster.get_roles(self.cluster)
|
|
|
|
def test_plugin_role_conflict_with_plugin_and_core(self):
|
|
self.create_plugin({
|
|
'role_x': {
|
|
'name': 'Role X', 'description': 'Role X is ...', },
|
|
})
|
|
plugin_in_conflict = self.create_plugin({
|
|
'role_x': {
|
|
'name': 'Role Y', 'description': 'Role Y is ...', },
|
|
'role_a': {
|
|
'name': 'Role A', 'description': 'Role A is ...', },
|
|
})
|
|
|
|
message_pattern = (
|
|
'^Plugin \(ID={0}\) is unable to register the following node '
|
|
'roles: role_a, role_x'
|
|
.format(plugin_in_conflict.id))
|
|
|
|
with self.assertRaisesRegexp(errors.AlreadyExists, message_pattern):
|
|
objects.Cluster.get_roles(self.cluster)
|
|
|
|
|
|
class TestClusterObjectGetNetworkManager(BaseTestCase):
|
|
def setUp(self):
|
|
super(TestClusterObjectGetNetworkManager, self).setUp()
|
|
self.cluster = self.env.create(
|
|
cluster_kwargs={'net_provider': 'neutron'})
|
|
|
|
def test_get_default(self):
|
|
nm = objects.Cluster.get_network_manager()
|
|
self.assertIs(nm, NetworkManager)
|
|
|
|
def check_neutron_network_manager(
|
|
self, net_provider, version, expected_manager):
|
|
self.cluster.net_provider = net_provider
|
|
self.cluster.release.version = version
|
|
nm = objects.Cluster.get_network_manager(self.cluster)
|
|
self.assertIs(expected_manager, nm)
|
|
|
|
def test_raise_if_unknown(self):
|
|
self.cluster.net_provider = "invalid_data"
|
|
self.assertRaisesWithMessage(
|
|
Exception,
|
|
'The network provider "invalid_data" is not supported.',
|
|
objects.Cluster.get_network_manager, self.cluster
|
|
)
|
|
|
|
def test_neutron_network_managers_by_version(self):
|
|
for version, manager_class in (
|
|
('2014.2.2-6.0', neutron.NeutronManagerLegacy),
|
|
('2014.2.2-6.1', neutron.NeutronManager61),
|
|
('2015.6.7-7.0', neutron.NeutronManager70),
|
|
('2016.1.1-8.0', neutron.NeutronManager80),
|
|
):
|
|
self.check_neutron_network_manager(
|
|
consts.CLUSTER_NET_PROVIDERS.neutron,
|
|
version, manager_class
|
|
)
|
|
|
|
def test_nova_network_managers_by_version(self):
|
|
for version, manager_class in (
|
|
('2014.2.2-6.0', nova_network.NovaNetworkManagerLegacy),
|
|
('2014.2.2-6.1', nova_network.NovaNetworkManager61),
|
|
('2015.6.7-7.0', nova_network.NovaNetworkManager70),
|
|
):
|
|
self.check_neutron_network_manager(
|
|
consts.CLUSTER_NET_PROVIDERS.nova_network,
|
|
version, manager_class
|
|
)
|
|
|
|
def test_get_neutron_80(self):
|
|
self.cluster.release.version = '2014.2.2-8.0'
|
|
nm = objects.Cluster.get_network_manager(self.cluster)
|
|
self.assertEqual(nm, neutron.NeutronManager80)
|
|
|
|
|
|
class TestRelease(BaseTestCase):
|
|
|
|
def test_get_all_components(self):
|
|
release = self.env.create_release(
|
|
version='2015.1-8.0',
|
|
operating_system=consts.RELEASE_OS.ubuntu,
|
|
modes=[consts.CLUSTER_MODES.ha_compact],
|
|
components_metadata=self.env.get_default_components(
|
|
name='hypervisor:test_component_1'))
|
|
|
|
self.env.create_plugin(
|
|
name='plugin_with_components',
|
|
package_version='4.0.0',
|
|
fuel_version=['8.0'],
|
|
releases=[{
|
|
'repository_path': 'repositories/ubuntu',
|
|
'version': '2015.1-8.0',
|
|
'os': 'ubuntu',
|
|
'mode': ['ha'],
|
|
'deployment_scripts_path': 'deployment_scripts/'}],
|
|
components_metadata=[dict(
|
|
name='storage:test_component_2',
|
|
label='Test storage',
|
|
incompatible=[{
|
|
'name': 'hypervisor:test_component_1',
|
|
'message': 'component_2 not compatible with component_1'}]
|
|
), dict(
|
|
name='network:test_component_3',
|
|
label='Test network',
|
|
compatible=[{
|
|
'name': 'storage:test_component_2'}])]
|
|
)
|
|
|
|
components = objects.Release.get_all_components(release)
|
|
|
|
self.assertItemsEqual(components, [{
|
|
'name': 'hypervisor:test_component_1',
|
|
'compatible': [
|
|
{'name': 'hypervisor:*'},
|
|
{'name': 'storage:object:block:swift'}],
|
|
'incompatible': [
|
|
{'name': 'network:*'},
|
|
{'name': 'additional_service:*'},
|
|
{'name': 'storage:test_component_2',
|
|
'message': 'Not compatible with Test storage'}]}, {
|
|
'name': 'storage:test_component_2',
|
|
'label': 'Test storage',
|
|
'compatible': [
|
|
{'name': 'network:test_component_3'}],
|
|
'incompatible': [
|
|
{'name': 'hypervisor:test_component_1',
|
|
'message': 'component_2 not compatible with component_1'}]}, {
|
|
'name': 'network:test_component_3',
|
|
'label': 'Test network',
|
|
'compatible': [
|
|
{'name': 'storage:test_component_2'}],
|
|
'incompatible': [
|
|
{'name': 'hypervisor:test_component_1',
|
|
'message': 'Not compatible with hypervisor:test_component_1'}]
|
|
}])
|
|
|
|
def test_contain_component(self):
|
|
components = [
|
|
{'name': 'test_component_type_1:test_component_1'},
|
|
{'name': 'test_component_type_2:*'}
|
|
]
|
|
|
|
self.assertTrue(objects.Release._contain(
|
|
components, 'test_component_type_1:test_component_1'))
|
|
|
|
self.assertTrue(objects.Release._contain(
|
|
components, 'test_component_type_2:test_component_3'))
|
|
|
|
self.assertFalse(objects.Release._contain(
|
|
components, 'test_component_type_1:test_component_4'))
|
|
|
|
|
|
class TestOpenstackConfig(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(TestOpenstackConfig, self).setUp()
|
|
|
|
self.cluster = self.env.create(
|
|
nodes_kwargs=[
|
|
{'role': 'controller', 'status': 'ready'},
|
|
{'role': 'compute', 'status': 'ready'},
|
|
{'role': 'cinder', 'status': 'ready'},
|
|
])
|
|
|
|
self.nodes = self.env.nodes
|
|
|
|
def test_create(self):
|
|
config = objects.OpenstackConfig.create({
|
|
'cluster_id': self.cluster.id,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(config.cluster_id, self.cluster.id)
|
|
self.assertEqual(config.config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.cluster)
|
|
self.assertTrue(config.is_active)
|
|
|
|
config = objects.OpenstackConfig.create({
|
|
'cluster_id': self.cluster.id,
|
|
'node_id': self.nodes[0].id,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(config.cluster_id, self.cluster.id)
|
|
self.assertEqual(config.node_id, self.nodes[0].id)
|
|
self.assertEqual(config.config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.node)
|
|
self.assertTrue(config.is_active)
|
|
|
|
config = objects.OpenstackConfig.create({
|
|
'cluster_id': self.cluster.id,
|
|
'node_role': 'cinder',
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(config.cluster_id, self.cluster.id)
|
|
self.assertEqual(config.node_role, 'cinder')
|
|
self.assertEqual(config.config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.role)
|
|
self.assertTrue(config.is_active)
|
|
|
|
def test_create_override(self):
|
|
config_1 = objects.OpenstackConfig.create({
|
|
'cluster_id': self.cluster.id,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
|
|
self.assertTrue(config_1.is_active)
|
|
|
|
config_2 = objects.OpenstackConfig.create({
|
|
'cluster_id': self.cluster.id,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
|
|
self.assertTrue(config_2.is_active)
|
|
self.assertFalse(config_1.is_active)
|
|
|
|
def test_disable(self):
|
|
config = objects.OpenstackConfig.create({
|
|
'cluster_id': self.cluster.id,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
|
|
objects.OpenstackConfig.disable(config)
|
|
self.assertFalse(config.is_active)
|
|
|
|
|
|
class TestOpenstackConfigCollection(BaseTestCase):
|
|
|
|
def setUp(self):
|
|
super(TestOpenstackConfigCollection, self).setUp()
|
|
|
|
self.cluster = self.env.create(
|
|
nodes_kwargs=[
|
|
{'role': 'controller', 'status': 'ready'},
|
|
{'role': 'compute', 'status': 'ready'},
|
|
{'role': 'cinder', 'status': 'ready'},
|
|
])
|
|
|
|
self.nodes = self.env.nodes
|
|
|
|
def test_create(self):
|
|
configs = objects.OpenstackConfigCollection.create({
|
|
'cluster_id': self.cluster.id,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(len(configs), 1)
|
|
self.assertEqual(configs[0].cluster_id, self.cluster.id)
|
|
self.assertEqual(configs[0].config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.cluster)
|
|
self.assertIsNone(configs[0].node_id)
|
|
|
|
def test_create_by_role(self):
|
|
configs = objects.OpenstackConfigCollection.create({
|
|
'cluster_id': self.cluster.id,
|
|
'node_role': 'controller',
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(len(configs), 1)
|
|
self.assertEqual(configs[0].cluster_id, self.cluster.id)
|
|
self.assertEqual(configs[0].config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.role)
|
|
self.assertEqual(configs[0].node_role, 'controller')
|
|
self.assertIsNone(configs[0].node_id)
|
|
|
|
def test_create_singlenode(self):
|
|
configs = objects.OpenstackConfigCollection.create({
|
|
'cluster_id': self.cluster.id,
|
|
'node_ids': [self.nodes[0].id],
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(len(configs), 1)
|
|
self.assertEqual(configs[0].cluster_id, self.cluster.id)
|
|
self.assertEqual(configs[0].config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.node)
|
|
self.assertEqual(configs[0].node_id, self.nodes[0].id)
|
|
|
|
def test_create_multinode(self):
|
|
node_ids = [n.id for n in self.nodes]
|
|
configs = objects.OpenstackConfigCollection.create({
|
|
'cluster_id': self.cluster.id,
|
|
'node_ids': node_ids,
|
|
'configuration': {'key': 'value'},
|
|
})
|
|
self.assertEqual(len(configs), len(self.nodes))
|
|
for config, node_id in six.moves.zip(configs, node_ids):
|
|
self.assertEqual(config.node_id, node_id)
|
|
self.assertEqual(configs[0].config_type,
|
|
consts.OPENSTACK_CONFIG_TYPES.node)
|
|
|
|
|
|
class TestNodeStatus(BaseTestCase):
|
|
def setUp(self):
|
|
super(TestNodeStatus, self).setUp()
|
|
self.node = self.env.create_node()
|
|
|
|
def test_in_progress_has_high_priority(self):
|
|
node = self.node
|
|
node.error_type = consts.NODE_ERRORS.deploy
|
|
|
|
node.status = consts.NODE_STATUSES.removing
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.removing, objects.Node.get_status(node)
|
|
)
|
|
node.status = consts.NODE_STATUSES.provisioning
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.provisioning, objects.Node.get_status(node)
|
|
)
|
|
node.status = consts.NODE_STATUSES.deploying
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.deploying, objects.Node.get_status(node)
|
|
)
|
|
node.status = consts.NODE_STATUSES.provisioned
|
|
node.progress = 1
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.deploying, objects.Node.get_status(node)
|
|
)
|
|
|
|
def test_in_pgogress_status(self):
|
|
node = self.node
|
|
node.progress = 1
|
|
node.status = consts.NODE_STATUSES.ready
|
|
node.pending_addition = True
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.provisioning, objects.Node.get_status(node)
|
|
)
|
|
node.pending_addition = False
|
|
node.pending_deletion = True
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.removing, objects.Node.get_status(node)
|
|
)
|
|
node.pending_deletion = False
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.deploying, objects.Node.get_status(node)
|
|
)
|
|
|
|
def test_error_state(self):
|
|
node = self.node
|
|
node.status = consts.NODE_STATUSES.error
|
|
node.error_type = consts.NODE_ERRORS.deploy
|
|
self.assertEqual(
|
|
consts.NODE_STATUSES.error, objects.Node.get_status(node)
|
|
)
|
|
|
|
|
|
class TestPlugin(BaseTestCase):
|
|
|
|
def test_name_unchangeable(self):
|
|
self.env.create_plugin(
|
|
name='name',
|
|
package_version='4.0.0',
|
|
fuel_version=['9.2']
|
|
)
|
|
plugin = objects.PluginCollection.all()[0]
|
|
self.assertRaises(errors.InvalidData, objects.Plugin.update,
|
|
plugin, {'name': 'new_name'})
|