zerg_support 0.0.5 → 0.0.8

data/lib/zerg_support/spawn.rb

@@ -4,15 +4,68 @@ module Zerg::Support::Process
 end
 
 if RUBY_PLATFORM =~ /win/ and RUBY_PLATFORM !~ /darwin/
-  require 'win32-process'
+  require 'win32/process'
 
   #:nodoc: all
   module Zerg::Support::Process
     def self.spawn(binary, args = [], options = {})
-      info = Process.create :app_name => binary,
+      # command line processing
+      command_line = '"' + binary + '" "' +
+          args.map { |a| a.gsub '"', '""' }.join('" "') + '"'
+      
+      # environment processing
+      environment_string = nil
+      if options[:env]
+        if options[:unsetenv_others]
+          environment = options[:env]
+        else
+          environment = Hash.new.merge(ENV).merge(options[:env])
+        end
+        environment_string = environment.keys.sort.
+            map { |k| "#{k}=#{environment[k]}" }.join "\0"
+        environment_string << "\0"
+      end
+      
+      # redirection processing
+      startup_info = {}
+      files = {}
+      stream_files = {}
+      deferred_opens = []
+      [[STDIN, :stdin], [STDOUT, :stdout], [STDERR, :stderr]].each do |pair|
+        next unless options[pair.first]
+        if options[pair.first].kind_of? String
+          filename = options[pair.first]
+          files[filename] ||= File.open(filename,
+                                        (pair.last == :stdin) ? 'r' : 'w+')
+          startup_info[pair.last] = files[filename]
+          stream_files[pair.first] = files[filename]
+        else
+          deferred_opens << Kernel.proc do
+            io = stream_files[options[pair.first]] || pair.first
+            startup_info[pair.last] = stream_files[pair.first] = io
+          end
+        end
+      end
+      deferred_opens.each { |d| d.call }
+      
+      # process leader
+      creation_flags = 0
+      if options[:pgroup]
+        creation_flags |= Process::DETACHED_PROCESS
+        if options[:pgroup].kind_of? Numeric and options[:pgroup] > 0
+          # TODO: what now?
+        else
+          creation_flags |= Process::CREATE_NEW_PROCESS_GROUP
+        end
+      end
+      
+      info = Process.create :command_line => command_line,
                             :cwd => options[:chdir] || Dir.pwd,
-                            :environment => options[:env],
-                            :creation_flags => 0
+                            :environment => environment_string,
+                            :creation_flags => creation_flags,
+                            :startup_info => startup_info                            
+      files.each { |name, io| io.close }
+      
       return info[:process_id]
     end
   end
@@ -109,12 +162,18 @@ module Zerg::Support::Process::Helpers
   # Performs IO redirections according to the given options. The options
   # follow the convention of Kernel.spawn in ruby1.9
   def self.do_redirects(options)
+    redirected_files = {}
     file_redirects = []
     fd_redirects = []
     options.each do |key, value|
       next unless key.kind_of? IO
       if value.kind_of? String
-        file_redirects << [key, value]
+        if redirected_files[value]
+          fd_redirects << [key, redirected_files[value]]
+        else
+          file_redirects << [key, value]
+          redirected_files[value] = key
+        end
       else
         fd_redirects << [key, value]
       end
@@ -123,4 +182,4 @@ module Zerg::Support::Process::Helpers
       r.first.reopen r.last
     end
   end
-end
+end

data/lib/zerg_support.rb

@@ -6,6 +6,16 @@ end
 module Zerg::Support
 end
 
+require 'rubygems'
 require 'zerg_support/gems.rb'
 require 'zerg_support/process.rb'
+require 'zerg_support/open_ssh.rb'
 require 'zerg_support/spawn.rb'
+
+# TODO(victor): document this
+module Zerg::Support::EventMachine  
+end
+
+require 'zerg_support/event_machine/connection_mocks.rb'
+require 'zerg_support/event_machine/frame_protocol.rb'
+require 'zerg_support/event_machine/object_protocol.rb'

data/test/fork_tree.rb

