solaris-kstat 1.0.3 → 1.1.0

data/lib/solaris/kstat/functions.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), 'structs')
+
+module Solaris
+  module Functions
+    extend FFI::Library
+    ffi_lib :kstat
+
+    include Solaris::Structs
+
+    attach_function :kstat_chain_update, [KstatCtl], :int
+    attach_function :kstat_close, [KstatCtl], :int
+    attach_function :kstat_lookup, [KstatCtl, :string, :int, :string], KstatStruct.by_ref
+    attach_function :kstat_open, [], KstatCtl.by_ref
+    attach_function :kstat_read, [KstatCtl, KstatStruct, :pointer], :int
+
+    private :kstat_chain_update
+    private :kstat_close
+    private :kstat_lookup
+    private :kstat_open
+    private :kstat_read
+  end
+end

data/lib/solaris/kstat/structs.rb

@@ -0,0 +1,260 @@
+require 'ffi'
+
+module Solaris
+  module Structs
+    extend FFI::Library
+
+    class KstatCtl < FFI::Struct
+      layout(
+        :kc_chain_id, :int,
+        :kc_chain, :pointer,
+        :kc_kd, :int
+      )
+    end
+
+    class KstatStruct < FFI::Struct
+      layout(
+        :ks_crtime, :long_long,
+        :ks_next, :pointer,
+        :ks_kid, :int,
+        :ks_module, [:char, 31],
+        :ks_resv, :uchar,
+        :ks_instance, :int,
+        :ks_name, [:char, 31],
+        :ks_type, :uchar,
+        :ks_class, [:char, 31],
+        :ks_flags, :uchar,
+        :ks_data, :pointer,
+        :ks_ndata, :uint,
+        :ks_data_size, :ulong,
+        :ks_snaptime, :long_long,
+        :ks_update, :int,
+        :ks_private, :pointer,
+        :ks_snapshot, :int,
+        :ks_lock, :pointer,
+      )
+    end
+
+    class Addr < FFI::Union
+      layout(
+        :ptr, :pointer,
+        :ptr32, :int32_t,
+        :pad, [:char, 8]
+      )
+    end
+
+    class Str < FFI::Struct
+      layout(:union, Addr, :len, :uint32_t)
+    end
+
+    class Value < FFI::Union
+      layout(
+        :c, [:char, 16],
+        :i32, :int32_t,
+        :ui32, :uint32_t,
+        :str, Str,
+        :i64, :int64_t,
+        :ui64, :uint64_t,
+        :l, :long,
+        :ul, :ulong_t,
+        :ll, :longlong_t,
+        :ull, :ulong_long,
+        :f, :float,
+        :d, :double
+      )
+    end
+
+    class KstatNamed < FFI::Struct
+      layout(
+        :name, [:char, 31],
+        :data_type, :uchar_t,
+        :value, Value
+      )
+    end
+
+    class Vminfo < FFI::Struct
+      layout(
+        :freemem, :uint64_t,
+        :swap_resv, :uint64_t,
+        :swap_alloc, :uint64_t,
+        :swap_avail, :uint64_t,
+        :swap_free, :uint64_t,
+        :updates, :uint64_t
+      )
+    end
+
+    class Flushmeter < FFI::Struct
+      layout(
+        :f_ctx, :uint,
+        :f_segment, :uint,
+        :f_page, :uint,
+        :f_partial, :uint,
+        :f_usr, :uint,
+        :f_region, :uint
+      )
+    end
+
+    class NcStats < FFI::Struct
+      layout(
+        :hits, :int,
+        :misses, :int,
+        :enters, :int,
+        :dbl_enters, :int,
+        :long_enter, :int,
+        :long_look, :int,
+        :move_to_front, :int,
+        :purges, :int
+      )
+    end
+
+    class Sysinfo < FFI::Struct
+      layout(
+        :updates, :uint,
+        :runque, :uint,
+        :runocc, :uint,
+        :swpque, :uint,
+        :swpocc, :uint,
+        :waiting, :uint
+      )
+    end
+
+    class Var < FFI::Struct
+      layout(
+        :v_buf,       :int,
+        :v_call,      :int,
+        :v_proc,      :int,
+        :v_maxupttl,  :int,
+        :v_nglobpris, :int,
+        :v_maxsyspri, :int,
+        :v_clist,     :int,
+        :v_maxup,     :int,
+        :v_hbuf,      :int,
+        :v_hmask,     :int,
+        :v_pbuf,      :int,
+        :v_sptmap,    :int,
+        :v_maxpmem,   :int,
+        :v_autoup,    :int,
+        :v_bufhwm,    :int
+      )
+    end
+
+    class KstatIntr < FFI::Struct
+      layout(:intrs, [:uint, 5])
+    end
+
+    class KstatIo < FFI::Struct
+      layout(
+        :nread, :ulong_long,
+        :nwritten, :ulong_long,
+        :reads, :uint,
+        :writes, :uint,
+        :wtime, :long_long,
+        :wlentime, :long_long,
+        :wlastupdate, :long_long,
+        :rtime, :long_long,
+        :rlentime, :long_long,
+        :rlastupdate, :long_long,
+        :wcnt, :uint,
+        :rcnt, :uint
+      )
+    end
+
+    class KstatTimer < FFI::Struct
+      layout(
+        :name, [:char, 31],
+        :resv, :uchar,
+        :num_events, :ulong_long,
+        :elapsed_time, :long_long,
+        :min_time, :long_long,
+        :max_time, :long_long,
+        :start_time, :long_long,
+        :stop_time, :long_long
+      )
+    end
+
+    class CpuSysinfo < FFI::Struct
+      layout(
+        :cpu, [:uint_t, 4],
+        :wait, [:uint_t, 3],
+        :bread, :uint_t,
+        :bwrite, :uint_t,
+        :lread, :uint_t,
+        :lwrite, :uint_t,
+        :phread, :uint_t,
+        :phwrite, :uint_t,
+        :pswitch, :uint_t,
+        :trap, :uint_t,
+        :intr, :uint_t,
+        :syscall, :uint_t,
+        :sysread, :uint_t,
+        :syswrite, :uint_t,
+        :sysfork, :uint_t,
+        :sysvfork, :uint_t,
+        :sysexec, :uint_t,
+        :readch, :uint_t,
+        :writech, :uint_t,
+        :rcvint, :uint_t,
+        :xmtint, :uint_t,
+        :mdmint, :uint_t,
+        :rawch, :uint_t,
+        :canch, :uint_t,
+        :outch, :uint_t,
+        :msg, :uint_t,
+        :sema, :uint_t,
+        :namei, :uint_t,
+        :ufsiget, :uint_t,
+        :ufsdirblk, :uint_t,
+        :ufsipage, :uint_t,
+        :ufsinopage, :uint_t,
+        :inodeovf, :uint_t,
+        :fileovf, :uint_t,
+        :procovf, :uint_t,
+        :intrthread, :uint_t,
+        :intrblk, :uint_t,
+        :idlethread, :uint_t,
+        :inv_swtch, :uint_t,
+        :nthreads, :uint_t,
+        :cpumigrate, :uint_t,
+        :xcalls, :uint_t,
+        :mutex_adenters, :uint_t,
+        :rw_rdfails, :uint_t,
+        :rw_wrfails, :uint_t,
+        :modload, :uint_t,
+        :modunload, :uint_t,
+        :bawrite, :uint_t,
+        :rw_enters, :uint_t,
+        :win_uo_cnt, :uint_t,
+        :win_uu_cnt, :uint_t,
+        :win_so_cnt, :uint_t,
+        :win_su_cnt, :uint_t,
+        :win_suo_cnt, :uint_t
+      )
+    end
+
+    class MikStruct < FFI::Struct
+      layout(:srtt, :uint32_t, :deviate, :uint32_t, :rtxcur, :uint32_t)
+    end
+
+    class Mntinfo < FFI::Struct
+      layout(
+        :mik_proto, [:char, 128],
+        :mik_vers, :uint32_t,
+        :mik_flags, :uint_t,
+        :mik_secmod, :uint_t,
+        :mik_curread, :uint32_t,
+        :mik_curwrite, :uint32_t,
+        :mik_timeo, :int,
+        :mik_retrans, :int,
+        :mik_acregmin, :uint_t,
+        :mik_acregmax, :uint_t,
+        :mik_acdirmin, :uint_t,
+        :mik_acdirmax, :uint_t,
+        :mik_timers, [MikStruct, 4],
+        :mik_noresponse, :uint32_t,
+        :mik_failover, :uint32_t,
+        :mik_remap, :uint32_t,
+        :mik_curserver, [:char, 257]
+      )
+    end
+  end
+end

