def test_get_samples(self):
next_value = iter((
virt_inspector.MemoryUsageStats(usage=1.0),
virt_inspector.MemoryUsageStats(usage=2.0),
))
def inspect_memory_usage(instance, duration):
return six.next(next_value)
(self.inspector.inspect_memory_usage) = mock.Mock(
side_effect=inspect_memory_usage)
mgr = manager.AgentManager()
pollster = memory.MemoryUsagePollster()
def _verify_memory_metering(expected_memory_mb):
cache = {}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.usage']),
set([s.name for s in samples]))
self.assertEqual(expected_memory_mb, samples[0].volume)
_verify_memory_metering(1.0)
_verify_memory_metering(2.0)
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_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 test_inspect_memory_usage(self):
fake_instance = {
'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
'id': 'fake_instance_id'
}
fake_stat = virt_inspector.MemoryUsageStats(usage=128)
def fake_xenapi_request(method, args):
metrics_rec = {
'memory_actual': '134217728',
}
if method == 'VM.get_by_name_label':
return ['vm_ref']
elif method == 'VM.get_metrics':
return 'metrics_ref'
elif method == 'VM_metrics.get_record':
return metrics_rec
else:
return None
session = self.inspector.session
with mock.patch.object(session,
'xenapi_request',
side_effect=fake_xenapi_request):
memory_stat = self.inspector.inspect_memory_usage(fake_instance)
self.assertEqual(fake_stat, memory_stat)
def test_inspect_memory_usage(self):
fake_instance = {
'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
'id': 'fake_instance_id'
}
fake_stat = virt_inspector.MemoryUsageStats(usage=64)
def _fake_xenapi_request(method, args):
fake_total_mem = 134217728.0
fake_free_mem = 65536.0
if method == 'VM.get_by_name_label':
return ['vm_ref']
elif method == 'VM.query_data_source':
if 'memory' in args:
return fake_total_mem
elif 'memory_internal_free' in args:
return fake_free_mem
else:
return None
else:
return None
session = self.inspector.session
with mock.patch.object(session,
'xenapi_request',
side_effect=_fake_xenapi_request):
memory_stat = self.inspector.inspect_memory_usage(fake_instance)
self.assertEqual(fake_stat, memory_stat)
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):
vm_mobj = self._get_vm_mobj_not_power_off_or_raise(instance)
mem_counter_id = self._ops.get_perf_counter_id(
VC_AVERAGE_MEMORY_CONSUMED_CNTR)
memory = self._ops.query_vm_aggregate_stats(vm_mobj, mem_counter_id,
duration)
# Stat provided from vSphere is in KB, converting it to MB.
memory = memory / units.Ki
return virt_inspector.MemoryUsageStats(usage=memory)
def inspect_memory_usage(self, instance, duration=None):
vm_moid = self._ops.get_vm_moid(instance.id)
if vm_moid is None:
raise virt_inspector.InstanceNotFoundException(
_('VM %s not found in VMware Vsphere') % instance.id)
mem_counter_id = self._ops.get_perf_counter_id(
VC_AVERAGE_MEMORY_CONSUMED_CNTR)
memory = self._ops.query_vm_aggregate_stats(vm_moid, mem_counter_id,
duration)
# Stat provided from vSphere is in KB, converting it to MB.
memory = memory / units.Ki
return virt_inspector.MemoryUsageStats(usage=memory)
def test_get_samples(self):
next_value = iter((
virt_inspector.MemoryUsageStats(usage=1.0),
virt_inspector.MemoryUsageStats(usage=2.0),
virt_inspector.InstanceNoDataException(),
virt_inspector.InstanceShutOffException(),
))
def inspect_memory_usage(instance, duration):
value = next(next_value)
if isinstance(value, virt_inspector.MemoryUsageStats):
return value
else:
raise value
self.inspector.inspect_memory_usage = mock.Mock(
side_effect=inspect_memory_usage)
mgr = manager.AgentManager(0, self.CONF)
pollster = memory.MemoryUsagePollster(self.CONF)
@mock.patch('ceilometer.compute.pollsters.memory.LOG')
def _verify_memory_metering(expected_count, expected_memory_mb,
expected_warnings, mylog):
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(expected_count, len(samples))
if expected_count > 0:
self.assertEqual(set(['memory.usage']),
set([s.name for s in samples]))
self.assertEqual(expected_memory_mb, samples[0].volume)
else:
self.assertEqual(expected_warnings, mylog.warning.call_count)
self.assertEqual(0, mylog.exception.call_count)
_verify_memory_metering(1, 1.0, 0)
_verify_memory_metering(1, 2.0, 0)
_verify_memory_metering(0, 0, 1)
_verify_memory_metering(0, 0, 0)
def test_inspect_memory_usage(self):
test_vm_mobj = mock.MagicMock()
test_vm_mobj.value = "vm-21"
fake_perf_counter_id = 'fake_perf_counter_id'
fake_memory_value = 1024.0
fake_stat = virt_inspector.MemoryUsageStats(usage=1.0)
self._inspector._get_vm_mobj_not_power_off_or_raise = mock.MagicMock()
self._inspector._get_vm_mobj_not_power_off_or_raise.return_value = (
test_vm_mobj)
ops_mock = self._inspector._ops
ops_mock.get_perf_counter_id.return_value = fake_perf_counter_id
ops_mock.query_vm_aggregate_stats.return_value = fake_memory_value
memory_stat = self._inspector.inspect_memory_usage(mock.MagicMock())
self.assertEqual(fake_stat, memory_stat)
def inspect_memory_usage(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"))
try:
free_mem = float(
self._call_xenapi("VM.query_data_source", vm_ref,
"memory_internal_free"))
except api.Failure:
# If PV tools is not installed in the guest instance, it's
# impossible to get free memory. So give it a default value
# as 0.
free_mem = 0
# memory provided from XenServer is in Bytes;
# memory_internal_free provided from XenServer is in KB,
# converting it to MB.
memory_usage = (total_mem - free_mem * units.Ki) / units.Mi
return virt_inspector.MemoryUsageStats(usage=memory_usage)
def test_inspect_memory_usage(self):
fake_instance_moid = 'fake_instance_moid'
fake_instance_id = 'fake_instance_id'
fake_perf_counter_id = 'fake_perf_counter_id'
fake_memory_value = 1024.0
fake_stat = virt_inspector.MemoryUsageStats(usage=1.0)
def construct_mock_instance_object(fake_instance_id):
instance_object = mock.MagicMock()
instance_object.id = fake_instance_id
return instance_object
fake_instance = construct_mock_instance_object(fake_instance_id)
self._inspector._ops.get_vm_moid.return_value = fake_instance_moid
(self._inspector._ops.
get_perf_counter_id.return_value) = fake_perf_counter_id
(self._inspector._ops.query_vm_aggregate_stats.
return_value) = fake_memory_value
memory_stat = self._inspector.inspect_memory_usage(fake_instance)
self.assertEqual(fake_stat, memory_stat)
def test_inspect_memory_usage_without_freeMem(self):
fake_instance = {
'OS-EXT-SRV-ATTR:instance_name': 'fake_instance_name',
'id': 'fake_instance_id'
}
fake_stat = virt_inspector.MemoryUsageStats(usage=128)
def _fake_xenapi_request(method, args):
if xenapi_inspector.api is None:
# the XenAPI may not exist in the test environment.
# In that case, we use the fake XenAPI for testing.
xenapi_inspector.api = fake_XenAPI
fake_total_mem = 134217728.0
fake_details = [
'INTERNAL_ERROR',
'Rrd.Invalid_data_source("memory_internal_free")'
]
if method == 'VM.get_by_name_label':
return ['vm_ref']
elif method == 'VM.query_data_source':
if 'memory' in args:
return fake_total_mem
elif 'memory_internal_free' in args:
raise xenapi_inspector.api.Failure(fake_details)
else:
return None
else:
return None
session = self.inspector.session
with mock.patch.object(session,
'xenapi_request',
side_effect=_fake_xenapi_request):
memory_stat = self.inspector.inspect_memory_usage(fake_instance)
self.assertEqual(fake_stat, memory_stat)
def inspect_memory_usage(self, instance, duration=None):
inst_stat = self._get_inst_stat('cpumem', instance)
return virt_inspector.MemoryUsageStats(usage=inst_stat['used_memory'])
def inspect_memory_usage(self, instance, duration=None):
instance_name = util.instance_name(instance)
usage = self._utils.get_memory_metrics(instance_name)
return virt_inspector.MemoryUsageStats(usage=usage)
