vmstat 0.1.0

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.DS_Store
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-head

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in vmstat.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Vincent Landgraf
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,155 @@
+# Vmstat
+
+This is a focused and fast library to get system information like:
+
+* _Memory_ (free, active, ...)
+* _Network Devices_ (name, in bytes, out bytes, ...)
+* _CPU_ (user, system, nice, idle)
+* _Load_ Average
+* _Disk_ (type, disk path, free bytes, total bytes, ...)
+
+*It currently supports:*
+
+* FreeBSD
+* MacOS X
+
+*It might support (but not tested):*
+
+* OpenBSD
+* NetBSD
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'vmstat'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install vmstat
+
+## Usage
+
+Just require the library.
+
+	require "vmstat"
+
+### Memory
+
+	Vmstat.memory # => {...}
+
+The result might look like this:
+
+	{:pagesize=>4096,
+	 :wired=>668069,
+	 :active=>185474,
+	 :inactive=>546881,
+	 :free=>694851,
+	 :wired_bytes=>2240024576,
+	 :active_bytes=>2736410624,
+	 :inactive_bytes=>759701504,
+	 :free_bytes=>2846109696,
+	 :zero_filled=>176898850,
+	 :reactivated=>41013,
+	 :purgeable=>344211,
+	 :purged=>11580,
+	 :pageins=>2254222,
+	 :pageouts=>0,
+	 :faults=>204524839,
+	 :copy_on_write_faults=>14379007,
+	 :lookups=>2255061,
+	 :hits=>95}
+
+
+### Network Devices
+
+	Vmstat.network # => {...}
+
+The result might look like this:
+
+	{:lo0=>
+	  {:in_bytes=>9082607,
+	   :in_errors=>0,
+	   :in_drops=>0,
+	   :out_bytes=>9082607,
+	   :out_errors=>0,
+	   :type=>24},
+	 :gif0=>
+	  {:in_bytes=>0,
+	   :in_errors=>0,
+	   :in_drops=>0,
+	   :out_bytes=>0,
+	   :out_errors=>0,
+	   :type=>55},
+	 :stf0=>
+	  {:in_bytes=>0,
+	   :in_errors=>0,
+	   :in_drops=>0,
+	   :out_bytes=>0,
+	   :out_errors=>0,
+	   :type=>57},
+	 :en0=>
+	  {:in_bytes=>7108891975,
+	   :in_errors=>0,
+	   :in_drops=>0,
+	   :out_bytes=>479503412,
+	   :out_errors=>0,
+	   :type=>6},
+	 :p2p0=>
+	  {:in_bytes=>0,
+	   :in_errors=>0,
+	   :in_drops=>0,
+	   :out_bytes=>0,
+	   :out_errors=>0,
+	   :type=>6}}
+
+### CPU
+	
+	Vmstat.cpu # => [...]
+
+The result might look like this, depending on the number of cpus:
+
+	[{:user=>297003, :system=>475804, :nice=>0, :idle=>11059640},
+	 {:user=>23349,  :system=>14186,  :nice=>0, :idle=>11792093},
+	 {:user=>247171, :system=>195309, :nice=>0, :idle=>11387262},
+	 {:user=>21783,  :system=>12823,  :nice=>0, :idle=>11794993},
+	 {:user=>221323, :system=>163723, :nice=>0, :idle=>11444653},
+	 {:user=>20608,  :system=>11808,  :nice=>0, :idle=>11797154},
+	 {:user=>195015, :system=>145772, :nice=>0, :idle=>11488869},
+	 {:user=>19793,  :system=>11077,  :nice=>0, :idle=>11798671}]
+
+### Load
+
+	Vmstat.load_avg #=> [0.35791015625, 0.4296875, 0.4609375]
+
+### Disk
+
+To get the disk data one can pass the mount point or the device name.
+
+	# like so
+	Vmstat.disk("/") # => {...}
+
+	# or so
+	Vmstat.disk("/dev/disk0s2") # => {...}
+
+The result looks like this:
+
+	{:type				=>	:devfs,
+	 :origin			=>	"devfs",
+	 :mount				=>	"/dev",
+	 :free_bytes		=>	0,
+	 :available_bytes	=>	0,
+	 :used_bytes		=>	192000,
+	 :total_bytes		=>	192000}
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,19 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'rspec/core/rake_task'
+
+Rake::ExtensionTask.new(:vmstat) do |ext|
+	ext.lib_dir = 'lib/vmstat'
+end
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Open an irb session preloaded with smartstat"
+task :console do
+  sh "irb -rubygems -I ./lib -r vmstat"
+end
+
+desc 'Default: run specs.'
+task :default => :spec