data/solaris-kstat.gemspec

@@ -2,25 +2,27 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'solaris-kstat'
-  spec.version    = '1.0.3'
+  spec.version    = '1.1.0'
   spec.author     = 'Daniel J. Berger'
   spec.license    = 'Artistic 2.0'
   spec.email      = 'djberg96@gmail.com'
-  spec.homepage   = 'http://www.rubyforge.org/projects/solarisutils'
+  spec.homepage   = 'https://github.com/djberg96/solaris-kstat'
   spec.summary    = 'Interface for the Solaris kstat library'
-  spec.test_file  = 'test/test_solaris_kstat.rb'
-  spec.extensions = ['ext/extconf.rb']
+  spec.test_files = Dir['test/*.rb']
   spec.files      = Dir['**/*'].reject{ |f| f.include?('git') }
 
   spec.rubyforge_project = 'solarisutils'
 
+  spec.add_dependency('ffi')
+
   spec.add_development_dependency('test-unit')
+  spec.add_development_dependency('mkmf-lite')
+  spec.add_development_dependency('rake')
 
   spec.extra_rdoc_files = [
     'README',
     'CHANGES',
     'MANIFEST',
-    'ext/solaris/rkstat.c'
   ]
 
   spec.description = <<-EOF

data/test/test_solaris_kstat.rb

