vmstat 0.1.1 → 1.0.0

data/ext/vmstat/vmstat.h

@@ -1,22 +1,15 @@
 #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);
+#define AVGCOUNT 3
 
-int system_int(const char *);
-unsigned long long system_ull(const char *);
+VALUE vmstat = Qnil;
+VALUE vmstat_network_interfaces(VALUE self);
+VALUE vmstat_cpu(VALUE self);
+VALUE vmstat_memory(VALUE self);
+VALUE vmstat_disk(VALUE self, VALUE path);
+VALUE vmstat_load_average(VALUE self);
+VALUE vmstat_boot_time(VALUE self);
 
-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;
+#if defined(__APPLE__)
+VALUE vmstat_task(VALUE self);
+#endif

data/lib/vmstat.rb

@@ -1,50 +1,92 @@
 require "vmstat/version"
-require "vmstat/vmstat" # native lib
 
 module Vmstat
-  # The type of ethernet devices on freebsd/mac os x
-  ETHERNET_TYPE = 0x06
+  autoload :Cpu,              "vmstat/cpu"
+  autoload :NetworkInterface, "vmstat/network_interface"
+  autoload :Disk,             "vmstat/disk"
+  autoload :Memory,           "vmstat/memory"
+  autoload :Task,             "vmstat/task"
+  autoload :LoadAverage,      "vmstat/load_average"
+  autoload :Snapshot,         "vmstat/snapshot"
+
+  # Creates a full snapshot of the systems hardware statistics.
+  # @param [Array<String>] the paths to the disks to snapshot.
+  # @return [Vmstat::Snapshot] a snapshot of all statistics.
+  # @example
+  #   Vmstat.snapshot # => #<struct Vmstat::Snapshot ...>
+  def self.snapshot(paths = ["/"])
+    Snapshot.new(paths)
+  end
+
+  # Fetches the boot time of the system.
+  # @return [Time] the boot time as regular time object.
+  # @example
+  #   Vmstat.boot_time # => 2012-10-09 18:42:37 +0200
+  def self.boot_time
+    # implemented in native extension ...
+  end
+
+  # Fetches the cpu statistics (usage counter for user, nice, system and idle)
+  # @return [Array<Vmstat::Cpu>] the array of cpu counter
+  # @example
+  #   Vmstat.cpu # => [#<struct Vmstat::Cpu ...>, #<struct Vmstat::Cpu ...>]
+  def self.cpu
+    # implemented in native extension ...
+  end
+
+  # Fetches the usage data and other useful disk information for the given path.
+  # @param [String] path the path (mount point or device path) to the disk
+  # @return [Vmstat::Disk] the disk information
+  # @example
+  #   Vmstat.disk("/") # => #<struct Vmstat::Disk type=:hfs, ...>
+  def self.disk(path)
+    # implemented in native extension ...
+  end
+
+  # Fetches the load average for the current system.
+  # @return [Vmstat::LoadAverage] the load average data
+  # @example
+  #   Vmstat.load_average # => #<struct Vmstat::LoadAverage one_minute=...>
+  def self.load_average
+    # implemented in native extension ...
+  end
+
+  # Fetches the memory usage information.
+  # @return [Vmstat::Memory] the memory data like free, used und total.
+  # @example
+  #   Vmstat.memory # => #<struct Vmstat::Memory ...>
+  def self.memory
+    # implemented in native extension ...
+  end
+
+  # Fetches the information for all available network devices.
+  # @return [Array<Vmstat::NetworkInterface>] the network device information
+  # @example
+  #   Vmstat.network_interfaces # => [#<struct Vmstat::NetworkInterface ...>, ...]
+  def self.network_interfaces
+    # implemented in native extension ...
+  end
 
-  # The type of loopback devices on freebsd/mac os x
-  LOOPBACK_TYPE = 0x18
+  # Fetches time and memory usage for the current process.
+  # @note Currently only on Mac OS X
+  # @return [Array<Vmstat::Task>] the network device information
+  # @example
+  #   Vmstat.task # => #<struct Vmstat::Task ...>
+  def self.task
+    # implemented in native extension ...
+  end
 
   # 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=> ...
+  # @return [Array<NetworkInterface>] the ethernet devices
   def self.ethernet_devices
-    filter_devices ETHERNET_TYPE
+    network_interfaces.select(&:ethernet?)
   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
-  #   # }}
+  # @return [Array<NetworkInterface>] the loopback devices
   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
+    network_interfaces.select(&:loopback?)
   end
 end
+
+require "vmstat/vmstat" # native lib

data/lib/vmstat/cpu.rb

@@ -0,0 +1,4 @@
+module Vmstat
+  class Cpu < Struct.new(:num, :user, :system, :nice, :idle)
+  end
+end

data/lib/vmstat/disk.rb

@@ -0,0 +1,20 @@
+module Vmstat
+  class Disk < Struct.new(:type, :origin, :mount, :block_size, 
+                          :free_blocks, :available_blocks, :total_blocks)
+    def free_bytes
+      free_blocks * block_size
+    end
+
+    def available_bytes
+      available_blocks * block_size
+    end
+
+    def used_bytes
+      (total_blocks - free_blocks) * block_size
+    end
+
+    def total_bytes
+      total_blocks * block_size
+    end
+  end
+end

data/lib/vmstat/load_average.rb

@@ -0,0 +1,4 @@
+module Vmstat
+  class LoadAverage < Struct.new(:one_minute, :five_minutes, :fifteen_minutes)
+  end
+end

data/lib/vmstat/memory.rb

