zerg_support 0.0.1 → 0.0.2

data/CHANGELOG

@@ -1 +1,3 @@
+v0.0.2. Process management.
+
 v0.0.1. Initial release. Support code for zerg* gem installation.

data/Manifest

@@ -1,8 +1,10 @@
+CHANGELOG
 lib/zerg_support/gems.rb
+lib/zerg_support/process.rb
 lib/zerg_support.rb
-test/test_gems.rb
-CHANGELOG
 LICENSE
-README
-Rakefile
 Manifest
+Rakefile
+README
+test/test_gems.rb
+test/test_process.rb

data/lib/zerg_support.rb

@@ -7,3 +7,4 @@ module Zerg::Support
 end
 
 require 'zerg_support/gems.rb'
+require 'zerg_support/process.rb'

data/lib/zerg_support/process.rb

@@ -0,0 +1,173 @@
+# process management
+# extends Base with process management features 
+
+require 'time'
+
+module Zerg::Support::Process
+  @@no_multiple_pids = false
+  
+  # Translates process info given by Sys::ProcTable into our own nicer format.
+  def self.xlate_process_info(low_info)
+    {
+      :pid => low_info.pid,
+      :parent_pid => low_info.ppid,
+      :real_uid => low_info.ruid || -1,
+      :real_gid => low_info.rgid || -1,
+      :start_time => low_info.start,
+      :nice => low_info.nice || 0,
+      :priority => low_info.priority || 0,
+      :syscall_priority => low_info.user_priority || 0,
+      :resident_size => low_info.id_rss || 0,
+      :code_size => low_info.ix_rss || 0,
+      :virtual_size => low_info.is_rss || 0,
+      :percent_cpu => low_info.pctcpu,
+      :percent_ram => low_info.pctmem,
+      :state => low_info.state,
+      :command_line => low_info.cmdline
+    }
+  end
+  
+  # Collects information about a single process. Returns nil 
+  def self.process_info(pid)
+    pinfo = Sys::ProcTable.ps pid
+    pinfo ? xlate_process_info(pinfo) : nil 
+  end
+  
+  # Collects information about processes with the given pids.
+  # Returns all processes if no list of pids is given.
+  def self.processes(pids = nil)
+    if @@no_multiple_pids and !pids.empty
+      pids.map { |pid| process_info pid }
+    else
+      begin
+        if pids
+          ps_result = Sys::ProcTable.ps(pids)
+        else
+          ps_result = Sys::ProcTable.ps
+        end
+        ps_result.map { |pinfo| xlate_process_info pinfo }
+      rescue TypeError
+        # we're using the real sys-proctable, and its ps doesn't like multiple
+        # arguments
+        @@no_multiple_pids = true
+        processes pids
+      end
+    end
+  end
+  
+  # Collects information about processes with the given pids.
+  # The information is returned indexed by the processes' pids.
+  def self.processes_by_id(pids = nil)
+    retval = {}
+    self.processes(pids).each { |pinfo| retval[pinfo[:pid]] = pinfo } 
+    return retval
+  end
+  
+  # Returns information about the descendants of the process with the given pid.
+  def self.process_tree(*root_pids)
+    procs_by_ppid = {}
+    proc_list = self.processes_by_id
+    proc_list.each do |pid, pinfo|
+      procs_by_ppid[pinfo[:parent_pid]] ||= []
+      procs_by_ppid[pinfo[:parent_pid]] << pinfo
+    end
+    
+    proc_queue = root_pids.map { |pid| proc_list[pid] }.select { |pinfo| pinfo }
+    
+    index = 0
+    while index < proc_queue.length
+      pid, index = proc_queue[index][:pid], index + 1
+      next unless procs_by_ppid.has_key? pid
+      proc_queue += procs_by_ppid[pid]
+    end
+    return proc_queue
+  end
+  
+  # Kills the process with the given pid.
+  def self.kill(pid)
+    begin
+      Process.kill "TERM", pid
+      Thread.new(pid) do |victim_pid|
+        Kernel.sleep 0.2
+        Process.kill "KILL", victim_pid
+      end
+    rescue
+      # we probably don't have the right to kill the process
+      print "#{$!.class.name}: #{$!}\n"
+    end    
+  end
+  
+  # Kills all the processes descending from the process with the given pid.
+  def self.kill_tree(root_pid)
+    self.process_tree(root_pid).each do |pinfo|
+      self.kill pinfo[:pid]
+    end
+  end
+end
+
+
+## Backend for process information listing
+
+begin
+  raise 'Use ps' unless RUBY_PLAYFORM =~ /win/ and RUBY_PLATFORM !~ /darwin/
+  require 'sys/proctable'
+rescue Exception
+  # Emulate the sys-proctable gem using the ps command.
+  # This will be slower than having native syscalls, but at least it doesn't
+  # crash ruby. (yes, sys-proctable 0.7.6, I mean you!)
+  
+  #:nodoc: all
+  module Sys; end
+  
+  #:nodoc: all
+  module Sys::ProcTable
+    class ProcInfo
+      def initialize(pid, ppid, ruid, rgid, uid, gid, start, nice, rss, rssize,
+                     text_size, vsz, user_time, total_time, pctcpu, pctmem,
+                     priority, user_priority, state, cmdline)
+        @pid, @ppid, @ruid, @rgid, @uid, @gid, @nice, @priority,
+             @user_priority = *([pid, ppid, ruid, rgid, uid, gid, nice,
+                                 priority, user_priority].map { |s| s.to_i })
+        @start = Time.parse start
+        @ix_rss, @id_rss, @is_rss = text_size.to_f, rssize.to_f, vsz.to_f
+        @pctcpu, @pctmem = *([pctcpu, pctmem].map { |s| s.to_f })        
+        @cmdline = cmdline
+      end
+      attr_reader :pid, :ppid, :ruid, :rgid, :uid, :gid, :nice, :priority,
+                  :user_priority, :start, :ix_rss, :id_rss, :is_rss, :pctcpu,
+                  :pctmem, :state, :cmdline
+    end
+
+    @@ps_root_cmdline = 'ps -o pid,ppid,ruid,rgid,uid,gid' +
+                        ',lstart=STARTED+++++++++++++++++++++++++++++++++' +
+                        ',nice,rss,rssize,tsiz,vsz,utime,cputime,pcpu=%CPU+,' +
+                        ',pmem=%MEM+,pri,usrpri,state,command'
+                        
+    @@ps_all_cmdline = @@ps_root_cmdline + ' -A'
+    @@ps_some_cmdline = @@ps_root_cmdline + ' -p '
+
+    def self.ps(pid = nil)
+      pids = pid ? (pid.kind_of?(Enumerable) ? pid : [pid]) : []
+      retval = []
+      ps_cmdline = pids.empty? ? @@ps_all_cmdline :
+                                 @@ps_some_cmdline + pids.join(',')
+      ps_output = Kernel.` ps_cmdline
+      header_splits = nil
+      ps_output.each_line do |pline|
+        if header_splits
+          # result line, break it up
+          retval << ProcInfo.new(*(header_splits.map { |hs| pline[hs].strip }))
+        else
+          # first line, compute headers
+          lengths = pline.split(/\S\s/).map { |h| h.length + 2 }
+          header_splits, sum = [], 0
+          lengths.each_index do |i|
+            header_splits[i] = Range.new sum, sum += lengths[i], true
+          end
+          header_splits[-1] = Range.new header_splits[-1].begin, -1, false          
+        end
+      end
+      return pids.length == 1 ? retval.first : retval
+    end
+  end
+end

data/test/test_gems.rb

@@ -11,7 +11,7 @@ class TestGems < Test::Unit::TestCase
   end
   
   def test_source_is_manually_tested
-    golden_hash = 'f02b6c7852af883d60d4ec0c658928579e61f270'
+    golden_hash = '7fca02be12fb30415a492544d91f977e8de0e440'
     source_hash = hash_gems_file
     
     assert_equal golden_hash, source_hash, <<END_MESSAGE

data/test/test_process.rb

@@ -0,0 +1,68 @@
+require 'English'
+require 'test/unit'
+
+require 'zerg_support'
+
+class TestProcess < Test::Unit::TestCase
+  def test_process_info
+    info = Zerg::Support::Process.process_info($PID)
+    assert info, 'Failed to find current process'
+    
+    $ARGV.each do |arg|
+      assert info[:command_line].index(arg),
+             "Command line for current process does not contain argument #{arg}"
+    end
+  end
+  
+  def test_process_list_contains_current_process
+    list = Zerg::Support::Process.processes_by_id
+    
+    assert list[$PID], 'Process list does not contain current process'
+  end
+
+  # spawn 2^exp children, and their command lines will contain "cookie"
+  def spawn_sleepers(exp, cookie)
+    unless child_pid = fork
+      exp.times { fork }
+      exec 'ruby', '-e', 'sleep 100', '--', cookie
+    end
+    sleep 0.5
+    return child_pid
+  end
+  
+  def now_cookie
+    "zerg_test_#{Time.now.to_f}"
+  end
+  
+  def test_process_tree
+    cookie = now_cookie
+    root_pid = spawn_sleepers 3, cookie
+    
+    tree_processes = Zerg::Support::Process.process_tree root_pid    
+    assert_equal 8, tree_processes.length, 'Missed some processes'
+    assert tree_processes.all? { |info| info[:command_line].index cookie },
+           'Got the wrong processes'
+  end
+  
+  def test_kill
+    cookie = now_cookie
+    victim_pid = spawn_sleepers 0, cookie
+    
+    Zerg::Support::Process.kill victim_pid
+    sleep 0.5
+    processes = Zerg::Support::Process.processes
+    assert_equal nil, processes[victim_pid], 'Victim was not killed'
+  end
+  
+  def test_kill_tree
+    cookie = now_cookie
+    root_pid = spawn_sleepers 3, cookie
+     
+    Zerg::Support::Process.kill_tree root_pid
+    sleep 0.5
+    processes = Zerg::Support::Process.processes
+    escaped = processes.select { |info| info[:command_line].index cookie }
+    
+    assert_equal [], escaped, 'Some process(es) escaped'
+  end
+end

data/zerg_support.gemspec

@@ -1,30 +1,28 @@
-# -*- encoding: utf-8 -*-
-
 Gem::Specification.new do |s|
   s.name = %q{zerg_support}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Victor Costan"]
-  s.date = %q{2008-11-12}
+  s.date = %q{2008-11-13}
   s.description = %q{Support libraries used by the Zerg system.}
   s.email = %q{victor@zergling.net}
-  s.extra_rdoc_files = ["lib/zerg_support/gems.rb", "lib/zerg_support.rb", "CHANGELOG", "LICENSE", "README"]
-  s.files = ["lib/zerg_support/gems.rb", "lib/zerg_support.rb", "test/test_gems.rb", "CHANGELOG", "LICENSE", "README", "Rakefile", "Manifest", "zerg_support.gemspec"]
+  s.extra_rdoc_files = ["CHANGELOG", "lib/zerg_support/gems.rb", "lib/zerg_support/process.rb", "lib/zerg_support.rb", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "lib/zerg_support/gems.rb", "lib/zerg_support/process.rb", "lib/zerg_support.rb", "LICENSE", "Manifest", "Rakefile", "README", "test/test_gems.rb", "test/test_process.rb", "zerg_support.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{http://www.zergling.net}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Zerg_support", "--main", "README"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{rails-pwnage}
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.2.0}
   s.summary = %q{Support libraries used by the Zerg system.}
-  s.test_files = ["test/test_gems.rb"]
+  s.test_files = ["test/test_gems.rb", "test/test_process.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 2
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if current_version >= 3 then
       s.add_development_dependency(%q<echoe>, [">= 0"])
     else
       s.add_dependency(%q<echoe>, [">= 0"])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: zerg_support
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Victor Costan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-12 00:00:00 -05:00
+date: 2008-11-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -29,20 +29,23 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
+- CHANGELOG
 - lib/zerg_support/gems.rb
+- lib/zerg_support/process.rb
 - lib/zerg_support.rb
-- CHANGELOG
 - LICENSE
 - README
 files: 
+- CHANGELOG
 - lib/zerg_support/gems.rb
+- lib/zerg_support/process.rb
 - lib/zerg_support.rb
-- test/test_gems.rb
-- CHANGELOG
 - LICENSE
-- README
-- Rakefile
 - Manifest
+- Rakefile
+- README
+- test/test_gems.rb
+- test/test_process.rb
 - zerg_support.gemspec
 has_rdoc: true
 homepage: http://www.zergling.net
@@ -71,9 +74,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rails-pwnage
-rubygems_version: 1.3.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Support libraries used by the Zerg system.
 test_files: 
 - test/test_gems.rb
+- test/test_process.rb