219 lines
8.6 KiB
Python
219 lines
8.6 KiB
Python
# Copyright 2016 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 json
|
|
|
|
from fuelweb_test import logger
|
|
from proboscis import asserts
|
|
|
|
from stacklight_tests import base_test
|
|
from stacklight_tests.influxdb_grafana.grafana_ui import api as ui_api
|
|
from stacklight_tests.influxdb_grafana import plugin_settings
|
|
|
|
|
|
class NotFound(Exception):
|
|
pass
|
|
|
|
|
|
class InfluxdbPluginApi(base_test.PluginApi):
|
|
def __init__(self):
|
|
super(InfluxdbPluginApi, self).__init__()
|
|
self._grafana_port = None
|
|
self._grafana_protocol = None
|
|
|
|
@property
|
|
def grafana_port(self):
|
|
if self._grafana_port is None:
|
|
if self.grafana_protocol == 'http':
|
|
self._grafana_port = 80
|
|
else:
|
|
self._grafana_port = 443
|
|
return self._grafana_port
|
|
|
|
@property
|
|
def grafana_protocol(self):
|
|
if self._grafana_protocol is None:
|
|
self._grafana_protocol = self.get_http_protocol()
|
|
return self._grafana_protocol
|
|
|
|
def get_plugin_settings(self):
|
|
return plugin_settings
|
|
|
|
def prepare_plugin(self):
|
|
self.helpers.prepare_plugin(self.settings.plugin_path)
|
|
|
|
def activate_plugin(self, options=None):
|
|
if options is None:
|
|
options = self.settings.default_options
|
|
self.helpers.activate_plugin(
|
|
self.settings.name, self.settings.version, options)
|
|
|
|
def get_influxdb_vip(self):
|
|
return self.helpers.get_vip_address('influxdb')
|
|
|
|
def get_grafana_vip(self):
|
|
if self.settings.version.startswith("0."):
|
|
# 0.x versions of the plugin uses the same VIP for InfluxDB and
|
|
# Grafana
|
|
return self.get_influxdb_vip()
|
|
else:
|
|
return self.helpers.get_vip_address('grafana')
|
|
|
|
def get_grafana_url(self, path=''):
|
|
return "{0}://{1}:{2}/{3}".format(self.grafana_protocol,
|
|
self.get_grafana_vip(),
|
|
self.grafana_port, path)
|
|
|
|
def get_influxdb_url(self, path=''):
|
|
return "http://{0}:8086/{1}".format(self.get_influxdb_vip(), path)
|
|
|
|
def do_influxdb_query(self,
|
|
query,
|
|
db=plugin_settings.influxdb_db_name,
|
|
user=plugin_settings.influxdb_user,
|
|
password=plugin_settings.influxdb_pass,
|
|
expected_code=200):
|
|
logger.debug("Making query to Influx DB: {}".format(query))
|
|
return self.checkers.check_http_get_response(
|
|
url=self.get_influxdb_url('query'),
|
|
expected_code=expected_code,
|
|
params={"db": db, "u": user, "p": password, "q": query})
|
|
|
|
def check_plugin_online(self):
|
|
logger.info("InfluxDB service is at {}".format(
|
|
self.get_influxdb_url()))
|
|
logger.info("Check that the InfluxDB server replies to ping requests")
|
|
self.checkers.check_http_get_response(
|
|
url=self.get_influxdb_url('ping'),
|
|
expected_code=204)
|
|
|
|
logger.info("Check that the InfluxDB API requires authentication")
|
|
self.do_influxdb_query("show measurements",
|
|
user=plugin_settings.influxdb_user,
|
|
password='rogue', expected_code=401)
|
|
|
|
logger.info("Check that the InfluxDB user is authorized")
|
|
self.do_influxdb_query("show measurements")
|
|
|
|
logger.info("Check that the InfluxDB user doesn't have admin rights")
|
|
self.do_influxdb_query("show servers", expected_code=401)
|
|
|
|
logger.info("Check that the InfluxDB root user has admin rights")
|
|
self.do_influxdb_query("show servers",
|
|
user=plugin_settings.influxdb_rootuser,
|
|
password=plugin_settings.influxdb_rootpass)
|
|
|
|
logger.info("Grafana service is at {}".format(
|
|
self.get_grafana_url()))
|
|
logger.info("Check that the Grafana UI server is running")
|
|
self.checkers.check_http_get_response(
|
|
self.get_grafana_url('login'))
|
|
|
|
logger.info("Check that the Grafana admin user is authorized")
|
|
self.checkers.check_http_get_response(
|
|
self.get_grafana_url('api/org'),
|
|
auth=(plugin_settings.grafana_user, plugin_settings.grafana_pass))
|
|
|
|
logger.info("Check that the Grafana API requires authentication")
|
|
self.checkers.check_http_get_response(
|
|
self.get_grafana_url('api/org'),
|
|
auth=(plugin_settings.grafana_user, 'rogue'), expected_code=401)
|
|
|
|
def check_influxdb_nodes_count(self, count=1):
|
|
logger.debug('Check the number of InfluxDB servers')
|
|
response = self.do_influxdb_query(
|
|
"show servers",
|
|
user=self.settings.influxdb_rootuser,
|
|
password=self.settings.influxdb_rootpass)
|
|
|
|
nodes_count_responsed = len(
|
|
response.json()["results"][0]["series"][0]["values"])
|
|
|
|
msg = "Expected {0} InfluxDB nodes, got {1}".format(
|
|
count, nodes_count_responsed)
|
|
asserts.assert_equal(count, nodes_count_responsed, msg)
|
|
|
|
def uninstall_plugin(self):
|
|
return self.helpers.uninstall_plugin(self.settings.name,
|
|
self.settings.version)
|
|
|
|
def check_uninstall_failure(self):
|
|
return self.helpers.check_plugin_cannot_be_uninstalled(
|
|
self.settings.name, self.settings.version)
|
|
|
|
def check_grafana_dashboards(self):
|
|
ui_api.check_grafana_dashboards(self.get_grafana_url())
|
|
|
|
def check_plugin_ldap(self, authz=False):
|
|
"""Check dashboard is available when using LDAP for authentication.
|
|
|
|
:param authz: adds checking LDAP for authorisation
|
|
:type authz: boolean
|
|
"""
|
|
ui_api.check_grafana_ldap(self.get_grafana_url(), authz)
|
|
|
|
def get_nova_instance_creation_time_metrics(self, time_point=None):
|
|
"""Gets instance creation metrics for provided interval
|
|
|
|
:param time_point: time interval
|
|
:type time_point: str
|
|
:returns: list of metrics
|
|
:rtype: list
|
|
"""
|
|
logger.info("Getting Nova instance creation metrics")
|
|
interval = "now() - 1h" if time_point is None else time_point
|
|
query = (
|
|
"select value "
|
|
"from openstack_nova_instance_creation_time "
|
|
"where time >= {interval}".format(interval=interval))
|
|
result = self.do_influxdb_query(query=query)
|
|
result = json.loads(
|
|
result.content)["results"][0]
|
|
|
|
if result:
|
|
return result["series"][0]["values"]
|
|
return []
|
|
|
|
def check_cluster_status(self, name, expected_status, interval='3m'):
|
|
output = ("SELECT last(value) FROM cluster_status WHERE "
|
|
"time > now() - {0} AND cluster_name='{1}'".format(interval,
|
|
name))
|
|
msg_header = "Wrong '{0}' service state has been found!".format(
|
|
name)
|
|
self._check_influx_query_last_value(output, expected_status,
|
|
msg_header)
|
|
|
|
def check_count_of_haproxy_backends(self, service, node_state='down',
|
|
expected_count=0, interval='3m'):
|
|
|
|
query = ("SELECT last(value) FROM haproxy_backend_servers WHERE "
|
|
"backend='{0}' AND state='{1}' and "
|
|
"time > now() - {2}".format(service, node_state, interval))
|
|
|
|
msg_header = ("Wrong amount of nodes with service '{0}' "
|
|
"in '{1}' state!".format(service, node_state))
|
|
self._check_influx_query_last_value(query, expected_count, msg_header)
|
|
|
|
def _check_influx_query_last_value(self, query, expected_value,
|
|
msg_header):
|
|
output = self.do_influxdb_query(query)
|
|
lines = output.json()
|
|
if not lines['results'][0]:
|
|
logger.error("The query ['result'] is empty!")
|
|
raise NotFound
|
|
state = lines['results'][0]['series'][0]['values'][0][1]
|
|
asserts.assert_equal(expected_value, state,
|
|
msg_header + " Expected {0} but"
|
|
" found {1}".format(expected_value, state))
|