@@ -0,0 +1,24 @@
+module Vmstat
+  class Memory < Struct.new(:pagesize,
+                            :wired, :active, :inactive, :free,
+                            :pageins, :pageouts,
+                            :zero_filled, :reactivated, :purgeable,
+                            :purged, :faults,
+                            :copy_on_write_faults, :lookups, :hits)
+    def wired_bytes
+      wired *  pagesize
+    end
+
+    def active_bytes
+      active * pagesize
+    end
+
+    def inactive_bytes
+      inactive * pagesize
+    end
+
+    def free_bytes
+      free * pagesize
+    end
+  end
+end

data/lib/vmstat/network_interface.rb

@@ -0,0 +1,19 @@
+module Vmstat
+  class NetworkInterface < Struct.new(:name, :in_bytes, :in_errors, :in_drops,
+                                      :out_bytes, :out_errors, :type)
+
+    # 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
+
+    def loopback?
+      type == LOOPBACK_TYPE
+    end
+
+    def ethernet?
+      type == ETHERNET_TYPE
+    end
+  end
+end

data/lib/vmstat/snapshot.rb

@@ -0,0 +1,17 @@
+module Vmstat
+  class Snapshot
+    attr_reader :at, :boot_time, :cpu, :disks, :load_average,
+                :memory, :network_interfaces, :task
+
+    def initialize(paths = [])
+      @at = Time.now
+      @boot_time = Vmstat.boot_time
+      @cpu = Vmstat.cpu
+      @disks = paths.map { |path| Vmstat.disk(path) }
+      @load_average = Vmstat.load_average
+      @memory = Vmstat.memory
+      @network_interfaces = Vmstat.network_interfaces
+      @task = Vmstat.task
+    end
+  end
+end

data/lib/vmstat/task.rb

@@ -0,0 +1,6 @@
+module Vmstat
+  class Task < Struct.new(:suspend_count, :virtual_size, :resident_size,
+                          :user_time_ms, :system_time_ms)
+  end
+end
+ 

data/lib/vmstat/version.rb

@@ -1,3 +1,3 @@
 module Vmstat
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/spec/spec_helper.rb

@@ -6,6 +6,7 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 $:.unshift(File.expand_path("../lib", __FILE__))
 require 'vmstat'
+require 'ostruct'
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true

data/spec/vmstat/cpu_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Vmstat::Cpu do
+  context "Vmstat#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 vmstat cpu object" do
+        should be_a(Vmstat::Cpu)
+      end
+
+      context "methods" do
+        it { should respond_to(:user) }
+        it { should respond_to(:system) }
+        it { should respond_to(:nice) }
+        it { should respond_to(:idle) }
+      end
+
+      context "content" do
+        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
+end

data/spec/vmstat/disk_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Vmstat::Disk do
+  context "Vmstat#disk" do
+    let(:disk) { Vmstat.disk("/") }
+    subject { disk }
+
+    it "should be a vmstat disk object" do
+      should be_a(Vmstat::Disk)
+    end
+
+    context "methods" do
+      it { should respond_to(:type) }
+      it { should respond_to(:origin) }
+      it { should respond_to(:mount) }
+      it { should respond_to(:free_bytes) }
+      it { should respond_to(:available_bytes) }
+      it { should respond_to(:used_bytes) }
+      it { should respond_to(:total_bytes) }
+    end
+    
+    context "content" do
+      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
+end

data/spec/vmstat/load_average_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Vmstat::LoadAverage do
+  context "Vmstat#load_average" do
+    subject { Vmstat.load_average }
+
+    it "should be an vmstat load average object" do
+      should be_a(Vmstat::LoadAverage)
+    end
+
+    context "methods" do
+      it { should respond_to(:one_minute) }
+      it { should respond_to(:five_minutes) }
+      it { should respond_to(:fifteen_minutes) }
+    end
+
+    context "content" do
+      its(:one_minute) { should be_a(Float) }
+      its(:five_minutes) { should be_a(Float) }
+      its(:fifteen_minutes) { should be_a(Float) }
+    end
+  end
+end

data/spec/vmstat/memory_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Vmstat::Memory do
+  context "Vmstat#memory" do
+    let(:memory) { Vmstat.memory }
+    subject { memory }
+
+    it "should be a vmstat memory object" do
+      should be_a(Vmstat::Memory)
+    end
+
+    context "methods" do
+      it { should respond_to(:pagesize) }
+      it { should respond_to(:wired) }
+      it { should respond_to(:active) }
+      it { should respond_to(:inactive) }
+      it { should respond_to(:free) }
+      it { should respond_to(:wired_bytes) }
+      it { should respond_to(:active_bytes) }
+      it { should respond_to(:inactive_bytes) }
+      it { should respond_to(:free_bytes) }
+      it { should respond_to(:zero_filled) }
+      it { should respond_to(:reactivated) }
+      it { should respond_to(:faults) }
+      it { should respond_to(:copy_on_write_faults) }
+    end
+
+    context "content" do
+      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
+end

data/spec/vmstat/network_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Vmstat::NetworkInterface do
+  context "Vmstat#network" do
+    let(:network) { Vmstat.network_interfaces }
+
+    it "should return the enthernet and loopback network data as an array" do
+      network.should be_a(Array)
+    end
+
+    context "loopback device" do
+      let(:loopback) { network.find { |interface| interface.loopback? } }
+      subject { loopback }
+
+      it "should be a vmstat network interface object" do
+        should be_a(Vmstat::NetworkInterface)
+      end
+
+      context "methods" do
+        it { should respond_to(:in_bytes) }
+        it { should respond_to(:out_bytes) }
+        it { should respond_to(:in_errors) }
+        it { should respond_to(:out_errors) }
+        it { should respond_to(:in_drops) }
+        it { should respond_to(:type) }
+      end
+
+      context "content" do
+        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
+end