def test_all_cluster_data_collected(self):
self.env.create(nodes_kwargs=[{'roles': ['compute']}])
self.env.create_node(status=consts.NODE_STATUSES.discover)
# Fetching installation info struct
info = InstallationInfo()
info = info.get_installation_info()
actual_cluster = info['clusters'][0]
# Creating cluster schema
cluster_schema = {}
for column in inspect(cluster_model.Cluster).columns:
cluster_schema[six.text_type(column.name)] = None
for rel in inspect(cluster_model.Cluster).relationships:
cluster_schema[six.text_type(rel.table.name)] = None
# Removing of not required fields
remove_fields = ('tasks', 'cluster_changes', 'nodegroups',
'pending_release_id', 'releases',
'replaced_provisioning_info', 'notifications',
'deployment_tasks', 'name',
'replaced_deployment_info', 'grouping')
for field in remove_fields:
cluster_schema.pop(field)
# Renaming fields for matching
rename_fields = (
('plugins', 'installed_plugins'),
('networking_configs', 'network_configuration'),
('release_id', 'release'),
)
for name_from, name_to in rename_fields:
cluster_schema.pop(name_from)
cluster_schema[name_to] = None
# If test failed here it means, that you have added properties
# to cluster and they are not exported into statistics.
# If you don't know what to do, contact fuel-stats team please.
for key in six.iterkeys(cluster_schema):
self.assertIn(key, actual_cluster)
def test_clusters_info_no_vmware_attributes_exception(self):
self.env.upload_fixtures(['openstack'])
info = InstallationInfo()
release = ReleaseCollection.filter_by(
None, operating_system=consts.RELEASE_OS.ubuntu)
nodes_params = [
{'roles': ['compute']},
{'roles': ['compute']},
{'roles': ['controller']}
]
cluster = self.env.create(
cluster_kwargs={
'release_id': release[0].id,
'mode': consts.CLUSTER_MODES.ha_compact,
'net_provider': consts.CLUSTER_NET_PROVIDERS.neutron},
nodes_kwargs=nodes_params
)
self.env.create_node(
{'status': consts.NODE_STATUSES.discover})
VmwareAttributes.delete(cluster.vmware_attributes)
self.env.db.flush()
self.assertNotRaises(AttributeError, info.get_clusters_info)
def test_get_attributes_exception_handled(self):
info = InstallationInfo()
variants = [
None,
{},
{
'common': None
},
{
'common': {
'libvirt_type': {}
}
},
{
'common': {
'libvirt_type': 3
}
},
]
for attrs in variants:
result = info.get_attributes(attrs, info.attributes_white_list)
self.assertDictEqual({}, result)
def test_plugins_info(self):
info = InstallationInfo()
cluster = self.env.create_cluster(api=False)
plugin_kwargs = self.env.get_default_plugin_metadata()
plugin_obj = plugins.Plugin(**plugin_kwargs)
self.db.add(plugin_obj)
self.db.flush()
plugin_kwargs["id"] = plugin_obj.id
cluster_plugin_kwargs = {
"cluster_id": cluster.id,
"plugin_id": plugin_obj.id
}
cluster_plugin = plugins.ClusterPlugins(**cluster_plugin_kwargs)
self.db.add(cluster_plugin)
self.db.flush()
expected_attributes_names = (
"id",
"name",
"version",
"releases",
"fuel_version",
"package_version",
)
expected_info = dict([(key, value)
for key, value in six.iteritems(plugin_kwargs)
if key in expected_attributes_names])
expected = [expected_info]
actual = info.get_cluster_plugins_info(cluster)
self.assertEqual(expected, actual)
def test_all_plugin_data_collected(self):
cluster = self.env.create_cluster(api=False)
self.env.create_plugin(api=False, cluster=cluster)
# Fetching plugin info
info = InstallationInfo().get_cluster_plugins_info(cluster)
actual_plugin = info[0]
# Creating plugin data schema
plugin_schema = {}
for column in inspect(plugins.Plugin).columns:
plugin_schema[six.text_type(column.name)] = None
# Removing of not required fields
remove_fields = ('description', 'title', 'authors', 'homepage')
for field in remove_fields:
plugin_schema.pop(field)
# If test failed here it means, that you have added properties
# to plugin and they are not exported into statistics.
# If you don't know what to do, contact fuel-stats team please.
for key in six.iterkeys(plugin_schema):
self.assertIn(key, actual_plugin)
def send_data_to_url(self, url, data):
resp = None
try:
headers = {
'content-type': 'application/json',
'master-node-uid': InstallationInfo().get_master_node_uid()
}
resp = requests.post(
url,
headers=headers,
data=jsonutils.dumps(data),
timeout=settings.COLLECTOR_RESP_TIMEOUT)
except (urllib3.exceptions.DecodeError,
urllib3.exceptions.ProxyError,
requests.exceptions.ConnectionError,
requests.exceptions.Timeout,
requests.exceptions.TooManyRedirects) as e:
logger.error("Sending data to collector failed: %s",
type(e).__name__)
except Exception as e:
logger.exception(
"Sending data to collector failed: %s", six.text_type(e))
return resp
def test_all_node_data_collected(self):
cluster = self.env.create_cluster(api=False)
self.env.create_node(cluster_id=cluster.id)
# Fetching nodes info
info = InstallationInfo().get_nodes_info(cluster.nodes)
actual_node = info[0]
node_schema = self.get_model_schema(models.Node)
# Removing of not required fields
remove_fields = (
'ip', 'uuid', 'agent_checksum', 'hostname', 'timestamp',
'replaced_provisioning_info', 'replaced_deployment_info',
'mac',
# Related tables
'clusters', 'cluster_changes',
'nodegroups', 'ip_addrs', 'node_nic_interfaces',
'node_bond_interfaces', 'network_groups'
)
for field in remove_fields:
node_schema.pop(field)
# Renaming fields for matching
rename_fields = (
('os_platform', 'os'),
)
for name_from, name_to in rename_fields:
node_schema.pop(name_from)
node_schema[name_to] = None
# If test failed here it means, that you have added properties
# to node and they are not exported into statistics.
# If you don't know what to do, contact fuel-stats team please.
for key in six.iterkeys(node_schema):
self.assertIn(key, actual_node)
def test_user_contacts_info_disabled_while_not_confirmed_by_user(self):
self.assertDictEqual(
InstallationInfo().get_installation_info()['user_information'],
{'contact_info_provided': False})
def test_release_info(self):
info = InstallationInfo()
f_info = info.fuel_release_info()
self.assertDictEqual(f_info, settings.VERSION)
def test_get_empty_attributes(self):
info = InstallationInfo()
trash_attrs = {'some': 'trash', 'nested': {'n': 't'}}
result = info.get_attributes(trash_attrs, info.attributes_white_list)
self.assertDictEqual({}, result)
def test_nodes_info(self):
info = InstallationInfo()
self.env.create(
release_kwargs={'operating_system': consts.RELEASE_OS.centos},
nodes_kwargs=[{
'status': consts.NODE_STATUSES.discover,
'roles': ['controller', 'compute'],
'meta': {}
}, {
'roles': [],
'pending_roles': ['compute'],
'meta': {
'cpu': {},
'interfaces': [{
'mac': 'x',
'name': 'eth0'
}],
'disks': [{
'name': 'a',
'disk': 'a'
}]
}
}])
self.env.make_bond_via_api('bond0',
consts.BOND_MODES.active_backup,
['eth0', 'eth1'],
node_id=self.env.nodes[0].id)
nodes_info = info.get_nodes_info(self.env.nodes)
self.assertEquals(len(self.env.nodes), len(nodes_info))
for idx, node in enumerate(self.env.nodes):
node_info = nodes_info[idx]
self.assertEquals(node_info['id'], node.id)
self.assertEquals(node_info['group_id'], node.group_id)
self.assertListEqual(node_info['roles'], node.roles)
self.assertEquals(node_info['os'], node.os_platform)
self.assertEquals(node_info['status'], node.status)
self.assertEquals(node_info['error_type'], node.error_type)
self.assertEquals(node_info['online'], node.online)
self.assertEquals(node_info['manufacturer'], node.manufacturer)
self.assertEquals(node_info['platform_name'], node.platform_name)
self.assertIn('meta', node_info)
for iface in node_info['meta']['interfaces']:
self.assertNotIn('mac', iface)
self.assertNotIn('fqdn', node_info['meta']['system'])
self.assertNotIn('serial', node_info['meta']['system'])
self.assertEquals(node_info['pending_addition'],
node.pending_addition)
self.assertEquals(node_info['pending_deletion'],
node.pending_deletion)
self.assertEquals(node_info['pending_roles'], node.pending_roles)
self.assertEqual(node_info['nic_interfaces'], [{
'id': i.id
} for i in node.nic_interfaces])
self.assertEqual(node_info['bond_interfaces'],
[{
'id': i.id,
'slaves': [s.id for s in i.slaves]
} for i in node.bond_interfaces])
