static void send_fsinfo(SOCKET sock)
{
sigar_file_system_usage_t fsusage;
gp_smon_to_mmon_packet_t pkt;
const char** fsdir;
int status = 0;
memset(&fsusage, 0, sizeof(sigar_file_system_usage_t));
for (fsdir = gx.fslist; *fsdir; fsdir++)
{
status = sigar_file_system_usage_get(gx.sigar, *fsdir, &fsusage);
if (status == SIGAR_OK)
{
TR2(("sigar_file_system_usage_get() succeeded. fsdir: %s total: %lu free: %lu used: %lu \n", *fsdir, fsusage.total, fsusage.free, fsusage.used));
memset(&pkt, 0, sizeof(gp_smon_to_mmon_packet_t));
gp_smon_to_mmon_set_header(&pkt,GPMON_PKTTYPE_FSINFO);
strncpy(pkt.u.fsinfo.key.fsname, *fsdir, sizeof(pkt.u.fsinfo.key.fsname) - 1);
pkt.u.fsinfo.bytes_used = FSUSAGE_TOBYTES(fsusage.used);
pkt.u.fsinfo.bytes_available = FSUSAGE_TOBYTES(fsusage.free);
pkt.u.fsinfo.bytes_total = FSUSAGE_TOBYTES(fsusage.total);
strncpy(pkt.u.fsinfo.key.hostname, gx.hostname, sizeof(pkt.u.fsinfo.key.hostname) - 1);
send_smon_to_mon_pkt(sock, &pkt);
}
else
{
TR2(("sigar_file_system_usage_get() failed. fsdir: %s status: %i \n", *fsdir, status));
}
}
}
void ZDiskInfo::refresh(){
if(_sigar){
sigar_file_system_list_t fsList;
sigar_file_system_list_get(_sigar, &fsList);
for(int i = 0; i < fsList.size; i++){
if((fsList.data[i].type==SIGAR_FSTYPE_LOCAL_DISK) ||
(fsList.data[i].type==SIGAR_FSTYPE_NETWORK) ||
(fsList.data[i].type==SIGAR_FSTYPE_RAM_DISK) ||
(fsList.data[i].type==SIGAR_FSTYPE_SWAP) ||
(fsList.data[i].type==SIGAR_FSTYPE_CDROM))
{
ZString devName = ZString(fsList.data[i].dev_name).rightOfLast("/");
QObject *fs = NULL;
if(_filesystems.contains(devName)){
fs = _filesystems.value(devName);
}else{
fs = new QObject(this);
fs->setObjectName(devName);
_filesystems.insert(devName, fs);
}
if(fs){
sigar_file_system_usage_t fsUse;
sigar_file_system_usage_get(_sigar, fsList.data[i].dir_name, &fsUse);
fs->setProperty("device", QVariant(fsList.data[i].dev_name));
fs->setProperty("mountpoint", QVariant(fsList.data[i].dir_name));
fs->setProperty("flags", QVariant(CAST(quint32,fsList.data[i].flags)));
fs->setProperty("options", QVariant(fsList.data[i].options));
fs->setProperty("filesystem", QVariant(fsList.data[i].sys_type_name));
fs->setProperty("type", QVariant(fsList.data[i].type_name));
fs->setProperty("available", QVariant(CAST(quint64,fsUse.avail)));
fs->setProperty("files", QVariant(CAST(quint64,fsUse.files)));
fs->setProperty("free", QVariant(CAST(quint64,fsUse.free)));
fs->setProperty("freeFiles", QVariant(CAST(quint64,fsUse.free_files)));
fs->setProperty("total", QVariant(CAST(quint64,fsUse.total)));
fs->setProperty("used", QVariant(CAST(quint64,fsUse.used)));
fs->setProperty("use", QVariant(fsUse.use_percent*100.0));
fs->setProperty("qtime", QVariant(CAST(quint64,fsUse.disk.qtime)));
fs->setProperty("queue", QVariant(CAST(quint64,fsUse.disk.queue)));
fs->setProperty("reads", QVariant(CAST(quint64,fsUse.disk.reads)));
fs->setProperty("bytesRead", QVariant(CAST(quint64,fsUse.disk.read_bytes)));
fs->setProperty("rtime", QVariant(CAST(quint64,fsUse.disk.rtime)));
fs->setProperty("serviceTime", QVariant(fsUse.disk.service_time));
fs->setProperty("snapTime", QVariant(CAST(quint64,fsUse.disk.snaptime)));
fs->setProperty("time", QVariant(CAST(quint64,fsUse.disk.time)));
fs->setProperty("writes", QVariant(CAST(quint64,fsUse.disk.writes)));
fs->setProperty("bytesWritten", QVariant(CAST(quint64,fsUse.disk.write_bytes)));
fs->setProperty("wtime", QVariant(CAST(quint64,fsUse.disk.wtime)));
}
}
}
sigar_file_system_list_destroy(_sigar, &fsList);
}
}
static void send_machine_metrics(SOCKET sock)
{
sigar_mem_t mem;
sigar_swap_t swap;
sigar_cpu_t cpu;
sigar_loadavg_t loadavg;
sigar_disk_usage_t tdisk;
sigar_net_interface_stat_t tnet;
static int first = 1;
static sigar_cpu_t pcpu = { 0 };
static sigar_swap_t pswap = { 0 };
gp_smon_to_mmon_packet_t pkt;
struct timeval currenttime = { 0 };
double seconds_duration = 0.0;
sigar_file_system_usage_t fsusage;
const char** fsdir;
const char** netname;
sigar_net_interface_stat_t netstat;
int cpu_total_diff;
/* NIC metrics */
apr_uint64_t rx_packets = 0;
apr_uint64_t tx_packets = 0;
apr_uint64_t rx_bytes = 0;
apr_uint64_t tx_bytes = 0;
/* Disk metrics */
apr_uint64_t reads = 0;
apr_uint64_t writes = 0;
apr_uint64_t read_bytes = 0;
apr_uint64_t write_bytes = 0;
memset(&mem, 0, sizeof(mem));
sigar_mem_get(gx.sigar, &mem);
TR2(("mem ram: %" FMT64 " total: %" FMT64 " used: %" FMT64 " free: %" FMT64 "\n",
mem.ram, mem.total, mem.used, mem.free));
memset(&swap, 0, sizeof(swap));
sigar_swap_get(gx.sigar, &swap);
TR2(("swap total: %" FMT64 " used: %" FMT64 "page_in: %" FMT64 " page_out: %" FMT64 "\n",
swap.total, swap.used, swap.page_in, swap.page_out));
memset(&cpu, 0, sizeof(cpu));
sigar_cpu_get(gx.sigar, &cpu);
TR2(("cpu user: %" FMT64 " sys: %" FMT64 " idle: %" FMT64 " wait: %" FMT64 " nice: %" FMT64 " total: %" FMT64 "\n",
cpu.user, cpu.sys, cpu.idle, cpu.wait, cpu.nice, cpu.total));
memset(&loadavg, 0, sizeof(loadavg));
sigar_loadavg_get(gx.sigar, &loadavg);
TR2(("load_avg: %e %e %e\n", loadavg.loadavg[0], loadavg.loadavg[1], loadavg.loadavg[2]));
memset(&tdisk, 0, sizeof(tdisk));
memset(&tnet, 0, sizeof(tnet));
for (fsdir = gx.fslist; *fsdir; fsdir++)
{
int e = sigar_file_system_usage_get(gx.sigar, *fsdir, &fsusage);
if (0 == e)
{
disk_device_t* disk = (disk_device_t*)apr_hash_get(disk_devices, *fsdir, APR_HASH_KEY_STRING);
/* Check if this is a new device */
if (!disk)
{
disk = (disk_device_t*)apr_palloc(gx.pool, sizeof(disk_device_t));
disk->name = apr_pstrdup(gx.pool, *fsdir);
disk->read_bytes = disk->write_bytes = disk->reads = disk->writes = 0;
apr_hash_set(disk_devices, disk->name, APR_HASH_KEY_STRING, disk);
}
reads = disk->reads;
writes = disk->writes;
read_bytes = disk->read_bytes;
write_bytes = disk->write_bytes;
// DISK READS
reads = metric_diff_calc(fsusage.disk.reads, disk->reads, disk->name, "disk reads");
disk->reads = fsusage.disk.reads; // old = new
// DISK WRITES
writes = metric_diff_calc(fsusage.disk.writes, disk->writes, disk->name, "disk writes");
disk->writes = fsusage.disk.writes; // old = new
// WRITE BYTES
write_bytes = metric_diff_calc(fsusage.disk.write_bytes, disk->write_bytes, disk->name, "disk write bytes");
disk->write_bytes = fsusage.disk.write_bytes; // old = new
// READ BYTES
read_bytes = metric_diff_calc(fsusage.disk.read_bytes, disk->read_bytes, disk->name, "disk read bytes");
disk->read_bytes = fsusage.disk.read_bytes; // old = new
tdisk.reads += reads;
tdisk.writes += writes;
tdisk.write_bytes += write_bytes;
tdisk.read_bytes += read_bytes;
}
}
TR2(("disk reads: %" APR_UINT64_T_FMT " writes: %" APR_UINT64_T_FMT
" rbytes: %" APR_UINT64_T_FMT " wbytes: %" APR_UINT64_T_FMT "\n",
tdisk.reads, tdisk.writes, tdisk.read_bytes, tdisk.write_bytes));
for (netname = gx.netlist; *netname; netname++)
{
int e = sigar_net_interface_stat_get(gx.sigar, *netname, &netstat);
if (0 == e)
{
net_device_t* nic = (net_device_t*)apr_hash_get(net_devices, *netname, APR_HASH_KEY_STRING);
/* Check if this is a new device */
if (!nic)
{
nic = (net_device_t*)apr_palloc(gx.pool, sizeof(net_device_t));
nic->name = apr_pstrdup(gx.pool, *netname);
nic->tx_bytes = nic->rx_bytes = nic->tx_packets = nic->rx_packets = 0;
apr_hash_set(net_devices, nic->name, APR_HASH_KEY_STRING, nic);
}
//////// RECEIVE PACKEtS
rx_packets = metric_diff_calc(netstat.rx_packets, nic->rx_packets, nic->name, "rx packets");
nic->rx_packets = netstat.rx_packets; // old = new
//////// RECEIVE BYTES
rx_bytes = metric_diff_calc(netstat.rx_bytes, nic->rx_bytes, nic->name, "rx bytes");
nic->rx_bytes = netstat.rx_bytes; // old = new
//////// SEND PACKETS
tx_packets = metric_diff_calc(netstat.tx_packets, nic->tx_packets, nic->name, "tx packets");
nic->tx_packets = netstat.tx_packets; // old = new
//////// SEND BYTES
tx_bytes = metric_diff_calc(netstat.tx_bytes, nic->tx_bytes, nic->name, "tx bytes");
nic->tx_bytes = netstat.tx_bytes; // old = new
tnet.rx_packets += rx_packets;
tnet.rx_bytes += rx_bytes;
tnet.tx_packets += tx_packets;
tnet.tx_bytes += tx_bytes;
}
}
TR2(("rx: %" APR_UINT64_T_FMT " rx_bytes: %" APR_UINT64_T_FMT "\n",
tnet.rx_packets, tnet.rx_bytes));
TR2(("tx: %" APR_UINT64_T_FMT " tx_bytes: %" APR_UINT64_T_FMT "\n",
tnet.tx_packets, tnet.tx_bytes));
if (first)
{
pswap = swap, pcpu = cpu;
/* We want 0s for these metrics on first pass rather
* than some possibly huge number that will throw off
* the UI graphs.
*/
memset(&tdisk, 0, sizeof(tdisk));
memset(&tnet, 0, sizeof(tnet));
}
first = 0;
gp_smon_to_mmon_set_header(&pkt,GPMON_PKTTYPE_METRICS);
pkt.u.metrics.mem.total = mem.total;
pkt.u.metrics.mem.used = mem.used;
pkt.u.metrics.mem.actual_used = mem.actual_used;
pkt.u.metrics.mem.actual_free = mem.actual_free;
pkt.u.metrics.swap.total = swap.total;
pkt.u.metrics.swap.used = swap.used;
pkt.u.metrics.swap.page_in = swap.page_in - pswap.page_in;
pkt.u.metrics.swap.page_out = swap.page_out - pswap.page_out;
cpu_total_diff = cpu.total - pcpu.total;
if (cpu_total_diff)
{
float cpu_user = calc_diff_percentage(cpu.user, pcpu.user, cpu_total_diff, "cpu.user") + calc_diff_percentage(cpu.nice, pcpu.nice, cpu_total_diff, "cpu.nice");
float cpu_sys = calc_diff_percentage(cpu.sys, pcpu.sys, cpu_total_diff, "cpu.sys") + calc_diff_percentage(cpu.wait, pcpu.wait, cpu_total_diff, "cpu.wait");
float cpu_idle = calc_diff_percentage(cpu.idle, pcpu.idle, cpu_total_diff, "cpu.idle");
pkt.u.metrics.cpu.user_pct = cpu_user;
pkt.u.metrics.cpu.sys_pct = cpu_sys;
pkt.u.metrics.cpu.idle_pct = cpu_idle;
}
else
{
pkt.u.metrics.cpu.user_pct = 0;
pkt.u.metrics.cpu.sys_pct = 0;
pkt.u.metrics.cpu.idle_pct = 0;
}
pkt.u.metrics.load_avg.value[0] = (float) loadavg.loadavg[0];
pkt.u.metrics.load_avg.value[1] = (float) loadavg.loadavg[1];
pkt.u.metrics.load_avg.value[2] = (float) loadavg.loadavg[2];
gettimeofday(¤ttime, NULL);
seconds_duration = subtractTimeOfDay(&g_time_last_reading, ¤ttime);
pkt.u.metrics.disk.ro_rate = (apr_uint64_t)ceil(tdisk.reads/seconds_duration);
pkt.u.metrics.disk.wo_rate = (apr_uint64_t)ceil(tdisk.writes/seconds_duration);
pkt.u.metrics.disk.rb_rate = (apr_uint64_t)ceil(tdisk.read_bytes/seconds_duration);
pkt.u.metrics.disk.wb_rate = (apr_uint64_t)ceil(tdisk.write_bytes/seconds_duration);
pkt.u.metrics.net.rp_rate = (apr_uint64_t)ceil(tnet.rx_packets/seconds_duration);
pkt.u.metrics.net.wp_rate = (apr_uint64_t)ceil(tnet.tx_packets/seconds_duration);
pkt.u.metrics.net.rb_rate = (apr_uint64_t)ceil(tnet.rx_bytes/seconds_duration);
pkt.u.metrics.net.wb_rate = (apr_uint64_t)ceil(tnet.tx_bytes/seconds_duration);
g_time_last_reading = currenttime;
strncpy(pkt.u.metrics.hname, gx.hostname, sizeof(pkt.u.metrics.hname) - 1);
pkt.u.metrics.hname[sizeof(pkt.u.metrics.hname) - 1] = 0;
send_smon_to_mon_pkt(sock, &pkt);
/* save for next time around */
pswap = swap, pcpu = cpu;
}
