win32-process 0.5.9 → 0.6.0

data/CHANGES

@@ -1,3 +1,16 @@
+= 0.6.0 - 31-Oct-2008
+* The mandatory argument for Process.create has been switched from 'app_name'
+  to 'command_line', to be more in line with underlying CreateProcess API.
+  Note that 'command_line' will default to 'app_name' if only the latter is
+  set, but both may be set individually. Keep in mind that 'app_name' must
+  be a full path to the executable. Thanks go to Jeremy Bopp for the patch.
+* Removed the deprecated ProcessError constant. Use Process::Error instead.
+* Explicitly include and extend the Windows::Thread module now. Thanks go to
+  Qi Lu for the spot.
+* Slightly more robust internal code handling for some of the other methods,
+  typically related to ensuring that HANDLE's are closed.
+* Example programs are now included with the gem.
+
 = 0.5.9 - 14-Jun-2008
 * Added a proper implementation of Process.ppid.
 

data/Rakefile

@@ -17,8 +17,6 @@ task :install_gem do
 end
 
 Rake::TestTask.new do |t|
-   t.libs << 'test'
    t.verbose = true
    t.warning = true
-   t.test_files = FileList['test/tc_process.rb']
 end

data/examples/test_create.rb

@@ -0,0 +1,39 @@
+##########################################################################
+# test_create.rb
+#
+# Simple test program for the Process.create() method.
+##########################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'examples'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('examples') rescue nil
+
+require "win32/process"
+
+p Process::WIN32_PROCESS_VERSION
+
+struct = Process.create(
+   :app_name         => "notepad.exe",
+   :creation_flags   => Process::DETACHED_PROCESS,
+   :process_inherit  => false,
+   :thread_inherit   => true,
+   :cwd              => "C:\\",
+   :inherit          => true,
+   :environment      => "SYSTEMROOT=#{ENV['SYSTEMROOT']};PATH=C:\\"
+)
+
+p struct
+
+=begin
+# Don't run this from an existing terminal
+pid = Process.create(
+   :app_name       => "cmd.exe",
+   :creation_flags => Process::DETACHED_PROCESS,
+   :startf_flags   => Process::USEPOSITION,
+   :x              => 0,
+   :y              => 0,
+   :title          => "Hi Dan"
+)
+
+puts "Pid of new process: #{pid}"
+=end

data/examples/test_fork_wait.rb

@@ -0,0 +1,33 @@
+##########################################################################
+# test_fork_wait.rb
+#
+# Generic test script for futzing around with the block form of fork/wait
+##########################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'examples'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('examples') rescue nil
+
+require 'win32/process'
+
+puts "VERSION: " + Process::WIN32_PROCESS_VERSION
+
+# In the child, using block form
+fork{
+  	7.times { |i|
+     	puts "Child: #{i}"
+     	sleep 1
+  	}
+}
+
+# Back in the parent
+4.times{ |i|
+   	puts "Parent: #{i}"
+   	sleep 1
+}
+
+# Wait for the children
+Process.wait
+
+# Children should be done here before continuing on
+puts "Continuing on..."

data/examples/test_fork_waitpid.rb

@@ -0,0 +1,50 @@
+##########################################################################
+# test_fork_waitpid.rb
+#
+# Generic test script for futzing around with the traditional form of
+# fork/wait, plus waitpid and waitpid2.
+##########################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'examples'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('examples') rescue nil
+
+require 'win32/process'
+
+puts "VERSION: " + Process::WIN32_PROCESS_VERSION
+
+pid = Process.fork
+puts "PID1: #{pid}"
+
+#child
+if pid.nil?
+   7.times{ |i|
+      puts "Child: #{i}"
+      sleep 1
+   }
+   exit(-1)
+end
+
+pid2 = Process.fork
+puts "PID2: #{pid2}"
+
+#child2
+if pid2.nil?
+   7.times{ |i|
+      puts "Child2: #{i}"
+      sleep 1
+   }
+   exit(1)
+end
+
+#parent
+2.times { |i|
+   puts "Parent: #{i}"
+   sleep 1
+}
+
+p Process.waitpid2(pid)
+p Process.waitpid2(pid2)
+
+puts "Continuing on..."
+

data/examples/test_kill.rb