@@ -0,0 +1,34 @@
+# Used in test_process.rb to produce a tree of children.
+# Usage:
+#   ruby test/fork_tree.rb level interval cookie
+# Arguments:
+#   level - the fork level; 0 means don't fork, otherwise fork two children
+#           with fork level-1
+#   interval - the time to sleep (in seconds)
+#   cookie - an argument that's preserved to help track down the process
+#            also, the PID will be written to cookie.pid unless the file already
+#            exists (this means that only the fork tree's root writes it)
+
+require 'English'
+
+# extract arguments
+level = ARGV[1].to_i
+interval = ARGV[2].to_f
+cookie = ARGV[3]
+
+# write PID file
+pid_file = cookie + ".pid"
+unless File.exist? pid_file
+  File.open(pid_file, "w") { |f| f.write $PID.to_s }
+end
+
+# spawn children
+unless level == 0
+  2.times do
+    Thread.new do
+      system "ruby test/fork_tree.rb -- #{level - 1} #{interval} #{cookie}"
+    end
+  end 
+end
+
+sleep interval

data/test/test_connection_mocks.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+
+require 'zerg_support'
+
+require 'rubygems'
+require 'flexmock/test_unit'
+
+class HollowReceiveMock < Zerg::Support::EventMachine::ReceiveMock
+end
+
+# Collects groups of 3 letters, stores them into idenity hashes.
+class ReceiveFooMock < Zerg::Support::EventMachine::ReceiveMock
+  object_name :foo
+  
+  def receive_data(data)
+    @s ||= ''
+    data.each_byte do |c|
+      @s << c
+      if @s.length == 3
+        receive_foo @s => @s
+        @s = ''
+      end
+    end
+  end
+end
+
+class ConnectionMocksTest < Test::Unit::TestCase
+  def test_send_mock
+    send_mock = Zerg::Support::EventMachine::SendMock.new    
+    assert_equal send_mock.string, ''
+    
+    send_mock.send_data('a')
+    assert_equal send_mock.string, 'a'
+
+    send_mock.send_data('bcd')
+    assert_equal send_mock.string, 'abcd'
+
+    send_mock.send_data('em')
+    assert_equal send_mock.string, 'abcdem'
+  end
+  
+  def test_receive_mock_calls_recieve_data
+    recv_mock = HollowReceiveMock.new ['a', 'bcd', 'em']
+    flexmock(recv_mock).should_receive(:receive_data).with('a').once
+    flexmock(recv_mock).should_receive(:receive_data).with('bcd').once
+    flexmock(recv_mock).should_receive(:receive_data).with('em').once
+    recv_mock.replay
+  end
+  
+  def test_receive_mock_collects_objects
+    foos = ReceiveFooMock.new(['a', 'bcd', 'emx']).replay.foos
+    assert_equal [{'abc' => 'abc'}, {'dem' => 'dem'}], foos
+
+    foos = ReceiveFooMock.new('ab').replay.foos
+    assert_equal [], foos
+  end
+end

data/test/test_frame_protocol.rb

