csigar 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47bd73004109a069e58520b246d15cc11bfdeba4
-  data.tar.gz: 993496c3b2ce640a396c6e1a76be9ce096acb9bc
+  metadata.gz: 7804b5c687d2dd767a30b7d92f9b886128ea4e83
+  data.tar.gz: 9b25e12b9dcca3aec625a74284862014d56d555e
 SHA512:
-  metadata.gz: d0c74d16f703c4196cb5e9128e2f5b262e8a2dfaee139ce296f01ee87d3ee9a80a0dc00d4b8e8a373cf316ccc737f612e2cd262912ec7c832bf7b067c3d91fb5
-  data.tar.gz: 88ec5ceae647140676f6e0fc02d0de2dea25ce35ea557d53f8ffe250a66b3c8c8b0bcaf2b2a0708d6129ae3d10d7a76c27480561e55f2adf99e3f7944730ad5b
+  metadata.gz: 3a48cae74e0750521cfa494452e78c6ec396b6a1fc9b9fdfe6564acb60ef116da0a5f5997d400ecbb23d53ccd8281eb9280708ec016c6ba7fd98811b11ed8620
+  data.tar.gz: 456d3736f2d986eb66afce6bbe08b1aea1bb44de46e2d30b8fbed1c67fdf495b18b4438d8a4144f7b8f5f6a25c18e440575659a2ab3b9264e47c654465898c0a

data/README.md

@@ -0,0 +1,39 @@
+# Instructions
+## Creating gem file
+`rake package`
+
+Creates a gem file in pkg/csigar-0.x.x.gem.
+
+## Installing gem file
+`gem install pkg/csigar-x.x.x.gem`
+
+Installs gem file to local ruby libs.
+
+## Publishing gem file
+`gem push pkg/csigar-x.x.x.gem`
+
+Pushes gem file to rubygems.org (account required).
+
+## Test using irb
+Start interactive ruby shell:
+`#>irb`
+Require module (must return "true"):
+`require 'csigar'`
+Build instance:
+`sigar = Csigar.new`
+Get test value (should return numeric value):
+`sigar.cpu_perc.wait`
+
+
+# Docs
+
+Visit the SIGAR Wiki for documentation, bugs, support, etc.:
+http://sigar.hyperic.com/
+
+2014-10-28
+Patched version of hyperic/sigar by jgottschlich@cloudscale.de
+- added cpu_perc_metric to ruby bindings
+- fixed Rakefile to use Gem::PackageTask instead of deprecated package
+- changed version number to 0.7.3
+
+

data/Rakefile

@@ -22,7 +22,7 @@ spec = Gem::Specification.new do |s|
   s.name = GEM
 #  s.version = props['version.major'] + '.' + props['version.minor'] + '.' + props['version.maint']
 #  '0.7.x' until the sigar-1.7.0 release
-  s.version = '0' + '.' + props['version.minor'] + '.' + '3'
+  s.version = '0' + '.' + props['version.minor'] + '.' + '4'
   s.summary = props['project.summary']
   s.description = s.summary
   s.author = props['project.author']
@@ -32,7 +32,7 @@ spec = Gem::Specification.new do |s|
   s.has_rdoc = false
   s.extensions = 'bindings/ruby/extconf.rb'
   s.files =
-    %w(LICENSE NOTICE README Rakefile version.properties) +
+    %w(LICENSE NOTICE README.md Rakefile version.properties) +
     %w(bindings/SigarWrapper.pm bindings/SigarBuild.pm) +
     `git ls-files -- bindings/ruby/*`.split("\n") +
     Dir.glob("include/*.h") +

data/bindings/SigarWrapper.pm

@@ -43,6 +43,7 @@ my %has_name_arg = map { $_, 1 } qw(FileSystemUsage DiskUsage
                                     FileAttrs DirStat DirUsage
                                     NetInterfaceConfig NetInterfaceStat);
 
+
 my %proc_no_arg = map { $_, 1 } qw(stat);
 
 my %get_not_impl = map { $_, 1 } qw(net_address net_route net_connection net_stat cpu_perc
@@ -527,6 +528,7 @@ use vars qw(%classes %cmds);
          plat => '*'
       },
     ],
+
     ProcMem => [
       {
          name => 'size', type => 'Long',
@@ -627,6 +629,51 @@ use vars qw(%classes %cmds);
          plat => '*'
       },
     ],