@@ -0,0 +1,35 @@
+##########################################################################
+# test_kill.rb
+#
+# Generic test script for futzing around Process.kill.  This script
+# requires the sys-proctable package (available on the RAA).
+##########################################################################
+Dir.chdir('..') if File.basename(Dir.pwd) == 'examples'
+$LOAD_PATH.unshift Dir.pwd
+$LOAD_PATH.unshift Dir.pwd + '/lib'
+Dir.chdir('examples') rescue nil
+
+require "win32/process"
+
+begin
+   require "sys/proctable"
+rescue LoadError
+   STDERR.puts "Whoa there!"
+   STDERR.puts "This script requires the sys-proctable package to work."
+   STDERR.puts "You can find it at http://ruby-sysutils.sf.net"
+   STDERR.puts "Exiting..."
+   exit
+end
+include Sys
+
+puts "VERSION: " + Process::WIN32_PROCESS_VERSION
+
+IO.popen("notepad")
+sleep 1 # Give it a chance to start before checking for its pid
+
+pids = []
+ProcTable.ps{ |s|
+   pids.push(s.pid) if s.cmdline =~ /notepad/i
+}
+
+p Process.kill(9,pids.last)

data/lib/win32/process.rb

@@ -15,7 +15,8 @@ module Process
    # Eliminates redefinition warnings.
    undef_method :kill, :wait, :wait2, :waitpid, :waitpid2, :ppid
    
-   WIN32_PROCESS_VERSION = '0.5.9'
+   # The version of this library
+   WIN32_PROCESS_VERSION = '0.6.0'
    
    include Windows::Process
    include Windows::Thread
@@ -27,6 +28,7 @@ module Process
    include Windows::Window
    include Windows::Unicode
    include Windows::ToolHelper
+
    extend Windows::Error
    extend Windows::Process
    extend Windows::Thread
@@ -64,13 +66,14 @@ module Process
       # TODO: update the $? global variable (if/when possible)
       status = WaitForSingleObject(handle, INFINITE)
       
-      unless GetExitCodeProcess(handle, exit_code)
-         error = get_last_error
+      begin
+         unless GetExitCodeProcess(handle, exit_code)
+            raise Error, get_last_error
+         end
+      ensure
          CloseHandle(handle)
-         raise Error, error
       end
       
-      CloseHandle(handle)
       @child_pids.delete(pid)
       
       # TODO: update the $? global variable (if/when possible)
@@ -99,13 +102,14 @@ module Process
       # TODO: update the $? global variable (if/when possible)
       status = WaitForSingleObject(handle, INFINITE)
       
-      unless GetExitCodeProcess(handle, exit_code)
-         error = get_last_error
+      begin
+         unless GetExitCodeProcess(handle, exit_code)
+            raise Error, get_last_error
+         end
+      ensure
          CloseHandle(handle)
-         raise Error, error
       end
       
-      CloseHandle(handle)
       @child_pids.delete(pid)
       
       # TODO: update the $? global variable (if/when possible)
@@ -156,70 +160,70 @@ module Process
        
          # No need for full access if the signal is zero
          if signal == 0
-            access = PROCESS_QUERY_INFORMATION|PROCESS_VM_READ
+            access = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ
             handle = OpenProcess(access, 0 , pid)
          else
             handle = OpenProcess(PROCESS_ALL_ACCESS, 0, pid)
          end
          
-         case signal
-            when 0   
-               if handle != 0
-                  killed_pids.push(pid)
-                  CloseHandle(handle)
-               else
-                  # If ERROR_ACCESS_DENIED is returned, we know it's running
-                  if GetLastError() == ERROR_ACCESS_DENIED
+         begin
+            case signal
+               when 0   
+                  if handle != 0
                      killed_pids.push(pid)
                   else
-                     raise Error, get_last_error
+                     # If ERROR_ACCESS_DENIED is returned, we know it's running
+                     if GetLastError() == ERROR_ACCESS_DENIED
+                        killed_pids.push(pid)
+                     else
+                        raise Error, get_last_error
+                     end
                   end
-               end
-            when 2
-               if GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid)
-                  killed_pids.push(pid)
-               end
-            when 3
-               if GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pid)
-                  killed_pids.push(pid)
-               end
-            when 9
-               if TerminateProcess(handle, pid)
-                  CloseHandle(handle)
-                  killed_pids.push(pid)
-                  @child_pids.delete(pid)           
-               else
-                  raise Error, get_last_error
-               end
-            else
-               if handle != 0
-                  thread_id = [0].pack('L')
-                  dll       = 'kernel32'
-                  eproc     = 'ExitProcess'
-                  
-                  thread = CreateRemoteThread(
-                     handle,
-                     0,
-                     0,
-                     GetProcAddress(GetModuleHandle(dll), eproc),
-                     0,
-                     0,
-                     thread_id
-                  )
-                  
-                  if thread
-                     WaitForSingleObject(thread, 5)
-                     CloseHandle(handle)
+               when 2
+                  if GenerateConsoleCtrlEvent(CTRL_C_EVENT, pid)
+                     killed_pids.push(pid)
+                  end
+               when 3
+                  if GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT, pid)
                      killed_pids.push(pid)