data/ext/vmstat/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile 'vmstat/vmstat'

data/ext/vmstat/vmstat.c

@@ -0,0 +1,282 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/sysctl.h>
+#include <net/if.h>
+#include <net/if_mib.h>
+#include <net/if_types.h>
+#include <sys/param.h>
+#include <sys/mount.h>
+#if defined(__APPLE__)
+#include <mach/mach.h>
+#endif
+#include <vmstat.h>
+
+void Init_vmstat() {
+  vmstat = rb_define_module("Vmstat");
+
+  rb_define_singleton_method(vmstat, "network", method_network, 0);
+  rb_define_singleton_method(vmstat, "cpu", method_cpu, 0);
+  rb_define_singleton_method(vmstat, "memory", method_memory, 0);
+  rb_define_singleton_method(vmstat, "disk", method_disk, 1);
+  rb_define_singleton_method(vmstat, "load_avg", method_load_avg, 0);
+  rb_define_singleton_method(vmstat, "boot_time", method_boot_time, 0);
+
+  // widely used symbols
+  SYM_TYPE = ID2SYM(rb_intern("type"));
+  SYM_FREE = ID2SYM(rb_intern("free"));
+
+  // network symbols
+  SYM_IN_BYTES = ID2SYM(rb_intern("in_bytes"));
+  SYM_IN_ERRORS = ID2SYM(rb_intern("in_errors"));
+  SYM_IN_DROPS = ID2SYM(rb_intern("in_drops"));
+  SYM_OUT_BYTES = ID2SYM(rb_intern("out_bytes"));
+  SYM_OUT_ERRORS = ID2SYM(rb_intern("out_errors"));
+
+  // cpu symbols
+  SYM_USER = ID2SYM(rb_intern("user"));
+  SYM_SYSTEM = ID2SYM(rb_intern("system"));
+  SYM_NICE = ID2SYM(rb_intern("nice"));
+  SYM_IDLE = ID2SYM(rb_intern("idle"));
+
+  // memory symbols
+  SYM_PAGESIZE = ID2SYM(rb_intern("pagesize"));
+  SYM_WIRED = ID2SYM(rb_intern("wired"));
+  SYM_ACTIVE = ID2SYM(rb_intern("active"));
+  SYM_INACTIVE = ID2SYM(rb_intern("inactive"));
+  SYM_WIRED_BYTES = ID2SYM(rb_intern("wired_bytes"));
+  SYM_ACTIVE_BYTES = ID2SYM(rb_intern("active_bytes"));
+  SYM_INACTIVE_BYTES = ID2SYM(rb_intern("inactive_bytes"));
+  SYM_FREE_BYTES = ID2SYM(rb_intern("free_bytes"));
+  SYM_ZERO_FILLED = ID2SYM(rb_intern("zero_filled"));
+  SYM_REACTIVATED = ID2SYM(rb_intern("reactivated"));
+  SYM_PURGEABLE = ID2SYM(rb_intern("purgeable"));
+  SYM_PURGED = ID2SYM(rb_intern("purged"));
+  SYM_PAGEINS = ID2SYM(rb_intern("pageins"));
+  SYM_PAGEOUTS = ID2SYM(rb_intern("pageouts"));
+  SYM_FAULTS = ID2SYM(rb_intern("faults"));
+  SYM_COW_FAULTS = ID2SYM(rb_intern("copy_on_write_faults"));
+  SYM_LOOKUPS = ID2SYM(rb_intern("lookups"));
+  SYM_HITS = ID2SYM(rb_intern("hits"));
+
+  // disk symbols
+  SYM_ORIGIN = ID2SYM(rb_intern("origin"));
+  SYM_MOUNT = ID2SYM(rb_intern("mount"));
+  SYM_AVAILABLE_BYTES = ID2SYM(rb_intern("available_bytes"));
+  SYM_USED_BYTES = ID2SYM(rb_intern("used_bytes"));
+  SYM_TOTAL_BYTES = ID2SYM(rb_intern("total_bytes"));
+}
+
+VALUE method_network(VALUE self) {
+  VALUE devices = rb_hash_new();
+  int i, err;
+  struct ifmibdata mibdata;
+  size_t len = sizeof(mibdata);
+  int ifmib_path[] = {
+    CTL_NET, PF_LINK, NETLINK_GENERIC, IFMIB_IFDATA, -1, IFDATA_GENERAL
+  };
+
+  for (i = 1, err = 0; err == 0; i++) {
+    ifmib_path[4] = i; // set the current row
+    err = sysctl(ifmib_path, 6, &mibdata, &len, NULL, 0);
+    if (err == 0) {
+      VALUE device = rb_hash_new();
+      rb_hash_aset(device, SYM_IN_BYTES, ULL2NUM(mibdata.ifmd_data.ifi_ibytes));
+      rb_hash_aset(device, SYM_IN_ERRORS, ULL2NUM(mibdata.ifmd_data.ifi_ierrors));
+      rb_hash_aset(device, SYM_IN_DROPS, ULL2NUM(mibdata.ifmd_data.ifi_iqdrops));
+      rb_hash_aset(device, SYM_OUT_BYTES, ULL2NUM(mibdata.ifmd_data.ifi_obytes));
+      rb_hash_aset(device, SYM_OUT_ERRORS, ULL2NUM(mibdata.ifmd_data.ifi_oerrors));
+      rb_hash_aset(device, SYM_TYPE, ULL2NUM(mibdata.ifmd_data.ifi_type));
+      rb_hash_aset(devices, ID2SYM(rb_intern(mibdata.ifmd_name)), device);
+    }
+  }
+
+  return devices;
+}
+
+#if defined(__APPLE__)
+VALUE method_cpu(VALUE self) {
+  VALUE cpus = rb_ary_new();
+  processor_info_array_t cpuInfo;
+  mach_msg_type_number_t numCpuInfo;
+  natural_t numCPUsU = 0U;
+  kern_return_t err = host_processor_info(mach_host_self(),
+    PROCESSOR_CPU_LOAD_INFO, &numCPUsU, &cpuInfo, &numCpuInfo);
+
+  if(err == KERN_SUCCESS) {
+    for(unsigned i = 0U; i < numCPUsU; ++i) {
+      VALUE cpu = rb_hash_new();
+      int pos = CPU_STATE_MAX * i;
+      rb_hash_aset(cpu, SYM_USER, ULL2NUM(cpuInfo[pos + CPU_STATE_USER]));
+      rb_hash_aset(cpu, SYM_SYSTEM, ULL2NUM(cpuInfo[pos + CPU_STATE_SYSTEM]));
+      rb_hash_aset(cpu, SYM_NICE, ULL2NUM(cpuInfo[pos + CPU_STATE_NICE]));
+      rb_hash_aset(cpu, SYM_IDLE, ULL2NUM(cpuInfo[pos + CPU_STATE_IDLE]));
+      rb_ary_push(cpus, cpu);
+    }
+  }
+  
+  return cpus;
+}
+
+VALUE method_memory(VALUE self) {
+  VALUE memory = Qnil;
+  vm_size_t pagesize;
+  uint host_count = HOST_VM_INFO_COUNT;
+  kern_return_t err;
+  vm_statistics_data_t vm_stat;
+  
+  err = host_page_size(mach_host_self(), &pagesize);
+  if (err == KERN_SUCCESS) {
+    err = host_statistics(mach_host_self(), HOST_VM_INFO,
+                          (host_info_t)&vm_stat, &host_count);
+    if (err == KERN_SUCCESS) {
+      memory = rb_hash_new();
+      rb_hash_aset(memory, SYM_PAGESIZE, ULL2NUM(pagesize));
+      rb_hash_aset(memory, SYM_WIRED, ULL2NUM(vm_stat.active_count));
+      rb_hash_aset(memory, SYM_ACTIVE, ULL2NUM(vm_stat.inactive_count));
+      rb_hash_aset(memory, SYM_INACTIVE, ULL2NUM(vm_stat.wire_count));
+      rb_hash_aset(memory, SYM_FREE, ULL2NUM(vm_stat.free_count));
+      rb_hash_aset(memory, SYM_WIRED_BYTES, ULL2NUM(vm_stat.wire_count * pagesize));
+      rb_hash_aset(memory, SYM_ACTIVE_BYTES, ULL2NUM(vm_stat.active_count * pagesize));
+      rb_hash_aset(memory, SYM_INACTIVE_BYTES, ULL2NUM(vm_stat.inactive_count * pagesize));
+      rb_hash_aset(memory, SYM_FREE_BYTES, ULL2NUM(vm_stat.free_count * pagesize));
+      rb_hash_aset(memory, SYM_ZERO_FILLED, ULL2NUM(vm_stat.zero_fill_count));
+      rb_hash_aset(memory, SYM_REACTIVATED, ULL2NUM(vm_stat.reactivations));
+      rb_hash_aset(memory, SYM_PURGEABLE, ULL2NUM(vm_stat.purgeable_count));
+      rb_hash_aset(memory, SYM_PURGED, ULL2NUM(vm_stat.purges));
+      rb_hash_aset(memory, SYM_PAGEINS, ULL2NUM(vm_stat.pageins));
+      rb_hash_aset(memory, SYM_PAGEOUTS, ULL2NUM(vm_stat.pageouts));
+      rb_hash_aset(memory, SYM_FAULTS, ULL2NUM(vm_stat.faults));
+      rb_hash_aset(memory, SYM_COW_FAULTS, ULL2NUM(vm_stat.cow_faults));
+      rb_hash_aset(memory, SYM_LOOKUPS, ULL2NUM(vm_stat.lookups));
+      rb_hash_aset(memory, SYM_HITS, ULL2NUM(vm_stat.hits));
+    }
+  }
+  
+  return memory;
+}
+#elif __linux
+    // linux
+#elif __unix // all unices not caught above
+typedef struct {
+  long user;
+  long nice;
+  long system;
+  long intr;
+  long idle;
+} cpu_time_t;
+
+VALUE method_cpu(VALUE self) {
+  VALUE cpus = rb_ary_new();
+  int cpu_count = system_int("hw.ncpu");
+  size_t len = sizeof(cpu_time_t) * cpu_count;
+  cpu_time_t * cp_times = ALLOC_N(cpu_time_t, cpu_count);
+  int i;
+  
+  if (sysctlbyname("kern.cp_times", cp_times, &len, NULL, 0) == 0) {
+    for (i = 0; i < cpu_count; i++) {
+      VALUE cpu = rb_hash_new();
+      cpu_time_t cp_time = cp_times[i];
+      rb_hash_aset(cpu, SYM_USER, LONG2NUM(cp_time.user));
+      rb_hash_aset(cpu, SYM_SYSTEM, LONG2NUM(cp_time.system + cp_time.intr));
+      rb_hash_aset(cpu, SYM_NICE, LONG2NUM(cp_time.nice));
+      rb_hash_aset(cpu, SYM_IDLE, LONG2NUM(cp_time.idle));
+      rb_ary_push(cpus, cpu);
+    }
+  }
+  free(cp_times);
+  
+  return cpus;
+}
+
+VALUE method_memory(VALUE self) {
+  VALUE memory = rb_hash_new();
+  unsigned long long pagesize = system_ull("vm.stats.vm.v_page_size");
+
+  rb_hash_aset(memory, SYM_PAGESIZE, ULL2NUM(pagesize));
+  rb_hash_aset(memory, SYM_WIRED, ULL2NUM(system_ull("vm.stats.vm.v_inactive_count")));
+  rb_hash_aset(memory, SYM_ACTIVE, ULL2NUM(system_ull("vm.stats.vm.v_active_count")));
+  rb_hash_aset(memory, SYM_INACTIVE, ULL2NUM(system_ull("vm.stats.vm.v_wire_count")));
+  rb_hash_aset(memory, SYM_FREE, ULL2NUM(system_ull("vm.stats.vm.v_free_count")));
+  rb_hash_aset(memory, SYM_WIRED_BYTES, ULL2NUM((system_ull("vm.stats.vm.v_cache_count") +
+                                                 system_ull("vm.stats.vm.v_wire_count")) * pagesize));
+  rb_hash_aset(memory, SYM_ACTIVE_BYTES, ULL2NUM(system_ull("vm.stats.vm.v_active_count") * pagesize));
+  rb_hash_aset(memory, SYM_INACTIVE_BYTES, ULL2NUM(system_ull("vm.stats.vm.v_inactive_count") * pagesize));
+  rb_hash_aset(memory, SYM_FREE_BYTES, ULL2NUM(system_ull("vm.stats.vm.v_free_count") * pagesize));
+  rb_hash_aset(memory, SYM_ZERO_FILLED, ULL2NUM(system_ull("vm.stats.misc.zero_page_count")));
+  rb_hash_aset(memory, SYM_REACTIVATED, ULL2NUM(system_ull("vm.stats.vm.v_reactivated")));
+  rb_hash_aset(memory, SYM_PURGEABLE, Qnil);
+  rb_hash_aset(memory, SYM_PURGED, Qnil);
+  rb_hash_aset(memory, SYM_PAGEINS, Qnil);
+  rb_hash_aset(memory, SYM_PAGEOUTS, Qnil);
+  rb_hash_aset(memory, SYM_FAULTS, ULL2NUM(system_ull("vm.stats.vm.v_vm_faults")));
+  rb_hash_aset(memory, SYM_COW_FAULTS, ULL2NUM(system_ull("vm.stats.vm.v_cow_faults")));
+  rb_hash_aset(memory, SYM_LOOKUPS, Qnil);
+  rb_hash_aset(memory, SYM_HITS, Qnil);
+  
+  return memory;
+}
+#elif __posix
+    // POSIX
+#endif
+
+VALUE method_disk(VALUE self, VALUE path) {
+  VALUE disk = Qnil;
+  struct statfs stat;
+
+  if (statfs(StringValueCStr(path), &stat) != -1) {
+    disk = rb_hash_new();
+    rb_hash_aset(disk, SYM_TYPE, ID2SYM(rb_intern(stat.f_fstypename)));
+    rb_hash_aset(disk, SYM_ORIGIN, rb_str_new(stat.f_mntfromname, strlen(stat.f_mntfromname)));
+    rb_hash_aset(disk, SYM_MOUNT, rb_str_new(stat.f_mntonname, strlen(stat.f_mntonname)));
+    rb_hash_aset(disk, SYM_FREE_BYTES, ULL2NUM(stat.f_bfree * stat.f_bsize));
+    rb_hash_aset(disk, SYM_AVAILABLE_BYTES, ULL2NUM(stat.f_bavail * stat.f_bsize));
+    rb_hash_aset(disk, SYM_USED_BYTES, ULL2NUM((stat.f_blocks - stat.f_bfree) * stat.f_bsize));
+    rb_hash_aset(disk, SYM_TOTAL_BYTES, ULL2NUM(stat.f_blocks * stat.f_bsize));
+  }
+
+  return disk;
+}
+
+#define AVGCOUNT 3
+VALUE method_load_avg(VALUE self) {
+  VALUE loads = rb_ary_new();
+  double loadavg[AVGCOUNT];
+  int i;
+
+  getloadavg(&loadavg[0], AVGCOUNT);
+  for(i = 0; i < AVGCOUNT; i++) {
+    rb_ary_push(loads, rb_float_new(loadavg[i]));
+  }
+
+  return loads;
+}
+
+VALUE method_boot_time(VALUE self) {
+  struct timeval tv;
+  size_t size = sizeof(tv);
+  static int which[] = { CTL_KERN, KERN_BOOTTIME };
+
+  if (sysctl(which, 2, &tv, &size, NULL, 0) == 0) {
+    return rb_time_new(tv.tv_sec, tv.tv_usec);
+  } else {
+    return Qnil;
+  }
+}
+
+int system_int(const char * name) {
+  int number;
+  size_t number_size = sizeof(number);
+  sysctlbyname(name, &number, &number_size, NULL, 0);
+  return number;
+}
+
+unsigned long long system_ull(const char * name) {
+  long number;
+  size_t number_size = sizeof(number);
+  if (sysctlbyname(name, &number, &number_size, NULL, 0) == -1) {
+    perror("sysctlbyname");
+    return -1;
+  } else {
+    return number;
+  }
+}