@@ -0,0 +1,119 @@
+require 'zerg_support'
+
+require 'test/unit'
+
+class TestFrameProtocol < Test::Unit::TestCase
+  FP = Zerg::Support::EventMachine::FrameProtocol
+
+  # Send mock for frames.
+  class SendFramesMock < Zerg::Support::EventMachine::SendMock
+    include FP
+  end
+
+  # Receive mock for frames.
+  class ReceiveFramesMock < Zerg::Support::EventMachine::ReceiveMock
+    include FP
+    object_name :frame
+  end
+
+  def setup
+    super
+    @send_mock = SendFramesMock.new
+  end
+  
+  def teardown
+    super
+  end
+
+  def continuous_data_test(frames)
+    truncated_data_test frames, []
+  end
+  
+  def truncated_data_test(frames, sub_lengths)
+    frames.each { |frame| @send_mock.send_frame frame }
+    in_string = @send_mock.string
+    in_strings, i = [], 0
+    sub_lengths.each do |sublen|
+      in_strings << in_string[i, sublen]
+      i += sublen
+    end
+    in_strings << in_string[i..-1] if i < in_string.length
+    out_frames = ReceiveFramesMock.new(@send_mock.string).replay.frames
+    assert_equal frames, out_frames
+  end
+
+  def test_empty_frame
+    continuous_data_test ['']    
+  end
+  
+  def test_byte_frame
+    continuous_data_test ['F']
+  end
+
+  def test_string_frame
+    continuous_data_test [(32...128).to_a.pack('C*')]
+  end
+  
+  def test_multiple_frames
+    continuous_data_test [(32...128).to_a.pack('C*'), '', 'F', '', '1234567890']
+  end
+  
+  def test_truncated_border
+    truncated_data_test ['A', 'A'], [1, 0, 2, 0]
+  end
+  
+  def test_truncated_border_and_joined_data_size
+    truncated_data_test ['A', 'A'], [1, 1, 1, 1]
+  end
+  
+  def test_truncated_size
+    long_frame = (32...128).to_a.pack('C*') * 5
+    truncated_data_test [long_frame], [1]
+  end
+
+  def test_truncated_size_and_data
+    long_frame = (32...128).to_a.pack('C*') * 5
+    truncated_data_test [long_frame], [1, 16]
+  end
+  
+  def test_badass
+    # TODO(not_me): this test takes 4 seconds; replace with more targeted tests
+    
+    # build the badass string
+    s2_frame = 'qwertyuiopasdfgh' * 8 * 128 # 16384 characters, size is 3 bytes
+    @send_mock.send_frame s2_frame
+    s2_string = @send_mock.string
+    s2_count = 3
+    send_string = s2_string * s2_count
+    ex_frames = [s2_frame] * s2_count
+    
+    # build cut points in a string
+    s2_points = [0, 1, 2, 3, 4, 5, 127, 128, 8190, 16381, 16382, 16383]
+    cut_points = []
+    0.upto(s2_count - 1) do |i|
+      cut_points += s2_points.map { |p| p + i * s2_string.length }
+    end
+    
+    # try all combinations of cutting up the string in 4 pieces
+    0.upto(cut_points.length - 1) do |i|
+      (i + 1).upto(cut_points.length - 1) do |j|
+        (j + 1).upto(cut_points.length - 1) do |k|
+          packets = [0...cut_points[i], cut_points[i]...cut_points[j],
+                     cut_points[j]...cut_points[k], cut_points[k]..-1].
+                    map { |r| send_string[r] }
+          assert_equal ex_frames, ReceiveFramesMock.new(packets).replay.frames
+        end
+      end
+    end
+  end  
+  
+  def test_natural_encoding
+    table = [[0, "\0"], [1, "\x01"], [127, "\x7f"], [128, "\x80\x01"],
+             [65535, "\xff\xff\x03"], [0xf0f0f0, "\xf0\xe1\xc3\x07"],
+             [0xaa55aa55aa55, "\xd5\xd4\xd6\xd2\xda\xca\x2a"]]
+    table.each do |entry|
+      assert_equal entry.last, FP.encode_natural(entry.first) 
+      assert_equal entry.first, FP.decode_natural(entry.last) 
+    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 = '7fca02be12fb30415a492544d91f977e8de0e440'
+    golden_hash = '21ba9ca1e8fa3aa205b468a884746eb37697df9b'
     source_hash = hash_gems_file
     
     assert_equal golden_hash, source_hash, <<END_MESSAGE