-                     @child_pids.delete(pid)
+                  end
+               when 9
+                  if TerminateProcess(handle, pid)
+                     killed_pids.push(pid)
+                     @child_pids.delete(pid)           
                   else
-                     CloseHandle(handle)
                      raise Error, get_last_error
                   end
                else
-                  raise Error, get_last_error
-               end
-               @child_pids.delete(pid)
+                  if handle != 0
+                     thread_id = [0].pack('L')
+                     dll       = 'kernel32'
+                     eproc     = 'ExitProcess'
+                     
+                     thread = CreateRemoteThread(
+                        handle,
+                        0,
+                        0,
+                        GetProcAddress(GetModuleHandle(dll), eproc),
+                        0,
+                        0,
+                        thread_id
+                     )
+                     
+                     if thread
+                        WaitForSingleObject(thread, 5)
+                        killed_pids.push(pid)
+                        @child_pids.delete(pid)
+                     else
+                        raise Error, get_last_error
+                     end
+                  else
+                     raise Error, get_last_error
+                  end
+                  @child_pids.delete(pid)
+            end
+         ensure
+            CloseHandle(handle) unless handle == INVALID_HANDLE_VALUE
          end
       }
       
@@ -232,7 +236,8 @@ module Process
    # returning a ProcessInfo struct. It accepts a hash as an argument.
    # There are several primary keys:
 	#
-   # * app_name         (mandatory)
+   # * command_line     (mandatory)
+   # * app_name         (default: nil)
    # * inherit          (default: false)
    # * process_inherit  (default: false)
    # * thread_inherit   (default: false)
@@ -245,7 +250,10 @@ module Process
    # * domain           (default: nil)
    # * password         (default: nil)
 	#
-   # Of these, the 'app_name' must be specified or an error is raised.
+   # Of these, the 'command_line' or 'app_name' must be specified or an
+   # error is raised. Both may be set individually, but 'command_line' should
+   # be preferred if only one of them is set because it does not (necessarily)
+   # require an explicit path or extension to work.
    #
    # The 'domain' and 'password' options are only relevent in the context
    # of 'with_logon'.
@@ -301,9 +309,9 @@ module Process
       end
       
       valid_keys = %w/
-         app_name inherit creation_flags cwd environment startup_info
-         thread_inherit process_inherit close_handles with_logon domain
-         password
+         app_name command_line inherit creation_flags cwd environment
+         startup_info thread_inherit process_inherit close_handles with_logon
+         domain password
       /
 
       valid_si_keys = %/
@@ -313,6 +321,7 @@ module Process
 
       # Set default values
       hash = {
+         'app_name'       => nil,
          'creation_flags' => 0,
          'close_handles'  => true
       }
@@ -339,9 +348,15 @@ module Process
          }
       end
       
-      # The +app_name+ key is mandatory
-      unless hash['app_name']
-         raise Error, 'app_name must be specified'
+      # The +command_line+ key is mandatory unless the +app_name+ key
+      # is specified.
+      unless hash['command_line']
+         if hash['app_name']
+            hash['command_line'] = hash['app_name']
+            hash['app_name'] = nil
+         else
+            raise Error, 'command_line or app_name must be specified'
+         end
       end
       
       # The environment string should be passed as a string of ';' separated
@@ -421,7 +436,8 @@ module Process
       if hash['with_logon']
          logon  = multi_to_wide(hash['with_logon'])
          domain = multi_to_wide(hash['domain'])
-         app    = multi_to_wide(hash['app_name'])
+         app    = hash['app_name'].nil? ? nil : multi_to_wide(hash['app_name'])
+         cmd    = hash['command_line'].nil? ? nil : multi_to_wide(hash['command_line'])
          cwd    = multi_to_wide(hash['cwd'])
          passwd = multi_to_wide(hash['password'])
          
@@ -432,8 +448,8 @@ module Process
             domain,                 # Domain
             passwd,                 # Password
             LOGON_WITH_PROFILE,     # Logon flags