@@ -1,15 +1,11 @@
-###############################################################################
+########################################################################
 # test_solaris_kstat.rb
 #
-# Test suite for the solaris-kstat Ruby library. You should run this via
-# the 'rake test' task.
-###############################################################################
-require 'rubygems'
-gem 'test-unit'
-
+# Test suite for the solaris-kstat Ruby library. You should run this
+# via the 'rake test' task.
+########################################################################
 require 'solaris/kstat'
-require 'test/unit'
-require 'set'
+require 'test-unit'
 include Solaris
 
 class TC_Solaris_Kstat < Test::Unit::TestCase
@@ -17,88 +13,124 @@ class TC_Solaris_Kstat < Test::Unit::TestCase
     @kstat = Kstat.new
   end
 
-  def test_version
-    assert_equal('1.0.3', Kstat::VERSION)
+  test "version number is set to the expected value" do
+    assert_equal('1.1.0', Kstat::VERSION)
   end
 
-  def test_name
+  test "name method basic functionality" do
     assert_respond_to(@kstat, :name)
-    assert_respond_to(@kstat, :name=)
-    assert_nil(@kstat.name)
     assert_nothing_raised{ @kstat.name }
+  end
+
+  test "name is nil by default" do
+    assert_nil(@kstat.name)
+  end
+
+  test "name= method basic functionality" do
+    assert_respond_to(@kstat, :name=)
     assert_nothing_raised{ @kstat.name = 'foo' }
   end
 
-  def test_module
+  test "name= method works as expected" do
+    assert_nothing_raised{ @kstat.name = 'cpu' }
+    assert_equal('cpu', @kstat.name)
+  end
+
+  test "module basic functionality" do
     assert_respond_to(@kstat, :module)
-    assert_respond_to(@kstat, :module=)
-    assert_nil(@kstat.module)
     assert_nothing_raised{ @kstat.module }
+  end
+
+  test "module is nil by default" do
+    assert_nil(@kstat.module)
+  end
+
+  test "module= method basic functionality" do
+    assert_respond_to(@kstat, :module=)
     assert_nothing_raised{ @kstat.module = 'bar' }
   end
 
