def test_get_vm_utilization(self):
self._createInvCache()
expected = ResourceUtilization()
self.mox.StubOutWithMock(self.manager.driver,
'get_resource_utilization')
self.manager.driver.get_resource_utilization(
mox.IgnoreArg(), mox.IgnoreArg(), Constants.Vm,
mox.IgnoreArg()).AndReturn(expected)
self.mox.ReplayAll()
result = self.manager.get_vm_utilization(self.context, 'uuid')
self.assertEqual(result, dict(ResourceUtilization=expected.__dict__))
self.mox.UnsetStubs()
def sample_vm_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_vm_perfdata for VM ' + uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
vm_stats_timestamp = None
vm_obj = InventoryCacheManager.get_object_from_cache(uuid,
Constants.Vm)
host_obj = InventoryCacheManager.get_object_from_cache(
vm_obj.get_vmHostId(),
Constants.VmHost)
#Check if VM is in running state, else the performance data for that VM is not valid
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
# Check if VM has old stats for sampling, else performance data is not sampled
if LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).timestamp
# Check the status of VM performance data collected, else the data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).status == 0 \
and LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).status == 0:
(pcentGuestCpu, guestCpus) = \
self._sample_cpu_stats(uuid)
(diskRead, diskWrite) = \
self._sample_disk_stats(uuid)
(netRead, netWrite) = self._sample_net_stats(uuid)
totalMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).totalMemory
freeMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).freeMemory
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentGuestCpu)
self.resource_utilization.set_ncpus(guestCpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(
host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
LOG.error(_('Performance data of VM ' + uuid
+ ' is not valid'))
self.resource_utilization.set_status(-1)
else:
LOG.error(_('Performance data of VM ' + uuid
+ ' is not yet sampled'))
self.resource_utilization.set_status(-1)
else:
LOG.info(_('VM ' + uuid + ' is not running'))
self.resource_utilization.set_status(-1)
LibvirtPerfMonitor.delete_perfdata_fromCache(uuid)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
LOG.info(_('Exiting sample_vm_perfdata for VM ' + uuid))
return self.resource_utilization
def sample_host_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_host_perfdata for VM Host '
+ uuid))
cpuTime = 0
prevcpuTime = 0
diskRead = 0
diskWrite = 0
netRead = 0
netWrite = 0
pcentHostCpu = 0.0
totalMemory = 0
freeMemory = 0
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
self.timestamp = time.time()
vm_stats_timestamp = None
vm_stats_oldtimestamp = None
host_obj = InventoryCacheManager.get_object_from_cache(uuid,
Constants.VmHost)
if host_obj.get_connectionState() == 'Disconnected':
LOG.info(_('Host ' + uuid + ' is disconnected'))
self.resource_utilization.set_status(-1)
return self.resource_utilization
# Host Performance data is calculated aggregating the performance data collected for VM's'''
for vm_id in host_obj.get_virtualMachineIds():
vm_obj = InventoryCacheManager.get_object_from_cache(vm_id,
Constants.Vm)
# Check if VM is in running state, else skip the performance data for that VM
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
#Check if VM has old stats for sampling, else performance data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).timestamp
vm_stats_oldtimestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).timestamp
LOG.debug(_('VM last sampled time stamp '
+ str(vm_stats_timestamp)))
# Check if the VM performance data is collected in last 5 minutes(considering buffer of 1 minute) and,
# status of the VM performance data, else performance data for VM is stale and is not valid
if self.timestamp - vm_stats_timestamp \
< CONF.perfmon_refresh_interval + 60 \
and LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).status == 0:
LOG.debug(_('Aggregating using performance data of VM '
+ vm_id))
(vmdiskRead, vmdiskWrite) = \
self._sample_disk_stats(vm_id)
(vmnetRead, vmnetWrite) = \
self._sample_net_stats(vm_id)
diskRead += vmdiskRead
diskWrite += vmdiskWrite
netRead += vmnetRead
netWrite += vmnetWrite
cpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).cpuStats.cycles['user'
]
prevcpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).cpuStats.cycles['user'
]
self.resource_utilization.set_status(0)
else:
LOG.error(_('Performance data of VM '
+ vm_id + ' is not valid '))
self.resource_utilization.set_status(-1)
break
else:
LOG.error(_('Performance data of VM ' + vm_id
+ ' is not yet sampled'))
self.resource_utilization.set_status(-1)
break
else:
LOG.info(_('VM ' + vm_id
+ ' is not running. Skipping performance data of VM for host perf data'
))
self.resource_utilization.set_status(0)
host_cpus = host_obj.get_processorCoresCount()
if self.resource_utilization.status == 0:
if vm_stats_timestamp is not None and vm_stats_oldtimestamp \
is not None:
pcentHostCpu = (cpuTime - prevcpuTime) * 100.0 \
/ ((vm_stats_timestamp - vm_stats_oldtimestamp)
* 1000.0 * 1000.0 * 1000.0)
pcentHostCpu = pcentHostCpu / int(host_cpus)
pcentHostCpu = max(0.0, min(100.0, pcentHostCpu))
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentHostCpu)
self.resource_utilization.set_ncpus(host_cpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
if (LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS) is not None) and \
(LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS).status == 0):
totalMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).totalMemory
freeMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).freeMemory
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
'''While all the VMs are in shutoff state the timestamp being shown is the
current time stamp '''
if vm_stats_timestamp is not None:
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
self.resource_utilization.set_timestamp(time.time())
LOG.info(_('Exiting sample_host_perfdata for VM Host ' + uuid))
return self.resource_utilization
class SamplePerfData:
def __init__(self):
self.resource_utilization = None
def sample_host_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_host_perfdata for VM Host '
+ uuid))
cpuTime = 0
prevcpuTime = 0
diskRead = 0
diskWrite = 0
netRead = 0
netWrite = 0
pcentHostCpu = 0.0
totalMemory = 0
freeMemory = 0
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
self.timestamp = time.time()
vm_stats_timestamp = None
vm_stats_oldtimestamp = None
host_obj = InventoryCacheManager.get_object_from_cache(uuid,
Constants.VmHost)
if host_obj.get_connectionState() == 'Disconnected':
LOG.info(_('Host ' + uuid + ' is disconnected'))
self.resource_utilization.set_status(-1)
return self.resource_utilization
# Host Performance data is calculated aggregating the performance data collected for VM's'''
for vm_id in host_obj.get_virtualMachineIds():
vm_obj = InventoryCacheManager.get_object_from_cache(vm_id,
Constants.Vm)
# Check if VM is in running state, else skip the performance data for that VM
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
#Check if VM has old stats for sampling, else performance data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).timestamp
vm_stats_oldtimestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).timestamp
LOG.debug(_('VM last sampled time stamp '
+ str(vm_stats_timestamp)))
# Check if the VM performance data is collected in last 5 minutes(considering buffer of 1 minute) and,
# status of the VM performance data, else performance data for VM is stale and is not valid
if self.timestamp - vm_stats_timestamp \
< CONF.perfmon_refresh_interval + 60 \
and LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).status == 0:
LOG.debug(_('Aggregating using performance data of VM '
+ vm_id))
(vmdiskRead, vmdiskWrite) = \
self._sample_disk_stats(vm_id)
(vmnetRead, vmnetWrite) = \
self._sample_net_stats(vm_id)
diskRead += vmdiskRead
diskWrite += vmdiskWrite
netRead += vmnetRead
netWrite += vmnetWrite
cpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).cpuStats.cycles['user'
]
prevcpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).cpuStats.cycles['user'
]
self.resource_utilization.set_status(0)
else:
LOG.error(_('Performance data of VM '
+ vm_id + ' is not valid '))
self.resource_utilization.set_status(-1)
break
else:
LOG.error(_('Performance data of VM ' + vm_id
+ ' is not yet sampled'))
self.resource_utilization.set_status(-1)
break
else:
LOG.info(_('VM ' + vm_id
+ ' is not running. Skipping performance data of VM for host perf data'
))
self.resource_utilization.set_status(0)
host_cpus = host_obj.get_processorCoresCount()
if self.resource_utilization.status == 0:
if vm_stats_timestamp is not None and vm_stats_oldtimestamp \
is not None:
pcentHostCpu = (cpuTime - prevcpuTime) * 100.0 \
/ ((vm_stats_timestamp - vm_stats_oldtimestamp)
* 1000.0 * 1000.0 * 1000.0)
pcentHostCpu = pcentHostCpu / int(host_cpus)
pcentHostCpu = max(0.0, min(100.0, pcentHostCpu))
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentHostCpu)
self.resource_utilization.set_ncpus(host_cpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
if (LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS) is not None) and \
(LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS).status == 0):
totalMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).totalMemory
freeMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).freeMemory
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
'''While all the VMs are in shutoff state the timestamp being shown is the
current time stamp '''
if vm_stats_timestamp is not None:
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
self.resource_utilization.set_timestamp(time.time())
LOG.info(_('Exiting sample_host_perfdata for VM Host ' + uuid))
return self.resource_utilization
def sample_vm_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_vm_perfdata for VM ' + uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
vm_stats_timestamp = None
vm_obj = InventoryCacheManager.get_object_from_cache(uuid,
Constants.Vm)
host_obj = InventoryCacheManager.get_object_from_cache(
vm_obj.get_vmHostId(),
Constants.VmHost)
#Check if VM is in running state, else the performance data for that VM is not valid
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
# Check if VM has old stats for sampling, else performance data is not sampled
if LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).timestamp
# Check the status of VM performance data collected, else the data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).status == 0 \
and LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).status == 0:
(pcentGuestCpu, guestCpus) = \
self._sample_cpu_stats(uuid)
(diskRead, diskWrite) = \
self._sample_disk_stats(uuid)
(netRead, netWrite) = self._sample_net_stats(uuid)
totalMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).totalMemory
freeMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).freeMemory
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentGuestCpu)
self.resource_utilization.set_ncpus(guestCpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(
host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
LOG.error(_('Performance data of VM ' + uuid
+ ' is not valid'))
self.resource_utilization.set_status(-1)
else:
LOG.error(_('Performance data of VM ' + uuid
+ ' is not yet sampled'))
self.resource_utilization.set_status(-1)
else:
LOG.info(_('VM ' + uuid + ' is not running'))
self.resource_utilization.set_status(-1)
LibvirtPerfMonitor.delete_perfdata_fromCache(uuid)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
LOG.info(_('Exiting sample_vm_perfdata for VM ' + uuid))
return self.resource_utilization
def _set_resource_utilization_defaults(self, uuid):
self.resource_utilization.set_cpuUserLoad(0.0)
self.resource_utilization.set_ncpus(0)
self.resource_utilization.set_hostCpuSpeed(0)
self.resource_utilization.set_hostMaxCpuSpeed(0)
self.resource_utilization.set_diskRead(0)
self.resource_utilization.set_diskWrite(0)
self.resource_utilization.set_netRead(0)
self.resource_utilization.set_netWrite(0)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(5)
self.resource_utilization.set_totalMemory(0)
self.resource_utilization.set_freeMemory(0)
self.resource_utilization.set_configuredMemory(0)
self.resource_utilization.set_timestamp(time.time())
self.resource_utilization.set_status(-1)
def _sample_cpu_stats(self, uuid):
''' cpu stats '''
LOG.debug(_('Entering _sample_cpu_stats for uuid ' + uuid))
prevcpuPerfTime = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).cpuPerfTime
prevCpuTime = LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).cpuStats.cycles['user']
cpuPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).cpuPerfTime
cpuTime = LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).cpuStats.cycles['user']
pcentbase = 0.0
perftime_delta = self._get_delta(cpuPerfTime,
prevcpuPerfTime)
if perftime_delta > 0:
pcentbase = self._get_delta(cpuTime, prevCpuTime) \
* 100.0 / (perftime_delta * 1000.0 * 1000.0 * 1000.0)
guestcpus = LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).ncpus
LOG.debug(_('prevcpuPerfTime ' + str(prevcpuPerfTime)
+ ' prevCpuTime ' + str(prevCpuTime) + ' cpuPerfTime '
+ str(cpuPerfTime) + ' cpuTime ' + str(cpuTime)
+ ' guestcpus ' + str(guestcpus)))
pcentGuestCpu = pcentbase / int(guestcpus)
LOG.debug(_('pcentGuestCpu ' + str(pcentGuestCpu)))
pcentGuestCpu = max(0.0, min(100.0, pcentGuestCpu))
LOG.debug(_('Exiting _sample_cpu_stats for uuid ' + uuid))
return (pcentGuestCpu, int(guestcpus))
def _sample_disk_stats(self, uuid):
''' disk stats '''
LOG.debug(_('Entering _sample_disk_stats for uuid ' + uuid))
prevdiskPerfTime = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).diskPerfTime
prevdiskReadBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).diskReadBytes
prevdiskWriteBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).diskWriteBytes
diskPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).diskPerfTime
diskReadBytes = LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).diskReadBytes
diskWriteBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).diskWriteBytes
LOG.debug(_('prevdiskPerfTime ' + str(prevdiskPerfTime)
+ ' prevdiskReadBytes ' + str(prevdiskReadBytes)
+ ' prevdiskWriteBytes ' + str(prevdiskWriteBytes)))
LOG.debug(_('diskPerfTime ' + str(diskPerfTime)
+ ' diskReadBytes ' + str(diskReadBytes)
+ ' diskWriteBytes ' + str(diskWriteBytes)))
diskRead = self._get_rate(
self._get_delta(diskReadBytes, prevdiskReadBytes),
self._get_delta(diskPerfTime, prevdiskPerfTime))
diskWrite = self._get_rate(
self._get_delta(diskWriteBytes, prevdiskWriteBytes),
self._get_delta(diskPerfTime, prevdiskPerfTime))
LOG.debug(_('diskRead ' + str(diskRead) + ' diskWrite ' +
str(diskWrite)))
LOG.debug(_('Exiting _sample_disk_stats for uuid ' + uuid))
return (diskRead, diskWrite)
def _sample_net_stats(self, uuid):
'''net stats'''
LOG.debug(_('Entering _sample_net_stats for uuid ' + uuid))
prevnetPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS).diskPerfTime
prevnetReceivedBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.OLD_STATS).netReceivedBytes
prevnetTransmittedBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.OLD_STATS).netTransmittedBytes
netPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.NEW_STATS).diskPerfTime
netReceivedBytes = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.NEW_STATS).netReceivedBytes
netTransmittedBytes = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.NEW_STATS).netTransmittedBytes
LOG.debug(_('prevnetPerfTime ' + str(prevnetPerfTime)
+ ' prevnetReceivedBytes '
+ str(prevnetReceivedBytes)
+ ' prevnetTransmittedBytes '
+ str(prevnetTransmittedBytes)))
LOG.debug(_('netPerfTime ' + str(netPerfTime)
+ ' netReceivedBytes ' + str(netReceivedBytes)
+ ' netTransmittedBytes ' + str(netTransmittedBytes)))
netRead = self._get_rate(
self._get_delta(netReceivedBytes, prevnetReceivedBytes),
self._get_delta(netPerfTime, prevnetPerfTime))
netWrite = self._get_rate(
self._get_delta(netTransmittedBytes, prevnetTransmittedBytes),
self._get_delta(netPerfTime, prevnetPerfTime))
LOG.debug(_('netRead ' + str(netRead) + ' netWrite '
+ str(netWrite)))
LOG.debug(_('Exiting _sample_net_stats for uuid ' + uuid))
return (netRead, netWrite)
def _get_delta(self, new_value, old_value):
if new_value == 0:
return 0
res = float(new_value - old_value)
if res < 0:
res = 0
return res
def _get_rate(self, deltaBytes, deltaTime):
if deltaTime > 0:
rate = deltaBytes / deltaTime
else:
rate = 0.0
return max(rate, 0, 0) # avoid negative values at poweroff
def sample_vm_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_vm_perfdata for VM ' + uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
vm_stats_timestamp = None
vm_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.Vm)
host_obj = InventoryCacheManager.get_object_from_cache(
vm_obj.get_vmHostId(), Constants.VmHost)
#Check if VM is in running state, else the performance data for that VM is not valid
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
# Check if VM has old stats for sampling, else performance data is not sampled
if LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).timestamp
# Check the status of VM performance data collected, else the data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).status == 0 \
and LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).status == 0:
(pcentGuestCpu, guestCpus) = \
self._sample_cpu_stats(uuid)
(diskRead, diskWrite) = \
self._sample_disk_stats(uuid)
(netRead, netWrite) = self._sample_net_stats(uuid)
totalMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).totalMemory
freeMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).freeMemory
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentGuestCpu)
self.resource_utilization.set_ncpus(guestCpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(
host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
LOG.error(
_('Performance data of VM ' + uuid + ' is not valid'))
self.resource_utilization.set_status(-1)
else:
LOG.error(
_('Performance data of VM ' + uuid +
' is not yet sampled'))
self.resource_utilization.set_status(-1)
else:
LOG.info(_('VM ' + uuid + ' is not running'))
self.resource_utilization.set_status(-1)
LibvirtPerfMonitor.delete_perfdata_fromCache(uuid)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
LOG.info(_('Exiting sample_vm_perfdata for VM ' + uuid))
return self.resource_utilization
def sample_host_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_host_perfdata for VM Host ' + uuid))
cpuTime = 0
prevcpuTime = 0
diskRead = 0
diskWrite = 0
netRead = 0
netWrite = 0
pcentHostCpu = 0.0
totalMemory = 0
freeMemory = 0
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
self.timestamp = time.time()
vm_stats_timestamp = None
vm_stats_oldtimestamp = None
host_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.VmHost)
if host_obj.get_connectionState() == 'Disconnected':
LOG.info(_('Host ' + uuid + ' is disconnected'))
self.resource_utilization.set_status(-1)
return self.resource_utilization
# Host Performance data is calculated aggregating the performance data collected for VM's'''
for vm_id in host_obj.get_virtualMachineIds():
vm_obj = InventoryCacheManager.get_object_from_cache(
vm_id, Constants.Vm)
# Check if VM is in running state, else skip the performance data for that VM
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
#Check if VM has old stats for sampling, else performance data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(
vm_id, Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).timestamp
vm_stats_oldtimestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).timestamp
LOG.debug(
_('VM last sampled time stamp ' +
str(vm_stats_timestamp)))
# Check if the VM performance data is collected in last 5 minutes(considering buffer of 1 minute) and,
# status of the VM performance data, else performance data for VM is stale and is not valid
if self.timestamp - vm_stats_timestamp \
< CONF.perfmon_refresh_interval + 60 \
and LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).status == 0:
LOG.debug(
_('Aggregating using performance data of VM ' +
vm_id))
(vmdiskRead, vmdiskWrite) = \
self._sample_disk_stats(vm_id)
(vmnetRead, vmnetWrite) = \
self._sample_net_stats(vm_id)
diskRead += vmdiskRead
diskWrite += vmdiskWrite
netRead += vmnetRead
netWrite += vmnetWrite
cpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).cpuStats.cycles['user'
]
prevcpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).cpuStats.cycles['user'
]
self.resource_utilization.set_status(0)
else:
LOG.error(
_('Performance data of VM ' + vm_id +
' is not valid '))
self.resource_utilization.set_status(-1)
break
else:
LOG.error(
_('Performance data of VM ' + vm_id +
' is not yet sampled'))
self.resource_utilization.set_status(-1)
break
else:
LOG.info(
_('VM ' + vm_id +
' is not running. Skipping performance data of VM for host perf data'
))
self.resource_utilization.set_status(0)
host_cpus = host_obj.get_processorCoresCount()
if self.resource_utilization.status == 0:
if vm_stats_timestamp is not None and vm_stats_oldtimestamp \
is not None:
pcentHostCpu = (cpuTime - prevcpuTime) * 100.0 \
/ ((vm_stats_timestamp - vm_stats_oldtimestamp)
* 1000.0 * 1000.0 * 1000.0)
pcentHostCpu = pcentHostCpu / int(host_cpus)
pcentHostCpu = max(0.0, min(100.0, pcentHostCpu))
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentHostCpu)
self.resource_utilization.set_ncpus(host_cpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
if (LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS) is not None) and \
(LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS).status == 0):
totalMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).totalMemory
freeMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).freeMemory
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
'''While all the VMs are in shutoff state the timestamp being shown is the
current time stamp '''
if vm_stats_timestamp is not None:
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
self.resource_utilization.set_timestamp(time.time())
LOG.info(_('Exiting sample_host_perfdata for VM Host ' + uuid))
return self.resource_utilization
class SamplePerfData:
def __init__(self):
self.resource_utilization = None
def sample_host_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_host_perfdata for VM Host ' + uuid))
cpuTime = 0
prevcpuTime = 0
diskRead = 0
diskWrite = 0
netRead = 0
netWrite = 0
pcentHostCpu = 0.0
totalMemory = 0
freeMemory = 0
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
self.timestamp = time.time()
vm_stats_timestamp = None
vm_stats_oldtimestamp = None
host_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.VmHost)
if host_obj.get_connectionState() == 'Disconnected':
LOG.info(_('Host ' + uuid + ' is disconnected'))
self.resource_utilization.set_status(-1)
return self.resource_utilization
# Host Performance data is calculated aggregating the performance data collected for VM's'''
for vm_id in host_obj.get_virtualMachineIds():
vm_obj = InventoryCacheManager.get_object_from_cache(
vm_id, Constants.Vm)
# Check if VM is in running state, else skip the performance data for that VM
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
#Check if VM has old stats for sampling, else performance data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(
vm_id, Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).timestamp
vm_stats_oldtimestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).timestamp
LOG.debug(
_('VM last sampled time stamp ' +
str(vm_stats_timestamp)))
# Check if the VM performance data is collected in last 5 minutes(considering buffer of 1 minute) and,
# status of the VM performance data, else performance data for VM is stale and is not valid
if self.timestamp - vm_stats_timestamp \
< CONF.perfmon_refresh_interval + 60 \
and LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).status == 0:
LOG.debug(
_('Aggregating using performance data of VM ' +
vm_id))
(vmdiskRead, vmdiskWrite) = \
self._sample_disk_stats(vm_id)
(vmnetRead, vmnetWrite) = \
self._sample_net_stats(vm_id)
diskRead += vmdiskRead
diskWrite += vmdiskWrite
netRead += vmnetRead
netWrite += vmnetWrite
cpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.NEW_STATS).cpuStats.cycles['user'
]
prevcpuTime += \
LibvirtPerfMonitor.get_perfdata_fromCache(vm_id,
Constants.OLD_STATS).cpuStats.cycles['user'
]
self.resource_utilization.set_status(0)
else:
LOG.error(
_('Performance data of VM ' + vm_id +
' is not valid '))
self.resource_utilization.set_status(-1)
break
else:
LOG.error(
_('Performance data of VM ' + vm_id +
' is not yet sampled'))
self.resource_utilization.set_status(-1)
break
else:
LOG.info(
_('VM ' + vm_id +
' is not running. Skipping performance data of VM for host perf data'
))
self.resource_utilization.set_status(0)
host_cpus = host_obj.get_processorCoresCount()
if self.resource_utilization.status == 0:
if vm_stats_timestamp is not None and vm_stats_oldtimestamp \
is not None:
pcentHostCpu = (cpuTime - prevcpuTime) * 100.0 \
/ ((vm_stats_timestamp - vm_stats_oldtimestamp)
* 1000.0 * 1000.0 * 1000.0)
pcentHostCpu = pcentHostCpu / int(host_cpus)
pcentHostCpu = max(0.0, min(100.0, pcentHostCpu))
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentHostCpu)
self.resource_utilization.set_ncpus(host_cpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
if (LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS) is not None) and \
(LibvirtPerfMonitor.get_perfdata_fromCache(uuid, Constants.NEW_STATS).status == 0):
totalMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).totalMemory
freeMemory = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).freeMemory
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
'''While all the VMs are in shutoff state the timestamp being shown is the
current time stamp '''
if vm_stats_timestamp is not None:
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
self.resource_utilization.set_timestamp(time.time())
LOG.info(_('Exiting sample_host_perfdata for VM Host ' + uuid))
return self.resource_utilization
def sample_vm_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sample_vm_perfdata for VM ' + uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
vm_stats_timestamp = None
vm_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.Vm)
host_obj = InventoryCacheManager.get_object_from_cache(
vm_obj.get_vmHostId(), Constants.VmHost)
#Check if VM is in running state, else the performance data for that VM is not valid
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
# Check if VM has old stats for sampling, else performance data is not sampled
if LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS) is not None:
vm_stats_timestamp = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).timestamp
# Check the status of VM performance data collected, else the data is not valid
if LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).status == 0 \
and LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).status == 0:
(pcentGuestCpu, guestCpus) = \
self._sample_cpu_stats(uuid)
(diskRead, diskWrite) = \
self._sample_disk_stats(uuid)
(netRead, netWrite) = self._sample_net_stats(uuid)
totalMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).totalMemory
freeMemory = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).freeMemory
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentGuestCpu)
self.resource_utilization.set_ncpus(guestCpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(
host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(vm_stats_timestamp))
else:
LOG.error(
_('Performance data of VM ' + uuid + ' is not valid'))
self.resource_utilization.set_status(-1)
else:
LOG.error(
_('Performance data of VM ' + uuid +
' is not yet sampled'))
self.resource_utilization.set_status(-1)
else:
LOG.info(_('VM ' + uuid + ' is not running'))
self.resource_utilization.set_status(-1)
LibvirtPerfMonitor.delete_perfdata_fromCache(uuid)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
LOG.info(_('Exiting sample_vm_perfdata for VM ' + uuid))
return self.resource_utilization
def _set_resource_utilization_defaults(self, uuid):
self.resource_utilization.set_cpuUserLoad(0.0)
self.resource_utilization.set_ncpus(0)
self.resource_utilization.set_hostCpuSpeed(0)
self.resource_utilization.set_hostMaxCpuSpeed(0)
self.resource_utilization.set_diskRead(0)
self.resource_utilization.set_diskWrite(0)
self.resource_utilization.set_netRead(0)
self.resource_utilization.set_netWrite(0)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(5)
self.resource_utilization.set_totalMemory(0)
self.resource_utilization.set_freeMemory(0)
self.resource_utilization.set_configuredMemory(0)
self.resource_utilization.set_timestamp(time.time())
self.resource_utilization.set_status(-1)
def _sample_cpu_stats(self, uuid):
''' cpu stats '''
LOG.debug(_('Entering _sample_cpu_stats for uuid ' + uuid))
prevcpuPerfTime = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).cpuPerfTime
prevCpuTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS).cpuStats.cycles['user']
cpuPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).cpuPerfTime
cpuTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).cpuStats.cycles['user']
pcentbase = 0.0
perftime_delta = self._get_delta(cpuPerfTime, prevcpuPerfTime)
if perftime_delta > 0:
pcentbase = self._get_delta(cpuTime, prevCpuTime) \
* 100.0 / (perftime_delta * 1000.0 * 1000.0 * 1000.0)
guestcpus = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).ncpus
LOG.debug(
_('prevcpuPerfTime ' + str(prevcpuPerfTime) + ' prevCpuTime ' +
str(prevCpuTime) + ' cpuPerfTime ' + str(cpuPerfTime) +
' cpuTime ' + str(cpuTime) + ' guestcpus ' + str(guestcpus)))
pcentGuestCpu = pcentbase / int(guestcpus)
LOG.debug(_('pcentGuestCpu ' + str(pcentGuestCpu)))
pcentGuestCpu = max(0.0, min(100.0, pcentGuestCpu))
LOG.debug(_('Exiting _sample_cpu_stats for uuid ' + uuid))
return (pcentGuestCpu, int(guestcpus))
def _sample_disk_stats(self, uuid):
''' disk stats '''
LOG.debug(_('Entering _sample_disk_stats for uuid ' + uuid))
prevdiskPerfTime = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).diskPerfTime
prevdiskReadBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).diskReadBytes
prevdiskWriteBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.OLD_STATS).diskWriteBytes
diskPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).diskPerfTime
diskReadBytes = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).diskReadBytes
diskWriteBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(uuid,
Constants.NEW_STATS).diskWriteBytes
LOG.debug(
_('prevdiskPerfTime ' + str(prevdiskPerfTime) +
' prevdiskReadBytes ' + str(prevdiskReadBytes) +
' prevdiskWriteBytes ' + str(prevdiskWriteBytes)))
LOG.debug(
_('diskPerfTime ' + str(diskPerfTime) + ' diskReadBytes ' +
str(diskReadBytes) + ' diskWriteBytes ' + str(diskWriteBytes)))
diskRead = self._get_rate(
self._get_delta(diskReadBytes, prevdiskReadBytes),
self._get_delta(diskPerfTime, prevdiskPerfTime))
diskWrite = self._get_rate(
self._get_delta(diskWriteBytes, prevdiskWriteBytes),
self._get_delta(diskPerfTime, prevdiskPerfTime))
LOG.debug(
_('diskRead ' + str(diskRead) + ' diskWrite ' + str(diskWrite)))
LOG.debug(_('Exiting _sample_disk_stats for uuid ' + uuid))
return (diskRead, diskWrite)
def _sample_net_stats(self, uuid):
'''net stats'''
LOG.debug(_('Entering _sample_net_stats for uuid ' + uuid))
prevnetPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS).diskPerfTime
prevnetReceivedBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.OLD_STATS).netReceivedBytes
prevnetTransmittedBytes = \
LibvirtPerfMonitor.get_perfdata_fromCache(
uuid,
Constants.OLD_STATS).netTransmittedBytes
netPerfTime = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).diskPerfTime
netReceivedBytes = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).netReceivedBytes
netTransmittedBytes = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS).netTransmittedBytes
LOG.debug(
_('prevnetPerfTime ' + str(prevnetPerfTime) +
' prevnetReceivedBytes ' + str(prevnetReceivedBytes) +
' prevnetTransmittedBytes ' + str(prevnetTransmittedBytes)))
LOG.debug(
_('netPerfTime ' + str(netPerfTime) + ' netReceivedBytes ' +
str(netReceivedBytes) + ' netTransmittedBytes ' +
str(netTransmittedBytes)))
netRead = self._get_rate(
self._get_delta(netReceivedBytes, prevnetReceivedBytes),
self._get_delta(netPerfTime, prevnetPerfTime))
netWrite = self._get_rate(
self._get_delta(netTransmittedBytes, prevnetTransmittedBytes),
self._get_delta(netPerfTime, prevnetPerfTime))
LOG.debug(_('netRead ' + str(netRead) + ' netWrite ' + str(netWrite)))
LOG.debug(_('Exiting _sample_net_stats for uuid ' + uuid))
return (netRead, netWrite)
def _get_delta(self, new_value, old_value):
if new_value == 0:
return 0
res = float(new_value - old_value)
if res < 0:
res = 0
return res
def _get_rate(self, deltaBytes, deltaTime):
if deltaTime > 0:
rate = deltaBytes / deltaTime
else:
rate = 0.0
return max(rate, 0, 0) # avoid negative values at poweroff
def sample_vm_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sampling utilization data for vm ' + uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
vm_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.Vm)
host_obj = InventoryCacheManager.get_object_from_cache(
vm_obj.get_vmHostId(), Constants.VmHost)
self.old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS)
self.new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS)
# Check if VM is in running state, else the utilization data for that
# VM is not valid
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
# Check if VM has old stats for sampling, else utilization data is
# not sampled
if self.old_stats is not None:
# Check the status of VM utilization data collected, else the
# data is not valid
if self.new_stats.status == 0 and self.old_stats.status == 0:
(pcentUserCpu, pcentSystemCpu,
guestCpus) = self._sample_cpu_stats(uuid)
(diskRead, diskWrite) = self._sample_disk_stats(uuid)
(netRead, netWrite) = self._sample_net_stats(uuid)
totalMemory = self.new_stats.totalMemory
freeMemory = self.new_stats.freeMemory
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentUserCpu)
self.resource_utilization.set_cpuSystemLoad(pcentSystemCpu)
self.resource_utilization.set_ncpus(guestCpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(
host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp
(self.new_stats.timestamp))
LOG.info(_('sampled utilization data for vm ' +
uuid + ' for window minutes '
+ str(window_minutes)))
else:
LOG.error(_(
'utilization data of vm ' + uuid + ' is not valid'))
else:
LOG.error(_(
'utilization data of vm ' + uuid + ' is not yet sampled'))
else:
LOG.error(_('vm ' + uuid + ' is not active'))
LibvirtPerfMonitor.delete_perfdata_fromCache(uuid)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
LOG.info(_('Exiting sample utilization data for vm ' + uuid))
return self.resource_utilization
def sample_host_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sampling utilization data for host '
+ uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
self.timestamp = time.time()
host_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.VmHost)
self.old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS)
self.new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS)
if host_obj.get_connectionState() == Constants.VMHOST_DISCONNECTED:
LOG.error(_('host ' + uuid + ' is disconnected'))
return self.resource_utilization
# Check if host has old stats for sampling, else utilization data is
# not sampled
if self.old_stats is not None:
# Check the status of host utilization data collected, else the
# data is not valid
if self.new_stats.status == 0 and self.old_stats.status == 0:
(pcentUserCpu, pcentSystemCpu,
host_cpus) = self._sample_cpu_stats(uuid)
host_cpu_speed = host_obj.get_processorSpeedMhz()
totalMemory = self.new_stats.totalMemory
freeMemory = self.new_stats.freeMemory
self.resource_utilization.set_cpuUserLoad(pcentUserCpu)
self.resource_utilization.set_cpuSystemLoad(pcentSystemCpu)
self.resource_utilization.set_ncpus(host_cpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(host_cpu_speed)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(
self.new_stats.timestamp))
LOG.info(_('sampled cpu/memory utilization data for host ' +
uuid + ' for window minutes ' + str(window_minutes)))
else:
LOG.error(_(
'utilization data of host ' + uuid + ' is not valid'))
else:
LOG.error(_(
'utilization data of host ' + uuid + ' is not yet sampled'))
# sample disk/network data only if sampling of cpu/memory is successful
if self.resource_utilization.get_status() == 0:
diskRead = 0
diskWrite = 0
netRead = 0
netWrite = 0
LOG.debug(_(
'aggregating disk/network utilization data using vms data for \
host ' + uuid))
# disk/network utilization data is calculated aggregating the
# performance data of VM's
for vm_id in host_obj.get_virtualMachineIds():
vm_obj = InventoryCacheManager.get_object_from_cache(
vm_id, Constants.Vm)
# Check if VM is in running state, else skip the utilization
# data for that VM
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
vm_old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
vm_id, Constants.OLD_STATS)
vm_new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
vm_id, Constants.NEW_STATS)
# Check if VM has old stats for sampling, else utilization
# data is not valid
if vm_old_stats is not None:
LOG.debug(_('time now :' + str(
self.timestamp) + ' last sampled time:' +
str(vm_new_stats.timestamp)))
# Check if the VM utilization data is collected in \
# last 5 minutes(considering buffer of 1 minute) and
# status of the VM utilization data, else performance
# data for VM is stale and is not valid
diff = self.timestamp - vm_new_stats.timestamp
if diff < CONF.perfmon_refresh_interval + 60 \
and vm_new_stats.status == 0:
(vmdiskRead, vmdiskWrite) = \
self._sample_disk_stats(
vm_id)
(vmnetRead, vmnetWrite) = self._sample_net_stats(
vm_id)
diskRead += vmdiskRead
diskWrite += vmdiskWrite
netRead += vmnetRead
netWrite += vmnetWrite
else:
LOG.error(_(
'disk/network utilization data of vm \
' + vm_id + ' on host ' + uuid + ' is not valid'))
break
else:
LOG.error(_('disk/network utilization data of vm ' +
vm_id + ' on host ' + uuid + ' is \
not yet sampled'))
break
else:
LOG.info(_('vm ' + vm_id + ' on host ' + uuid +
' is not active. skipping disk/network \
utilization data of vm '))
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
LOG.info(_('sampled disk/network utilization data for host ' +
uuid + ' for window minutes ' + str(window_minutes)))
LOG.info(_('Exiting sampling utilization data for host ' + uuid))
return self.resource_utilization
class SamplePerfData:
""" Class responsible for sampling KVM Host utilization data for
specified window minutes """
def __init__(self):
self.resource_utilization = None
def sample_host_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sampling utilization data for host '
+ uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
self.timestamp = time.time()
host_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.VmHost)
self.old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS)
self.new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS)
if host_obj.get_connectionState() == Constants.VMHOST_DISCONNECTED:
LOG.error(_('host ' + uuid + ' is disconnected'))
return self.resource_utilization
# Check if host has old stats for sampling, else utilization data is
# not sampled
if self.old_stats is not None:
# Check the status of host utilization data collected, else the
# data is not valid
if self.new_stats.status == 0 and self.old_stats.status == 0:
(pcentUserCpu, pcentSystemCpu,
host_cpus) = self._sample_cpu_stats(uuid)
host_cpu_speed = host_obj.get_processorSpeedMhz()
totalMemory = self.new_stats.totalMemory
freeMemory = self.new_stats.freeMemory
self.resource_utilization.set_cpuUserLoad(pcentUserCpu)
self.resource_utilization.set_cpuSystemLoad(pcentSystemCpu)
self.resource_utilization.set_ncpus(host_cpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(host_cpu_speed)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp(
self.new_stats.timestamp))
LOG.info(_('sampled cpu/memory utilization data for host ' +
uuid + ' for window minutes ' + str(window_minutes)))
else:
LOG.error(_(
'utilization data of host ' + uuid + ' is not valid'))
else:
LOG.error(_(
'utilization data of host ' + uuid + ' is not yet sampled'))
# sample disk/network data only if sampling of cpu/memory is successful
if self.resource_utilization.get_status() == 0:
diskRead = 0
diskWrite = 0
netRead = 0
netWrite = 0
LOG.debug(_(
'aggregating disk/network utilization data using vms data for \
host ' + uuid))
# disk/network utilization data is calculated aggregating the
# performance data of VM's
for vm_id in host_obj.get_virtualMachineIds():
vm_obj = InventoryCacheManager.get_object_from_cache(
vm_id, Constants.Vm)
# Check if VM is in running state, else skip the utilization
# data for that VM
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
vm_old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
vm_id, Constants.OLD_STATS)
vm_new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
vm_id, Constants.NEW_STATS)
# Check if VM has old stats for sampling, else utilization
# data is not valid
if vm_old_stats is not None:
LOG.debug(_('time now :' + str(
self.timestamp) + ' last sampled time:' +
str(vm_new_stats.timestamp)))
# Check if the VM utilization data is collected in \
# last 5 minutes(considering buffer of 1 minute) and
# status of the VM utilization data, else performance
# data for VM is stale and is not valid
diff = self.timestamp - vm_new_stats.timestamp
if diff < CONF.perfmon_refresh_interval + 60 \
and vm_new_stats.status == 0:
(vmdiskRead, vmdiskWrite) = \
self._sample_disk_stats(
vm_id)
(vmnetRead, vmnetWrite) = self._sample_net_stats(
vm_id)
diskRead += vmdiskRead
diskWrite += vmdiskWrite
netRead += vmnetRead
netWrite += vmnetWrite
else:
LOG.error(_(
'disk/network utilization data of vm \
' + vm_id + ' on host ' + uuid + ' is not valid'))
break
else:
LOG.error(_('disk/network utilization data of vm ' +
vm_id + ' on host ' + uuid + ' is \
not yet sampled'))
break
else:
LOG.info(_('vm ' + vm_id + ' on host ' + uuid +
' is not active. skipping disk/network \
utilization data of vm '))
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
LOG.info(_('sampled disk/network utilization data for host ' +
uuid + ' for window minutes ' + str(window_minutes)))
LOG.info(_('Exiting sampling utilization data for host ' + uuid))
return self.resource_utilization
def sample_vm_perfdata(self, uuid, window_minutes):
LOG.info(_('Entering sampling utilization data for vm ' + uuid))
self.resource_utilization = ResourceUtilization()
self._set_resource_utilization_defaults(uuid)
vm_obj = InventoryCacheManager.get_object_from_cache(
uuid, Constants.Vm)
host_obj = InventoryCacheManager.get_object_from_cache(
vm_obj.get_vmHostId(), Constants.VmHost)
self.old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS)
self.new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS)
# Check if VM is in running state, else the utilization data for that
# VM is not valid
if vm_obj.get_powerState() == Constants.VM_POWER_STATES[1]:
# Check if VM has old stats for sampling, else utilization data is
# not sampled
if self.old_stats is not None:
# Check the status of VM utilization data collected, else the
# data is not valid
if self.new_stats.status == 0 and self.old_stats.status == 0:
(pcentUserCpu, pcentSystemCpu,
guestCpus) = self._sample_cpu_stats(uuid)
(diskRead, diskWrite) = self._sample_disk_stats(uuid)
(netRead, netWrite) = self._sample_net_stats(uuid)
totalMemory = self.new_stats.totalMemory
freeMemory = self.new_stats.freeMemory
host_cpu_speed = host_obj.get_processorSpeedMhz()
self.resource_utilization.set_cpuUserLoad(pcentUserCpu)
self.resource_utilization.set_cpuSystemLoad(pcentSystemCpu)
self.resource_utilization.set_ncpus(guestCpus)
self.resource_utilization.set_hostCpuSpeed(host_cpu_speed)
self.resource_utilization.set_hostMaxCpuSpeed(
host_cpu_speed)
self.resource_utilization.set_diskRead(diskRead)
self.resource_utilization.set_diskWrite(diskWrite)
self.resource_utilization.set_netRead(netRead)
self.resource_utilization.set_netWrite(netWrite)
self.resource_utilization.set_totalMemory(totalMemory)
self.resource_utilization.set_configuredMemory(totalMemory)
self.resource_utilization.set_freeMemory(freeMemory)
self.resource_utilization.set_status(0)
self.resource_utilization.set_timestamp(
datetime.datetime.utcfromtimestamp
(self.new_stats.timestamp))
LOG.info(_('sampled utilization data for vm ' +
uuid + ' for window minutes '
+ str(window_minutes)))
else:
LOG.error(_(
'utilization data of vm ' + uuid + ' is not valid'))
else:
LOG.error(_(
'utilization data of vm ' + uuid + ' is not yet sampled'))
else:
LOG.error(_('vm ' + uuid + ' is not active'))
LibvirtPerfMonitor.delete_perfdata_fromCache(uuid)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(window_minutes)
LOG.info(_('Exiting sample utilization data for vm ' + uuid))
return self.resource_utilization
def _set_resource_utilization_defaults(self, uuid):
self.resource_utilization.set_cpuUserLoad(0.0)
self.resource_utilization.set_cpuSystemLoad(0.0)
self.resource_utilization.set_ncpus(0)
self.resource_utilization.set_hostCpuSpeed(0)
self.resource_utilization.set_hostMaxCpuSpeed(0)
self.resource_utilization.set_diskRead(0)
self.resource_utilization.set_diskWrite(0)
self.resource_utilization.set_netRead(0)
self.resource_utilization.set_netWrite(0)
self.resource_utilization.set_resourceId(uuid)
self.resource_utilization.set_granularity(5)
self.resource_utilization.set_totalMemory(0)
self.resource_utilization.set_freeMemory(0)
self.resource_utilization.set_configuredMemory(0)
self.resource_utilization.set_timestamp(time.time())
self.resource_utilization.set_status(-1)
def _sample_cpu_stats(self, uuid):
''' sample cpu stats for given window minutes'''
prevcpuPerfTime = self.old_stats.cpuPerfTime
prevCpuUserTime = self.old_stats.cpuStats.cycles['user']
prevCpuSystemTime = self.old_stats.cpuStats.cycles['system']
cpuPerfTime = self.new_stats.cpuPerfTime
cpuUserTime = self.new_stats.cpuStats.cycles['user']
cpuSystemTime = self.new_stats.cpuStats.cycles['system']
pcentUserbase = 0.0
pcentSystembase = 0.0
pcentUserCpu = 0.0
pcentSystemCpu = 0.0
# cpu user and kernel time is obtained in nano seconds and time \
# delta is in seconds
# Hence dividing the delta of cpu time by 10 pow 9
perftime_delta = self._get_delta(cpuPerfTime, prevcpuPerfTime)
cpus = self.new_stats.ncpus
if perftime_delta > 0:
pcentUserbase = self._get_delta(cpuUserTime, prevCpuUserTime)\
* 100.0 / (
perftime_delta * 1000.0 * 1000.0 * 1000.0)
pcentUserCpu = pcentUserbase / int(cpus)
pcentUserCpu = max(0.0, min(100.0, pcentUserCpu))
if (cpuSystemTime > 0):
pcentSystembase = self._get_delta(
cpuSystemTime, prevCpuSystemTime) * 100.0 / (
perftime_delta * 1000.0 * 1000.0 * 1000.0)
pcentSystemCpu = pcentSystembase / int(cpus)
pcentSystemCpu = max(0.0, min(100.0, pcentSystemCpu))
LOG.debug(_('pcentUserCpu ' + str(pcentUserCpu) + ' \
pcentSystemCpu ' + str(
pcentSystemCpu) + ' cpus ' + str(cpus)))
return (pcentUserCpu, pcentSystemCpu, int(cpus))
def _sample_disk_stats(self, uuid):
''' sample disk stats for given window minutes '''
old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS)
new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS)
prevdiskPerfTime = old_stats.diskPerfTime
prevdiskReadBytes = old_stats.diskReadBytes
prevdiskWriteBytes = old_stats.diskWriteBytes
diskPerfTime = new_stats.diskPerfTime
diskReadBytes = new_stats.diskReadBytes
diskWriteBytes = new_stats.diskWriteBytes
LOG.debug(_('prevdiskPerfTime ' + str(prevdiskPerfTime) + ' \
prevdiskReadBytes ' + str(prevdiskReadBytes)
+ ' prevdiskWriteBytes ' + str(prevdiskWriteBytes)))
LOG.debug(_('diskPerfTime ' + str(diskPerfTime) + ' diskReadBytes \
' + str(diskReadBytes)
+ ' diskWriteBytes ' + str(diskWriteBytes)))
diskRead = self._get_rate(self._get_delta(
diskReadBytes, prevdiskReadBytes),
self._get_delta(
diskPerfTime, prevdiskPerfTime))
diskWrite = self._get_rate(self._get_delta(
diskWriteBytes, prevdiskWriteBytes),
self._get_delta(diskPerfTime,
prevdiskPerfTime))
LOG.debug(_('diskRead ' + str(
diskRead) + ' diskWrite ' + str(diskWrite)))
return (diskRead, diskWrite)
def _sample_net_stats(self, uuid):
'''sample network stats for given window minutes'''
old_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.OLD_STATS)
new_stats = LibvirtPerfMonitor.get_perfdata_fromCache(
uuid, Constants.NEW_STATS)
prevnetPerfTime = old_stats.diskPerfTime
prevnetReceivedBytes = old_stats.netReceivedBytes
prevnetTransmittedBytes = old_stats.netTransmittedBytes
netPerfTime = new_stats.diskPerfTime
netReceivedBytes = new_stats.netReceivedBytes
netTransmittedBytes = new_stats.netTransmittedBytes
LOG.debug(_('prevnetPerfTime ' + str(prevnetPerfTime) + ' \
prevnetReceivedBytes ' + str(prevnetReceivedBytes)
+ ' prevnetTransmittedBytes ' +
str(prevnetTransmittedBytes)))
LOG.debug(_('netPerfTime ' + str(netPerfTime) + '\
netReceivedBytes ' + str(netReceivedBytes)
+ ' netTransmittedBytes ' + str(netTransmittedBytes)))
netRead = self._get_rate(self._get_delta(
netReceivedBytes, prevnetReceivedBytes),
self._get_delta(netPerfTime, prevnetPerfTime))
netWrite = self._get_rate(self._get_delta(
netTransmittedBytes, prevnetTransmittedBytes),
self._get_delta(netPerfTime, prevnetPerfTime))
LOG.debug(_('netRead ' + str(netRead) + ' netWrite ' + str(netWrite)))
return (netRead, netWrite)
def _get_delta(self, new_value, old_value):
if new_value == 0:
return 0
res = float(new_value - old_value)
if res < 0:
res = 0
return res
def _get_rate(self, deltaBytes, deltaTime):
if deltaTime > 0:
rate = deltaBytes / deltaTime
else:
rate = 0.0
return max(rate, 0, 0) # avoid negative values at poweroff