-            nil,                    # App name
-            app,                    # Command line
+            app,                    # App name
+            cmd,                    # Command line
             hash['creation_flags'], # Creation flags
             env,                    # Environment
             cwd,                    # Working directory
@@ -442,8 +458,8 @@ module Process
          )
       else     
          bool = CreateProcess(
-            nil,                    # App name
-            hash['app_name'],       # Command line
+            hash['app_name'],       # App name
+            hash['command_line'],   # Command line
             process_security,       # Process attributes
             thread_security,        # Thread attributes
             hash['inherit'],        # Inherit handles?
@@ -456,7 +472,7 @@ module Process
       end      
       
       # TODO: Close stdin, stdout and stderr handles in the si_hash unless
-      # they're pointing to one of the standard handles already.
+      # they're pointing to one of the standard handles already. [Maybe]
       unless bool
          raise Error, "CreateProcess() failed: ", get_last_error
       end
@@ -610,16 +626,20 @@ module Process
       proc_entry = 0.chr * 296 # 36 + 260
       proc_entry[0, 4] = [proc_entry.size].pack('L') # Set dwSize member
       
-      unless Process32First(handle, proc_entry)
-         CloseHandle(handle)
-         raise Error, get_last_error
-      end
+      begin             
+         unless Process32First(handle, proc_entry)
+            error = get_last_error
+            raise Error, error
+         end
 
-      while Process32Next(handle, proc_entry)
-         if proc_entry[8, 4].unpack('L')[0] == Process.pid
-            ppid = proc_entry[24, 4].unpack('L')[0] # th32ParentProcessID
-            break
+         while Process32Next(handle, proc_entry)
+            if proc_entry[8, 4].unpack('L')[0] == Process.pid
+               ppid = proc_entry[24, 4].unpack('L')[0] # th32ParentProcessID
+               break
+            end
          end
+      ensure
+         CloseHandle(handle)
       end
 
       ppid
@@ -683,9 +703,6 @@ module Process
    module_function :ppid
 end
 
-# For backwards compatibility. Deprecated.
-ProcessError = Process::Error
-
 # Create a global fork method
 module Kernel
    undef_method :fork # Eliminate redefinition warning

data/test/{tc_process.rb → test_win32_process.rb}

@@ -3,7 +3,7 @@
 #
 # Test suite for the win32-process library.  This test suite will start
 # at least two instances of Notepad on your system, which will then
-# be killed. Requires the sys-proctable package.
+# be killed. Requires the sys-proctable library.
 #
 # I haven't added a lot of test cases for fork/wait because it's difficult
 # to run such tests without causing havoc with Test::Unit itself.  Ideas
@@ -11,42 +11,36 @@
 #
 # You should run this test case via the 'rake test' task.
 ###############################################################################
+require 'rubygems'
+gem 'test-unit'
+
 require 'test/unit'
 require 'win32/process'
-
-begin
-   require 'sys/proctable'
-rescue LoadError => e
-   site = 'http://www.rubyforge.org/projects/sysutils'
-   msg = %Q{
-      Stopping! The sys-proctable library is required to run this test suite.
-      You can find it at #{site} or the RAA.
-      Or, you can just 'gem install sys-proctable' and try again.
-   }
-   STDERR.puts msg
-   exit!
-end   
-
+require 'sys/proctable'
 include Sys
 
-IO.popen("notepad")
-IO.popen("notepad")
-sleep 1
+class TC_Win32Process < Test::Unit::TestCase  
 
-$pids = []
-ProcTable.ps{ |s|
-   next unless s.comm =~ /notepad/i
-   $pids.push(s.pid)
-}
+   # Start two instances of notepad and give them a chance to fire up
+   def self.startup
+      IO.popen('notepad')
+      IO.popen('notepad')
+      sleep 1 # Give the notepad instances a second to startup
+      
+      @@pids = []
+
+      ProcTable.ps{ |struct|
+         next unless struct.comm =~ /notepad/i
+         @@pids << struct.pid
+      }
+   end
 
-class TC_Win32Process < Test::Unit::TestCase  
    def setup
-      @pids = $pids
       @pid = nil
    end
   
    def test_version
-      assert_equal('0.5.9', Process::WIN32_PROCESS_VERSION)
+      assert_equal('0.6.0', Process::WIN32_PROCESS_VERSION)
    end
    
    def test_kill
@@ -56,23 +50,23 @@ class TC_Win32Process < Test::Unit::TestCase
    def test_kill_expected_errors
       assert_raises(ArgumentError){ Process.kill }
       assert_raises(Process::Error){ Process.kill('SIGBOGUS') }
-      assert_raises(Process::Error){ Process.kill(0,9999999) }
+      assert_raises(Process::Error){ Process.kill(0, 9999999) }
    end
    
    def test_kill_signal_0
-      pid = @pids.first
+      pid = @@pids.first
       assert_nothing_raised{ Process.kill(0, pid) }
    end
    
    def test_kill_signal_1
-      pid = @pids.shift
+      pid = @@pids.shift
       assert_nothing_raised{ Process.kill(1, pid) }
    end
    
    def test_kill_signal_9
-      pid = @pids.pop
+      pid = @@pids.pop
       msg = "Could not find pid #{pid}"
-      assert_nothing_raised(msg){ Process.kill(9,pid) }
+      assert_nothing_raised(msg){ Process.kill(9, pid) }
    end
 
    def test_fork
@@ -81,6 +75,7 @@ class TC_Win32Process < Test::Unit::TestCase
       	
    def test_create
       assert_respond_to(Process, :create)
+
       assert_nothing_raised{
          @pid = Process.create(
             :app_name         => "notepad.exe",
@@ -90,6 +85,7 @@ class TC_Win32Process < Test::Unit::TestCase
             :cwd              => "C:\\"
          ).process_id
       }
+
       assert_nothing_raised{ Process.kill(1, @pid) }
    end
    
@@ -137,6 +133,10 @@ class TC_Win32Process < Test::Unit::TestCase
    end
    
    def teardown
-      @pids = []
-   end     
+      @pid = nil
+   end
+
+   def self.shutdown
+      @@pids = []
+   end
 end

data/win32-process.gemspec

@@ -3,7 +3,7 @@ require "rubygems"
 spec = Gem::Specification.new do |gem|
    desc = "Adds create, fork, wait, wait2, waitpid, and a special kill method"
    gem.name        = "win32-process"
-   gem.version     = "0.5.9"
+   gem.version     = "0.6.0"
    gem.authors     = ['Daniel Berger', 'Park Heesob']
    gem.email       = "djberg96@gmail.com"
    gem.rubyforge_project = 'win32utils'
@@ -11,9 +11,9 @@ spec = Gem::Specification.new do |gem|
    gem.platform    = Gem::Platform::RUBY
    gem.summary     = desc
    gem.description = desc
-   gem.test_file   = "test/tc_process.rb"
+   gem.test_files  = Dir["test/*.rb"]
    gem.has_rdoc    = true
-   gem.files       = Dir["lib/win32/*.rb"] + Dir["test/*"] + Dir["[A-Z]*"]
+   gem.files       = Dir["lib/win32/*.rb"] + Dir["test/*"] + Dir["[A-Z]*"] + Dir["examples/*"]
    gem.files.reject! { |fn| fn.include? "CVS" }
    gem.require_path = "lib"
    gem.extra_rdoc_files = ["README", "CHANGES", "MANIFEST"]
@@ -21,6 +21,6 @@ spec = Gem::Specification.new do |gem|
 end
 
 if $0 == __FILE__
-   Gem.manage_gems
+   Gem.manage_gems if Gem::RubyGemsVersion.to_f < 1.3
    Gem::Builder.new(spec).build
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: win32-process
 version: !ruby/object:Gem::Version 
-  version: 0.5.9
+  version: 0.6.0
 platform: ruby
 authors: 
 - Daniel Berger
@@ -10,11 +10,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-14 00:00:00 -06:00
+date: 2008-10-31 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: windows-pr
+  type: :runtime
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -34,10 +35,8 @@ extra_rdoc_files:
 - MANIFEST
 files: 
 - lib/win32/process.rb
-- test/CVS
-- test/tc_process.rb
+- test/test_win32_process.rb
 - CHANGES
-- CVS
 - examples
 - lib
 - MANIFEST
@@ -45,6 +44,10 @@ files:
 - README
 - test
 - win32-process.gemspec
+- examples/test_create.rb
+- examples/test_fork_wait.rb
+- examples/test_fork_waitpid.rb
+- examples/test_kill.rb
 has_rdoc: true
 homepage: http://www.rubyforge.org/projects/win32utils
 post_install_message: 
@@ -67,9 +70,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: win32utils
-rubygems_version: 1.1.1
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Adds create, fork, wait, wait2, waitpid, and a special kill method
 test_files: 
-- test/tc_process.rb
+- test/test_win32_process.rb