data/test/test_object_protocol.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+
+require 'zerg_support'
+
+class ObjectProtocolTest < Test::Unit::TestCase
+  OP = Zerg::Support::EventMachine::ObjectProtocol
+  
+  class SendObjectMock < Zerg::Support::EventMachine::SendMock
+    include OP
+  end
+  class ReceiveObjectMock < Zerg::Support::EventMachine::ReceiveMock
+    include OP
+    object_name :object
+  end
+  
+  def one_test(*objects)
+    send_mock = SendObjectMock.new
+    objects.each { |o| send_mock.send_object o }
+    assert_equal objects, ReceiveObjectMock.new(send_mock.string).replay.objects
+  end
+  
+  def test_border_cases
+    one_test({})
+    one_test(nil)
+    one_test('')
+    one_test(false)
+    one_test(0)
+    one_test([])
+  end
+  
+  def test_literals
+    one_test(1)
+    one_test(true)
+    one_test('A')
+    one_test("A\nB\nC\tD")
+  end
+  
+  def test_arrays
+    one_test(['A'])
+    one_test(['B', 'C'])
+    one_test([0, 'C', [9, 'e'], true])
+  end
+  
+  def test_hashes
+    one_test({:command => 'run', :binary => '/bin/sh', :quick => false})
+    one_test({:command => 'run', :args => { :key => 'v3', :log => true}})
+  end
+  
+  def test_multiple_nested
+    one_test({:command => 'init', :user => "m\0e", :key => false },
+             {:command => 'package', :map => {'dir' => 1, 'NA' => true} },
+             "1234567890",
+             {:command => 'run', :sequence => [1, nil, 2, true, "Q\n"]})
+  end
+end

data/test/test_open_ssh.rb

