def get_samples(self, manager, cache, resources): self._inspection_duration = self._record_poll_time() for instance in resources: LOG.debug(_('Checking memory usage for instance %s'), instance.id) try: instance_name = util.instance_name(instance) memory_info = manager.inspector.inspect_memory_usage( instance_name, self._inspection_duration) if (memory_info): usg=memory_info.usage else: usg=0; # Workaround https://bugs.launchpad.net/fuel/+bug/1379794 LOG.debug(_("MEMORY USAGE: %(instance)s %(usage)f"), ({'instance': getattr(instance, 'id'), 'usage': usg})) yield util.make_sample_from_instance( instance, name='memory.usage', type=sample.TYPE_GAUGE, unit='MB', volume=usg, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug(_('Obtaining Memory Usage is not implemented for %s' ), manager.inspector.__class__.__name__) except Exception as err: LOG.exception(_('Could not get Memory Usage for ' '%(id)s: %(e)s'), {'id': instance.id, 'e': err})
def get_samples(self, manager, cache, instance): LOG.info(_('checking instance %s'), instance.id) instance_name = util.instance_name(instance) try: cpu_info = manager.inspector.inspect_cpus(instance_name) LOG.info( _("CPUTIME USAGE: %(instance)s %(time)d") % ({ 'instance': instance.__dict__, 'time': cpu_info.time })) cpu_num = {'cpu_number': cpu_info.number} yield util.make_sample_from_instance( instance, name='cpu', type=sample.TYPE_CUMULATIVE, unit='ns', volume=cpu_info.time, additional_metadata=cpu_num, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except Exception as err: LOG.error( _('could not get CPU time for %(id)s: %(e)s') % ({ 'id': instance.id, 'e': err })) LOG.exception(err)
def get_samples(self, manager, cache, resources): self._inspection_duration = self._record_poll_time() for instance in resources: LOG.debug('Checking resident memory for instance %s', instance.id) instance_name = util.instance_name(instance) try: memory_info = manager.inspector.inspect_memory_resident( instance_name, self._inspection_duration) LOG.debug("RESIDENT MEMORY: %(instance)s %(resident)f", {'instance': instance, 'resident': memory_info.resident}) yield util.make_sample_from_instance( instance, name='memory.resident', type=sample.TYPE_GAUGE, unit='MB', volume=memory_info.resident, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug('Obtaining Resident Memory is not implemented' ' for %s', self.inspector.__class__.__name__) except Exception as err: LOG.exception(_('Could not get Resident Memory Usage for ' '%(id)s: %(e)s'), {'id': instance.id, 'e': err})
def _populate_cache(self, inspector, cache, instance): i_cache = cache.setdefault(self.CACHE_KEY_DISK_INFO, {}) if instance.id not in i_cache: instance_name = util.instance_name(instance) all_capacity = 0 all_allocation = 0 all_physical = 0 per_disk_capacity = {} per_disk_allocation = {} per_disk_physical = {} disk_info = inspector.inspect_disk_info(instance_name) for disk, info in disk_info: all_capacity += info.capacity all_allocation += info.allocation all_physical += info.physical per_disk_capacity[disk.device] = info.capacity per_disk_allocation[disk.device] = info.allocation per_disk_physical[disk.device] = info.physical per_disk_info = { 'capacity': per_disk_capacity, 'allocation': per_disk_allocation, 'physical': per_disk_physical, } i_cache[instance.id] = DiskInfoData( all_capacity, all_allocation, all_physical, per_disk_info ) return i_cache[instance.id]
def inspect_memory_usage(self, instance, duration=None): instance_name = util.instance_name(instance) domain = self._get_domain_not_shut_off_or_raise(instance) try: memory_stats = domain.memoryStats() if (memory_stats and memory_stats.get('available') and memory_stats.get('unused')): memory_used = (memory_stats.get('available') - memory_stats.get('unused')) # Stat provided from libvirt is in KB, converting it to MB. memory_used = memory_used / units.Ki return virt_inspector.MemoryUsageStats(usage=memory_used) else: msg = _('Failed to inspect memory usage of instance ' '<name=%(name)s, id=%(id)s>, ' 'can not get info from libvirt.') % { 'name': instance_name, 'id': instance.id } raise virt_inspector.InstanceNoDataException(msg) # memoryStats might launch an exception if the method is not supported # by the underlying hypervisor being used by libvirt. except libvirt.libvirtError as e: msg = _('Failed to inspect memory usage of %(instance_uuid)s, ' 'can not get info from libvirt: %(error)s') % { 'instance_uuid': instance.id, 'error': e } raise virt_inspector.NoDataException(msg)
def inspect_vnics(self, instance): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) dom_id = self._call_xenapi("VM.get_domid", vm_ref) vif_refs = self._call_xenapi("VM.get_VIFs", vm_ref) bw_all = self._call_plugin_serialized('bandwidth', 'fetch_all_bandwidth') for vif_ref in vif_refs or []: vif_rec = self._call_xenapi("VIF.get_record", vif_ref) interface = virt_inspector.Interface(name=vif_rec['uuid'], mac=vif_rec['MAC'], fref=None, parameters=None) bw_vif = bw_all[dom_id][vif_rec['device']] # TODO(jianghuaw): Currently the plugin can only support # rx_bytes and tx_bytes, so temporarily set others as -1. stats = virt_inspector.InterfaceStats(rx_bytes=bw_vif['bw_in'], rx_packets=-1, rx_drop=-1, rx_errors=-1, tx_bytes=bw_vif['bw_out'], tx_packets=-1, tx_drop=-1, tx_errors=-1) yield (interface, stats)
def _get_vms(self, manager): vms = nova_client.Client().instance_get_all_by_host(cfg.CONF.host) for vm in vms: instance_name = util.instance_name(vm) state = manager.inspector.inspect_state(instance_name) if state.state == inspector.PAUSED: yield vm
def inspect_memory_usage_rate(self,instance,duration=None): instance_name=util.instance_name(instance) vm_ref=self._lookup_by_name(instance_name) total_mem=float(self._call_xenapi("VM.query_data_source", vm_ref, "memory")) return total_mem
def get_samples(self, manager, cache, resources): for instance in resources: try: disk_size_info = self._populate_cache( self.inspector, cache, instance, ) for disk_info in self._get_samples(instance, disk_size_info): yield disk_info except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except virt_inspector.InstanceShutOffException as e: LOG.warning(_LW('Instance %(instance_id)s was shut off while ' 'getting samples of %(pollster)s: %(exc)s'), {'instance_id': instance.id, 'pollster': self.__class__.__name__, 'exc': e}) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug('%(inspector)s does not provide data for ' ' %(pollster)s', {'inspector': self.inspector.__class__.__name__, 'pollster': self.__class__.__name__}) except Exception as err: instance_name = util.instance_name(instance) LOG.exception(_('Ignoring instance %(name)s ' '(%(instance_id)s) : %(error)s') % ( {'name': instance_name, 'instance_id': instance.id, 'error': err}))
def get_samples(self, manager, cache, resources): for instance in resources: LOG.info(_('checking instance %s'), instance.id) instance_name = util.instance_name(instance) try: cpu_info = manager.inspector.inspect_cpus(instance_name) LOG.info(_("CPUTIME USAGE: %(instance)s %(time)d"), { 'instance': instance.__dict__, 'time': cpu_info.time }) cpu_num = {'cpu_number': cpu_info.number} yield util.make_sample_from_instance( instance, name='cpu', type=sample.TYPE_CUMULATIVE, unit='ns', volume=cpu_info.time, additional_metadata=cpu_num, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug(_('Obtaining CPU time is not implemented for %s'), manager.inspector.__class__.__name__) except Exception as err: LOG.exception(_('could not get CPU time for %(id)s: %(e)s'), { 'id': instance.id, 'e': err })
def make_vnic_sample(instance, name, type, unit, volume, vnic_data): metadata = copy.copy(vnic_data) resource_metadata = dict(zip(metadata._fields, metadata)) resource_metadata['instance_id'] = instance.id resource_metadata['instance_type'] = (instance.flavor['id'] if instance.flavor else None) compute_util.add_reserved_user_metadata(instance.metadata, resource_metadata) if vnic_data.fref is not None: rid = vnic_data.fref else: instance_name = util.instance_name(instance) rid = "%s-%s-%s" % (instance_name, instance.id, vnic_data.name) return sample.Sample(name=name, type=type, unit=unit, volume=volume, user_id=instance.user_id, project_id=instance.tenant_id, resource_id=rid, timestamp=timeutils.utcnow().isoformat(), resource_metadata=resource_metadata)
def get_samples(self, manager, cache, resources): for instance in resources: instance_name = util.instance_name(instance) try: c_data = self._populate_cache( self.inspector, cache, instance, ) for s in self._get_samples(instance, c_data): yield s except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except virt_inspector.InstanceShutOffException as e: LOG.warn( _LW('Instance %(instance_id)s was shut off while ' 'getting samples of %(pollster)s: %(exc)s'), { 'instance_id': instance.id, 'pollster': self.__class__.__name__, 'exc': e }) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( '%(inspector)s does not provide data for ' ' %(pollster)s', { 'inspector': self.inspector.__class__.__name__, 'pollster': self.__class__.__name__ }) except Exception as err: LOG.exception(_('Ignoring instance %(name)s: %(error)s'), { 'name': instance_name, 'error': err })
def get_samples(self, manager, cache, resources): for instance in resources: LOG.info(_('checking instance %s'), instance.id) instance_name = util.instance_name(instance) try: cpu_info = manager.inspector.inspect_cpus(instance_name) LOG.info(_("CPUTIME USAGE: %(instance)s %(time)d") % ( {'instance': instance.__dict__, 'time': cpu_info.time})) cpu_num = {'cpu_number': cpu_info.number} yield util.make_sample_from_instance( instance, name='cpu', type=sample.TYPE_CUMULATIVE, unit='ns', volume=cpu_info.time, additional_metadata=cpu_num, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug(_('Obtaining CPU time is not implemented for %s' ), manager.inspector.__class__.__name__) except Exception as err: LOG.error(_('could not get CPU time for %(id)s: %(e)s') % ( {'id': instance.id, 'e': err})) LOG.exception(err)
def get_samples(self, manager, cache, resources): for instance in resources: try: disk_iops_info = self._populate_cache( self.inspector, cache, instance, ) for disk_iops in self._get_samples(instance, disk_iops_info): yield disk_iops except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug('%(inspector)s does not provide data for ' '%(pollster)s', {'inspector': self.inspector.__class__.__name__, 'pollster': self.__class__.__name__}) raise plugin_base.PollsterPermanentError(resources) except Exception as err: instance_name = util.instance_name(instance) LOG.exception(_LE('Ignoring instance %(name)s: %(error)s'), {'name': instance_name, 'error': err})
def inspect_disk_latency(self, instance, duration): instance_name = util.instance_name(instance) for disk_metrics in self._utils.get_disk_latency_metrics( instance_name): yield virt_inspector.DiskLatencyStats( device=disk_metrics['instance_id'], disk_latency=disk_metrics['disk_latency'] / 1000)
def inspect_disks(self, instance): instance_name = util.instance_name(instance) domain = self._lookup_by_uuid(instance) state = domain.info()[0] if state == libvirt.VIR_DOMAIN_SHUTOFF: LOG.warn( _('Failed to inspect disks of instance Name ' '%(instance_name)s UUID %(instance_uuid)s, ' 'domain is in state of SHUTOFF'), { 'instance_name': instance_name, 'instance_uuid': instance.id }) return tree = etree.fromstring(domain.XMLDesc(0)) for device in filter(bool, [ target.get("dev") for target in tree.findall('devices/disk/target') ]): disk = virt_inspector.Disk(device=device) block_stats = domain.blockStats(device) stats = virt_inspector.DiskStats(read_requests=block_stats[0], read_bytes=block_stats[1], write_requests=block_stats[2], write_bytes=block_stats[3], errors=block_stats[4]) yield (disk, stats)
def get_samples(self, manager, cache, resources): self._inspection_duration = self._record_poll_time() for instance in resources: instance_name = util.instance_name(instance) LOG.debug('checking net info for instance %s', instance.id) try: vnics = self._get_vnics_for_instance( cache, self.inspector, instance, ) for vnic, info in vnics: LOG.debug(self.NET_USAGE_MESSAGE, instance_name, vnic.name, self._get_rx_info(info), self._get_tx_info(info)) yield self._get_sample(instance, vnic, info) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except virt_inspector.InstanceShutOffException as e: LOG.warning(_LW('Instance %(instance_id)s was shut off while ' 'getting samples of %(pollster)s: %(exc)s'), {'instance_id': instance.id, 'pollster': self.__class__.__name__, 'exc': e}) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug('%(inspector)s does not provide data for ' ' %(pollster)s', {'inspector': self.inspector.__class__.__name__, 'pollster': self.__class__.__name__}) except Exception as err: LOG.exception(_('Ignoring instance %(name)s: %(error)s'), {'name': instance_name, 'error': err})
def get_samples(self, manager, cache, resources): for instance in resources: try: disk_iops_info = self._populate_cache( self.inspector, cache, instance, ) for disk_iops in self._get_samples(instance, disk_iops_info): yield disk_iops except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( '%(inspector)s does not provide data for ' '%(pollster)s', { 'inspector': self.inspector.__class__.__name__, 'pollster': self.__class__.__name__ }) raise plugin_base.PollsterPermanentError(resources) except Exception as err: instance_name = util.instance_name(instance) LOG.exception(_('Ignoring instance %(name)s: %(error)s'), { 'name': instance_name, 'error': err })
def get_samples(self, manager, cache, resources): for instance in resources: instance_name = util.instance_name(instance) LOG.debug(_('checking net info for instance %s'), instance.id) try: vnics = self._get_vnics_for_instance( cache, manager.inspector, instance, ) for vnic, info in vnics: LOG.debug(self.NET_USAGE_MESSAGE, instance_name, vnic.name, self._get_rx_info(info), self._get_tx_info(info)) yield self._get_sample(instance, vnic, info) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug(_('%(inspector)s does not provide data for ' ' %(pollster)s'), ({ 'inspector': manager.inspector.__class__.__name__, 'pollster': self.__class__.__name__})) except Exception as err: LOG.warning(_('Ignoring instance %(name)s: %(error)s') % ( {'name': instance_name, 'error': err})) LOG.exception(err)
def _get_vnics_for_instance(self, cache, inspector, instance): instance_name = util.instance_name(instance) i_cache = cache.setdefault(self.CACHE_KEY_VNIC, {}) if instance_name not in i_cache: i_cache[instance_name] = list( self._get_vnic_info(inspector, instance)) return i_cache[instance_name]
def get_samples(self, manager, cache, resources): for instance in resources: instance_name = util.instance_name(instance) try: c_data = self._populate_cache( self.inspector, cache, instance, ) for s in self._get_samples(instance, c_data): yield s except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except virt_inspector.InstanceShutOffException as e: LOG.debug('Instance %(instance_id)s was shut off while ' 'getting samples of %(pollster)s: %(exc)s', {'instance_id': instance.id, 'pollster': self.__class__.__name__, 'exc': e}) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug('%(inspector)s does not provide data for ' ' %(pollster)s', {'inspector': self.inspector.__class__.__name__, 'pollster': self.__class__.__name__}) raise plugin_base.PollsterPermanentError(resources) except Exception as err: LOG.exception(_('Ignoring instance %(name)s: %(error)s'), {'name': instance_name, 'error': err})
def get_samples(self, manager, cache, resources): for instance in resources: LOG.debug(_('checking instance %s'), instance.id) instance_name = util.instance_name(instance) try: checkpoint_pause = manager.inspector.inspect_checkpoint( instance)[2] LOG.debug(_("CHECKPOINT PAUSE: %(instance)s %(time)d"), { 'instance': instance.__dict__, 'time': checkpoint_pause }) yield util.make_sample_from_instance( instance, name='checkpoint.pause', type=sample.TYPE_GAUGE, unit='ms', volume=checkpoint_pause, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( _('Obtaining checkpoint pause is not implemented for %s'), manager.inspector.__class__.__name__) except Exception as err: LOG.exception( _('could not get checkpoint pause for %(id)s: %(e)s'), { 'id': instance.id, 'e': err })
def _populate_cache(self, inspector, cache, instance): i_cache = cache.setdefault(self.CACHE_KEY_DISK_INFO, {}) if instance.id not in i_cache: instance_name = util.instance_name(instance) all_capacity = 0 all_allocation = 0 all_physical = 0 per_disk_capacity = {} per_disk_allocation = {} per_disk_physical = {} disk_info = inspector.inspect_disk_info(instance_name) for disk, info in disk_info: all_capacity += info.capacity all_allocation += info.allocation all_physical += info.physical per_disk_capacity[disk.device] = info.capacity per_disk_allocation[disk.device] = info.allocation per_disk_physical[disk.device] = info.physical per_disk_info = { 'capacity': per_disk_capacity, 'allocation': per_disk_allocation, 'physical': per_disk_physical, } i_cache[instance.id] = DiskInfoData(all_capacity, all_allocation, all_physical, per_disk_info) return i_cache[instance.id]
def get_samples(self, manager, cache, resources): self._inspection_duration = self._record_poll_time() for instance in resources: instance_name = util.instance_name(instance) LOG.debug(_('checking net info for instance %s'), instance.id) try: vnics = self._get_vnics_for_instance( cache, manager.inspector, instance, ) for vnic, info in vnics: LOG.debug(self.NET_USAGE_MESSAGE, instance_name, vnic.name, self._get_rx_info(info), self._get_tx_info(info)) yield self._get_sample(instance, vnic, info) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( _('%(inspector)s does not provide data for ' ' %(pollster)s'), { 'inspector': manager.inspector.__class__.__name__, 'pollster': self.__class__.__name__ }) except Exception as err: LOG.exception(_('Ignoring instance %(name)s: %(error)s'), { 'name': instance_name, 'error': err })
def inspect_memory_usage(self, instance, duration=None): instance_name = util.instance_name(instance) domain = self._get_domain_not_shut_off_or_raise(instance) try: memory_stats = domain.memoryStats() if (memory_stats and memory_stats.get('available') and memory_stats.get('unused')): memory_used = (memory_stats.get('available') - memory_stats.get('unused')) # Stat provided from libvirt is in KB, converting it to MB. memory_used = memory_used / units.Ki return virt_inspector.MemoryUsageStats(usage=memory_used) else: msg = _('Failed to inspect memory usage of instance ' '<name=%(name)s, id=%(id)s>, ' 'can not get info from libvirt.') % { 'name': instance_name, 'id': instance.id} raise virt_inspector.InstanceNoDataException(msg) # memoryStats might launch an exception if the method is not supported # by the underlying hypervisor being used by libvirt. except libvirt.libvirtError as e: msg = _('Failed to inspect memory usage of %(instance_uuid)s, ' 'can not get info from libvirt: %(error)s') % { 'instance_uuid': instance.id, 'error': e} raise virt_inspector.NoDataException(msg)
def make_vnic_sample(instance, name, type, unit, volume, vnic_data): metadata = copy.copy(vnic_data) resource_metadata = dict(zip(metadata._fields, metadata)) resource_metadata['instance_id'] = instance.id resource_metadata['instance_type'] = (instance.flavor['id'] if instance.flavor else None) compute_util.add_reserved_user_metadata(instance.metadata, resource_metadata) if vnic_data.fref is not None: rid = vnic_data.fref else: instance_name = util.instance_name(instance) rid = "%s-%s-%s" % (instance_name, instance.id, vnic_data.name) return sample.Sample( name=name, type=type, unit=unit, volume=volume, user_id=instance.user_id, project_id=instance.tenant_id, resource_id=rid, timestamp=timeutils.isotime(), resource_metadata=resource_metadata )
def inspect_vnics(self, instance, duration): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) dom_id = self.session.VM.get_domid(vm_ref) vif_refs = self.session.VM.get_VIFs(vm_ref) bw_all = self.session.call_plugin_serialized('bandwidth', 'fetch_all_bandwidth') LOG.debug("inspect_vnics, all bandwidth: %s", bw_all, instance=instance) for vif_ref in vif_refs: vif_rec = self.session.VIF.get_record(vif_ref) bw_vif = bw_all[dom_id][vif_rec['device']] # TODO(jianghuaw): Currently the plugin can only support # rx_bytes and tx_bytes, so temporarily set others as -1. yield virt_inspector.InterfaceStats(name=vif_rec['uuid'], mac=vif_rec['MAC'], fref=None, parameters=None, rx_bytes=bw_vif['bw_in'], rx_packets=-1, rx_drop=-1, rx_errors=-1, tx_bytes=bw_vif['bw_out'], tx_packets=-1, tx_drop=-1, tx_errors=-1, rx_bytes_delta=-1, tx_bytes_delta=-1)
def get_samples(self, manager, cache, resources): for instance in resources: instance_name = util.instance_name(instance) try: c_data = self._populate_cache( manager.inspector, cache, instance, instance_name, ) yield self._get_sample(instance, c_data) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_('Exception while getting samples %s'), err) except NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( _('%(inspector)s does not provide data for ' ' %(pollster)s'), { 'inspector': manager.inspector.__class__.__name__, 'pollster': self.__class__.__name__ }) except Exception as err: LOG.exception(_('Ignoring instance %(name)s: %(error)s'), { 'name': instance_name, 'error': err })
def inspect_memory_usage(self, instance, duration=None): instance_name = util.instance_name(instance) domain = self._lookup_by_uuid(instance) state = domain.info()[0] if state == libvirt.VIR_DOMAIN_SHUTOFF: LOG.warn(_('Failed to inspect memory usage of instance Name ' '%(instance_name)s UUID %(instance_uuid)s, ' 'domain is in state of SHUTOFF'), {'instance_name': instance_name, 'instance_uuid': instance.id}) return try: memory_stats = domain.memoryStats() if (memory_stats and memory_stats.get('available') and memory_stats.get('unused')): memory_used = (memory_stats.get('available') - memory_stats.get('unused')) # Stat provided from libvirt is in KB, converting it to MB. memory_used = memory_used / units.Ki return virt_inspector.MemoryUsageStats(usage=memory_used) else: LOG.warn(_('Failed to inspect memory usage of instance Name ' '%(instance_name)s UUID %(instance_uuid)s, ' 'can not get info from libvirt'), {'instance_name': instance_name, 'instance_uuid': instance.id}) # memoryStats might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt except libvirt.libvirtError as e: LOG.warn(_('Failed to inspect memory usage of %(instance_uuid)s, ' 'can not get info from libvirt: %(error)s'), {'instance_uuid': instance.id, 'error': e})
def get_samples(self, manager, cache, resources): self._inspection_duration = self._record_poll_time() for instance in resources: LOG.debug('Checking resident memory for instance %s', instance.id) instance_name = util.instance_name(instance) try: memory_info = manager.inspector.inspect_memory_resident( instance_name, self._inspection_duration) LOG.debug("RESIDENT MEMORY: %(instance)s %(resident)f", { 'instance': instance, 'resident': memory_info.resident }) yield util.make_sample_from_instance( instance, name='memory.resident', type=sample.TYPE_GAUGE, unit='MB', volume=memory_info.resident, ) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug('Exception while getting samples %s', err) except ceilometer.NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( 'Obtaining Resident Memory is not implemented' ' for %s', self.inspector.__class__.__name__) except Exception as err: LOG.exception( _('Could not get Resident Memory Usage for ' '%(id)s: %(e)s'), { 'id': instance.id, 'e': err })
def get_samples(self, manager, cache, resources): self._inspection_duration = self._record_poll_time() for instance in resources: instance_name = util.instance_name(instance) LOG.debug(_("checking net info for instance %s"), instance.id) try: vnics = self._get_vnics_for_instance(cache, manager.inspector, instance) for vnic, info in vnics: LOG.debug( self.NET_USAGE_MESSAGE, instance_name, vnic.name, self._get_rx_info(info), self._get_tx_info(info), ) yield self._get_sample(instance, vnic, info) except virt_inspector.InstanceNotFoundException as err: # Instance was deleted while getting samples. Ignore it. LOG.debug(_("Exception while getting samples %s"), err) except NotImplementedError: # Selected inspector does not implement this pollster. LOG.debug( _("%(inspector)s does not provide data for " " %(pollster)s"), ({"inspector": manager.inspector.__class__.__name__, "pollster": self.__class__.__name__}), ) except Exception as err: LOG.warning(_("Ignoring instance %(name)s: %(error)s") % ({"name": instance_name, "error": err})) LOG.exception(err)
def inspect_instance(self, instance, duration): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) cpu_util = self._get_cpu_usage(vm_ref, instance_name) memory_usage = self._get_memory_usage(vm_ref) return virt_inspector.InstanceStats(cpu_util=cpu_util, memory_usage=memory_usage)
def inspect_memory_usage(self, instance, duration=None): instance_name = util.instance_name(instance) domain = self._lookup_by_name(instance_name) state = domain.info()[0] if state == libvirt.VIR_DOMAIN_SHUTOFF: LOG.warn( _('Failed to inspect memory usage of %(instance_name)s, ' 'domain is in state of SHUTOFF'), {'instance_name': instance_name}) return try: memory_stats = domain.memoryStats() if (memory_stats and memory_stats.get('available') and memory_stats.get('unused')): memory_used = (memory_stats.get('available') - memory_stats.get('unused')) # Stat provided from libvirt is in KB, converting it to MB. memory_used = memory_used / units.Ki return virt_inspector.MemoryUsageStats(usage=memory_used) else: LOG.warn( _('Failed to inspect memory usage of ' '%(instance_name)s, can not get info from libvirt'), {'instance_name': instance_name}) # memoryStats might launch an exception if the method # is not supported by the underlying hypervisor being # used by libvirt except libvirt.libvirtError as e: LOG.warn( _('Failed to inspect memory usage of %(instance_name)s, ' 'can not get info from libvirt: %(error)s'), { 'instance_name': instance_name, 'error': e })
def inspect_memory_usage(self, instance, duration=None): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) metrics_ref = self._call_xenapi("VM.get_metrics", vm_ref) metrics_rec = self._call_xenapi("VM_metrics.get_record", metrics_ref) # Stat provided from XenServer is in B, converting it to MB. memory = int(metrics_rec["memory_actual"]) / units.Mi return virt_inspector.MemoryUsageStats(usage=memory)
def inspect_memory_usage(self, instance, duration=None): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) metrics_ref = self._call_xenapi("VM.get_metrics", vm_ref) metrics_rec = self._call_xenapi("VM_metrics.get_record", metrics_ref) # Stat provided from XenServer is in B, converting it to MB. memory = int(metrics_rec['memory_actual']) / units.Mi return virt_inspector.MemoryUsageStats(usage=memory)
def _get_vnics_for_instance(self, cache, inspector, instance): instance_name = util.instance_name(instance) i_cache = cache.setdefault(self.CACHE_KEY_VNIC, {}) if instance_name not in i_cache: i_cache[instance_name] = list( self._get_vnic_info(inspector, instance) ) return i_cache[instance_name]
def inspect_disk_iops(self, instance): instance_name = util.instance_name(instance) for disk_metrics in self._utils.get_disk_iops_count(instance_name): disk = virt_inspector.Disk(device=disk_metrics['instance_id']) stats = virt_inspector.DiskIOPSStats( iops_count=disk_metrics['iops_count']) yield (disk, stats)
def inspect_disk_latency(self, instance): instance_name = util.instance_name(instance) for disk_metrics in self._utils.get_disk_latency_metrics( instance_name): disk = virt_inspector.Disk(device=disk_metrics['instance_id']) stats = virt_inspector.DiskLatencyStats( disk_latency=disk_metrics['disk_latency']) yield (disk, stats)
def inspect_instance(self, instance, duration): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) cpu_util = self._get_cpu_usage(vm_ref, instance_name) memory_usage = self._get_memory_usage(vm_ref) LOG.debug("inspect_instance, cpu_util: %(cpu)s, memory_usage: %(mem)s", {'cpu': cpu_util, 'mem': memory_usage}, instance=instance) return virt_inspector.InstanceStats(cpu_util=cpu_util, memory_usage=memory_usage)
def inspect_checkpoint(self, instance): instance_name = util.instance_name(instance) domain = self._lookup_by_uuid(instance) info = domain.jobInfo() return virt_inspector.CheckpointStats( checkpoint_size=info[12], checkpoint_length=info[13], checkpoint_pause=info[14], checkpoint_count=info[15], checkpoint_proxyDiscompare=info[16])
def inspect_disks(self, instance, duration): instance_name = util.instance_name(instance) for disk_metrics in self._utils.get_disk_metrics(instance_name): yield virt_inspector.DiskStats( device=disk_metrics['instance_id'], read_requests=0, # Return bytes read_bytes=disk_metrics['read_mb'] * units.Mi, write_requests=0, write_bytes=disk_metrics['write_mb'] * units.Mi, errors=0)
def inspect_cpus(self, instance): instance_name = util.instance_name(instance) (cpu_clock_used, cpu_count, uptime) = self._utils.get_cpu_metrics(instance_name) host_cpu_clock, host_cpu_count = self._utils.get_host_cpu_info() cpu_percent_used = (cpu_clock_used / float(host_cpu_clock * cpu_count)) # Nanoseconds cpu_time = (long(uptime * cpu_percent_used) * units.k) return virt_inspector.CPUStats(number=cpu_count, time=cpu_time)
def inspect_cpus(self, instance): instance_name = util.instance_name(instance) (cpu_clock_used, cpu_count, uptime) = self._utils.get_cpu_metrics(instance_name) cpu_percent_used = cpu_clock_used / self._host_max_cpu_clock # Nanoseconds cpu_time = (int(uptime * cpu_percent_used) * units.k) return virt_inspector.CPUStats(number=cpu_count, time=cpu_time)
def inspect_disks(self, instance, duration): instance_name = util.instance_name(instance) for disk_metrics in self._utils.get_disk_metrics(instance_name): yield virt_inspector.DiskStats( device=disk_metrics['instance_id'], read_requests=0, # Return bytes read_bytes=disk_metrics['read_mb'] * units.Mi, write_requests=0, write_bytes=disk_metrics['write_mb'] * units.Mi, errors=0, wr_total_times=0, rd_total_times=0)
def inspect_instance(self, instance, duration): instance_name = util.instance_name(instance) (cpu_clock_used, cpu_count, uptime) = self._utils.get_cpu_metrics(instance_name) cpu_percent_used = cpu_clock_used / self._host_max_cpu_clock # Nanoseconds cpu_time = (int(uptime * cpu_percent_used) * units.k) memory_usage = self._utils.get_memory_metrics(instance_name) return virt_inspector.InstanceStats(cpu_number=cpu_count, cpu_time=cpu_time, memory_usage=memory_usage)
def inspect_instance(self, instance, duration): instance_name = util.instance_name(instance) (cpu_clock_used, cpu_count, uptime) = self._utils.get_cpu_metrics(instance_name) cpu_percent_used = cpu_clock_used / self._host_max_cpu_clock # Nanoseconds cpu_time = (int(uptime * cpu_percent_used) * units.k) memory_usage = self._utils.get_memory_metrics(instance_name) return virt_inspector.InstanceStats( cpu_number=cpu_count, cpu_time=cpu_time, memory_usage=memory_usage)
def _get_domain_not_shut_off_or_raise(self, instance): instance_name = util.instance_name(instance) domain = self._lookup_by_uuid(instance) state = domain.info()[0] if state == libvirt.VIR_DOMAIN_SHUTOFF: msg = _('Failed to inspect data of instance ' '<name=%(name)s, id=%(id)s>, ' 'domain state is SHUTOFF.') % { 'name': instance_name, 'id': instance.id} raise virt_inspector.InstanceShutOffException(msg) return domain
def inspect_disks(self, instance): instance_name = util.instance_name(instance) for disk_metrics in self._utils.get_disk_metrics(instance_name): disk = virt_inspector.Disk(device=disk_metrics['instance_id']) stats = virt_inspector.DiskStats( read_requests=0, # Return bytes read_bytes=disk_metrics['read_mb'] * units.Mi, write_requests=0, write_bytes=disk_metrics['write_mb'] * units.Mi, errors=0) yield (disk, stats)
def get_samples(self, manager, cache, instance): instance_name = util.instance_name(instance) try: c_data = self._populate_cache( manager.inspector, cache, instance, instance_name, ) yield self._get_sample(instance, c_data) except Exception as err: LOG.warning('Ignoring instance %s: %s', instance_name, err) LOG.exception(err)
def inspect_cpu_util(self, instance, duration=None): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) vcpus_number = int(self._call_xenapi("VM.get_VCPUs_max", vm_ref)) if vcpus_number <= 0: msg = _("Could not get VM %s CPU number") % instance_name raise XenapiException(msg) utils = 0.0 for index in range(vcpus_number): utils += float(self._call_xenapi("VM.query_data_source", vm_ref, "cpu%d" % index)) utils = utils / int(vcpus_number) * 100 return virt_inspector.CPUUtilStats(util=utils)
def get_counters(self, manager, cache, instance): instance_name = util.instance_name(instance) c_data = self._populate_cache( manager.inspector, cache, instance, instance_name, ) try: yield self._get_counter(instance, c_data) except Exception as err: LOG.warning('Ignoring instance %s: %s', instance_name, err) LOG.exception(err)
def inspect_cpu_util(self, instance, duration=None): instance_name = util.instance_name(instance) vm_ref = self._lookup_by_name(instance_name) metrics_ref = self._call_xenapi("VM.get_metrics", vm_ref) metrics_rec = self._call_xenapi("VM_metrics.get_record", metrics_ref) vcpus_number = metrics_rec["VCPUs_number"] vcpus_utils = metrics_rec["VCPUs_utilisation"] if len(vcpus_utils) == 0: msg = _("Could not get VM %s CPU Utilization") % instance_name raise XenapiException(msg) utils = 0.0 for num in range(int(vcpus_number)): utils += vcpus_utils.get(str(num)) utils = utils / int(vcpus_number) * 100 return virt_inspector.CPUUtilStats(util=utils)
def inspect_vnics(self, instance, duration): instance_name = util.instance_name(instance) for vnic_metrics in self._utils.get_vnic_metrics(instance_name): yield virt_inspector.InterfaceStats( name=vnic_metrics["element_name"], mac=vnic_metrics["address"], fref=None, parameters=None, rx_bytes=vnic_metrics['rx_mb'] * units.Mi, rx_packets=0, rx_drop=0, rx_errors=0, tx_bytes=vnic_metrics['tx_mb'] * units.Mi, tx_packets=0, tx_drop=0, tx_errors=0)
def get_samples(self, manager, cache, instance): instance_name = util.instance_name(instance) LOG.info('checking instance %s', instance.id) try: vnics = self._get_vnics_for_instance( cache, manager.inspector, instance_name, ) for vnic, info in vnics: LOG.info(self.NET_USAGE_MESSAGE, instance_name, vnic.name, info.rx_bytes, info.tx_bytes) yield self._get_sample(instance, vnic, info) except Exception as err: LOG.warning('Ignoring instance %s: %s', instance_name, err) LOG.exception(err)