def test_get_reserved_metadata_with_namespace(self):
mgr = manager.AgentManager(0, self.CONF)
pollster = pollsters_instance.InstancePollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual({'stack': '2cadc4b4-8789-123c-b4eg-edd2f0a9c128'},
samples[0].resource_metadata['user_metadata'])
self.CONF.set_override('reserved_metadata_namespace', [])
mgr = manager.AgentManager(0, self.CONF)
pollster = pollsters_instance.InstancePollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertNotIn('user_metadata', samples[0].resource_metadata)
def test_get_samples(self):
self._mock_inspect_instance(
virt_inspector.InstanceStats(memory_swap_in=1.0,
memory_swap_out=2.0),
virt_inspector.InstanceStats(memory_swap_in=3.0,
memory_swap_out=4.0),
)
mgr = manager.AgentManager(0, self.CONF)
def _check_memory_swap_in(expected_swap_in):
pollster = instance_stats.MemorySwapInPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.swap.in']),
set([s.name for s in samples]))
self.assertEqual(expected_swap_in, samples[0].volume)
def _check_memory_swap_out(expected_swap_out):
pollster = instance_stats.MemorySwapOutPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.swap.out']),
set([s.name for s in samples]))
self.assertEqual(expected_swap_out, samples[0].volume)
_check_memory_swap_in(1.0)
_check_memory_swap_out(4.0)
def test_get_samples(self):
next_value = iter((
virt_inspector.CPUUtilStats(util=40),
virt_inspector.CPUUtilStats(util=60),
))
def inspect_cpu_util(name, duration):
return next(next_value)
self.inspector.inspect_cpu_util = (mock.
Mock(side_effect=inspect_cpu_util))
mgr = manager.AgentManager(0, self.CONF)
pollster = cpu.CPUUtilPollster(self.CONF)
def _verify_cpu_util_metering(expected_util):
cache = {}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['cpu_util']),
set([s.name for s in samples]))
self.assertEqual(expected_util, samples[0].volume)
_verify_cpu_util_metering(40)
_verify_cpu_util_metering(60)
def test_get_samples(self):
next_value = iter((
virt_inspector.MemoryBandwidthStats(total=1892352, local=1802240),
virt_inspector.MemoryBandwidthStats(total=1081344, local=90112),
))
def inspect_memory_bandwidth(instance, duration):
return next(next_value)
self.inspector.inspect_memory_bandwidth = mock.Mock(
side_effect=inspect_memory_bandwidth)
mgr = manager.AgentManager(0, self.CONF)
def _check_memory_bandwidth_total(expected_usage):
pollster = memory.MemoryBandwidthTotalPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.bandwidth.total']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
def _check_memory_bandwidth_local(expected_usage):
pollster = memory.MemoryBandwidthLocalPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.bandwidth.local']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
_check_memory_bandwidth_total(1892352)
_check_memory_bandwidth_local(90112)
def test_get_samples(self):
next_value = iter((
virt_inspector.CPUStats(time=1 * (10 ** 6), number=2),
virt_inspector.CPUStats(time=3 * (10 ** 6), number=2),
# cpu_time resets on instance restart
virt_inspector.CPUStats(time=2 * (10 ** 6), number=2),
))
def inspect_cpus(name):
return next(next_value)
self.inspector.inspect_cpus = mock.Mock(side_effect=inspect_cpus)
mgr = manager.AgentManager(0, self.CONF)
pollster = cpu.CPUPollster(self.CONF)
def _verify_cpu_metering(expected_time):
cache = {}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['cpu']), set([s.name for s in samples]))
self.assertEqual(expected_time, samples[0].volume)
self.assertEqual(2, samples[0].resource_metadata.get('cpu_number'))
# ensure elapsed time between polling cycles is non-zero
time.sleep(0.001)
_verify_cpu_metering(1 * (10 ** 6))
_verify_cpu_metering(3 * (10 ** 6))
_verify_cpu_metering(2 * (10 ** 6))
def test_get_samples(self):
next_value = iter((
virt_inspector.CPUL3CacheUsageStats(l3_cache_usage=90112),
virt_inspector.CPUL3CacheUsageStats(l3_cache_usage=180224),
))
def inspect_cpu_l3_cache(name):
return next(next_value)
self.inspector.inspect_cpu_l3_cache = (mock.Mock(
side_effect=inspect_cpu_l3_cache))
mgr = manager.AgentManager(0, self.CONF)
pollster = cpu.CPUL3CachePollster(self.CONF)
def _verify_cpu_l3_cache_metering(expected_usage):
cache = {}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['cpu_l3_cache']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
_verify_cpu_l3_cache_metering(90112)
_verify_cpu_l3_cache_metering(180224)
def test_builder(self):
@staticmethod
def fake_get_ext_mgr(namespace):
if 'builder' in namespace:
return extension.ExtensionManager.make_test_instance(
[
extension.Extension('builder',
None,
TestPollsterBuilder,
None),
]
)
else:
return extension.ExtensionManager.make_test_instance(
[
extension.Extension('test',
None,
None,
agentbase.TestPollster()),
]
)
with mock.patch.object(manager.AgentManager, '_get_ext_mgr',
new=fake_get_ext_mgr):
mgr = manager.AgentManager(namespaces=['central'])
self.assertEqual(3, len(mgr.extensions))
for ext in mgr.extensions:
self.assertIn(ext.name, ['builder1', 'builder2', 'test'])
self.assertIsInstance(ext.obj, agentbase.TestPollster)
def test_get_samples(self):
self._mock_inspect_instance(
virt_inspector.InstanceStats(memory_bandwidth_total=1892352,
memory_bandwidth_local=1802240),
virt_inspector.InstanceStats(memory_bandwidth_total=1081344,
memory_bandwidth_local=90112),
)
mgr = manager.AgentManager(0, self.CONF)
def _check_memory_bandwidth_total(expected_usage):
pollster = instance_stats.MemoryBandwidthTotalPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.bandwidth.total']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
def _check_memory_bandwidth_local(expected_usage):
pollster = instance_stats.MemoryBandwidthLocalPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['memory.bandwidth.local']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
_check_memory_bandwidth_total(1892352)
_check_memory_bandwidth_local(90112)
def test_get_flavor_name_as_metadata_instance_type(self):
mgr = manager.AgentManager()
pollster = pollsters_instance.InstancePollster()
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual('m1.small',
samples[0].resource_metadata['instance_type'])
def setUp(self):
self.manager = manager.AgentManager()
super(TestLocationMetadata, self).setUp()
# Mimics an instance returned from nova api call
self.INSTANCE_PROPERTIES = {'name': 'display name',
'OS-EXT-SRV-ATTR:instance_name':
'instance-000001',
'OS-EXT-AZ:availability_zone':
'foo-zone',
'reservation_id': 'reservation id',
'architecture': 'x86_64',
'kernel_id': 'kernel id',
'os_type': 'linux',
'ramdisk_id': 'ramdisk id',
'status': 'active',
'ephemeral_gb': 0,
'root_gb': 20,
'disk_gb': 20,
'image': {'id': 1,
'links': [{"rel": "bookmark",
'href': 2}]},
'hostId': '1234-5678',
'flavor': {'id': 1,
'disk': 20,
'ram': 512,
'vcpus': 2,
'ephemeral': 0},
'metadata': {'metering.autoscale.group':
'X' * 512,
'metering.ephemeral_gb': 42}}
self.instance = FauxInstance(**self.INSTANCE_PROPERTIES)
def test_get_samples(self):
self._mock_inspect_instance(
virt_inspector.InstanceStats(memory_resident=1.0),
virt_inspector.InstanceStats(memory_resident=2.0),
virt_inspector.InstanceStats(),
virt_inspector.InstanceShutOffException(),
)
mgr = manager.AgentManager(0, self.CONF)
pollster = instance_stats.MemoryResidentPollster(self.CONF)
@mock.patch('ceilometer.compute.pollsters.LOG')
def _verify_resident_memory_metering(expected_count,
expected_resident_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.resident']),
set([s.name for s in samples]))
self.assertEqual(expected_resident_memory_mb,
samples[0].volume)
else:
self.assertEqual(expected_warnings, mylog.warning.call_count)
self.assertEqual(0, mylog.exception.call_count)
_verify_resident_memory_metering(1, 1.0, 0)
_verify_resident_memory_metering(1, 2.0, 0)
_verify_resident_memory_metering(0, 0, 1)
_verify_resident_memory_metering(0, 0, 0)
def _check_get_samples_cache(self, factory):
vnic0 = virt_inspector.Interface(name='vnet0',
fref='fa163e71ec6e',
mac='fa:16:3e:71:ec:6d',
parameters=dict(
ip='10.0.0.2',
projmask='255.255.255.0',
projnet='proj1',
dhcp_server='10.0.0.1'))
stats0 = virt_inspector.InterfaceStats(rx_bytes=1,
rx_packets=2,
rx_drop=20,
rx_errors=21,
tx_bytes=3,
tx_packets=4,
tx_drop=22,
tx_errors=23)
vnics = [(vnic0, stats0)]
mgr = manager.AgentManager(0, self.CONF)
pollster = factory(self.CONF)
cache = {
pollster.CACHE_KEY_VNIC: {
self.instance.id: vnics,
},
}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
def test_get_samples(self):
self._mock_inspect_instance(
virt_inspector.InstanceStats(cpu_time=1 * (10**6),
cpu_number=2,
vcpu_number=2),
virt_inspector.InstanceStats(cpu_time=3 * (10**6),
cpu_number=2,
vcpu_number=2),
# cpu_time resets on instance restart
virt_inspector.InstanceStats(cpu_time=2 * (10**6),
cpu_number=2,
vcpu_number=2),
)
mgr = manager.AgentManager(0, self.CONF)
pollster = instance_stats.CPUPollster(self.CONF)
def _verify_cpu_metering(expected_time):
cache = {}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['cpu']), set([s.name for s in samples]))
self.assertEqual(expected_time, samples[0].volume)
self.assertEqual(2, samples[0].resource_metadata.get('cpu_number'))
self.assertEqual(2,
samples[0].resource_metadata.get('vcpu_number'))
# ensure elapsed time between polling cycles is non-zero
time.sleep(0.001)
_verify_cpu_metering(1 * (10**6))
_verify_cpu_metering(3 * (10**6))
_verify_cpu_metering(2 * (10**6))
def test_load_normal_plugins(self):
mgr = manager.AgentManager(0,
self.conf,
namespaces=['ipmi'],
pollster_list=['hardware.ipmi.node.*'])
# 8 pollsters for Node Manager
self.assertEqual(8, len(mgr.extensions))
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 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 setUp(self):
super(TestRunTasks, self).setUp()
self.notifications = []
self.stubs.Set(rpc, 'cast', self.faux_notify)
self.mgr = manager.AgentManager()
self.mgr.pollsters = [('test', self.Pollster())]
self.ctx = context.RequestContext("user", "project")
self.mgr.periodic_tasks(self.ctx)
def setUp(self):
super(_BaseTestVPNPollster, self).setUp()
self.addCleanup(mock.patch.stopall)
self.context = context.get_admin_context()
self.manager = manager.AgentManager()
plugin_base._get_keystone = mock.Mock()
plugin_base._get_keystone.service_catalog.get_endpoints = (
mock.MagicMock(return_value={'network': mock.ANY}))
def setUp(self):
super(_BaseTestVPNPollster, self).setUp()
self.addCleanup(mock.patch.stopall)
self.manager = manager.AgentManager()
plugin_base._get_keystone = mock.Mock()
catalog = (plugin_base._get_keystone.session.auth.get_access.
return_value.service_catalog)
catalog.get_endpoints = mock.MagicMock(
return_value={'network': mock.ANY})
def test_get_samples_with_empty_stats(self):
self._mock_inspect_instance(virt_inspector.NoDataException())
mgr = manager.AgentManager(0, self.CONF)
pollster = instance_stats.MemoryBandwidthTotalPollster(self.CONF)
def all_samples():
return list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertRaises(plugin_base.PollsterPermanentError, all_samples)
def test_load_failed_plugins(self, LOG):
mgr = manager.AgentManager(namespaces=['ipmi'],
pollster_list=['hardware.ipmi.node.*'])
# 0 pollsters
self.assertEqual(0, len(mgr.extensions))
err_msg = 'Skip loading extension for hardware.ipmi.node.%s'
pollster_names = ['power', 'temperature']
calls = [mock.call(err_msg % n) for n in pollster_names]
LOG.error.assert_has_calls(calls=calls, any_order=True)
def test_get_reserved_metadata_with_keys(self):
self.CONF = self.useFixture(fixture_config.Config()).conf
self.CONF.set_override('reserved_metadata_keys', ['fqdn'])
mgr = manager.AgentManager()
pollster = pollsters_instance.InstancePollster()
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual({'fqdn': 'vm_fqdn',
'stack': '2cadc4b4-8789-123c-b4eg-edd2f0a9c128'},
samples[0].resource_metadata['user_metadata'])
def test_get_reserved_metadata_with_keys(self):
self.CONF.set_override('reserved_metadata_keys', ['fqdn'])
mgr = manager.AgentManager(0, self.CONF)
pollster = cpu.CPUPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(
{
'fqdn': 'vm_fqdn',
'stack': '2cadc4b4-8789-123c-b4eg-edd2f0a9c128'
}, samples[0].resource_metadata['user_metadata'])
def test_metadata(self):
factory = net.OutgoingBytesPollster
pollster = factory(self.CONF)
mgr = manager.AgentManager(0, self.CONF)
pollster = factory(self.CONF)
s = list(pollster.get_samples(mgr, {}, [self.faux_instance]))[0]
user_metadata = s.resource_metadata['user_metadata']
expected = self.INSTANCE_PROPERTIES[
'metadata']['metering.autoscale.group'][:256]
self.assertEqual(expected, user_metadata['autoscale_group'])
self.assertEqual(2, len(user_metadata))
def setUp(self):
super(_BaseTestFWPollster, self).setUp()
self.addCleanup(mock.patch.stopall)
conf = service.prepare_service([], [])
self.CONF = self.useFixture(fixture_config.Config(conf)).conf
self.manager = manager.AgentManager(0, self.CONF)
plugin_base._get_keystone = mock.Mock()
catalog = (plugin_base._get_keystone.session.auth.get_access.
return_value.service_catalog)
catalog.get_endpoints = mock.MagicMock(
return_value={'network': mock.ANY})
def test_get_samples_instance(self):
mgr = manager.AgentManager()
pollster = pollsters_instance.InstancePollster()
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual('instance', samples[0].name)
self.assertEqual(1, samples[0].resource_metadata['vcpus'])
self.assertEqual(512, samples[0].resource_metadata['memory_mb'])
self.assertEqual(20, samples[0].resource_metadata['disk_gb'])
self.assertEqual(20, samples[0].resource_metadata['root_gb'])
self.assertEqual(0, samples[0].resource_metadata['ephemeral_gb'])
self.assertEqual('active', samples[0].resource_metadata['status'])
def setUp(self):
super(_BaseTestLBPollster, self).setUp()
self.addCleanup(mock.patch.stopall)
self.manager = manager.AgentManager()
cfg.CONF.set_override('neutron_lbaas_version',
'v1',
group='service_types')
plugin_base._get_keystone = mock.Mock()
catalog = (plugin_base._get_keystone.session.auth.get_access.
return_value.service_catalog)
catalog.get_endpoints = mock.MagicMock(
return_value={'network': mock.ANY})
def test_get_samples(self):
fake_value = virt_inspector.PerfEventsStats(cpu_cycles=7259361,
instructions=8815623,
cache_references=74184,
cache_misses=16737)
def inspect_perf_events(instance, duration):
return fake_value
self.inspector.inspect_perf_events = mock.Mock(
side_effect=inspect_perf_events)
mgr = manager.AgentManager(0, self.CONF)
def _check_perf_events_cpu_cycles(expected_usage):
pollster = perf.PerfEventsCPUCyclesPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['perf.cpu.cycles']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
def _check_perf_events_instructions(expected_usage):
pollster = perf.PerfEventsInstructionsPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['perf.instructions']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
def _check_perf_events_cache_references(expected_usage):
pollster = perf.PerfEventsCacheReferencesPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['perf.cache.references']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
def _check_perf_events_cache_misses(expected_usage):
pollster = perf.PerfEventsCacheMissesPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(set(['perf.cache.misses']),
set([s.name for s in samples]))
self.assertEqual(expected_usage, samples[0].volume)
_check_perf_events_cpu_cycles(7259361)
_check_perf_events_instructions(8815623)
_check_perf_events_cache_references(74184)
_check_perf_events_cache_misses(16737)
def test_get_samples_no_caching(self):
cpu_stats = virt_inspector.CPUStats(time=1 * (10 ** 6), number=2)
self.inspector.inspect_cpus = mock.Mock(return_value=cpu_stats)
mgr = manager.AgentManager(0, self.CONF)
pollster = cpu.CPUPollster(self.CONF)
cache = {}
samples = list(pollster.get_samples(mgr, cache, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(10 ** 6, samples[0].volume)
self.assertEqual(0, len(cache))
def test_load_failed_plugins(self, LOG):
# Here we additionally check that namespaces will be converted to the
# list if param was not set as a list.
try:
manager.AgentManager(namespaces='ipmi',
pollster_list=['hardware.ipmi.node.*'])
except manager.EmptyPollstersList:
err_msg = 'Skip loading extension for hardware.ipmi.node.%s'
pollster_names = [
'power', 'temperature', 'outlet_temperature',
'airflow', 'cups', 'cpu_util', 'mem_util', 'io_util']
calls = [mock.call(err_msg % n) for n in pollster_names]
LOG.exception.assert_has_calls(calls=calls, any_order=True)
def test_get_metadata(self):
mgr = manager.AgentManager(0, self.CONF)
pollster = cpu.CPUPollster(self.CONF)
samples = list(pollster.get_samples(mgr, {}, [self.instance]))
self.assertEqual(1, len(samples))
self.assertEqual(1, samples[0].resource_metadata['vcpus'])
self.assertEqual(512, samples[0].resource_metadata['memory_mb'])
self.assertEqual(20, samples[0].resource_metadata['disk_gb'])
self.assertEqual(20, samples[0].resource_metadata['root_gb'])
self.assertEqual(0, samples[0].resource_metadata['ephemeral_gb'])
self.assertEqual('active', samples[0].resource_metadata['status'])
self.assertEqual('active', samples[0].resource_metadata['state'])
self.assertIsNone(samples[0].resource_metadata['task_state'])