data/ext/vmstat/vmstat.h

@@ -0,0 +1,22 @@
+#include <ruby.h>
+
+VALUE vmstat = Qnil;
+VALUE vmstat_hardware = Qnil;
+VALUE method_network(VALUE self);
+VALUE method_cpu(VALUE self);
+VALUE method_memory(VALUE self);
+VALUE method_disk(VALUE self, VALUE path);
+VALUE method_load_avg(VALUE self);
+VALUE method_boot_time(VALUE self);
+
+int system_int(const char *);
+unsigned long long system_ull(const char *);
+
+VALUE SYM_TYPE, SYM_FREE, SYM_FREE_BYTES;
+VALUE SYM_IN_BYTES, SYM_IN_ERRORS, SYM_IN_DROPS, SYM_OUT_BYTES, SYM_OUT_ERRORS;
+VALUE SYM_USER, SYM_SYSTEM, SYM_NICE, SYM_IDLE;
+VALUE SYM_ORIGIN, SYM_MOUNT, SYM_AVAILABLE_BYTES, SYM_TOTAL_BYTES, SYM_USED_BYTES;
+VALUE SYM_PAGESIZE, SYM_WIRED, SYM_ACTIVE, SYM_INACTIVE, SYM_ZERO_FILLED,
+      SYM_REACTIVATED, SYM_PURGEABLE, SYM_PURGED, SYM_PAGEINS, SYM_PAGEOUTS,
+      SYM_FAULTS, SYM_COW_FAULTS, SYM_LOOKUPS, SYM_HITS, SYM_WIRED_BYTES,
+      SYM_ACTIVE_BYTES, SYM_INACTIVE_BYTES;

