def _initialize_tests(self):
"""Perform final initialization before tests get run."""
# Access the sentries for inspecting service units
self.ceil_sentry = self.d.sentry['ceilometer'][0]
self.ceil_agent_sentry = self.d.sentry['ceilometer-agent'][0]
self.pxc_sentry = self.d.sentry['percona-cluster'][0]
self.keystone_sentry = self.d.sentry['keystone'][0]
self.rabbitmq_sentry = self.d.sentry['rabbitmq-server'][0]
self.nova_sentry = self.d.sentry['nova-compute'][0]
if self._get_openstack_release() >= self.xenial_pike:
self.gnocchi_sentry = self.d.sentry['gnocchi'][0]
self.run_ceilometer_upgrade_action()
else:
self.mongodb_sentry = self.d.sentry['mongodb'][0]
u.log.debug('openstack release val: {}'.format(
self._get_openstack_release()))
u.log.debug('openstack release str: {}'.format(
self._get_openstack_release_string()))
# Authenticate admin with keystone endpoint
self.keystone_session, self.keystone = u.get_default_keystone_session(
self.keystone_sentry,
openstack_release=self._get_openstack_release())
self.log.debug('Instantiating ceilometer client...')
if self._get_openstack_release() >= self.xenial_pike:
self.ceil = ceilo_client.Client(session=self.keystone_session, )
else:
# Authenticate admin with ceilometer endpoint
ep = self.keystone.service_catalog.url_for(service_type='metering',
interface='publicURL')
os_token = self.keystone.auth_token
self.ceil = ceilo_client.Client(endpoint=ep, token=os_token)
def _initialize_tests(self):
"""Perform final initialization before tests get run."""
# Access the sentries for inspecting service units
self.ceil_sentry = self.d.sentry['ceilometer'][0]
self.ceil_agent_sentry = self.d.sentry['ceilometer-agent'][0]
self.pxc_sentry = self.d.sentry['percona-cluster'][0]
self.keystone_sentry = self.d.sentry['keystone'][0]
self.rabbitmq_sentry = self.d.sentry['rabbitmq-server'][0]
self.mongodb_sentry = self.d.sentry['mongodb'][0]
self.nova_sentry = self.d.sentry['nova-compute'][0]
u.log.debug('openstack release val: {}'.format(
self._get_openstack_release()))
u.log.debug('openstack release str: {}'.format(
self._get_openstack_release_string()))
# Authenticate admin with keystone endpoint
self.keystone = u.authenticate_keystone_admin(self.keystone_sentry,
user='******',
password='******',
tenant='admin')
# Authenticate admin with ceilometer endpoint
ep = self.keystone.service_catalog.url_for(service_type='metering',
interface='publicURL')
os_token = self.keystone.auth_token
self.log.debug('Instantiating ceilometer client...')
self.ceil = ceilo_client.Client(endpoint=ep, token=os_token)
def ceilometerclient(request):
"""Initialization of Ceilometer client."""
#endpoint = base.url_for(request, 'metering')
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False)
cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', None)
# LOG.debug('ceilometerclient connection created using token "%s" '
# 'and endpoint "%s"' % (request.user.token.id, endpoint))
# return ceilometer_client.Client('2', endpoint,
# token=(lambda: request.user.token.id),
# insecure=insecure,
# cacert=cacert)
LOG.info("********** tenant_name is **********" +
str(request.get("tenant_name")))
LOG.info("********** username is **********" +
str(request.get("username")))
LOG.info("********** password is **********" +
str(request.get("password")))
LOG.info("********** auth url is **********" +
str(request.get("auth_url")))
return ceilometer_client.Client(None,
username=request.get("username"),
password=request.get("password"),
tenant_name=request.get("tenant_name"),
auth_url=request.get("auth_url"),
insecure=insecure,
cacert=cacert)
def ceilometer(self):
if ceilometerclient is None:
return None
if self._ceilometer:
return self._ceilometer
if self.auth_token is None:
logger.error(_("Ceilometer connection failed, no auth_token!"))
return None
con = self.context
args = {
'auth_url': con.auth_url,
'service_type': 'metering',
'project_id': con.tenant,
'token': lambda: self.auth_token,
'endpoint': self.url_for(service_type='metering'),
'ca_file': self._get_client_option('ceilometer', 'ca_file'),
'cert_file': self._get_client_option('ceilometer', 'cert_file'),
'key_file': self._get_client_option('ceilometer', 'key_file'),
'insecure': self._get_client_option('ceilometer', 'insecure')
}
client = ceilometerclient.Client(**args)
self._ceilometer = client
return self._ceilometer
def __init__(self, session):
# Ceilometer Client needs a method that returns the token
def get_token():
return session.token
self.client = ceilometer_client.Client(
endpoint=session.get_endpoint("metering"), token=get_token)
self.project_id = session.project_id
def __init__(self, session):
# Ceilometer Client needs a method that returns the token
def get_token():
return session.token
self.client = ceilometer_client.Client(
endpoint=session.get_endpoint("metering"),
endpoint_type=session.endpoint_type,
region_name=session.region_name,
token=get_token, insecure=session.insecure)
self.project_id = session.project_id
def test_400_api_connection(self):
"""Simple api calls to check service is up and responding."""
if self.current_release >= CeilometerTest.XENIAL_PIKE:
logging.info('Skipping API checks as ceilometer api has been '
'removed')
return
logging.info('Instantiating ceilometer client...')
ceil = ceilo_client.Client(
session=openstack_utils.get_overcloud_keystone_session())
logging.info('Checking api functionality...')
assert (ceil.samples.list() == [])
assert (ceil.meters.list() == [])
def _connect_ceilometer(self):
if self._ceilometer_connection_tried:
return
self._ceilometer_connection_tried = True
try:
ceilometer_endpoint = self._keystone.service_catalog.url_for(
service_type='metering')
# ceilometer client wants the auth token as callable object to
# allow refreshing it so we pass a lambda
self._ceilometer = ceilometerclient.Client(
ceilometer_endpoint, token=lambda: self._keystone.auth_token)
self.logger.info('ceilometer connected')
except keystone_exceptions.EndpointNotFound as e:
self._ceilometer = None
self.logger.warn(e)
def __init__(self):
v3_kwargs = {
"username":
CONF.read_option('keystone_authtoken', 'username'),
"password":
CONF.read_option('keystone_authtoken', 'password'),
"project_name":
CONF.read_option('keystone_authtoken', 'project_name'),
"user_domain_name":
CONF.read_option('keystone_authtoken', 'user_domain_name'),
"project_domain_name":
CONF.read_option('keystone_authtoken', 'project_domain_name'),
"auth_url":
CONF.read_option('keystone_authtoken', 'auth_url'),
"region_name":
CONF.read_option('keystone_authtoken', 'region_name'),
}
self.clm_client = clm_clientv20.Client('', **v3_kwargs)
def testAPI():
kwargs = {
'project_name': resource.os_project_name,
'project_domain_name': resource.os_project_domain_name,
'username': resource.os_username,
'password': resource.os_password,
'user_domain_name': resource.os_user_domain_name,
'auth_url': resource.os_auth_url
}
client = ceiloclient.Client(resource.ceilometer_endpoint, **kwargs)
query_samples = client.query_samples
filter = "{\"=\": {\"meter\": \"image.size\"}}"
orderby = "[{\"timestamp\": \"DESC\"}]"
limit = 1
result = query_samples.query(filter=filter, orderby=orderby, limit=limit)
# print result[0].to_dict().get("metadata").get("sample_end_time")
print result
def get_ceilometerclient(self):
"""Telemetry(ceilometer) client
"""
v3_kwargs = {
"username":
self.conf.get_option('keystone_authtoken', 'username'),
"password":
self.conf.get_option('keystone_authtoken', 'password'),
"project_name":
self.conf.get_option('keystone_authtoken', 'project_name'),
"user_domain_name":
self.conf.get_option('keystone_authtoken', 'user_domain_name'),
"project_domain_name":
self.conf.get_option('keystone_authtoken', 'project_domain_name'),
"auth_url":
self.conf.get_option('keystone_authtoken', 'auth_url'),
"region_name":
self.conf.get_option('keystone_authtoken', 'region_name')
}
return clm_clientv20.Client('', **v3_kwargs)
def getStartTime(self):
kwargs = {
'project_name': self.resource.os_project_name,
'project_domain_name': self.resource.os_project_domain_name,
'username': self.resource.os_username,
'password': self.resource.os_password,
'user_domain_name': self.resource.os_user_domain_name,
'auth_url': self.resource.os_auth_url
}
client = ceiloclient.Client(self.resource.ceilometer_endpoint, **kwargs)
filter = "{\"=\": {\"meter\": \"ecs.objects\"}}"
orderby = "[{\"timestamp\": \"DESC\"}]"
limit = 1
result = client.query_samples.query(filter=filter, orderby=orderby, limit=limit)
if (result is not None) and (len(result) > 0) and (result[0].to_dict() is not None) and (result[0].to_dict().get("metadata") is not None) and (result[0].to_dict().get("metadata").get("end_time") is not None):
return dateutil.parser.parse(result[0].to_dict().get("metadata").get("end_time"))
else:
return self.resource.sample_start_time
def ceilometer(self):
if ceilometerclient is None:
return None
if self._ceilometer:
return self._ceilometer
if self.auth_token is None:
logger.error("Ceilometer connection failed, no auth_token!")
return None
con = self.context
args = {
'auth_url': con.auth_url,
'service_type': 'metering',
'project_id': con.tenant,
'token': self.auth_token,
'endpoint': self.url_for(service_type='metering'),
}
client = ceilometerclient.Client(**args)
self._ceilometer = client
return self._ceilometer
def get_ceilometer_client(**kwargs):
return ceilometerclient.Client('')
def ceilometer_client(self) -> ceilometer_client.Client:
if not self._ceilometer_client:
self._ceilometer_client = ceilometer_client.Client(session=self._session)
return self._ceilometer_client
def metering(self):
if not self._metering:
self._metering = metering_client.Client(session=self._session())
return self._metering
def probe(self):
try:
ceilometer = ceilclient.Client(session=self.get_session(),
cacert=self.openstack['cacert'],
insecure=self.openstack['insecure'])
except Exception as e:
self.exit_error('cannot start ceil ' + str(e))
now = datetime.datetime.now(self.tzone)
tstart = now - self.tframe
query = []
query.append({
'field': 'timestamp',
'op': 'gt',
'value': tstart.strftime(date_format)
})
try:
teste = ceilometer.statistics.list(self.meter, q=query)
#print "meters = %s" % ceilometer.meters.list()
#print "resources = %s" % ceilometer.resources.list()
#print "alarms = %s" % ceilometer.alarms.list()
except Exception as e:
self.exit_error('cannot load: ' + str(e))
for t in teste:
period_end = self.tzone.localize(
datetime.datetime.strptime(
getattr(t, 'period_end', '')[:19], date_format))
age = now - period_end
yield osnag.Metric('count', getattr(t, 'count', ''), uom='samples')
yield osnag.Metric('age', age.total_seconds() / 60, uom='m')
yield osnag.Metric('value',
getattr(t, self.aggregate, ''),
min=getattr(t, 'min', ''),
max=getattr(t, 'max', ''),
uom=getattr(t, 'unit', ''))
if self.verbose:
print
print 'now: %s' % now.strftime(date_format_tz)
print 'query start %s' % tstart.strftime(date_format_tz)
print 'duration_start: %s' % getattr(t, 'duration_start', '')
print 'period_start: %s' % getattr(t, 'period_start', '')
print 'duration_end: %s' % getattr(t, 'duration_end', '')
print 'period_end: %s' % period_end.strftime(
date_format_tz)
print 'age %s minutes' % str(
age.total_seconds() / 60)
print 'count: %s samples' % getattr(t, 'count', '')
print 'min: %s ' % getattr(t, 'min', '') + getattr(
t, 'unit', '')
print 'max: %s ' % getattr(t, 'max', '') + getattr(
t, 'unit', '')
print 'duration: %s minutes' % (
int(getattr(t, 'duration', '')) / 60)
print 'avg: %s ' % getattr(t, 'avg', '') + getattr(
t, 'unit', '')
print 'sum: %s ' % getattr(t, 'sum', '') + getattr(
t, 'unit', '')
print
def metering(cls):
"""Creates a Ceilometer client"""
return metering_client.Client(session=cls._session())
def probe(self):
try:
keystone = ksclient.Client(
username=self.openstack['username'],
password=self.openstack['password'],
tenant_name=self.openstack['tenant_name'],
auth_url=self.openstack['auth_url'],
cacert=self.openstack['cacert'],
insecure=self.openstack['insecure'])
except Exception as e:
self.exit_error('cannot get token ' + str(e))
try:
ceilometer = ceilclient.Client(
endpoint=keystone.service_catalog.url_for(
endpoint_type='public', service_type='metering'),
token=lambda: keystone.auth_token,
cacert=self.openstack['cacert'],
insecure=self.openstack['insecure'])
except Exception as e:
self.exit_error('cannot start ceil ' + str(e))
now = datetime.datetime.now(self.tzone)
tstart = now - self.tframe
query = []
query.append({
'field': 'start',
'op': 'eq',
'value': tstart.strftime(date_format)
})
try:
teste = ceilometer.statistics.list(self.meter, q=query)
#print "meters = %s" % ceilometer.meters.list()
#print "resources = %s" % ceilometer.resources.list()
#print "alarms = %s" % ceilometer.alarms.list()
except Exception as e:
self.exit_error('cannot load: ' + str(e))
for t in teste:
period_end = self.tzone.localize(
datetime.datetime.strptime(
getattr(t, 'period_end', '')[:19], date_format))
age = now - period_end
yield osnag.Metric('count', getattr(t, 'count', ''), uom='samples')
yield osnag.Metric('age', age.total_seconds() / 60, uom='m')
yield osnag.Metric('value',
getattr(t, self.aggregate, ''),
min=float(getattr(t, 'min', '')),
max=getattr(t, 'max', ''),
uom=getattr(t, 'unit', ''))
if self.verbose:
print
print 'now: %s' % now.strftime(date_format_tz)
print 'query start %s' % tstart.strftime(date_format_tz)
print 'duration_start: %s' % getattr(t, 'duration_start', '')
print 'period_start: %s' % getattr(t, 'period_start', '')
print 'duration_end: %s' % getattr(t, 'duration_end', '')
print 'period_end: %s' % period_end.strftime(
date_format_tz)
print 'age %s minutes' % str(
age.total_seconds() / 60)
print 'count: %s samples' % getattr(t, 'count', '')
print 'min: %s ' % getattr(t, 'min', '') + getattr(
t, 'unit', '')
print 'max: %s ' % getattr(t, 'max', '') + getattr(
t, 'unit', '')
print 'duration: %s minutes' % (
int(getattr(t, 'duration', '')) / 60)
print 'avg: %s ' % getattr(t, 'avg', '') + getattr(
t, 'unit', '')
print 'sum: %s ' % getattr(t, 'sum', '') + getattr(
t, 'unit', '')
print