+    ProcDiskIO => [
+      {
+         name => 'bytes_read', type => 'Long',
+         desc => 'Bytes Read',
+         plat => 'LW'
+      },
+      {
+         name => 'bytes_written', type => 'Long',
+         desc => 'Bytes Written',
+         plat => 'LW'
+      },
+      {
+         name => 'bytes_total', type => 'Long',
+         desc => 'Bytes Total',
+         plat => 'LWAHS'
+      }
+    ],
+
+    ProcCumulativeDiskIO => [
+      {
+         name => 'bytes_read', type => 'Long',
+         desc => 'Bytes Read from Start',
+         plat => 'LW'
+      },
+      {
+         name => 'bytes_written', type => 'Long',
+         desc => 'Bytes Written from Start',
+         plat => 'LW'
+      },
+      {
+         name => 'bytes_total', type => 'Long',
+         desc => 'Bytes Total from Start',
+         plat => 'LWAHS'
+      }
+    ],
+
+    DumpPidCache => [
+      {
+         name => 'dummy', type => 'Long',
+         desc => 'Dummy',
+         plat => 'LWAHS'
+      }
+    ],
+
+
     ProcState => [
       {
          name => 'state', type => 'Char',

data/include/sigar.h

@@ -292,6 +292,47 @@ typedef struct {
 SIGAR_DECLARE(int) sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
                                       sigar_proc_mem_t *procmem);
 
+typedef struct {
+     sigar_uint64_t 
+        bytes_read,
+        bytes_written,
+        bytes_total;
+} sigar_proc_disk_io_t;
+
+SIGAR_DECLARE(int) sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                                          sigar_proc_disk_io_t *proc_disk_io);
+
+typedef struct {
+    sigar_uint64_t
+        bytes_read,
+        bytes_written,
+        bytes_total;
+    sigar_uint64_t last_time;
+    sigar_uint64_t
+        bytes_read_diff,
+        bytes_written_diff,
+        bytes_total_diff;
+} sigar_cached_proc_disk_io_t;
+
+
+typedef struct {
+    sigar_uint64_t
+        bytes_read,
+        bytes_written,
+        bytes_total;
+} sigar_proc_cumulative_disk_io_t;
+
+SIGAR_DECLARE(int) sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                                          sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io);
+
+
+typedef struct  { 
+    sigar_uint64_t dummy;
+}sigar_dump_pid_cache_t;
+
+SIGAR_DECLARE(int) sigar_dump_pid_cache_get(sigar_t *sigar, sigar_dump_pid_cache_t *info);
+
+
 typedef struct {
     sigar_uid_t uid;
     sigar_gid_t gid;

data/include/sigar_private.h

@@ -68,7 +68,8 @@
    sigar_cache_t *proc_cpu; \
    sigar_cache_t *net_listen; \
    sigar_cache_t *net_services_tcp; \
-   sigar_cache_t *net_services_udp
+   sigar_cache_t *net_services_udp;\
+   sigar_cache_t *proc_io
 
 #if defined(WIN32)
 #   define SIGAR_INLINE __inline
@@ -398,11 +399,15 @@ int sigar_get_iftype(const char *name, int *type, int *inst);
 #define SIGAR_NIC_SIT      "IPv6-in-IPv4"
 #define SIGAR_NIC_IRDA     "IrLAP"
 #define SIGAR_NIC_EC       "Econet"
-
+#define PID_CACHE_CLEANUP_PERIOD 1000*60*10 /* 10 minutes */
+#define PID_CACHE_ENTRY_EXPIRE_PERIOD 1000*60*20 /* 20 minutes */
 #ifndef WIN32
 #include <netdb.h>
 #endif
 
+#define PROC_PID_CPU_CACHE 1
+#define PROC_PID_IO_CACHE 2
+
 #define SIGAR_HOSTENT_LEN 1024
 #if defined(_AIX)
 #define SIGAR_HAS_HOSTENT_DATA

data/include/sigar_util.h

@@ -170,15 +170,21 @@ struct sigar_cache_entry_t {
     sigar_cache_entry_t *next;
     sigar_uint64_t id;
     void *value;
+    sigar_uint64_t last_access_time;
 };
 
 typedef struct {
     sigar_cache_entry_t **entries;
     unsigned int count, size;
     void (*free_value)(void *ptr);
+    sigar_uint64_t entry_expire_period;
+    sigar_uint64_t cleanup_period_millis;
+    sigar_uint64_t last_cleanup_time;
 } sigar_cache_t;
 
 sigar_cache_t *sigar_cache_new(int size);
+sigar_cache_t *sigar_expired_cache_new(int size, sigar_uint64_t cleanup_period_millis, sigar_uint64_t entry_expire_period);
+void sigar_cache_dump(sigar_cache_t *table);
 
 sigar_cache_entry_t *sigar_cache_get(sigar_cache_t *table,
                                      sigar_uint64_t key);

data/src/os/aix/aix_sigar.c

@@ -754,6 +754,23 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
     return SIGAR_OK;
 }
 
+int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                           sigar_proc_cumulative_disk_io_t *cumulative_proc_disk_io)
+{
+    int status = sigar_getprocs(sigar, pid);
+    struct procsinfo64 *pinfo = sigar->pinfo;
+
+    if (status != SIGAR_OK) {
+        return status;
+    }
+    cumulative_proc_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
+    cumulative_proc_disk_io->bytes_written =  SIGAR_FIELD_NOTIMPL;
+    cumulative_proc_disk_io->bytes_total = pinfo->pi_ioch;
+
+    return SIGAR_OK;
+}
+
+
 int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
                         sigar_proc_cred_t *proccred)
 {

data/src/os/darwin/darwin_sigar.c

@@ -16,6 +16,17 @@
  * limitations under the License.
  */
 
+#ifdef DARWIN
+#include <sys/socket.h>
+#include <sys/fcntl.h>
+#include <mach/thread_info.h>
+#endif
+
+#include "sigar.h"
+#include "sigar_private.h"
+#include "sigar_util.h"
+#include "sigar_os.h"
+
 #include <sys/param.h>
 #include <sys/mount.h>
 #if !(defined(__FreeBSD__) && (__FreeBSD_version >= 800000))
@@ -33,7 +44,6 @@
 #include <mach/mach_port.h>
 #include <mach/task.h>
 #include <mach/thread_act.h>
-#include <mach/thread_info.h>
 #include <mach/vm_map.h>
 #if !defined(HAVE_SHARED_REGION_H) && defined(__MAC_10_5) /* see Availability.h */
 #  define HAVE_SHARED_REGION_H /* suckit autoconf */
@@ -107,11 +117,6 @@
 #include <netinet/tcp_var.h>
 #include <netinet/tcp_fsm.h>
 
-#include "sigar.h"
-#include "sigar_private.h"
-#include "sigar_util.h"
-#include "sigar_os.h"
-
 #define NMIB(mib) (sizeof(mib)/sizeof(mib[0]))
 
 #ifdef __FreeBSD__
@@ -1241,6 +1246,13 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
     return SIGAR_OK;
 }
 
