def collect(resource_type):
try:
operational_clusters = ClusterCollection.filter_by(
iterable=None, status=consts.CLUSTER_STATUSES.operational).all()
error_clusters = ClusterCollection.filter_by(
iterable=None, status=consts.CLUSTER_STATUSES.error).all()
all_envs_last_recs = \
OpenStackWorkloadStatsCollection.get_last_by_resource_type(
resource_type)
ready_or_error_ids = set([c.id for c in operational_clusters] +
[c.id for c in error_clusters])
envs_ids_to_clear = set(r.cluster_id for r in all_envs_last_recs) - \
ready_or_error_ids
# Clear current resource data for unavailable clusters.
# Current OSWL data is cleared for those clusters which status is not
# 'operational' nor 'error' or when cluster was removed. Data is
# cleared for cluster only if it was updated recently (today or
# yesterday). While this collector is running with interval much
# smaller than one day it should not miss any unavailable cluster.
for id in envs_ids_to_clear:
oswl_statistics_save(id, resource_type, [])
# Collect current OSWL data and update data in DB
for cluster in operational_clusters:
try:
client_provider = helpers.ClientProvider(cluster)
proxy_for_os_api = utils.get_proxy_for_cluster(cluster)
version_info = utils.get_version_info(cluster)
with utils.set_proxy(proxy_for_os_api):
data = helpers.get_info_from_os_resource_manager(
client_provider, resource_type)
oswl_statistics_save(cluster.id, resource_type, data,
version_info=version_info)
except errors.StatsException as e:
logger.error("Cannot collect OSWL resource {0} for cluster "
"with id {1}. Details: {2}."
.format(resource_type,
cluster.id,
six.text_type(e))
)
except Exception as e:
logger.exception("Error while collecting OSWL resource {0} "
"for cluster with id {1}. Details: {2}."
.format(resource_type,
cluster.id,
six.text_type(e))
)
db.commit()
except Exception as e:
logger.exception("Exception while collecting OS workloads "
"for resource name {0}. Details: {1}"
.format(resource_type, six.text_type(e)))
finally:
db.remove()
def check_creds(updated_attrs, expected_creds):
Cluster.update_attributes(cluster, updated_attributes)
with patch(get_host_for_auth_path,
return_value=expected_auth_host):
client_provider = helpers.ClientProvider(cluster)
creds = client_provider.credentials
self.assertEqual(expected_creds, creds)
def test_fail_if_no_online_controllers(self):
cluster = self.env.create(nodes_kwargs=[{
"online": False,
"roles": ["controller"]
}])
client_provider = helpers.ClientProvider(cluster)
with self.assertRaises(errors.NoOnlineControllers):
client_provider.credentials
def test_clients_providing(self, creds_mock):
fake_credentials = ("fake_username", "fake_password",
"fake_tenant_name", "fake_auth_url")
auth_kwargs = {
"username": fake_credentials[0],
"password": fake_credentials[1],
"tenant_name": fake_credentials[2],
"project_name": fake_credentials[2],
"auth_url": fake_credentials[3]
}
creds_mock.return_value = fake_credentials
client_provider = helpers.ClientProvider(cluster=None)
nova_client_path = ("nailgun.statistics.oswl."
"helpers.nova_client.Client")
cinder_client_path = ("nailgun.statistics.oswl."
"helpers.cinder_client.Client")
return_value_mock = Mock()
with patch(nova_client_path,
Mock(return_value=return_value_mock)) as nova_client_mock:
self.assertTrue(client_provider.nova is return_value_mock)
client_provider.nova
nova_client_mock.assert_called_once_with(
settings.OPENSTACK_API_VERSION["nova"],
*fake_credentials,
service_type=consts.NOVA_SERVICE_TYPE.compute,
insecure=True)
with patch(cinder_client_path,
Mock(return_value=return_value_mock)) as cinder_client_mock:
self.assertTrue(client_provider.cinder is return_value_mock)
client_provider.cinder
cinder_client_mock.assert_called_once_with(
settings.OPENSTACK_API_VERSION["cinder"],
*fake_credentials,
insecure=True)
with patch.object(client_provider,
"_get_keystone_client",
return_value=return_value_mock) as get_kc_mock:
kc = client_provider.keystone
self.assertTrue(kc is return_value_mock)
client_provider.keystone
get_kc_mock.assert_called_once_with(auth_kwargs)
def test_get_keystone_client(self, kd_mock, kc_v2_mock, kc_v3_mock):
version_data_v2 = [{"version": (2, 0)}]
version_data_v3 = [{"version": (3, 0)}]
mixed_version_data = [{"version": (4, 0)}, {"version": (3, 0)}]
not_supported_version_data = [{"version": (4, 0)}]
auth_creds = {"auth_url": "fake"}
client_provider = helpers.ClientProvider(cluster=None)
discover_inst_mock = Mock()
kd_mock.return_value = discover_inst_mock
kc_v2_inst_mock = Mock()
kc_v2_mock.return_value = kc_v2_inst_mock
kc_v3_inst_mock = Mock()
kc_v3_mock.return_value = kc_v3_inst_mock
def check_returned(version_data, client_class_mock, client_inst_mock):
discover_inst_mock.version_data = Mock(return_value=version_data)
kc_client_inst = client_provider._get_keystone_client(auth_creds)
kd_mock.assert_called_with(**auth_creds)
self.assertTrue(kc_client_inst is client_inst_mock)
client_class_mock.assert_called_with(**auth_creds)
check_returned(version_data_v2, kc_v2_mock, kc_v2_inst_mock)
check_returned(version_data_v3, kc_v3_mock, kc_v3_inst_mock)
check_returned(mixed_version_data, kc_v3_mock, kc_v3_inst_mock)
fail_message = ("Failed to discover keystone version "
"for auth_url {0}".format(auth_creds["auth_url"]))
discover_inst_mock.version_data = \
Mock(return_value=not_supported_version_data)
self.assertRaisesRegexp(Exception, fail_message,
client_provider._get_keystone_client,
auth_creds)
