def create_client(env, api_version=2, endpoint=None, exclude=[]):
env = dict((k, v) for k, v in env.items() if k not in exclude)
if not env.get('auth_plugin'):
with mock.patch('ceilometerclient.client.AuthPlugin.'
'redirect_to_aodh_endpoint') as redirect_aodh:
redirect_aodh.side_effect = ks_exc.EndpointNotFound
return client.Client(api_version, endpoint, **env)
else:
env['auth_plugin'].redirect_to_aodh_endpoint.side_effect = \
ks_exc.EndpointNotFound
return client.Client(api_version, endpoint, **env)
def ceilometer(self):
if ceilometerclient is None:
return None
if self._ceilometer:
return self._ceilometer
con = self.context
endpoint_type = self._get_client_option('ceilometer', 'endpoint_type')
endpoint = self.url_for(service_type='metering',
endpoint_type=endpoint_type)
args = {
'auth_url': con.auth_url,
'service_type': 'metering',
'project_id': con.tenant,
'token': lambda: self.auth_token,
'endpoint_type': endpoint_type,
'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('2', endpoint, **args)
self._ceilometer = client
return self._ceilometer
def create_client(env, api_version=2, endpoint=None, exclude=[]):
env = dict((k, v) for k, v in env.items()
if k not in exclude)
with mock.patch(
'ceilometerclient.v2.client.Client._get_redirect_client',
return_value=None):
return client.Client(api_version, endpoint, **env)
def getAPIEvents(config):
ceilometer = ceilometer_client.Client(
2, session=config['session'], interface=config['auth']['OS_INTERFACE'])
query = []
# Start and End required
query.append(
dict(field='start_timestamp',
op='ge',
value='{}'.format(config['start'])))
query.append(
dict(field='end_timestamp', op='le', value='{}'.format(config['end'])))
if config['filter_noise']:
# Requires our second set of panko patches
query.append(
dict(field='event_type', op='eq', value='!compute.metrics.update'))
if config['nostate']:
for skip in config['skip_events']:
query.append(
dict(field='event_type', op='eq', value='!{}'.format(skip)))
events = []
for event in ceilometer.events.list(q=query, limit=100000):
events.append(event.to_dict())
return events
def ceilometer(self):
try:
return ceilometer_client.Client(
'2', session=self.session.keystone_session)
except ceilometer_exceptions.BaseException as e:
logger.exception('Failed to create ceilometer client: %s', e)
reraise(e)
def _get_metering_client(self):
user_domain_name = self.conf.user_domain_name
project_domain_name = self.conf.project_domain_name
try:
endpoint = self.identity_client.get_endpoint_url('metering',
self.conf.region)
except kc_exceptions.EndpointNotFound:
return None
else:
args = {
'username': self.conf.username,
'password': self.conf.password,
'tenant_name': self.conf.tenant_name,
'auth_url': self.conf.auth_url,
'insecure': self.insecure,
'cacert': self.ca_file,
'region_name': self.conf.region,
'endpoint_type': 'publicURL',
'service_type': 'metering',
}
# ceilometerclient can't ignore domain details for
# v2 auth_url
if self.auth_version == '3':
args.update(
{'user_domain_name': user_domain_name,
'project_domain_name': project_domain_name})
return ceilometer_client.Client(self.CEILOMETER_VERSION,
endpoint, **args)
def get_ceilometer_client(token=None, endpoint=None, previous_tries=0):
if previous_tries > 3:
return None
# first try to use auth details from auth_ref so we
# don't need to auth with keystone every time
auth_ref = get_auth_ref()
if not token:
token = auth_ref['token']['id']
if not endpoint:
endpoint = get_endpoint_url_for_service(
'metering',
auth_ref['serviceCatalog'])
ceilometer = ceilometer_client.Client('2', endpoint=endpoint, token=token)
try:
meters = ceilometer.meters.list()
# Exceptions are only thrown when we iterate over meter
[i.meter_id for i in meters]
except ce_exc.HTTPUnauthorized:
auth_ref = force_reauth()
token = auth_ref['token']['id']
ceilometer = get_ceilometer_client(token, endpoint, previous_tries + 1)
except ce_exc.HTTPException:
raise
except Exception as e:
status_err(str(e))
return ceilometer
def _credentials(self, token):
"""
:rtype : ceilometer_client
:type self: Admin
"""
return clients.Client(2,
endpoint=self._ceilometer_url,
token=lambda: 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)
return ceilometer_client.Client('2', endpoint,
token=(lambda: request.user.token.id),
insecure=insecure,
cacert=cacert)
def ceilometerclient(request):
""" Initialization of Ceilometer client.
"""
endpoint = base.url_for(request, 'metering')
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False)
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)
def usageclient(auth_ref):
catalog = auth_ref.get('catalog')
endpoint = next(ep['url'] for ep in next(
s['endpoints'] for s in catalog if s['name'] == 'ceilometer')
if ep['interface'] == 'public')
insecure = getattr(settings, 'OPENSTACK_SSL_NO_VERIFY', False)
cacert = getattr(settings, 'OPENSTACK_SSL_CACERT', None)
return ceilometer_client.Client('2',
endpoint,
token=auth_ref['auth_token'],
insecure=insecure,
cacert=cacert)
def ceilometer(self, version='1'):
"""Returns ceilometer client."""
client = ceilometer.Client(version,
username=self.endpoint.username,
password=self.endpoint.password,
tenant_name=self.endpoint.tenant_name,
endpoint=self.endpoint.auth_url,
region_name=self.endpoint.region_name,
timeout=CONF.openstack_client_http_timeout,
insecure=CONF.https_insecure,
cacert=CONF.https_cacert)
return client
def select_version(version):
try:
self.log.info("Attempting to use Ceilometer v%s APIs", version)
cedrv = ceclient.Client(version=version,
region_name = region_name,
service_type = service_type,
session=self._sess_handle.session)
except Exception as e:
self.log.info(str(e))
raise
else:
self.log.info("Ceilometer API v%s selected", version)
return (version, cedrv)
def setUp(self):
ksclient = mock.Mock()
ksclient.auth_token = "abc*token*abc"
ksclient.service_catalog = mock.Mock()
ksclient.service_catalog.get_endpoints = mock.Mock(
return_value={
u'metering': [{
u'adminURL': BASE_URL,
u'region': u'RegionOne',
u'id': u'8e88da8f3ca54ed8a1c4b56ccb39d2b6'
}]
})
self.c = client.Client(ksclient)
self.response = mock.Mock()
def _get_metering_client(self):
try:
endpoint = self.identity_client.get_endpoint_url('metering',
self.conf.region)
except kc_exceptions.EndpointNotFound:
return None
else:
args = {
'session': self.identity_client.session,
'region_name': self.conf.region,
'endpoint_type': 'publicURL',
'service_type': 'metering',
}
return ceilometer_client.Client(self.CEILOMETER_VERSION,
endpoint, **args)
def ceilometer(self, version='2'):
""" Returns ceilometer client."""
kc = self.keystone()
metering_api_url = kc.service_catalog.url_for(service_type='metering')
auth_token = kc.auth_token
if not hasattr(auth_token, '__call__'):
# python-ceilometerclient requires auth_token to be a callable
auth_token = lambda: kc.auth_token
client = ceilometer.Client(version,
endpoint=metering_api_url,
token=auth_token,
timeout=CONF.openstack_client_http_timeout,
insecure=CONF.https_insecure,
cacert=CONF.https_cacert)
return client
def ceilometer(self, version='2'):
"""Returns ceilometer client."""
kc = self.keystone()
endpoint = kc.service_catalog.get_endpoints()['metering'][0]
auth_token = kc.auth_token
if not hasattr(auth_token, '__call__'):
# python-ceilometerclient requires auth_token to be a callable
auth_token = lambda: kc.auth_token
client = ceilometer.Client(version,
endpoint=endpoint['publicURL'],
token=auth_token,
region_name=self.endpoint.region_name,
timeout=CONF.openstack_client_http_timeout,
insecure=CONF.https_insecure,
cacert=CONF.https_cacert)
return client
def _credentials(self, token):
"""
:rtype : ceilometer_client
:type self: User
"""
self.tenant_list = list()
keystone = dict(token=token, auth_url=self._auth_url)
kclient = ksclient.Client(**keystone)
tenants = kclient.tenants.list()
for tenant in tenants:
self.tenant_list.append(tenant.id)
return clients.Client(2,
endpoint=self._ceilometer_auth_url,
token=lambda: token)
def probe(self):
try:
ceilometer = client.Client(self.api_version, session=self.session, region_name=self.region_name)
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 _create(self):
con = self.context
endpoint_type = self._get_client_option('ceilometer', 'endpoint_type')
endpoint = self.url_for(service_type='metering',
endpoint_type=endpoint_type)
args = {
'auth_url': con.auth_url,
'service_type': 'metering',
'project_id': con.tenant,
'token': lambda: self.auth_token,
'endpoint_type': endpoint_type,
'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')
}
return cc.Client('2', endpoint, **args)
from novaclient import client as novaclient
from neutronclient.v2_0 import client as neutronclient
from ceilometerclient import client as ceilometerclient
auth = v3.Password(auth_url='http://controller:35357/v3',
username='******',
password='******',
project_name='admin',
user_domain_id='default',
project_domain_id='default')
sess = session.Session(auth=auth)
keystone = keystoneclient.Client(session=sess)
nova = novaclient.Client('2.1', session=sess)
neutron = neutronclient.Client(session=sess)
ceilometer = ceilometerclient.Client(2, session=sess)
servers_list = nova.servers.list(search_opts={'all_tenants': 1})
routers_list = neutron.list_routers()[u'routers']
lbs_list = neutron.list_lbaas_loadbalancers()[u'loadbalancers']
plaint_private_networks = (u'127.0.0.0/8', u'10.0.0.0/8', u'172.16.0.0/12',
u'192.168.0.0/16')
private_networks = []
for network in plaint_private_networks:
private_networks.append(ipaddress.ip_network(network))
for project in keystone.projects.list():
instance_public_ips = []
router_public_ips = []
lbs_public_ips = []
from prettytable import PrettyTable
allServerCpu = PrettyTable(["uuid", "Name", "Last CPU_UTIL Sample (%)"])
allServerCpu.align["uuid"] = "l"
allServerCpu.padding_width = 1
os_username = os.environ.get('OS_USERNAME')
os_password = os.environ.get('OS_PASSWORD')
os_regionname = os.environ.get('OS_REGION_NAME')
os_project_name = os.environ.get('OS_PROJECT_NAME')
os_auth_url = os.environ.get('OS_AUTH_URL')
novaclient = client.Client("2.0",
os_username,
os_password,
os_project_name,
os_auth_url,
service_type="compute",
region_name=os_regionname)
servers = novaclient.servers.list(detailed=True)
ceilometerclient = ceilometerclient.client.get_client(
2,
os_username=os_username,
os_password=os_password,
os_tenant_name=os_project_name,
os_auth_url=os_auth_url,
region_name=os_regionname)
# Print last CPU check for all running server within a project
project_domain_id = args.project_domain_id
end_time = args.period_end
start_time = args.period_start
from keystoneauth1.identity import v3
from keystoneauth1 import session
from keystoneclient.v3 import client
auth = v3.Password(auth_url=os_auth_url + "v3",
username=username,
password=password,
project_name=admin_project_name,
user_domain_id=user_domain_id,
project_domain_id=project_domain_id)
sess = session.Session(auth=auth)
keystone = client.Client(session=sess)
cclient = ceilometerclient.client.get_client(2,
username=username,
password=password,
project_name=admin_project_name,
os_auth_url=os_auth_url)
if not os.path.exists(dir_path):
os.makedirs(dir_path)
def volumes(project_id):
volumes_hours = 0
volume_samples = cclient.new_samples.list(q=[
dict(field='project', op='eq', value=project_id),
dict(field='timestamp', op='gt', value=start_time),
def setUp(self):
self.c = client.Client('http://localhost:9000')
self.response = mock.Mock()
def _build_ceilometer_client(
self, vim_account: dict) -> ceilometer_client.Client:
sess = OpenstackUtils.get_session(vim_account)
return ceilometer_client.Client("2", session=sess)
def create_client(env, api_version=2, endpoint=None, exclude=[]):
env = dict((k, v) for k, v in env.items() if k not in exclude)
# Run the same tests with direct instantiation of the Client
return client.Client(api_version, endpoint, **env)
#!/usr/bin/python
# -*- coding: utf-8 -*-
# list meters - client initialized with lambda’d auth_token
from ceilometerclient import client
from os import environ as env
import keystoneclient.v2_0.client as ksclient
#getting the credentials
keystone = {}
keystone['username']=env['OS_USERNAME']
keystone['password']=env['OS_PASSWORD']
keystone['auth_url']=env['OS_AUTH_URL']
keystone['tenant_name']=env['OS_TENANT_NAME']
#creating a keystone client
ceilometer_client = client._get_ksclient(**keystone)
token = ceilometer_client.auth_token
#creating an endpoint
ceilo_endpoint = client._get_endpoint(ceilometer_client, **keystone)
#creating a ceilometer client
ceilometer = client.Client('2',endpoint = ceilo_endpoint, token = token)
#tests
meters = ceilometer.meters.list()
print meters