+int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                           sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
+{
+    return SIGAR_ENOTIMPL;
+}
+
+
 int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
                         sigar_proc_cred_t *proccred)
 {
@@ -3708,4 +3720,4 @@ int sigar_os_sys_info_get(sigar_t *sigar,
 #endif
 
     return SIGAR_OK;
-}
+}

data/src/os/hpux/hpux_sigar.c

@@ -307,6 +307,25 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
     return SIGAR_OK;
 }
 
+int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid, 
+                           sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
+{
+
+    int status = sigar_pstat_getproc(sigar, pid);
+    struct pst_status *pinfo = sigar->pinfo;
+
+    if (status != SIGAR_OK) {
+        return status;
+    }
+    proc_cumulative_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL; 
+    proc_cumulative_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL; 
+    proc_cumulative_disk_io->bytes_total =  pinfo->pst_ioch;
+
+
+   return SIGAR_OK;
+}
+
+
 int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
                         sigar_proc_cred_t *proccred)
 {

data/src/os/linux/linux_sigar.c

@@ -768,6 +768,34 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
     return SIGAR_OK;
 }
 
+SIGAR_INLINE sigar_uint64_t get_named_proc_token(char *buffer,
+                                                 char *token) {
+  char *ptr = strstr(buffer, token);
+  if (!ptr) {
+    return SIGAR_FIELD_NOTIMPL;
+  }
+  ptr = sigar_skip_token(ptr);
+  return sigar_strtoul(ptr);
+}
+
+int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                           sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
+{
+    char buffer[BUFSIZ];
+    
+    int status = SIGAR_PROC_FILE2STR(buffer, pid, "/io");
+    
+    if (status != SIGAR_OK) {
+        return status;
+    }
+
+    proc_cumulative_disk_io->bytes_read = get_named_proc_token(buffer, "\nread_bytes");
+    proc_cumulative_disk_io->bytes_written = get_named_proc_token(buffer, "\nwrite_bytes");
+    proc_cumulative_disk_io->bytes_total = proc_cumulative_disk_io->bytes_read + proc_cumulative_disk_io->bytes_written;
+
+    return SIGAR_OK;
+}
+
 #define NO_ID_MSG "[proc_cred] /proc/%lu" PROC_PSTATUS " missing "
 
 int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,

data/src/os/solaris/solaris_sigar.c

@@ -407,7 +407,7 @@ int sigar_cpu_get(sigar_t *sigar, sigar_cpu_t *cpu)
         cpu->idle  += xcpu->idle;
         cpu->nice  += xcpu->nice;
         cpu->wait  += xcpu->wait;
-        cpu->total = xcpu->total;
+        cpu->total += xcpu->total;
     }
 
     return SIGAR_OK;
@@ -719,6 +719,21 @@ int sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
     return SIGAR_OK;
 }
 