data/lib/vmstat.rb

@@ -0,0 +1,50 @@
+require "vmstat/version"
+require "vmstat/vmstat" # native lib
+
+module Vmstat
+  # The type of ethernet devices on freebsd/mac os x
+  ETHERNET_TYPE = 0x06
+
+  # The type of loopback devices on freebsd/mac os x
+  LOOPBACK_TYPE = 0x18
+
+  # Filters all available ethernet devices.
+  # @return [Hash<Symbol, Hash>] the ethernet device name and values
+  # @example
+  #   Vmstat.ethernet_devices # => { :en0 => {
+  #   #    :in_bytes=>7104874723,
+  #   #    :in_errors=>0,
+  #   #    :in_drops=>0,
+  #   #    :out_bytes=>478849502,
+  #   #    :out_errors=>0,
+  #   #    :type=>6},
+  #   #  :p2p0=> ...
+  def self.ethernet_devices
+    filter_devices ETHERNET_TYPE
+  end
+
+  # Filters all available loopback devices.
+  # @return [Hash<Symbol, Hash>] the loopback device name and values
+  # @example
+  #   Vmstat.loopback_devices # => { :lo0 => { 
+  #   # :in_bytes=>6935997,
+  #   # :in_errors=>0,
+  #   # :in_drops=>0,
+  #   # :out_bytes=>6935997,
+  #   # :out_errors=>0,
+  #   # :type=>24
+  #   # }}
+  def self.loopback_devices
+    filter_devices LOOPBACK_TYPE
+  end
+
+  # A method to filter the devices.
+  # @param [Fixnum] type the type to filter for
+  # @return [Hash<Symbol, Hash>] the filtered device name and values
+  # @api private
+  def self.filter_devices(type)
+    network.select do |name, attrbutes|
+      attrbutes[:type] == type
+    end
+  end
+end