-  def test_instance
+  test "module= method works as expected" do
+    assert_nothing_raised{ @kstat.module = 'bar' }
+    assert_equal('bar', @kstat.module)
+  end
+
+  test "instance method basic functionality" do
     assert_respond_to(@kstat, :instance)
-    assert_respond_to(@kstat, :instance=)
-    assert_nil(@kstat.instance)
     assert_nothing_raised{ @kstat.instance }
+  end
+
+  test "instance method is -1 by default" do
+    assert_equal(-1, @kstat.instance)
+  end
+
+  test "instance= method basic functionality" do
+    assert_respond_to(@kstat, :instance=)
     assert_nothing_raised{ @kstat.instance = 0 }
   end
 
-  def test_constructor_valid_values
-    assert_nothing_raised{ Kstat.new('cpu_info',0,'cpu_info0').record }
-    assert_nothing_raised{ Kstat.new(nil,0,'cpu_info0').record }
-    assert_nothing_raised{ Kstat.new('cpu_info',0,nil).record }
+  test "instance= method works as expected" do
+    assert_nothing_raised{ @kstat.instance = 0 }
+    assert_equal(0, @kstat.instance)
   end
 
-  def test_constructor_invalid_values
-    assert_raises(Kstat::Error){ Kstat.new('bogus').record }
-    assert_raises(Kstat::Error){ Kstat.new('cpu_info',99).record }
-    assert_raises(Kstat::Error){ Kstat.new('cpu_info',0,'bogus').record }
-    assert_raises(TypeError){ Kstat.new('cpu_info','x').record }
+  test "the module argument must be a string" do
+    assert_nothing_raised{ Kstat.new('cpu_info') }
+    assert_raise(TypeError){ Kstat.new(0) }
   end
 
-  def test_record_basic
+  test "the instance argument must be a number" do
+    assert_nothing_raised{ Kstat.new(nil, 0, nil) }
+    assert_raise(TypeError){ Kstat.new(nil, 'test', nil) }
+  end
+
+  test "the name argument must be a string" do
+    assert_nothing_raised{ Kstat.new('cpu_info', 0, 'cpu_info0') }
+    assert_raise(TypeError){ Kstat.new('cpu_info', 0, 0) }
+  end
+
+  test "record method basic functionality" do
     assert_respond_to(@kstat, :record)
+    assert_nothing_raised{ @kstat.record }
   end
 
-  def test_record_named
+  test "named record works as expected" do
     assert_nothing_raised{ @kstat.record['cpu_info'][0]['cpu_info0'] }
     assert_kind_of(Hash, @kstat.record['cpu_info'][0]['cpu_info0'])
   end
 
-  def test_record_io
+  test "io record works as expected" do
     assert_nothing_raised{ @kstat.record['nfs'][1]['nfs1'] }
     assert_kind_of(Hash, @kstat.record['nfs'][1]['nfs1'])
   end
 
-  def test_record_intr
+  test "intr record works as expected" do
     assert_nothing_raised{ @kstat.record['fd'][0]['fd0'] }
     assert_kind_of(Hash, @kstat.record['fd'][0]['fd0'])
   end
 
-  def test_record_raw_vminfo
-    keys = %w/class freemem swap_alloc swap_avail swap_free swap_resv/
+  test "raw vminfo record returns expected values" do
+    keys = %w[class freemem swap_alloc swap_avail swap_free swap_resv updates]
 
     assert_nothing_raised{ @kstat.record['unix'][0]['vminfo'] }
     assert_kind_of(Hash, @kstat.record['unix'][0]['vminfo'])
     assert_equal(keys, @kstat.record['unix'][0]['vminfo'].keys.sort)
   end
 
-  def test_record_raw_var
-    keys = %w/
+  test "raw var record returns expected values" do
+    keys = %w[
       class v_autoup v_buf v_bufhwm v_call v_clist v_hbuf v_hmask
       v_maxpmem v_maxsyspri v_maxup v_maxupttl v_nglobpris v_pbuf
       v_proc v_sptmap
-    /
+    ]
 
     assert_nothing_raised{ @kstat.record['unix'][0]['var'] }
     assert_kind_of(Hash, @kstat.record['unix'][0]['var'])
     assert_equal(keys,  @kstat.record['unix'][0]['var'].keys.sort)
   end
 