+int sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid, 
+                           sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
+{
+   prusage_t usage;
+   int status;
+   if ((status = sigar_proc_usage_get(sigar, &usage, pid)) != SIGAR_OK) {
+        return status;
+   }
+   proc_cumulative_disk_io->bytes_read = SIGAR_FIELD_NOTIMPL;
+   proc_cumulative_disk_io->bytes_written = SIGAR_FIELD_NOTIMPL;
+   proc_cumulative_disk_io->bytes_total =  usage.pr_ioch;
+
+    return SIGAR_OK;
+}
+
 int sigar_proc_cred_get(sigar_t *sigar, sigar_pid_t pid,
                         sigar_proc_cred_t *proccred)
 {

data/src/os/win32/sigar_os.h

@@ -345,6 +345,8 @@ typedef struct {
     sigar_uint64_t handles;
     sigar_uint64_t threads;
     sigar_uint64_t page_faults;
+	sigar_uint64_t bytes_read;
+	sigar_uint64_t bytes_written;
 } sigar_win32_pinfo_t;
 
 typedef struct {

data/src/os/win32/win32_sigar.c

@@ -62,6 +62,8 @@ typedef enum {
 #define PERF_TITLE_PPID       1410
 #define PERF_TITLE_PRIORITY   682
 #define PERF_TITLE_START_TIME 684
+#define PERF_TITLE_IO_READ_BYTES_SEC	1420
+#define PERF_TITLE_IO_WRITE_BYTES_SEC	1422
 
 typedef enum {
     PERF_IX_CPUTIME,
@@ -74,6 +76,8 @@ typedef enum {
     PERF_IX_PPID,
     PERF_IX_PRIORITY,
     PERF_IX_START_TIME,
+	PERF_IX_IO_READ_BYTES_SEC,
+	PERF_IX_IO_WRITE_BYTES_SEC,
     PERF_IX_MAX
 } perf_proc_offsets_t;
 
@@ -1210,6 +1214,23 @@ SIGAR_DECLARE(int) sigar_proc_mem_get(sigar_t *sigar, sigar_pid_t pid,
     return SIGAR_OK;
 }
 
+SIGAR_DECLARE(int) sigar_proc_cumulative_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                                          sigar_proc_cumulative_disk_io_t *proc_cumulative_disk_io)
+{
+    int status = get_proc_info(sigar, pid);
+    sigar_win32_pinfo_t *pinfo = &sigar->pinfo;
+
+    if (status != SIGAR_OK) {
+        return status;
+    }
+
+    proc_cumulative_disk_io->bytes_read = pinfo->bytes_read;
+    proc_cumulative_disk_io->bytes_written = pinfo->bytes_written;
+    proc_cumulative_disk_io->bytes_total = proc_cumulative_disk_io->bytes_read + proc_cumulative_disk_io->bytes_written;
+
+    return SIGAR_OK;
+}
+
 #define TOKEN_DAC (STANDARD_RIGHTS_READ | READ_CONTROL | TOKEN_QUERY)
 
 SIGAR_DECLARE(int)
@@ -1441,6 +1462,12 @@ static int get_proc_info(sigar_t *sigar, sigar_pid_t pid)
           case PERF_TITLE_START_TIME:
             perf_offsets[PERF_IX_START_TIME] = offset;
             break;
+		  case PERF_TITLE_IO_READ_BYTES_SEC:
+			perf_offsets[PERF_IX_IO_READ_BYTES_SEC] = offset;
+			break;
+		  case PERF_TITLE_IO_WRITE_BYTES_SEC:
+			perf_offsets[PERF_IX_IO_WRITE_BYTES_SEC] = offset;
+			break;
         }
     }
 
@@ -1466,6 +1493,8 @@ static int get_proc_info(sigar_t *sigar, sigar_pid_t pid)
         pinfo->handles  = PERF_VAL(PERF_IX_HANDLE_CNT);
         pinfo->threads  = PERF_VAL(PERF_IX_THREAD_CNT);
         pinfo->page_faults = PERF_VAL(PERF_IX_PAGE_FAULTS);
+		pinfo->bytes_read = PERF_VAL(PERF_IX_IO_READ_BYTES_SEC);
+		pinfo->bytes_written = PERF_VAL(PERF_IX_IO_WRITE_BYTES_SEC);
 
         return SIGAR_OK;
     }
@@ -3693,6 +3722,7 @@ int sigar_who_list_get_win32(sigar_t *sigar,
 #define SIGAR_ARCH "x86"
 #endif
 
+
 int sigar_os_sys_info_get(sigar_t *sigar,
                           sigar_sys_info_t *sysinfo)
 {
@@ -3700,7 +3730,7 @@ int sigar_os_sys_info_get(sigar_t *sigar,
     char *vendor_name, *vendor_version, *code_name=NULL;
 
     version.dwOSVersionInfoSize = sizeof(version);
-    GetVersionEx((OSVERSIONINFO *)&version);
+    GetVersionEx((OSVERSIONINFO *)&version); 
 
     if (version.dwMajorVersion == 4) {
         vendor_name = "Windows NT";
@@ -3740,11 +3770,25 @@ int sigar_os_sys_info_get(sigar_t *sigar,
                 code_name = "Vienna";
             }
         }
-        else {
-            vendor_name = "Windows 2008";
-            vendor_version = "2008";
-            code_name = "Longhorn Server";
-        }
+	else {
+             // not nt work station
+             if (version.dwMinorVersion == 0 || version.dwMinorVersion ==1) {
+            	vendor_name = "Windows 2008";
+            	vendor_version = "2008";
+	        code_name = "Longhorn Server";
+             }
+	     else  if (version.dwMinorVersion == 2) {
+ 	    	vendor_name = "Windows 2012";
+            	vendor_version = "2012";
+            	code_name = "Windows Server 8";
+	     }
+	     else {
+		// defaults
+		 vendor_name = "Windows Unknown";
+		 vendor_version = "2012";
+	     }
+	}
+
     }
 
     SIGAR_SSTRCPY(sysinfo->name, "Win32");

data/src/sigar.c

@@ -30,6 +30,11 @@
 #ifndef WIN32
 #include <arpa/inet.h>
 #endif
+#if defined(HAVE_UTMPX_H)
+# include <utmpx.h>
+#elif defined(HAVE_UTMP_H)
+# include <utmp.h>
+#endif
 
 #include "sigar.h"
 #include "sigar_private.h"
@@ -59,6 +64,7 @@ SIGAR_DECLARE(int) sigar_open(sigar_t **sigar)
         (*sigar)->net_listen = NULL;
         (*sigar)->net_services_tcp = NULL;
         (*sigar)->net_services_udp = NULL;
+	(*sigar)->proc_io = NULL;
     }
 
     return status;
@@ -91,6 +97,11 @@ SIGAR_DECLARE(int) sigar_close(sigar_t *sigar)
     if (sigar->net_services_udp) {
         sigar_cache_destroy(sigar->net_services_udp);
     }
+    if (sigar->proc_io) {
+        sigar_cache_destroy(sigar->proc_io);
+    }
+
+
 
     return sigar_os_close(sigar);
 }