@@ -0,0 +1,125 @@
+require 'zerg_support'
+
+require 'test/unit'
+
+module OpenSSHData; end
+
+class OpenSshTest < Test::Unit::TestCase
+  include OpenSSHData
+  OpenSSH = Zerg::Support::OpenSSH
+
+  def setup
+    @rsa_key = OpenSSH.load_key StringIO.new(obsidian_rsa_privkey)
+    @dsa_key = OpenSSH.load_key StringIO.new(obsidian_dsa_privkey)
+  end
+  
+  @@mpi_test_table = [[0, "\0"], [0x80, "\0\x80"], [0x1234, "\x12\x34"],
+                      [0xAA55, "\0\xAA\x55"]]
+  def test_encode_mpi
+    @@mpi_test_table.each {|e| assert_equal e.last, OpenSSH.encode_mpi(e.first) }
+  end
+  
+  def test_decode_mpi
+    @@mpi_test_table.each {|e| assert_equal e.first, OpenSSH.decode_mpi(e.last) }
+  end
+
+  @@pubkey_pack_table =  [[[], ''], [[''], "\0\0\0\0"],
+                          [['A'], "\0\0\0\1A"],
+                          [['A', 'BC'], "\0\0\0\1A\0\0\0\2BC"]]
+  
+  def test_pack_pubkey_components
+    @@pubkey_pack_table.each do |e|
+      assert_equal e.last, OpenSSH.pack_pubkey_components(e.first)
+    end    
+  end
+  
+  def test_unpack_pubkey_components
+    @@pubkey_pack_table.each do |e|
+      assert_equal e.first, OpenSSH.unpack_pubkey_components(e.last)
+    end
+  end
+  
+  def test_load_key
+    assert_equal obsidian_rsa_privkey, @rsa_key.to_pem
+    assert_equal obsidian_dsa_privkey, @dsa_key.to_pem
+  end
+  
+  def test_encode_pubkey
+    assert_equal obsidian_rsa_pubkey, OpenSSH.encode_pubkey(@rsa_key)
+    assert_equal obsidian_dsa_pubkey, OpenSSH.encode_pubkey(@dsa_key)
+  end
+  
+  def test_decode_pubkey
+    assert_equal @rsa_key.public_key.to_pem,
+                 OpenSSH.decode_pubkey(obsidian_rsa_pubkey).to_pem
+    assert_equal @dsa_key.public_key.to_pem,
+                 OpenSSH.decode_pubkey(obsidian_dsa_pubkey).to_pem
+  end
+end
+
+module OpenSSHData
+  def known_hosts_file
+    <<END_KH
+github.com,65.74.177.129 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq2A7hRGmdnm9tUDbO9IDSwBK6TbQa+PXYPCPy6rbTrTtw7PHkccKrpp0yVhp5HdEIcKr6pLlVDBfOLX9QUsyCOV0wzfjIJNlGEYsdlLJizHhbn2mUjvSAHQqZETYP81eFzLQNnPHt4EVVUh7VfDESU84KezmD5QlWpXLmvU31/yMf+Se8xhHTvKSCZIFImWwoG6mbUoWf9nzpIoaSjB+weqqUUmpaaasXVal72J+UX2B+2RPW3RcT0eOzQgqlJL3RKrTJvdsjE3JEAvGq3lGHSZXy28G3skua2SmVi/w4yCE6gbODqnTWlg7+wC604ydGXA8VJiS5ap43JXiUFFAaQ==
+obsidian.local ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAq7VciLo2wB+/2ThHXejC/kgkN205zlyS5cvN40Mqi3qvRVS75X1RawDoLot8eJ9KCYqZFr2Dr73d/EQNltN7dKJoPIj1IKxoraWkyNFbhhzpYuOltg9oO5UBSTNLupqla7zcdj4IwCCkBYk4+TS0dwmi20buOJ0FPY5PgbzmMnUiV9ipBqeJSdZB+TePH1gqlt7AP/6ti/0gxb2K7F69dZl/BSxMEzRCfBlTFC3f/4n8IdCuSJvNxxY+TtRnLL5CKUhj9QaIBan6JCkdRvVOBY7wmsNT8nGDzfDFSDD3KKn93g4LRkyMeaYlSDLxKy8PnNhjWgBNH1YNYyicsGfBKQ==
+rubyforge.org,205.234.109.19 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA3tPhdPUFGAYyrT1quRSOevLbAdKAJ6Ovwqw0m99R0QkqUwMUh09pgedWZeij7HtAHtoWPrNFev8FrwcwnL14NgA/gwNnXxbqd4twC1HyFShUf7POry8bz3Qk+84STHeMY8++hhn8LgNyfuVQswHoW661aqieLM6pF8q8xIUtkXA7daNpJAL4nTN1TxgUoCDpCa0EbUPkGpwFPNtGPuokRXNOCR9g8T6LmPQbzGUTc4CzFfQ9rrHaimqkEmRWJbBOaik1bdQNqOh6MUDDuUSpkJV7fwu3bl4fF5/1kw2HCREEjJmESOYnZhOS+MCp1qAUcuXqpMqXD8ATNsuXqrIhTQ==
+END_KH
+  end
+
+  def obsidian_rsa_pubkey
+    'AAAAB3NzaC1yc2EAAAABIwAAAQEAq7VciLo2wB+/2ThHXejC/kgkN205zlyS5cvN40Mqi3qvRVS75X1RawDoLot8eJ9KCYqZFr2Dr73d/EQNltN7dKJoPIj1IKxoraWkyNFbhhzpYuOltg9oO5UBSTNLupqla7zcdj4IwCCkBYk4+TS0dwmi20buOJ0FPY5PgbzmMnUiV9ipBqeJSdZB+TePH1gqlt7AP/6ti/0gxb2K7F69dZl/BSxMEzRCfBlTFC3f/4n8IdCuSJvNxxY+TtRnLL5CKUhj9QaIBan6JCkdRvVOBY7wmsNT8nGDzfDFSDD3KKn93g4LRkyMeaYlSDLxKy8PnNhjWgBNH1YNYyicsGfBKQ=='
+  end
+  
+  def obsidian_dsa_pubkey
+    'AAAAB3NzaC1kc3MAAACBAPdWp4HhWUoNawosyEBvrhPSbjhCJiKnVWiUS6bo0BCGzTHhugrkv2HgtlKhWo8nqTw5E4YxzFVyZ0YQt4m7NYDLTZVjrqbIpL/3F5qNXco127O/im0cG27AKC8Jf7knmUTjd8EBhtK65tNDmxPtzKQtemlNTVPX1VccOn6eLtn1AAAAFQDtQC21TJrf/p5WNsU9UIJzO9/hIwAAAIEAgwTrIfleQMEAK9N3xeMVZpAGfSAoX6owLtk3z+iQ3rM9FRvM/CgezOgezLowJghkw/bcQDmMuudBUuijrM3zZWdr6eqoNbFTR/KKiUx3cYf0LAHNPbXfVz+P7BXqjcEj75qnwuHQMp7vNMg+dmV40UA2TiC5/8QlaZVwkOSPN6gAAACAPMGJEFkoR0ayfkd0S/tnY9ilO17T6rdoDuF25ATtNUd6Zji6tslxBkQFWtTeinO3rGkqJRPndq0wp3E33AOHhJE/FOIlWl4Tf6aeU95Y4enYujKQDiImSTXmdiw5wq/LFdc3a2waOUvuI+647wxgHhqTmD7xI2biGZLYN9Oasy0='    
+  end
+
+  def obsidian_rsa_privkey
+    <<END_RSAK
+-----BEGIN RSA PRIVATE KEY-----
+MIIEoQIBAAKCAQEAq7VciLo2wB+/2ThHXejC/kgkN205zlyS5cvN40Mqi3qvRVS7
+5X1RawDoLot8eJ9KCYqZFr2Dr73d/EQNltN7dKJoPIj1IKxoraWkyNFbhhzpYuOl
+tg9oO5UBSTNLupqla7zcdj4IwCCkBYk4+TS0dwmi20buOJ0FPY5PgbzmMnUiV9ip
+BqeJSdZB+TePH1gqlt7AP/6ti/0gxb2K7F69dZl/BSxMEzRCfBlTFC3f/4n8IdCu
+SJvNxxY+TtRnLL5CKUhj9QaIBan6JCkdRvVOBY7wmsNT8nGDzfDFSDD3KKn93g4L
+RkyMeaYlSDLxKy8PnNhjWgBNH1YNYyicsGfBKQIBIwKCAQA/xwUc13Nr7okWKtit
+2hyKVU9HyXve7y8/aPSzf1jx+l5blIBN7LfXSXrPdaNCvtJbULyEygxXN+S8yNHY
+73b/b4XNV3D9gd281x/y0WsjL09fPpyitUP435LDatL8Ks+6TXZ1D7obedaFtqAi
+DEMHpH5Rch33xUsW3RY3gK1F8GHzYh+zMd0llH8w6IVBv0hrWttyp+4By1dhXA3L
+alYYOlGbu5cNuJfz50v4T/uB9F63JqHtAxEjqD7SvjCUbogGPxEH1k4Or+3xGuvR
+yTPaiuR9kehBstjbqc91rTLnGOr5a1VUIq6++0tCVOXQa+x5J5zCu/baGTdfkgRU
+loILAoGBAOHQcGIEgD1xHwFX9AafarF+1j4pPkM1p2u+9DNTIl1f2Rk6yOHlHZGF
+mfozMyh6l4HpvPTT7nflM4YR0JWJNbQIpCY8CdYKMXBVWcH4PXuqwyGKJBZMXWkn
+hKvelJ0UZUwx5+n8fTmSxLcIIlz5uKEE5k23/3cKkP7P6+Z6YuIZAoGBAMKpYBkM
+A4JMJ3QJ5TVsdFOoO0b1wThRgQTZR6ic9rNeXnZiL0mmr44DX2T1rTnEm6KZv2f2
+kWLQp5jx8BPFI+TUv16j4xrnnuHPhuBordCYQizSPcxXqL8b8a/KU+S5xofRjwB6
++8szd/JmGFDY8WgWrtIL32TdRhcIFg0Dg1mRAoGAE1sCUYtbcvsRSUINmirr41QD
+vC9rvJ4y6/pss/Eu1M2zhdHWtEbWphLEDiGlTJzLKGR96Rl61xOlVKJw9t/gCB3/
+cP3U9RbRCaDqb7YxJ9tvz6zBQ71nF6RNM02XtbFKgt+0yunBlzh3QuNwqOI0ZZK0
+p5Ntqx4pr3DoVZV2MKMCgYBprGdeDdYE54MhvDqZWCHkRWIB8x+/fLPAzbkvpap+
+oPFzdyD8GKhxqg82zoKbs991hqm8GCMJwboRMuFp0WtBtVHxjCrUF1ZAEZJckJje
+85GjTY9DCwPVdZHUdSY6VjiS33mD6v23c7YkgJDbbnRrtIrJy+5MsqJkRjfbLcr2
+GwKBgQCWDKVM8mZJcmM3KJwzBWh+b5T7tIbOBFaCvOBq4G0UUZGytWVUaddSbdh5
+YJ+1CoLDB+Wp3U95B1USQuSYwwr0wOYy42HBII7HnkaphT9HgDIhgvttFhX162oC
+bRizr31NgiGtgJbHJ9QPhaLvn3mZtZAFfRaEEdZslUzqRSACww==
+-----END RSA PRIVATE KEY-----
+END_RSAK
+  end
+
+  def obsidian_dsa_privkey
+    <<END_DSAK
+-----BEGIN DSA PRIVATE KEY-----
+MIIBvAIBAAKBgQD3VqeB4VlKDWsKLMhAb64T0m44QiYip1VolEum6NAQhs0x4boK
+5L9h4LZSoVqPJ6k8OROGMcxVcmdGELeJuzWAy02VY66myKS/9xeajV3KNduzv4pt
+HBtuwCgvCX+5J5lE43fBAYbSuubTQ5sT7cykLXppTU1T19VXHDp+ni7Z9QIVAO1A
+LbVMmt/+nlY2xT1QgnM73+EjAoGBAIME6yH5XkDBACvTd8XjFWaQBn0gKF+qMC7Z
+N8/okN6zPRUbzPwoHszoHsy6MCYIZMP23EA5jLrnQVLoo6zN82Vna+nqqDWxU0fy
+iolMd3GH9CwBzT2131c/j+wV6o3BI++ap8Lh0DKe7zTIPnZleNFANk4guf/EJWmV
+cJDkjzeoAoGAPMGJEFkoR0ayfkd0S/tnY9ilO17T6rdoDuF25ATtNUd6Zji6tslx
+BkQFWtTeinO3rGkqJRPndq0wp3E33AOHhJE/FOIlWl4Tf6aeU95Y4enYujKQDiIm
+STXmdiw5wq/LFdc3a2waOUvuI+647wxgHhqTmD7xI2biGZLYN9Oasy0CFQDL/9Z1
+fSLn88m1sUeWAZ4Ys2IIxw==
+-----END DSA PRIVATE KEY-----
+END_DSAK
+  end
+end

