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