data/lib/vmstat/version.rb

@@ -0,0 +1,3 @@
+module Vmstat
+  VERSION = "0.1.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+$:.unshift(File.expand_path("../lib", __FILE__))
+require 'vmstat'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/vmstat_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Vmstat do
+  context "#network" do
+    let(:network) { Vmstat.network }
+
+    it "should return the enthernet and loopback network data as hash" do
+      network.should be_a(Hash)
+    end
+
+    context "loopback device" do
+      let(:loopback) { network[:lo0] }
+      subject { loopback }
+
+      it "should contain the a loopback device info also as a hash" do
+        should be_a(Hash)
+      end
+
+      context "keys" do
+        it { should have_key(:in_bytes) }
+        it { should have_key(:out_bytes) }
+        it { should have_key(:in_errors) }
+        it { should have_key(:out_errors) }
+        it { should have_key(:in_drops) }
+        it { should have_key(:type) }
+      end
+
+      context "type" do
+        subject { OpenStruct.new loopback }
+
+        its(:in_bytes) { should be_a_kind_of(Numeric) }
+        its(:out_bytes) { should be_a_kind_of(Numeric) }
+        its(:in_errors) { should be_a_kind_of(Numeric) }
+        its(:out_errors) { should be_a_kind_of(Numeric) }
+        its(:in_drops) { should be_a_kind_of(Numeric) }
+        its(:type) { should be_a_kind_of(Numeric) }
+      end
+    end
+  end
+
+  context "#cpu" do
+    let(:cpu) { Vmstat.cpu }
+
+    it "should return an array of ethernet information" do
+      cpu.should be_a(Array)
+    end
+
+    context "first cpu" do
+      let(:first_cpu) { cpu.first }
+      subject { first_cpu }
+
+      it "should return a hash containing per cpu information" do
+        should be_a(Hash)
+      end
+
+      context "keys" do
+        it { should have_key(:user) }
+        it { should have_key(:system) }
+        it { should have_key(:nice) }
+        it { should have_key(:idle) }
+      end
+
+      context "type" do
+        subject { OpenStruct.new first_cpu }
+
+        its(:user) { should be_a_kind_of(Numeric) }
+        its(:system) { should be_a_kind_of(Numeric) }
+        its(:nice) { should be_a_kind_of(Numeric) }
+        its(:idle) { should be_a_kind_of(Numeric) }
+      end
+    end
+  end
+
+  context "#memory" do
+    let(:memory) { Vmstat.memory }
+    subject { memory }
+
+    it "should be a hash of memory data" do
+      should be_a(Hash)
+    end
+
+    context "keys" do
+      it { should have_key(:pagesize) }
+      it { should have_key(:wired) }
+      it { should have_key(:active) }
+      it { should have_key(:inactive) }
+      it { should have_key(:free) }
+      it { should have_key(:wired_bytes) }
+      it { should have_key(:active_bytes) }
+      it { should have_key(:inactive_bytes) }
+      it { should have_key(:free_bytes) }
+      it { should have_key(:zero_filled) }
+      it { should have_key(:reactivated) }
+      it { should have_key(:faults) }
+      it { should have_key(:copy_on_write_faults) }
+    end
+
+    context "type" do
+      subject { OpenStruct.new memory }
+
+      its(:pagesize) { should be_a_kind_of(Numeric) }
+      its(:wired) { should be_a_kind_of(Numeric) }
+      its(:active) { should be_a_kind_of(Numeric) }
+      its(:inactive) { should be_a_kind_of(Numeric) }
+      its(:free) { should be_a_kind_of(Numeric) }
+      its(:wired_bytes) { should be_a_kind_of(Numeric) }
+      its(:active_bytes) { should be_a_kind_of(Numeric) }
+      its(:inactive_bytes) { should be_a_kind_of(Numeric) }
+      its(:free_bytes) { should be_a_kind_of(Numeric) }
+      its(:zero_filled) { should be_a_kind_of(Numeric) }
+      its(:reactivated) { should be_a_kind_of(Numeric) }
+      its(:faults) { should be_a_kind_of(Numeric) }
+      its(:copy_on_write_faults) { should be_a_kind_of(Numeric) }
+    end
+  end
+
+  context "#disk" do
+    let(:disk) { Vmstat.disk("/") }
+    subject { disk }
+
+    it "should be a hash of disk data" do
+      should be_a(Hash)
+    end
+
+    context "keys" do
+      it { should have_key(:type) }
+      it { should have_key(:origin) }
+      it { should have_key(:mount) }
+      it { should have_key(:free_bytes) }
+      it { should have_key(:available_bytes) }
+      it { should have_key(:used_bytes) }
+      it { should have_key(:total_bytes) }
+    end
+    
+    context "type" do
+      subject { OpenStruct.new disk }
+
+      its(:type) { should be_a(Symbol) }
+      its(:origin) { should be_a(String) }
+      its(:mount) { should be_a(String) }
+      its(:free_bytes) { should be_a_kind_of(Numeric) }
+      its(:available_bytes) { should be_a_kind_of(Numeric) }
+      its(:used_bytes) { should be_a_kind_of(Numeric) }
+      its(:total_bytes) { should be_a_kind_of(Numeric) }
+    end
+  end
+
+  context "#load_avg" do
+    subject { Vmstat.load_avg }
+
+    it "should be an array" do
+      should be_a(Array)
+    end
+
+    it "should have three floats" do
+      subject[0].should be_a(Float)
+      subject[1].should be_a(Float)
+      subject[2].should be_a(Float)
+    end
+  end
+
+  context "#boot_time" do
+    let(:boot_time) { Vmstat.boot_time }
+
+    it "should be an array" do
+      boot_time.should be_a(Time)
+    end
+
+    it "has to be a time before now" do
+      boot_time.should < Time.now
+    end
+  end
+
+  context "#filter_devices" do
+    it "should filter ethernet devices" do
+      Vmstat.ethernet_devices.size.should == 2
+    end
+
+    it "should filter loopback devices" do
+      Vmstat.loopback_devices.size.should == 1
+    end
+  end
+end