data/test/test_process.rb

@@ -4,6 +4,11 @@ require 'test/unit'
 require 'zerg_support'
 
 class TestProcess < Test::Unit::TestCase
+  def teardown
+    @pid_files.each { |f| File.delete f rescue nil } if @pid_files
+    super
+  end
+  
   def test_process_info
     info = Zerg::Support::Process.process_info($PID)
     assert info, 'Failed to find current process'
@@ -20,18 +25,21 @@ class TestProcess < Test::Unit::TestCase
     assert list[$PID], 'Process list does not contain current process'
   end
 
-  # spawn 2^exp children, and their command lines will contain "cookie"
+  # spawn 2^(exp+1)-1 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
+    Thread.new { system "ruby test/fork_tree.rb -- #{exp} 100 #{cookie}" }
+    on_windows = RUBY_PLATFORM =~ /win/ && RUBY_PLATFORM !~ /darwin/
+    sleep on_windows ? 0.5 : 0.1
+    pid_file = "#{cookie}.pid"
+    @pid_files ||= []
+    @pid_files << pid_file
+    pid = File.read(pid_file).to_i
+    sleep on_windows ? 0.4 : 0.5
+    return pid
   end
   
   def now_cookie
-    "zerg_test_#{Time.now.to_f}"
+    "zerg_test_#{Time.now.to_f}s"
   end
   
   def test_process_tree
@@ -39,9 +47,11 @@ class TestProcess < Test::Unit::TestCase
     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_equal 15, tree_processes.length, 'Missed some processes'
     assert tree_processes.all? { |info| info[:command_line].index cookie },
            'Got the wrong processes'
+           
+    Zerg::Support::Process.kill_tree root_pid
   end
   
   def test_kill