-  def test_record_raw_biostats
-    keys = %w/
+  test "raw biostats returns expected values" do
+    keys = %w[
       buffer_cache_hits
       buffer_cache_lookups
       buffers_locked_by_someone
@@ -106,15 +138,15 @@ class TC_Solaris_Kstat < Test::Unit::TestCase
       duplicate_buffers_found
       new_buffer_requests
       waits_for_buffer_allocs
-    /
+    ]
 
     assert_nothing_raised{ @kstat.record['unix'][0]['biostats'] }
     assert_kind_of([Hash, NilClass], @kstat.record['unix'][0]['biostats'])
     assert_equal(keys,  @kstat.record['unix'][0]['biostats'].keys.sort)
   end
 
-  def test_record_raw_cpu_stat
-    keys = %w/
+  test "raw cpu_stat returns expected values" do
+    keys = %w[
       class cpu_idle cpu_user cpu_kernel cpu_wait wait_io wait_swap
       wait_pio bread bwrite lread lwrite phread phwrite pswitch
       trap intr syscall sysread syswrite sysfork sysvfork sysexec
@@ -122,22 +154,20 @@ class TC_Solaris_Kstat < Test::Unit::TestCase
       sema namei ufsiget ufsdirblk ufsipage ufsinopage inodeovf
       fileovf procovf intrthread intrblk idlethread inv_swtch
       nthreads cpumigrate xcalls mutex_adenters rw_rdfails
-      rw_wrfails modload modunload bawrite
-    /
+      rw_wrfails modload modunload bawrite win_so_cnt win_su_cnt
+      win_suo_cnt win_uo_cnt win_uu_cnt rw_enters
+    ]
 
     assert_nothing_raised{ @kstat.record['cpu_stat'][0]['cpu_stat0'] }
     assert_kind_of(Hash, @kstat.record['cpu_stat'][0]['cpu_stat0'])
 
-    # Too big and difficult to sort manually - so use a Set
-    set1 = Set.new(keys)
-    set2 = Set.new(@kstat.record['cpu_stat'][0]['cpu_stat0'].keys)
-    diff = set1 - set2
-
-    assert_equal(set1,set2,'Diff was: #{diff.to_a}')
+    set1 = keys.sort
+    set2 = @kstat.record['cpu_stat'][0]['cpu_stat0'].keys.sort
+    assert_equal(set1, set2)
   end
 
-  def test_record_ncstats
-    keys = %w/
+  test "ncstats returns expected values" do
+    keys = %w[
       class
       dbl_enters
       enters
@@ -146,25 +176,29 @@ class TC_Solaris_Kstat < Test::Unit::TestCase
       long_look misses
       move_to_front
       purges
-    /
+    ]
 
     assert_nothing_raised{ @kstat.record['unix'][0]['ncstats'] }
     assert_kind_of(Hash, @kstat.record['unix'][0]['ncstats'])
     assert_equal(keys, @kstat.record['unix'][0]['ncstats'].keys.sort)
   end
 
-  def test_record_sysinfo
-    keys = %w/class runocc runque swpocc swpque updates waiting/
+  test "sysinfo works as expected" do
+    keys = %w[class runocc runque swpocc swpque updates waiting]
 
     assert_nothing_raised{ @kstat.record['unix'][0]['sysinfo'] }
     assert_kind_of(Hash, @kstat.record['unix'][0]['sysinfo'])
     assert_equal(keys, @kstat.record['unix'][0]['sysinfo'].keys.sort)
   end
 
-  def test_class_set
+  test "class key is set to expected value" do
     assert_equal("misc", @kstat.record['unix'][0]['sysinfo']['class'])
   end
 
+  test "ffi functions are private" do
+    assert_not_respond_to(Kstat, :kstat_open)
+  end
+
   def teardown
     @kstat = nil
   end