@@ -118,7 +129,7 @@ SIGAR_DECLARE(int) sigar_proc_cpu_get(sigar_t *sigar, sigar_pid_t pid,
     int status;
 
     if (!sigar->proc_cpu) {
-        sigar->proc_cpu = sigar_cache_new(128);
+        sigar->proc_cpu = sigar_expired_cache_new(128, PID_CACHE_CLEANUP_PERIOD, PID_CACHE_ENTRY_EXPIRE_PERIOD);
     }
 
     entry = sigar_cache_get(sigar->proc_cpu, pid);
@@ -167,6 +178,106 @@ SIGAR_DECLARE(int) sigar_proc_cpu_get(sigar_t *sigar, sigar_pid_t pid,
 
     return SIGAR_OK;
 }
+void copy_cached_disk_io_into_disk_io( sigar_cached_proc_disk_io_t *cached,  sigar_proc_disk_io_t *proc_disk_io) {
+   proc_disk_io->bytes_read = cached->bytes_read_diff;
+   proc_disk_io->bytes_written = cached->bytes_written_diff;
+   proc_disk_io->bytes_total = cached->bytes_total_diff;
+}
+
+sigar_uint64_t get_io_diff(sigar_uint64_t current_value, sigar_uint64_t prev_value,  sigar_uint64_t time_diff) {
+   double io_diff;
+   sigar_uint64_t int_io_diff;
+   if ( current_value == SIGAR_FIELD_NOTIMPL ) {
+      return SIGAR_FIELD_NOTIMPL;
+   }
+   io_diff = (( current_value - prev_value)/(double)time_diff)*SIGAR_MSEC;
+   int_io_diff = (sigar_uint64_t)io_diff;
+   if (int_io_diff >=0) {
+      return int_io_diff;
+   }
+   return 0;
+}
+
+void calculate_io_diff(sigar_proc_cumulative_disk_io_t * proc_disk_io, sigar_cached_proc_disk_io_t *cached,  sigar_uint64_t time_diff, int is_first_time) {
+   /*calculate avg diff /read/write/total per second*/
+   if (!is_first_time) {
+       cached->bytes_written_diff = get_io_diff(proc_disk_io->bytes_written, cached->bytes_written, time_diff);
+       cached->bytes_read_diff = get_io_diff(proc_disk_io->bytes_read, cached->bytes_read, time_diff);
+       cached->bytes_total_diff = get_io_diff(proc_disk_io->bytes_total, cached->bytes_total, time_diff);
+   }
+   else {
+       cached->bytes_total_diff =  cached->bytes_read_diff =  cached->bytes_written_diff = 0.0;
+   }
+   // now put in cache the current cumulative values
+   cached->bytes_written = proc_disk_io->bytes_written;
+   cached->bytes_read = proc_disk_io->bytes_read;
+   cached->bytes_total = proc_disk_io->bytes_total;
+}
+
+SIGAR_DECLARE(int) sigar_proc_disk_io_get(sigar_t *sigar, sigar_pid_t pid,
+                                          sigar_proc_disk_io_t *proc_disk_io)
+{
+    sigar_cache_entry_t *entry;
+    sigar_cached_proc_disk_io_t *prev;
+    sigar_proc_cumulative_disk_io_t  cumulative_proc_disk_io;
+    sigar_uint64_t time_now = sigar_time_now_millis();
+    sigar_uint64_t time_diff;
+    int status, is_first_time;
+
+    if (!sigar->proc_io) {
+        sigar->proc_io =  sigar_expired_cache_new(128, PID_CACHE_CLEANUP_PERIOD, PID_CACHE_ENTRY_EXPIRE_PERIOD);
+    }
+
+    entry = sigar_cache_get(sigar->proc_io, pid);
+    if (entry->value) {
+        prev = (sigar_cached_proc_disk_io_t *)entry->value;
+    }
+    else {
+        prev = entry->value = malloc(sizeof(*prev));
+        SIGAR_ZERO(prev);
+    }
+    is_first_time = (prev->last_time == 0);
+    time_diff = time_now - prev->last_time;
+
+    if (time_diff < 1000) {
+        /* we were just called within < 1 second ago. */
+        copy_cached_disk_io_into_disk_io(prev, proc_disk_io);
+	if (time_diff < 0) {
+	   // something is wrong at least from now on the time will be ok
+ 	   prev->last_time = time_now;
+        }
+        return SIGAR_OK;
+    }
+    prev->last_time = time_now;
+
+
+    status =
+        sigar_proc_cumulative_disk_io_get(sigar, pid,
+                            &cumulative_proc_disk_io);
+
+    if (status != SIGAR_OK) {
+        return status;
+    }
+    calculate_io_diff(&cumulative_proc_disk_io, prev, time_diff,  is_first_time);
+    copy_cached_disk_io_into_disk_io(prev, proc_disk_io);
+    return SIGAR_OK;
+}
+
+void get_cache_info(sigar_cache_t * cache, char * name){
+   if (cache == NULL) {
+      return;
+   }
+
+   printf("******** %s *********\n", name);
+   sigar_cache_dump(cache);
+}
+
+SIGAR_DECLARE(int) sigar_dump_pid_cache_get(sigar_t *sigar, sigar_dump_pid_cache_t *info) {
+  
+  get_cache_info(sigar->proc_cpu, "proc cpu cache");
+  get_cache_info(sigar->proc_io, "proc io cache");
+  return SIGAR_OK;
+}
 
 SIGAR_DECLARE(int) sigar_proc_stat_get(sigar_t *sigar,
                                        sigar_proc_stat_t *procstat)
@@ -1024,40 +1135,7 @@ SIGAR_DECLARE(int) sigar_who_list_destroy(sigar_t *sigar,
     return SIGAR_OK;
 }
 
-#ifdef DARWIN
-#include <AvailabilityMacros.h>
-#endif
-#ifdef MAC_OS_X_VERSION_10_5
-#  if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
-#    define SIGAR_NO_UTMP
-#  endif
-/* else 10.4 and earlier or compiled with -mmacosx-version-min=10.3 */
-#endif
-
-#if defined(__sun)
-#  include <utmpx.h>
-#  define SIGAR_UTMP_FILE _UTMPX_FILE
-#  define ut_time ut_tv.tv_sec
-#elif defined(WIN32)
-/* XXX may not be the default */
-#define SIGAR_UTMP_FILE "C:\\cygwin\\var\\run\\utmp"
-#define UT_LINESIZE	16
-#define UT_NAMESIZE	16
-#define UT_HOSTSIZE	256
-#define UT_IDLEN	2
-#define ut_name ut_user
-
-struct utmp {
-    short ut_type;	
-    int ut_pid;		
-    char ut_line[UT_LINESIZE];
-    char ut_id[UT_IDLEN];
-    time_t ut_time;	
-    char ut_user[UT_NAMESIZE];	
-    char ut_host[UT_HOSTSIZE];	
-    long ut_addr;	
-};
-#elif defined(NETWARE)
+#if defined(NETWARE)
 static char *getpass(const char *prompt)
 {
     static char password[BUFSIZ];
@@ -1067,109 +1145,48 @@ static char *getpass(const char *prompt)
 
     return (char *)&password;
 }
-#elif !defined(SIGAR_NO_UTMP)
-#  include <utmp.h>
-#  ifdef UTMP_FILE
-#    define SIGAR_UTMP_FILE UTMP_FILE
-#  else
-#    define SIGAR_UTMP_FILE _PATH_UTMP
-#  endif
-#endif
-
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(DARWIN)
-#  define ut_user ut_name
-#endif
-
-#ifdef DARWIN
-/* XXX from utmpx.h; sizeof changed in 10.5 */
-/* additionally, utmpx does not work on 10.4 */
-#define SIGAR_HAS_UTMPX
-#define _PATH_UTMPX     "/var/run/utmpx"
-#define _UTX_USERSIZE   256     /* matches MAXLOGNAME */
-#define _UTX_LINESIZE   32
-#define _UTX_IDSIZE     4
-#define _UTX_HOSTSIZE   256
-struct utmpx {
-    char ut_user[_UTX_USERSIZE];    /* login name */
-    char ut_id[_UTX_IDSIZE];        /* id */
-    char ut_line[_UTX_LINESIZE];    /* tty name */
-    pid_t ut_pid;                   /* process id creating the entry */
-    short ut_type;                  /* type of this entry */
-    struct timeval ut_tv;           /* time entry was created */
-    char ut_host[_UTX_HOSTSIZE];    /* host name */
-    __uint32_t ut_pad[16];          /* reserved for future use */
-};
-#define ut_xtime ut_tv.tv_sec
-#define UTMPX_USER_PROCESS      7
-/* end utmpx.h */
-#define SIGAR_UTMPX_FILE _PATH_UTMPX
 #endif
 
-#if !defined(NETWARE) && !defined(_AIX)
-
 #define WHOCPY(dest, src) \
     SIGAR_SSTRCPY(dest, src); \
     if (sizeof(src) < sizeof(dest)) \
         dest[sizeof(src)] = '\0'
 
-#ifdef SIGAR_HAS_UTMPX
-static int sigar_who_utmpx(sigar_t *sigar,
-                           sigar_who_list_t *wholist)
+static int sigar_who_utmp(sigar_t *sigar,
+                          sigar_who_list_t *wholist)
 {
-    FILE *fp;
-    struct utmpx ut;
+#if defined(HAVE_UTMPX_H)
+    struct utmpx *ut;
 
-    if (!(fp = fopen(SIGAR_UTMPX_FILE, "r"))) {
-        return errno;
-    }
+    setutxent();
 
-    while (fread(&ut, sizeof(ut), 1, fp) == 1) {
+    while ((ut = getutxent()) != NULL) {
         sigar_who_t *who;
 
-        if (*ut.ut_user == '\0') {
+        if (*ut->ut_user == '\0') {
             continue;
         }
 
-#ifdef UTMPX_USER_PROCESS
-        if (ut.ut_type != UTMPX_USER_PROCESS) {
+        if (ut->ut_type != USER_PROCESS) {
             continue;
         }
-#endif
 
         SIGAR_WHO_LIST_GROW(wholist);
         who = &wholist->data[wholist->number++];
 
-        WHOCPY(who->user, ut.ut_user);
-        WHOCPY(who->device, ut.ut_line);
-        WHOCPY(who->host, ut.ut_host);
+        WHOCPY(who->user, ut->ut_user);
+        WHOCPY(who->device, ut->ut_line);
+        WHOCPY(who->host, ut->ut_host);
 
-        who->time = ut.ut_xtime;
+        who->time = ut->ut_tv.tv_sec;
     }
 
-    fclose(fp);
-
-    return SIGAR_OK;
-}
-#endif
-
-#if defined(SIGAR_NO_UTMP) && defined(SIGAR_HAS_UTMPX)
-#define sigar_who_utmp sigar_who_utmpx
-#else
-static int sigar_who_utmp(sigar_t *sigar,
-                          sigar_who_list_t *wholist)
-{
+    endutxent();
+#elif defined(HAVE_UTMP_H)
     FILE *fp;
-#ifdef __sun
-    /* use futmpx w/ pid32_t for sparc64 */
-    struct futmpx ut;
-#else
     struct utmp ut;
-#endif
-    if (!(fp = fopen(SIGAR_UTMP_FILE, "r"))) {
-#ifdef SIGAR_HAS_UTMPX
-        /* Darwin 10.5 */
-        return sigar_who_utmpx(sigar, wholist);
-#endif
+
+    if (!(fp = fopen(_PATH_UTMP, "r"))) {
         return errno;
     }
 
@@ -1189,7 +1206,7 @@ static int sigar_who_utmp(sigar_t *sigar,
         SIGAR_WHO_LIST_GROW(wholist);
         who = &wholist->data[wholist->number++];
 
-        WHOCPY(who->user, ut.ut_user);
+        WHOCPY(who->user, ut.ut_name);
         WHOCPY(who->device, ut.ut_line);
         WHOCPY(who->host, ut.ut_host);
 
@@ -1197,11 +1214,10 @@ static int sigar_who_utmp(sigar_t *sigar,
     }
 
     fclose(fp);
+#endif
 
     return SIGAR_OK;
 }
-#endif /* SIGAR_NO_UTMP */
-#endif /* NETWARE */
 
 #if defined(WIN32)
 

data/src/sigar_cache.c

@@ -35,7 +35,7 @@ static void free_value(void *ptr)
     free(ptr);
 }
 
-sigar_cache_t *sigar_cache_new(int size)
+sigar_cache_t *sigar_expired_cache_new(int size, sigar_uint64_t cleanup_period_millis, sigar_uint64_t entry_expire_period)
 {
     sigar_cache_t *table = malloc(sizeof(*table));
     table->count = 0;
@@ -43,16 +43,27 @@ sigar_cache_t *sigar_cache_new(int size)
     table->entries = malloc(ENTRIES_SIZE(size));
     memset(table->entries, '\0', ENTRIES_SIZE(size));
     table->free_value = free_value;
+    table->cleanup_period_millis = cleanup_period_millis;
+    table->last_cleanup_time = sigar_time_now_millis();
+    table->entry_expire_period = entry_expire_period;
     return table;
 }
 
-#ifdef DEBUG_CACHE
+sigar_cache_t *sigar_cache_new(int size)
+{
+    return sigar_expired_cache_new(size, SIGAR_FIELD_NOTIMPL, SIGAR_FIELD_NOTIMPL);
+}
+
+
+/*#ifdef DEBUG_CACHE*/
 /* see how well entries are distributed */
-static void sigar_cache_dump(sigar_cache_t *table)
+void sigar_cache_dump(sigar_cache_t *table)
 {
     int i;
     sigar_cache_entry_t **entries = table->entries;
-
+    printf("table size %lu\n", (long)table->size); 
+    printf("table count %lu\n", (long)table->count);
+    
     for (i=0; i<table->size; i++) {
         sigar_cache_entry_t *entry = *entries++;
 
@@ -68,12 +79,12 @@ static void sigar_cache_dump(sigar_cache_t *table)
     printf("\n");
     fflush(stdout);
 }
-#endif
+/*#endif*/
 
 static void sigar_cache_rehash(sigar_cache_t *table)
 {
     int i;
-    unsigned int new_size = table->size * 2 + 1;
+    unsigned int new_size = table->count * 2 + 1;
     sigar_cache_entry_t **entries = table->entries;
     sigar_cache_entry_t **new_entries =
         malloc(ENTRIES_SIZE(new_size));
@@ -101,16 +112,76 @@ static void sigar_cache_rehash(sigar_cache_t *table)
 #define SIGAR_CACHE_IX(t, k) \
     t->entries + (k % t->size)
 
+void sigar_perform_cleanup_if_necessary(sigar_cache_t *table) { 
+    sigar_uint64_t current_time;
+	int i;
+	sigar_cache_entry_t **entries;
+    if (table->cleanup_period_millis == SIGAR_FIELD_NOTIMPL) {
+		/* no cleanup for this cache) */
+		return;
+    }
+    current_time = sigar_time_now_millis();
+    if ((current_time - table->last_cleanup_time) < table->cleanup_period_millis) {
+        /* not enough time has passed since last cleanup */
+        return;
+    }	
+
+    /* performing cleanup */    
+    entries = table->entries;
+
+    table->last_cleanup_time = current_time;
+    
+    for (i=0; i<table->size; i++) {
+        sigar_cache_entry_t *entry, *ptr, *entry_prev=NULL, **entry_in_table;
+        entry_in_table = entries;
+        entry = *entries++;
+
+        while (entry) {
+			sigar_uint64_t period_with_no_access = current_time - entry->last_access_time;
+            ptr = entry->next;            
+            if (table->entry_expire_period < period_with_no_access) {
+		       /* no one acess this entry for too long - we can delete it */
+	           if (entry->value) {
+                   table->free_value(entry->value);
+                } 
+                free(entry);
+		        table->count--;
+                if (entry_prev != NULL) {
+                   entry_prev->next = ptr;
+                }
+                else {
+                   /* removing first entry - head of list should point to next entry */               
+                   *entry_in_table = ptr;
+                } 
+            }
+            else {
+              /* entry not expired - advance entry_prev to current entry*/
+              entry_prev = entry;
+	        }
+            entry = ptr;
+        }
+    }
+    if (table->count < (table->size/4)) {
+	/* hash table (the array size) too big for the amount of values it contains perform rehash */
+        sigar_cache_rehash(table);
+    }
+}
+
+   
+
+
 sigar_cache_entry_t *sigar_cache_find(sigar_cache_t *table,
                                       sigar_uint64_t key)
 {
     sigar_cache_entry_t *entry, **ptr;
+    sigar_perform_cleanup_if_necessary(table);
 
     for (ptr = SIGAR_CACHE_IX(table, key), entry = *ptr;
          entry;
          ptr = &entry->next, entry = *ptr)
     {
         if (entry->id == key) {
+            entry->last_access_time = sigar_time_now_millis();
             return entry;
         }
     }
@@ -123,17 +194,19 @@ sigar_cache_entry_t *sigar_cache_get(sigar_cache_t *table,
                                      sigar_uint64_t key)
 {
     sigar_cache_entry_t *entry, **ptr;
+    sigar_perform_cleanup_if_necessary(table);
 
     for (ptr = SIGAR_CACHE_IX(table, key), entry = *ptr;
          entry;
          ptr = &entry->next, entry = *ptr)
     {
         if (entry->id == key) {
+            entry->last_access_time = sigar_time_now_millis();
             return entry;
         }
     }
 
-    if (table->count++ > table->size) {
+    if (++table->count > table->size) {
         sigar_cache_rehash(table);
 
         for (ptr = SIGAR_CACHE_IX(table, key), entry = *ptr;
@@ -147,6 +220,7 @@ sigar_cache_entry_t *sigar_cache_get(sigar_cache_t *table,
     entry->id = key;
     entry->value = NULL;
     entry->next = NULL;
+    entry->last_access_time = sigar_time_now_millis();
 
     return entry;
 }

data/src/sigar_ptql.c

@@ -1338,6 +1338,14 @@ static ptql_lookup_t PTQL_Cpu[] = {
     { NULL }
 };
 
+static ptql_lookup_t PTQL_Disk_IO[] = {
+    { "BytesRead", PTQL_LOOKUP_ENTRY(proc_disk_io, bytes_read, UI64) },
+    { "BytesWritten",      PTQL_LOOKUP_ENTRY(proc_disk_io, bytes_written, UI64) },
+    { "BytesTotal",       PTQL_LOOKUP_ENTRY(proc_disk_io, bytes_total, UI64) },
+    { NULL }
+};
+
+
 static ptql_lookup_t PTQL_CredName[] = {
     { "User",  PTQL_LOOKUP_ENTRY(proc_cred_name, user, STR) },
     { "Group", PTQL_LOOKUP_ENTRY(proc_cred_name, group, STR) },
@@ -1424,6 +1432,7 @@ static ptql_entry_t ptql_map[] = {
     { "Port",     PTQL_Port },
     { "Pid",      PTQL_Pid },
     { "Service",  PTQL_Service },
+    { "Disk_IO",   PTQL_Disk_IO },
     { NULL }
 };
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: csigar
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Doug MacEachern, Joerg Gottschlich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-28 00:00:00.000000000 Z
+date: 2014-10-31 00:00:00.000000000 Z
 dependencies: []
 description: Patched version of System Information Gatherer And Reporter (original
   by Doug McEachern, patched by Joerg Gottschlich)
@@ -20,7 +20,7 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - NOTICE
-- README
+- README.md
 - Rakefile
 - version.properties
 - bindings/SigarWrapper.pm

data/README

@@ -1,8 +0,0 @@
-Visit the SIGAR Wiki for documentation, bugs, support, etc.:
-http://sigar.hyperic.com/
-
-2014-10-28
-Patched version of hyperic/sigar by jgottschlich@cloudscale.de
-- added cpu_perc_metric to ruby bindings
-- fixed Rakefile to use Gem::PackageTask instead of deprecated package
-- changed version number to 0.7.3