ruby-libgtop2 0.1.0

data/ext/libgtop/rb_glibtop_proc_mem.c

@@ -0,0 +1,37 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procuid.h>
+
+
+static VALUE rb_glibtop_proc_mem(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_mem buf;
+    VALUE hash;
+
+    glibtop_get_proc_mem(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("size"), rb_uint2inum(buf.size));
+    rb_hash_aset(hash, rb_str_new2("vsize"), rb_uint2inum(buf.vsize));
+    rb_hash_aset(hash, rb_str_new2("resident"), rb_uint2inum(buf.resident));
+    rb_hash_aset(hash, rb_str_new2("share"), rb_uint2inum(buf.share));
+    rb_hash_aset(hash, rb_str_new2("rss"), rb_uint2inum(buf.rss));
+    rb_hash_aset(hash, rb_str_new2("rss_rlim"), rb_uint2inum(buf.rss_rlim));
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_mem()
+{
+    rb_define_method(cLibGTop, "proc_mem", rb_glibtop_proc_mem, 1);
+}

data/ext/libgtop/rb_glibtop_proc_open_files.c

@@ -0,0 +1,65 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#if (LIBGTOP_CHECK_VERSION(2, 9, 4))
+#include <glibtop/procopenfiles.h>
+
+static VALUE rb_glibtop_proc_open_files(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_open_files buf;
+    glibtop_open_files_entry* files;
+    VALUE hash, entry_hash, array, socket;
+    int i;
+
+    files = glibtop_get_proc_open_files(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("number"), rb_uint2inum(buf.number));
+    rb_hash_aset(hash, rb_str_new2("total"), rb_uint2inum(buf.total));
+    rb_hash_aset(hash, rb_str_new2("size"), rb_uint2inum(buf.size));
+
+    array = rb_ary_new();
+    rb_hash_aset(hash, rb_str_new2("entry"), array);
+
+    for ( i = 0; i < buf.number; ++i) {
+        entry_hash = rb_hash_new();
+        rb_hash_aset(entry_hash, rb_str_new2("fd"), INT2FIX(files[i].fd));
+        rb_hash_aset(entry_hash, rb_str_new2("type"), INT2FIX(files[i].type));
+        switch (files[i].type) {
+            case GLIBTOP_FILE_TYPE_FILE:
+                rb_hash_aset(entry_hash, rb_str_new2("file"), rb_str_new2(files[i].info.file.name));
+                break;
+            case GLIBTOP_FILE_TYPE_PIPE:
+                rb_hash_aset(entry_hash, rb_str_new2("pipe"), rb_str_new2("pipe"));
+                break;
+            case GLIBTOP_FILE_TYPE_INETSOCKET:
+                socket = rb_ary_new();
+                rb_ary_push(socket, rb_str_new2(files[i].info.sock.dest_host));
+                rb_ary_push(socket, INT2FIX(files[i].info.sock.dest_port));
+                rb_hash_aset(entry_hash, rb_str_new2("socket"), socket);
+                break;
+            case GLIBTOP_FILE_TYPE_LOCALSOCKET:
+                rb_hash_aset(entry_hash, rb_str_new2("localsocket"), rb_str_new2(files[i].info.localsock.name));
+                break;
+        }
+        rb_ary_push(array, entry_hash);
+    }
+
+    g_free(files);
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_open_files()
+{
+    rb_define_method(cLibGTop, "proc_open_files", rb_glibtop_proc_open_files, 1);
+}
+#endif

data/ext/libgtop/rb_glibtop_proc_segment.c

@@ -0,0 +1,39 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procsegment.h>
+
+
+static VALUE rb_glibtop_proc_segment(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_segment buf;
+    VALUE hash;
+
+    glibtop_get_proc_segment(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("text_rss"), rb_uint2inum(buf.text_rss));
+    rb_hash_aset(hash, rb_str_new2("shlib_rss"), rb_uint2inum(buf.shlib_rss));
+    rb_hash_aset(hash, rb_str_new2("data_rss"), rb_uint2inum(buf.data_rss));
+    rb_hash_aset(hash, rb_str_new2("stack_rss"), rb_uint2inum(buf.stack_rss));
+    rb_hash_aset(hash, rb_str_new2("dirty_size"), rb_uint2inum(buf.dirty_size));
+    rb_hash_aset(hash, rb_str_new2("start_code"), rb_uint2inum(buf.start_code));
+    rb_hash_aset(hash, rb_str_new2("end_code"), rb_uint2inum(buf.end_code));
+    rb_hash_aset(hash, rb_str_new2("start_stack"), rb_uint2inum(buf.start_stack));
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_segment()
+{
+    rb_define_method(cLibGTop, "proc_segment", rb_glibtop_proc_segment, 1);
+}

data/ext/libgtop/rb_glibtop_proc_signal.c

@@ -0,0 +1,48 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procsignal.h>
+
+#define signal_mask_2_ruby_array(array, signal_mask) \
+    array = rb_ary_new2(2); \
+    for (i = 0; i < 2; i++){ \
+        rb_ary_push(array, rb_uint2inum(signal_mask[i])); \
+    }
+
+
+static VALUE rb_glibtop_proc_signal(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_signal buf;
+    VALUE hash, signal, blocked, sigignore, sigcatch;
+    int i;
+
+    glibtop_get_proc_signal(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+
+    signal_mask_2_ruby_array(signal, buf.signal);
+    signal_mask_2_ruby_array(blocked, buf.blocked);
+    signal_mask_2_ruby_array(sigignore, buf.sigignore);
+    signal_mask_2_ruby_array(sigcatch, buf.sigcatch);
+
+    rb_hash_aset(hash, rb_str_new2("signal"), signal);
+    rb_hash_aset(hash, rb_str_new2("blocked"), blocked);
+    rb_hash_aset(hash, rb_str_new2("sigignore"), sigignore);
+    rb_hash_aset(hash, rb_str_new2("sigcatch"), sigcatch);
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_signal()
+{
+    rb_define_method(cLibGTop, "proc_signal", rb_glibtop_proc_signal, 1);
+}

data/ext/libgtop/rb_glibtop_proc_state.c

@@ -0,0 +1,46 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procstate.h>
+
+
+static VALUE rb_glibtop_proc_state(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_state buf;
+    char state[2];
+    VALUE hash;
+
+    glibtop_get_proc_state(&buf, NUM2LONG(pid));
+
+    state[0] = buf.state;
+    state[1] = '\0';
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("cmd"), rb_str_new2(buf.cmd));
+    rb_hash_aset(hash, rb_str_new2("state"), rb_str_new2(state));
+    rb_hash_aset(hash, rb_str_new2("uid"), INT2NUM(buf.uid));
+    rb_hash_aset(hash, rb_str_new2("gid"), INT2NUM(buf.gid));
+#if (LIBGTOP_CHECK_VERSION(2, 5, 1))
+    rb_hash_aset(hash, rb_str_new2("ruid"), INT2NUM(buf.ruid));
+    rb_hash_aset(hash, rb_str_new2("rgid"), INT2NUM(buf.rgid));
+    rb_hash_aset(hash, rb_str_new2("has_cpu"), INT2NUM(buf.has_cpu));
+    rb_hash_aset(hash, rb_str_new2("processor"), INT2NUM(buf.processor));
+    rb_hash_aset(hash, rb_str_new2("last_processor"), INT2NUM(buf.last_processor));
+#endif
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_state()
+{
+    rb_define_method(cLibGTop, "proc_state", rb_glibtop_proc_state, 1);
+}

data/ext/libgtop/rb_glibtop_proc_time.c

@@ -0,0 +1,54 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/proctime.h>
+
+
+static VALUE rb_glibtop_proc_time(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_time buf;
+    VALUE hash, xcpu_list, xcpu;
+    int ncpu, i;
+
+    glibtop_get_proc_time(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("start_time"), rb_uint2inum(buf.start_time));
+    rb_hash_aset(hash, rb_str_new2("rtime"), rb_uint2inum(buf.rtime));
+    rb_hash_aset(hash, rb_str_new2("utime"), rb_uint2inum(buf.utime));
+    rb_hash_aset(hash, rb_str_new2("stime"), rb_uint2inum(buf.stime));
+    rb_hash_aset(hash, rb_str_new2("cutime"), rb_uint2inum(buf.cutime));
+    rb_hash_aset(hash, rb_str_new2("cstime"), rb_uint2inum(buf.cstime));
+    rb_hash_aset(hash, rb_str_new2("timeout"), rb_uint2inum(buf.timeout));
+    rb_hash_aset(hash, rb_str_new2("it_real_value"), rb_uint2inum(buf.it_real_value));
+    rb_hash_aset(hash, rb_str_new2("frequency"), rb_uint2inum(buf.frequency));
+
+    ncpu = glibtop_global_server->ncpu ? glibtop_global_server->ncpu : 1;
+    xcpu_list = rb_ary_new2(ncpu);
+
+    for (i = 0; i < ncpu; i++) {
+       xcpu = rb_hash_new();
+
+       rb_hash_aset(xcpu, rb_str_new2("utime"), rb_uint2inum(buf.xcpu_utime[i]));
+       rb_hash_aset(xcpu, rb_str_new2("stime"), rb_uint2inum(buf.xcpu_stime[i]));
+
+       rb_ary_push(xcpu_list, xcpu);
+    }
+    rb_hash_aset(hash, rb_str_new2("xcpu"), xcpu_list);
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_time()
+{
+    rb_define_method(cLibGTop, "proc_time", rb_glibtop_proc_time, 1);
+}

data/ext/libgtop/rb_glibtop_proc_uid.c

@@ -0,0 +1,58 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/procuid.h>
+
+
+static VALUE rb_glibtop_proc_uid(VALUE self, VALUE pid)
+{ 
+    glibtop_proc_uid buf;
+    VALUE hash, groups;
+    int i;
+
+    glibtop_get_proc_uid(&buf, NUM2LONG(pid));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("uid"), INT2NUM(buf.uid));
+    rb_hash_aset(hash, rb_str_new2("euid"), INT2NUM(buf.euid));
+    rb_hash_aset(hash, rb_str_new2("gid"), INT2NUM(buf.gid));
+    rb_hash_aset(hash, rb_str_new2("egid"), INT2NUM(buf.egid));
+#if (LIBGTOP_CHECK_VERSION(2, 5, 1))
+    rb_hash_aset(hash, rb_str_new2("suid"), INT2NUM(buf.suid));
+    rb_hash_aset(hash, rb_str_new2("sgid"), INT2NUM(buf.sgid));
+    rb_hash_aset(hash, rb_str_new2("fsuid"), INT2NUM(buf.fsuid));
+    rb_hash_aset(hash, rb_str_new2("fsgid"), INT2NUM(buf.fsgid));
+#endif
+    rb_hash_aset(hash, rb_str_new2("pid"), INT2NUM(buf.pid));
+    rb_hash_aset(hash, rb_str_new2("ppid"), INT2NUM(buf.ppid));
+    rb_hash_aset(hash, rb_str_new2("pgrp"), INT2NUM(buf.pgrp));
+    rb_hash_aset(hash, rb_str_new2("session"), INT2NUM(buf.session));
+    rb_hash_aset(hash, rb_str_new2("tty"), INT2NUM(buf.tty));
+    rb_hash_aset(hash, rb_str_new2("tpgid"), INT2NUM(buf.tpgid));
+    rb_hash_aset(hash, rb_str_new2("priority"), INT2NUM(buf.priority));
+    rb_hash_aset(hash, rb_str_new2("nice"), INT2NUM(buf.nice));
+
+#if (LIBGTOP_CHECK_VERSION(2, 5, 1))
+    groups = rb_ary_new2(buf.ngroups);
+    for (i = 0; i < GLIBTOP_MAX_GROUPS && i < buf.ngroups; i++){
+        rb_ary_push(groups, INT2NUM(buf.groups[i]));
+    }
+    rb_hash_aset(hash, rb_str_new2("groups"), groups);
+#endif
+
+    return hash;
+}
+
+
+void Init_glibtop_proc_uid()
+{
+    rb_define_method(cLibGTop, "proc_uid", rb_glibtop_proc_uid, 1);
+}

data/ext/libgtop/rb_glibtop_proclist.c

@@ -0,0 +1,56 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+#include <glibtop/proclist.h>
+
+
+static VALUE rb_glibtop_proclist(VALUE self, VALUE which, VALUE arg)
+{ 
+    glibtop_proclist buf;
+    unsigned int* pids_buf;
+    VALUE hash, pids;
+    int i;
+
+    pids_buf = glibtop_get_proclist(&buf, NUM2INT(which), NUM2INT(arg));
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("number"), rb_uint2inum(buf.number));
+    rb_hash_aset(hash, rb_str_new2("size"), rb_uint2inum(buf.size));
+    rb_hash_aset(hash, rb_str_new2("total"), rb_uint2inum(buf.total));
+
+    pids = rb_ary_new2(buf.number);
+    for (i = 0; i < buf.number; i++){
+      rb_ary_push(pids, rb_uint2inum(pids_buf[i]));
+    }
+    rb_hash_aset(hash, rb_str_new2("pids"), pids);
+
+    g_free(pids_buf);
+
+    return hash;
+}
+
+
+void Init_glibtop_proclist()
+{
+    rb_define_const(cLibGTop, "KERN_PROC_ALL", INT2FIX(GLIBTOP_KERN_PROC_ALL));
+    rb_define_const(cLibGTop, "KERN_PROC_PID", INT2FIX(GLIBTOP_KERN_PROC_PID));
+    rb_define_const(cLibGTop, "KERN_PROC_PGRP", INT2FIX(GLIBTOP_KERN_PROC_PGRP));
+    rb_define_const(cLibGTop, "KERN_PROC_SESSION", INT2FIX(GLIBTOP_KERN_PROC_SESSION));
+    rb_define_const(cLibGTop, "KERN_PROC_TTY", INT2FIX(GLIBTOP_KERN_PROC_TTY));
+    rb_define_const(cLibGTop, "KERN_PROC_UID", INT2FIX(GLIBTOP_KERN_PROC_UID));
+    rb_define_const(cLibGTop, "KERN_PROC_RUID", INT2FIX(GLIBTOP_KERN_PROC_RUID));
+    rb_define_const(cLibGTop, "KERN_PROC_MASK", INT2FIX(GLIBTOP_KERN_PROC_MASK));
+    rb_define_const(cLibGTop, "EXCLUDE_IDLE", INT2FIX(GLIBTOP_EXCLUDE_IDLE));
+    rb_define_const(cLibGTop, "EXCLUDE_SYSTEM", INT2FIX(GLIBTOP_EXCLUDE_SYSTEM));
+    rb_define_const(cLibGTop, "EXCLUDE_NOTTY", INT2FIX(GLIBTOP_EXCLUDE_NOTTY));
+
+    rb_define_method(cLibGTop, "proclist", rb_glibtop_proclist, 2);
+}

data/ext/libgtop/rb_glibtop_sem_limits.c

@@ -0,0 +1,40 @@
+/*
+ * GLibTop is a wrapper library of a libgtop-2.x
+ *
+ * @author DATE Ken <itacchi@gmail.com>
+ * @see http://rubyforge.org/projects/ruby-libgtop2/
+ */
+
+#include <ruby.h>
+#include <rb_glibtop.h>
+
+
+static VALUE rb_glibtop_sem_limits(VALUE self)
+{ 
+    glibtop_sem_limits buf;
+    VALUE hash;
+
+    glibtop_get_sem_limits(&buf);
+
+    hash = rb_hash_new();
+
+    rb_hash_aset(hash, rb_str_new2("flags"), rb_uint2inum(buf.flags));
+    rb_hash_aset(hash, rb_str_new2("semmap"), rb_uint2inum(buf.semmap));
+    rb_hash_aset(hash, rb_str_new2("semmni"), rb_uint2inum(buf.semmni));
+    rb_hash_aset(hash, rb_str_new2("semmns"), rb_uint2inum(buf.semmns));
+    rb_hash_aset(hash, rb_str_new2("semmnu"), rb_uint2inum(buf.semmnu));
+    rb_hash_aset(hash, rb_str_new2("semmsl"), rb_uint2inum(buf.semmsl));
+    rb_hash_aset(hash, rb_str_new2("semopm"), rb_uint2inum(buf.semopm));
+    rb_hash_aset(hash, rb_str_new2("semume"), rb_uint2inum(buf.semume));
+    rb_hash_aset(hash, rb_str_new2("semusz"), rb_uint2inum(buf.semusz));
+    rb_hash_aset(hash, rb_str_new2("semvmx"), rb_uint2inum(buf.semvmx));
+    rb_hash_aset(hash, rb_str_new2("semaem"), rb_uint2inum(buf.semaem));
+
+    return hash;
+}
+
+
+void Init_glibtop_sem_limits()
+{
+    rb_define_method(cLibGTop, "sem_limits", rb_glibtop_sem_limits, 0);
+}