def _do_pull_for_server(self, pdu, server_endpoint, outlet):
try:
LOG.debug(
"PDU address is %s | server is %s | plugged on outlet %s",
pdu, server_endpoint, outlet)
value = self.wrapper.get_snmpv2(
pdu, self.metric, outlet
)
milliseconds_since_epoch = int(time.time() * 1000)
resource_metadata = {
"host": server_endpoint,
"title": self.title,
"epoch": str(milliseconds_since_epoch)
}
measurement = Measurement(
name=self.probe_id,
unit=self.unit,
type_=self.type,
value=float(value),
resource_id=server_endpoint,
host=server_endpoint,
resource_metadata=resource_metadata,
)
LOG.debug("[PDU] Message = %r", measurement.as_dict())
return measurement
except Exception as exc:
LOG.warning(
"Sorry, we have not received a response of PDU (%s) "
"for getting the OID(%s) "
"on the server `%s` thrown Exception is <%s>",
pdu, self.metric, server_endpoint, exc.args[0]
)
def test_puller_send_measurements(self, m_as_dict):
data_puller = FakeMetricPuller(
title=FakeMetricPuller.get_entry_name(),
probe_id=FakeMetricPuller.get_default_probe_id(),
interval=FakeMetricPuller.get_default_interval(),
)
measurement_dict = OrderedDict(
name="dummy.data.puller",
unit="",
type_="",
value=13.37,
resource_id="test_hostname",
host="test_hostname",
timestamp="2015-08-04T15:15:45.703542",
)
m_as_dict.return_value = measurement_dict
measurement = Measurement(**measurement_dict)
with patch.object(MetricPuller, 'notify') as m_notify:
data_puller.send_measurements([measurement])
expected_encoded_msg = msgpack.dumps(measurement_dict)
self.assertTrue(m_notify.called)
m_notify.assert_called_once_with(expected_encoded_msg)
def do_pull(self):
LOG.info("[%s] Pulling measurements...", self.key)
value = self.wrapper.disk_usage(get_root_path(), self.metric)
resource_metadata = {"host": platform.node(), "title": self.title}
measurement = Measurement(
name=self.probe_id,
unit=self.unit,
type_="gauge",
value=value,
resource_id=platform.node(),
resource_metadata=resource_metadata,
)
LOG.info("[%s] Measurements collected.", self.key)
return [measurement]
def do_pull(self):
random_value = random.Random().randint(1, 10)
random_message = "[%s] random data generated on %s" % (
random_value, datetime.datetime.now()
)
measurement = Measurement(
name=self.probe_id,
unit="",
type_="",
value=random_value,
resource_id=platform.node(),
resource_metadata={
"state": "ok",
"static_data": self.static_data,
"description": random_message
},
)
return [measurement]
def do_pull(self):
"""Retrives the number of CPUs on the host"""
LOG.info("[%s] Pulling measurements...", self.key)
value = self.wrapper.cpu_usage(self.metric)
resource_metadata = {
"host": platform.node(),
"title": self.title
}
measurement = Measurement(
name=self.probe_id,
unit=self.unit,
type_="gauge",
value=value,
resource_id=platform.node(),
resource_metadata=resource_metadata,
)
LOG.info("[%s] Measurements collected.", self.key)
return [measurement]
def test_send_measurements(self, m_as_dict):
self.agent.register_drivers()
measurement_dict = OrderedDict(
name="dummy.data.puller",
unit="",
type_="",
value=13.37,
resource_id="test_hostname",
host="test_hostname",
timestamp="2015-08-04T15:15:45.703542",
)
m_as_dict.return_value = measurement_dict
measurement = Measurement(**measurement_dict)
for driver in self.agent.drivers.values():
driver.send_measurements([measurement])
break # only the first one
expected_encoded_msg = msgpack.dumps(measurement_dict)
self.m_agent_socket.return_value.send.assert_called_once_with(
expected_encoded_msg)
def do_pull(self):
LOG.info("[%s] Pulling measurements...", self.key)
measurements = []
for instance in self.wrapper.get_instances():
value = self.wrapper.instance_cpu_percent(instance)
resource_metadata = {
"host": platform.node(),
"title": self.title,
"display_name": instance.name
}
measurement = Measurement(
name=self.probe_id,
unit=self.unit,
type_="gauge",
value=value,
resource_id=instance.id,
resource_metadata=resource_metadata,
)
LOG.info("[%s] Measurements collected.", self.key)
measurements.append(measurement)
return measurements
class TestSwapDrivers(BaseTestCase):
fake_swap = sswap(total=17099124736,
used=10,
free=17099124726,
percent=0.0,
sin=0,
sout=0)
scenarios = (
("TotalSwapPuller", {
"puller_factory":
swap.TotalSwapPuller,
"swap_patch":
patch.object(psutil, "swap_memory", Mock(return_value=fake_swap)),
"expected_data":
Measurement(name="compute.node.swap.total",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=17099124736,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "swap_total"
})
}),
("FreeSwapPuller", {
"puller_factory":
swap.FreeSwapPuller,
"swap_patch":
patch.object(psutil, "swap_memory", Mock(return_value=fake_swap)),
"expected_data":
Measurement(name="compute.node.swap.free",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=17099124726,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "swap_free"
})
}),
("UsedSwapPuller", {
"puller_factory":
swap.UsedSwapPuller,
"swap_patch":
patch.object(psutil, "swap_memory", Mock(return_value=fake_swap)),
"expected_data":
Measurement(name="compute.node.swap.used",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=10,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "swap_used"
})
}),
)
@freeze_time("2015-08-04T15:15:45.703542+00:00")
@patch.object(platform, "node", Mock(return_value="test_node"))
def test_swap(self):
data_puller = self.puller_factory(
self.puller_factory.get_name(),
self.puller_factory.get_default_probe_id(),
self.puller_factory.get_default_interval(),
)
with self.swap_patch:
pulled_data = data_puller.do_pull()
self.assertEqual(
[measurement.as_dict() for measurement in pulled_data],
[self.expected_data.as_dict()])
class TestMemoryDrivers(BaseTestCase):
fake_svmem = svmem(total=16749080576,
available=15042203648,
percent=10.2,
used=3770953728,
free=12978126848,
active=2177314816,
inactive=1093963776,
buffers=322965504,
cached=1741111296)
scenarios = (
("TotalMemoryPuller", {
"puller_factory":
memory.TotalMemoryPuller,
"memory_patch":
patch.object(psutil, "virtual_memory",
Mock(return_value=fake_svmem)),
"expected_data":
Measurement(name="compute.node.memory.total",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=16749080576,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "memory_total"
})
}),
("FreeMemoryPuller", {
"puller_factory":
memory.FreeMemoryPuller,
"memory_patch":
patch.object(psutil, "virtual_memory",
Mock(return_value=fake_svmem)),
"expected_data":
Measurement(name="compute.node.memory.free",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=12978126848,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "memory_free"
})
}),
("UsedMemoryPuller", {
"puller_factory":
memory.UsedMemoryPuller,
"memory_patch":
patch.object(psutil, "virtual_memory",
Mock(return_value=fake_svmem)),
"expected_data":
Measurement(name="compute.node.memory.used",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=3770953728,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "memory_used"
})
}),
)
@freeze_time("2015-08-04T15:15:45.703542+00:00")
@patch.object(platform, "node", Mock(return_value="test_node"))
def test_memory(self):
data_puller = self.puller_factory(
self.puller_factory.get_name(),
self.puller_factory.get_default_probe_id(),
self.puller_factory.get_default_interval(),
)
with self.memory_patch:
pulled_data = data_puller.do_pull()
self.assertEqual(
[measurement.as_dict() for measurement in pulled_data],
[self.expected_data.as_dict()])
def test_pdu_drivers(self):
data_puller = self.pdu_puller_factory(
self.pdu_puller_factory.get_name(),
self.pdu_puller_factory.get_default_probe_id(),
self.pdu_puller_factory.get_default_interval(),
pdu_servers=OrderedDict([("PDU_1", "127.0.0.1"),
("PDU_2", "192.168.1.1")]),
mapping=[
{
"PDU_1": [{
"serv1.hostname": 1
}, {
"serv2.hostname": 2
}]
},
{
"PDU_2": [{
"serv3.hostname": 1
}]
},
],
)
expected_measurements = [
Measurement(
name=self.expected_data["probe_id"],
host="serv1.hostname",
resource_id="serv1.hostname",
resource_metadata={
"epoch": "1438701345703",
"host": "serv1.hostname",
"title": self.expected_data["title"]
},
timestamp="2015-08-04T15:15:45.703542+00:00",
type_=self.expected_data["type"],
unit=self.expected_data["unit"],
value=13.37,
),
Measurement(
name=self.expected_data["probe_id"],
host="serv2.hostname",
resource_id="serv2.hostname",
resource_metadata={
"epoch": "1438701345703",
"host": "serv2.hostname",
"title": self.expected_data["title"]
},
timestamp="2015-08-04T15:15:45.703542+00:00",
type_=self.expected_data["type"],
unit=self.expected_data["unit"],
value=13.37,
),
Measurement(
name=self.expected_data["probe_id"],
host="serv3.hostname",
resource_id="serv3.hostname",
resource_metadata={
"epoch": "1438701345703",
"host": "serv3.hostname",
"title": self.expected_data["title"]
},
timestamp="2015-08-04T15:15:45.703542+00:00",
type_=self.expected_data["type"],
unit=self.expected_data["unit"],
value=13.37,
),
]
pulled_data = data_puller.do_pull()
self.assertEqual(data_puller.title, self.expected_data["title"])
self.assertEqual(data_puller.probe_id, self.expected_data["probe_id"])
self.assertEqual(data_puller.interval, self.expected_data["interval"])
self.assertEqual(data_puller.unit, self.expected_data["unit"])
self.assertEqual(data_puller.type, self.expected_data["type"])
self.assertEqual(
[measurement.as_dict() for measurement in pulled_data],
[measurement.as_dict() for measurement in expected_measurements],
)
class TestDiskDrivers(BaseTestCase):
fake_statvfs = statvfs_result((
4096, # bsize
4096, # frsize
236216421, # blocks
231166945, # bfree
219162081, # bavail
60006400, # files
59315784, # ffree
59315784, # favail
4096, # flag
255, # namemax
))
scenarios = (
("disk.DiskTotalSpacePuller", {
"puller_factory": disk.DiskTotalSpacePuller,
"disk_patch": patch.object(
os, "statvfs", Mock(return_value=fake_statvfs)),
"expected_data": Measurement(
name="compute.node.disk.total",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=4096 * 236216421,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "disk_total"
}
)
}),
("disk.DiskFreeSpacePuller", {
"puller_factory": disk.DiskFreeSpacePuller,
"disk_patch": patch.object(
os, "statvfs", Mock(return_value=fake_statvfs)),
"expected_data": Measurement(
name="compute.node.disk.free",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=4096 * 219162081,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "disk_free"
}
)
}),
("disk.DiskUsedSpacePuller", {
"puller_factory": disk.DiskUsedSpacePuller,
"disk_patch": patch.object(
os, "statvfs", Mock(return_value=fake_statvfs)),
"expected_data": Measurement(
name="compute.node.disk.used",
timestamp="2015-08-04T15:15:45.703542+00:00",
unit="bytes",
type_="gauge",
value=(236216421 - 231166945) * 4096,
resource_id="test_node",
host="test_node",
resource_metadata={
"host": "test_node",
"title": "disk_used"
}
)
}),
)
@freeze_time("2015-08-04T15:15:45.703542+00:00")
@patch.object(platform, "node", Mock(return_value="test_node"))
def test_disk(self):
data_puller = self.puller_factory(
self.puller_factory.get_name(),
self.puller_factory.get_default_probe_id(),
self.puller_factory.get_default_interval(),
)
with self.disk_patch:
pulled_data = data_puller.do_pull()
self.assertEqual(
[measurement.as_dict() for measurement in pulled_data],
[self.expected_data.as_dict()]
)