childprocess 0.2.5 → 0.2.6

data/lib/childprocess/windows/process_builder.rb

@@ -0,0 +1,170 @@
+module ChildProcess
+  module Windows
+    class ProcessBuilder
+      attr_accessor :inherit, :detach, :duplex, :environment, :stdout, :stderr
+      attr_reader :stdin
+
+      def initialize(args)
+        @args        = args
+
+        @inherit     = false
+        @detach      = false
+        @duplex      = false
+        @environment = nil
+
+        @stdout      = nil
+        @stderr      = nil
+        @stdin       = nil
+
+        @flags       = 0
+        @cmd_ptr     = nil
+        @env_ptr     = nil
+      end
+
+      def start
+        create_command_pointer
+        create_environment_pointer
+
+        setup_detach
+        setup_io
+
+        pid = create_process
+        close_handles
+
+        pid
+      end
+
+      private
+
+      def create_command_pointer
+        string = @args.map { |arg| quote_if_necessary(arg.to_s) }.join ' '
+        @cmd_ptr = FFI::MemoryPointer.from_string string
+      end
+
+      def create_environment_pointer
+        return unless @environment.kind_of?(Hash) && @environment.any?
+
+        # inherited env
+        strings = ENV.map { |k,v| "#{k}=#{v}\0" }
+
+        # extras
+        @environment.each do |key, value|
+          if key.include?("=")
+            raise InvalidEnvironmentVariableName, key
+          end
+
+          strings << "#{key}=#{value}\0"
+        end
+
+        strings << "\0" # terminate the env block
+        env_str = strings.join
+
+        @env_ptr = FFI::MemoryPointer.new(:long, env_str.bytesize)
+        @env_ptr.write_bytes env_str, 0, env_str.bytesize
+      end
+
+      def create_process
+        ok = Lib.create_process(
+          nil,          # application name
+          @cmd_ptr,     # command line
+          nil,          # process attributes
+          nil,          # thread attributes
+          @inherit,     # inherit handles
+          @flags,       # creation flags
+          @env_ptr,     # environment
+          nil,          # current directory
+          startup_info, # startup info
+          process_info  # process info
+        )
+
+        ok or raise LaunchError, Lib.last_error_message
+
+        process_info[:dwProcessId]
+      end
+
+      def startup_info
+        @startup_info ||= StartupInfo.new
+      end
+
+      def process_info
+        @process_info ||= ProcessInfo.new
+      end
+
+      def setup_detach
+        @flags |= DETACHED_PROCESS if @detach
+      end
+
+      def setup_io
+        if @stdout || @stderr
+          startup_info[:dwFlags] ||= 0
+          startup_info[:dwFlags] |= STARTF_USESTDHANDLES
+
+          @inherit = true
+
+          if @stdout
+            startup_info[:hStdOutput] = std_stream_handle_for(@stdout)
+          end
+
+          if @stderr
+            startup_info[:hStdError] = std_stream_handle_for(@stderr)
+          end
+        end
+
+        setup_stdin if @duplex
+      end
+
+      def setup_stdin
+        read_pipe_ptr  = FFI::MemoryPointer.new(:pointer)
+        write_pipe_ptr = FFI::MemoryPointer.new(:pointer)
+        sa             = SecurityAttributes.new(:inherit => true)
+
+        ok = Lib.create_pipe(read_pipe_ptr, write_pipe_ptr, sa, 0)
+        Lib.check_error ok
+
+        @read_pipe  = read_pipe_ptr.read_pointer
+        @write_pipe = write_pipe_ptr.read_pointer
+
+        Lib.set_handle_inheritance @write_pipe.address, false
+
+        startup_info[:hStdInput] = @read_pipe
+      end
+
+      def close_handles
+        Lib.close_handle process_info[:hProcess]
+        Lib.close_handle process_info[:hThread]
+
+        if @duplex
+          @stdin = Lib.io_for(Lib.duplicate_handle(@write_pipe), File::WRONLY)
+          Lib.close_handle @read_pipe
+          Lib.close_handle @write_pipe
+        end
+      end
+
+      def std_stream_handle_for(io)
+        handle = Lib.handle_for(io.fileno)
+
+        begin
+          Lib.set_handle_inheritance handle, true
+        rescue ChildProcess::Error
+          # If the IO was set to close on exec previously, this call will fail.
+          # That's probably OK, since the user explicitly asked for it to be
+          # closed (at least I have yet to find other cases where this will
+          # happen...)
+        end
+
+        handle
+      end
+
+      def quote_if_necessary(str)
+        quote = str.start_with?('"') ? "'" : '"'
+
+        case str
+        when /[\s\\'"]/
+          [quote, str, quote].join
+        else
+          str
+        end
+      end
+    end # ProcessBuilder
+  end # Windows
+end # ChildProcess

data/lib/childprocess/windows/structs.rb

@@ -1,81 +1,83 @@
-module ChildProcess::Windows
-  # typedef struct _STARTUPINFO {
-  #   DWORD  cb;
-  #   LPTSTR lpReserved;
-  #   LPTSTR lpDesktop;
-  #   LPTSTR lpTitle;
-  #   DWORD  dwX;
-  #   DWORD  dwY;
-  #   DWORD  dwXSize;
-  #   DWORD  dwYSize;
-  #   DWORD  dwXCountChars;
-  #   DWORD  dwYCountChars;
-  #   DWORD  dwFillAttribute;
-  #   DWORD  dwFlags;
-  #   WORD   wShowWindow;
-  #   WORD   cbReserved2;
-  #   LPBYTE lpReserved2;
-  #   HANDLE hStdInput;
-  #   HANDLE hStdOutput;
-  #   HANDLE hStdError;
-  # } STARTUPINFO, *LPSTARTUPINFO;
+module ChildProcess
+  module Windows
+    # typedef struct _STARTUPINFO {
+    #   DWORD  cb;
+    #   LPTSTR lpReserved;
+    #   LPTSTR lpDesktop;
+    #   LPTSTR lpTitle;
+    #   DWORD  dwX;
+    #   DWORD  dwY;
+    #   DWORD  dwXSize;
+    #   DWORD  dwYSize;
+    #   DWORD  dwXCountChars;
+    #   DWORD  dwYCountChars;
+    #   DWORD  dwFillAttribute;
+    #   DWORD  dwFlags;
+    #   WORD   wShowWindow;
+    #   WORD   cbReserved2;
+    #   LPBYTE lpReserved2;
+    #   HANDLE hStdInput;
+    #   HANDLE hStdOutput;
+    #   HANDLE hStdError;
+    # } STARTUPINFO, *LPSTARTUPINFO;
 
-  class StartupInfo < FFI::Struct
-    layout :cb,               :ulong,
-           :lpReserved,       :pointer,
-           :lpDesktop,        :pointer,
-           :lpTitle,          :pointer,
-           :dwX,              :ulong,
-           :dwY,              :ulong,
-           :dwXSize,          :ulong,
-           :dwYSize,          :ulong,
-           :dwXCountChars,    :ulong,
-           :dwYCountChars,    :ulong,
-           :dwFillAttribute,  :ulong,
-           :dwFlags,          :ulong,
-           :wShowWindow,      :ushort,
-           :cbReserved2,      :ushort,
-           :lpReserved2,      :pointer,
-           :hStdInput,        :pointer, # void ptr
-           :hStdOutput,       :pointer, # void ptr
-           :hStdError,        :pointer # void ptr
-  end
+    class StartupInfo < FFI::Struct
+      layout :cb,               :ulong,
+             :lpReserved,       :pointer,
+             :lpDesktop,        :pointer,
+             :lpTitle,          :pointer,
+             :dwX,              :ulong,
+             :dwY,              :ulong,
+             :dwXSize,          :ulong,
+             :dwYSize,          :ulong,
+             :dwXCountChars,    :ulong,
+             :dwYCountChars,    :ulong,
+             :dwFillAttribute,  :ulong,
+             :dwFlags,          :ulong,
+             :wShowWindow,      :ushort,
+             :cbReserved2,      :ushort,
+             :lpReserved2,      :pointer,
+             :hStdInput,        :pointer, # void ptr
+             :hStdOutput,       :pointer, # void ptr
+             :hStdError,        :pointer # void ptr
+    end
 
-  #
-  # typedef struct _PROCESS_INFORMATION {
-  #   HANDLE hProcess;
-  #   HANDLE hThread;
-  #   DWORD  dwProcessId;
-  #   DWORD  dwThreadId;
-  # } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
-  #
+    #
+    # typedef struct _PROCESS_INFORMATION {
+    #   HANDLE hProcess;
+    #   HANDLE hThread;
+    #   DWORD  dwProcessId;
+    #   DWORD  dwThreadId;
+    # } PROCESS_INFORMATION, *LPPROCESS_INFORMATION;
+    #
 
-  class ProcessInfo < FFI::Struct
-    layout :hProcess,    :pointer, # void ptr
-           :hThread,     :pointer, # void ptr
-           :dwProcessId, :ulong,
-           :dwThreadId,  :ulong
-  end
+    class ProcessInfo < FFI::Struct
+      layout :hProcess,    :pointer, # void ptr
+             :hThread,     :pointer, # void ptr
+             :dwProcessId, :ulong,
+             :dwThreadId,  :ulong
+    end
 
-  #
-  # typedef struct _SECURITY_ATTRIBUTES {
-  #   DWORD  nLength;
-  #   LPVOID lpSecurityDescriptor;
-  #   BOOL   bInheritHandle;
-  # } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
-  #
+    #
+    # typedef struct _SECURITY_ATTRIBUTES {
+    #   DWORD  nLength;
+    #   LPVOID lpSecurityDescriptor;
+    #   BOOL   bInheritHandle;
+    # } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
+    #
 
-  class SecurityAttributes < FFI::Struct
-    layout :nLength,              :ulong,
-           :lpSecurityDescriptor, :pointer, # void ptr
-           :bInheritHandle,       :int
+    class SecurityAttributes < FFI::Struct
+      layout :nLength,              :ulong,
+             :lpSecurityDescriptor, :pointer, # void ptr
+             :bInheritHandle,       :int
 
-    def initialize(opts = {})
-      super()
+      def initialize(opts = {})
+        super()
 
-      self[:nLength]              = self.class.size
-      self[:lpSecurityDescriptor] = nil
-      self[:bInheritHandle]       = opts[:inherit] ? 1 : 0
+        self[:nLength]              = self.class.size
+        self[:lpSecurityDescriptor] = nil
+        self[:bInheritHandle]       = opts[:inherit] ? 1 : 0
+      end
     end
-  end
-end
+  end # Windows
+end # ChildProcess

data/spec/childprocess_spec.rb

@@ -3,8 +3,6 @@
 require File.expand_path('../spec_helper', __FILE__)
 
 describe ChildProcess do
-  EXIT_TIMEOUT = 10
-
   it "returns self when started" do
     process = sleeping_ruby
 
@@ -46,7 +44,7 @@ describe ChildProcess do
 
   it "accepts a timeout argument to #stop" do
     process = sleeping_ruby.start
-    process.stop(EXIT_TIMEOUT)
+    process.stop(exit_timeout)
   end
 
   it "lets child process inherit the environment of the current process" do
@@ -112,102 +110,6 @@ describe ChildProcess do
     pending "how do we spec this?"
   end
 
-  it "can redirect stdout, stderr" do
-    process = ruby(<<-CODE)
-      [STDOUT, STDERR].each_with_index do |io, idx|
-        io.sync = true
-        io.puts idx
-      end
-
-      sleep 0.2
-    CODE
-
-    out = Tempfile.new("stdout-spec")
-    err = Tempfile.new("stderr-spec")
-
-    begin
-      process.io.stdout = out
-      process.io.stderr = err
-
-      process.start
-      process.io.stdin.should be_nil
-      process.wait
-
-      out.rewind
-      err.rewind
-
-      out.read.should == "0\n"
-      err.read.should == "1\n"
-    ensure
-      out.close
-      err.close
-    end
-  end
-
-  it "can redirect stdout only" do
-    process = ruby(<<-CODE)
-      [STDOUT, STDERR].each_with_index do |io, idx|
-        io.sync = true
-        io.puts idx
-      end
-
-      sleep 0.2
-    CODE
-
-    out = Tempfile.new("stdout-spec")
-
-    begin
-      process.io.stdout = out
-
-      process.start
-      process.wait
-
-      out.rewind
-
-      out.read.should == "0\n"
-    ensure
-      out.close
-    end
-  end
-
-  it "can write to stdin if duplex = true" do
-    process = cat
-
-    out = Tempfile.new("duplex")
-    out.sync = true
-
-    begin
-      process.io.stdout = out
-      process.io.stderr = out
-      process.duplex = true
-
-      process.start
-      process.io.stdin.puts "hello world"
-      process.io.stdin.close
-
-      process.poll_for_exit(EXIT_TIMEOUT)
-
-      out.rewind
-      out.read.should == "hello world\n"
-    ensure
-      out.close
-    end
-  end
-
-  it "can set close-on-exec when IO is inherited" do
-    server = TCPServer.new("localhost", 4433)
-    ChildProcess.close_on_exec server
-
-    process = sleeping_ruby
-    process.io.inherit!
-
-    process.start
-    sleep 0.5 # give the forked process a chance to exec() (which closes the fd)
-
-    server.close
-    lambda { TCPServer.new("localhost", 4433).close }.should_not raise_error
-  end
-
   it "preserves Dir.pwd in the child" do
     Tempfile.open("dir-spec-out") do |file|
       process = ruby("print Dir.pwd")

data/spec/io_spec.rb

@@ -0,0 +1,128 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe ChildProcess do
+ it "can redirect stdout, stderr" do
+    process = ruby(<<-CODE)
+      [STDOUT, STDERR].each_with_index do |io, idx|
+        io.sync = true
+        io.puts idx
+      end
+    CODE
+
+    out = Tempfile.new("stdout-spec")
+    err = Tempfile.new("stderr-spec")
+
+    begin
+      process.io.stdout = out
+      process.io.stderr = err
+
+      process.start
+      process.io.stdin.should be_nil
+      process.wait
+
+      out.rewind
+      err.rewind
+
+      out.read.should == "0\n"
+      err.read.should == "1\n"
+    ensure
+      out.close
+      err.close
+    end
+  end
+
+  it "can redirect stdout only" do
+    process = ruby(<<-CODE)
+      [STDOUT, STDERR].each_with_index do |io, idx|
+        io.sync = true
+        io.puts idx
+      end
+    CODE
+
+    out = Tempfile.new("stdout-spec")
+
+    begin
+      process.io.stdout = out
+
+      process.start
+      process.wait
+
+      out.rewind
+      out.read.should == "0\n"
+    ensure
+      out.close
+    end
+  end
+
+  it "can write to stdin if duplex = true" do
+    process = cat
+
+    out = Tempfile.new("duplex")
+    out.sync = true
+
+    begin
+      process.io.stdout = out
+      process.io.stderr = out
+      process.duplex = true
+
+      process.start
+      process.io.stdin.puts "hello world"
+      process.io.stdin.close
+
+      process.poll_for_exit(exit_timeout)
+
+      out.rewind
+      out.read.should == "hello world\n"
+    ensure
+      out.close
+    end
+  end
+
+  #
+  # this works on JRuby 1.6.5 on my Mac, but for some reason
+  # hangs on Travis (running 1.6.5.1 + OpenJDK).
+  #
+  # http://travis-ci.org/#!/jarib/childprocess/jobs/487331
+  #
+
+  it "works with pipes", :jruby => false do
+    process = ruby(<<-CODE)
+      STDOUT.puts "stdout"
+      STDERR.puts "stderr"
+    CODE
+
+    stdout, stdout_w = IO.pipe
+    stderr, stderr_w = IO.pipe
+
+    process.io.stdout = stdout_w
+    process.io.stderr = stderr_w
+
+    process.duplex = true
+
+    process.start
+    process.wait
+
+    # write streams are closed *after* the process
+    # has exited - otherwise it won't work on JRuby
+    # with the current Process implementation
+
+    stdout_w.close
+    stderr_w.close
+
+    stdout.read.should == "stdout\n"
+    stderr.read.should == "stderr\n"
+  end
+
+  it "can set close-on-exec when IO is inherited" do
+    server = TCPServer.new("localhost", 4433)
+    ChildProcess.close_on_exec server
+
+    process = sleeping_ruby
+    process.io.inherit!
+
+    process.start
+    server.close
+
+    lambda { TCPServer.new("localhost", 4433).close }.should_not raise_error
+  end
+end