119 lines
3.4 KiB
C++
119 lines
3.4 KiB
C++
#include "metrics/Host.h"
|
|
|
|
#include <stdexcept>
|
|
#include <cstring>
|
|
#include <arpa/inet.h>
|
|
|
|
#include "network/common/Buffer.h"
|
|
|
|
namespace metrics
|
|
{
|
|
|
|
// ---- Вспомогательные функции для float <-> uint32_t ----
|
|
static uint32_t floatToNetwork(float f)
|
|
{
|
|
uint32_t tmp;
|
|
static_assert(sizeof(tmp) == sizeof(f), "Size mismatch");
|
|
std::memcpy(&tmp, &f, sizeof(f));
|
|
return htonl(tmp);
|
|
}
|
|
|
|
static float networkToFloat(uint32_t n)
|
|
{
|
|
uint32_t tmp = ntohl(n);
|
|
float f;
|
|
std::memcpy(&f, &tmp, sizeof(f));
|
|
return f;
|
|
}
|
|
|
|
// ---- Сериализация ----
|
|
std::vector<uint8_t> Host::serialize() const
|
|
{
|
|
network::Buffer buf;
|
|
|
|
buf.writeUint8(1); // version
|
|
buf.writeString(hostname);
|
|
|
|
// CPU
|
|
buf.writeFloat(cpu.totalLoad);
|
|
buf.writeUint8(static_cast<uint8_t>(cpu.coreLoads.size()));
|
|
for (float f : cpu.coreLoads)
|
|
buf.writeFloat(f);
|
|
for (const auto &f : cpu.coreTemps)
|
|
{
|
|
buf.writeFloat(f.current);
|
|
buf.writeFloat(f.max);
|
|
}
|
|
|
|
// Memory
|
|
buf.writeUint64(memory.memory.used);
|
|
buf.writeUint64(memory.memory.available);
|
|
buf.writeUint64(memory.memory.total);
|
|
buf.writeUint64(memory.swap.used);
|
|
buf.writeUint64(memory.swap.available);
|
|
buf.writeUint64(memory.swap.total);
|
|
|
|
// Disks
|
|
buf.writeUint8(static_cast<uint8_t>(disks.size()));
|
|
for (const auto &d : disks)
|
|
{
|
|
buf.writeString(d.name);
|
|
buf.writeString(d.path);
|
|
buf.writeUint64(d.metrics.used);
|
|
buf.writeUint64(d.metrics.available);
|
|
buf.writeUint64(d.metrics.total);
|
|
}
|
|
|
|
return buf.data();
|
|
}
|
|
|
|
// ---- Десериализация ----
|
|
Host Host::deserialize(const std::vector<uint8_t> &data)
|
|
{
|
|
Host h;
|
|
network::Buffer buf(const_cast<std::vector<uint8_t> &>(data));
|
|
|
|
uint8_t version = buf.readUint8();
|
|
if (version != 1)
|
|
throw std::runtime_error("Unsupported protocol version");
|
|
|
|
h.hostname = buf.readString();
|
|
|
|
// CPU
|
|
h.cpu.totalLoad = buf.readFloat();
|
|
uint8_t numCpu = buf.readUint8();
|
|
h.cpu.coreLoads.clear();
|
|
h.cpu.coreLoads.reserve(numCpu);
|
|
for (uint8_t i = 0; i < numCpu; ++i)
|
|
h.cpu.coreLoads.push_back(buf.readFloat());
|
|
h.cpu.coreTemps.clear();
|
|
h.cpu.coreTemps.reserve(numCpu);
|
|
for (uint8_t i = 0; i < numCpu; ++i)
|
|
h.cpu.coreTemps.push_back({buf.readFloat(), buf.readFloat()});
|
|
|
|
// Memory
|
|
h.memory.memory.used = buf.readUint64();
|
|
h.memory.memory.available = buf.readUint64();
|
|
h.memory.memory.total = buf.readUint64();
|
|
h.memory.swap.used = buf.readUint64();
|
|
h.memory.swap.available = buf.readUint64();
|
|
h.memory.swap.total = buf.readUint64();
|
|
|
|
// Disks
|
|
uint8_t numDisks = buf.readUint8();
|
|
h.disks.clear();
|
|
h.disks.reserve(numDisks);
|
|
for (uint8_t i = 0; i < numDisks; ++i)
|
|
{
|
|
Disk disk;
|
|
disk.name = buf.readString();
|
|
disk.path = buf.readString();
|
|
disk.metrics.used = buf.readUint64();
|
|
disk.metrics.available = buf.readUint64();
|
|
disk.metrics.total = buf.readUint64();
|
|
h.disks.push_back(disk);
|
|
}
|
|
|
|
return h;
|
|
}
|
|
} // namespace metrics
|