data/vmstat.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vmstat/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "vmstat"
+  gem.version       = Vmstat::VERSION
+  gem.authors       = ["Vincent Landgraf"]
+  gem.email         = ["vilandgr@googlemail.com"]
+  gem.description   = %q{
+    A focused and fast library t gather memory, 
+    cpu, network, load avg and disk information
+  }
+  gem.summary       = %q{A focused and fast library t gather system information}
+  gem.homepage      = "http://threez.github.com/ruby-vmstat/"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.extensions    = ["ext/vmstat/extconf.rb"]
+
+  gem.add_development_dependency('rspec')
+  gem.add_development_dependency('rake-compiler')
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: vmstat
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Vincent Landgraf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! "\n    A focused and fast library t gather memory, \n    cpu, network,
+  load avg and disk information\n  "
+email:
+- vilandgr@googlemail.com
+executables: []
+extensions:
+- ext/vmstat/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/vmstat/extconf.rb
+- ext/vmstat/vmstat.c
+- ext/vmstat/vmstat.h
+- lib/vmstat.rb
+- lib/vmstat/version.rb
+- spec/spec_helper.rb
+- spec/vmstat_spec.rb
+- vmstat.gemspec
+homepage: http://threez.github.com/ruby-vmstat/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A focused and fast library t gather system information
+test_files:
+- spec/spec_helper.rb
+- spec/vmstat_spec.rb
+has_rdoc: