childprocess 0.8.0 → 2.0.0

data/lib/childprocess/unix/posix_spawn_process.rb

@@ -1,134 +1,134 @@
-require 'ffi'
-require 'thread'
-
-module ChildProcess
-  module Unix
-    class PosixSpawnProcess < Process
-      private
-
-      @@cwd_lock = Mutex.new
-
-      def launch_process
-        pid_ptr = FFI::MemoryPointer.new(:pid_t)
-        actions = Lib::FileActions.new
-        attrs   = Lib::Attrs.new
-
-        if io.stdout
-          actions.add_dup fileno_for(io.stdout), fileno_for(STDOUT)
-        else
-          actions.add_open fileno_for(STDOUT), "/dev/null", File::WRONLY, 0644
-        end
-
-        if io.stderr
-          actions.add_dup fileno_for(io.stderr), fileno_for(STDERR)
-        else
-          actions.add_open fileno_for(STDERR), "/dev/null", File::WRONLY, 0644
-        end
-
-        if duplex?
-          reader, writer = ::IO.pipe
-          actions.add_dup fileno_for(reader), fileno_for(STDIN)
-          actions.add_close fileno_for(writer)
-        end
-
-        attrs.pgroup = 0 if leader?
-        attrs.flags |= Platform::POSIX_SPAWN_USEVFORK if defined? Platform::POSIX_SPAWN_USEVFORK
-
-        # wrap in helper classes in order to avoid GC'ed pointers
-        argv = Argv.new(@args)
-        envp = Envp.new(ENV.to_hash.merge(@environment))
-
-        ret = 0
-        @@cwd_lock.synchronize do
-          Dir.chdir(@cwd || Dir.pwd) do
-            if ChildProcess.jruby?
-              # on JRuby, the current working directory is for some reason not inherited.
-              # We'll work around it by making a chdir call through FFI.
-              # TODO: report this to JRuby
-              Lib.chdir Dir.pwd
-            end
-
-            ret = Lib.posix_spawnp(
-              pid_ptr,
-              @args.first, # TODO: not sure this matches exec() behaviour
-              actions,
-              attrs,
-              argv,
-              envp
-            )
-          end
-        end
-
-        if duplex?
-          io._stdin = writer
-          reader.close
-        end
-
-        actions.free
-        attrs.free
-
-        if ret != 0
-          raise LaunchError, "#{Lib.strerror(ret)} (#{ret})"
-        end
-
-        @pid = pid_ptr.read_int
-        ::Process.detach(@pid) if detach?
-      end
-
-      if ChildProcess.jruby?
-        def fileno_for(obj)
-          ChildProcess::JRuby.posix_fileno_for(obj)
-        end
-      else
-        def fileno_for(obj)
-          obj.fileno
-        end
-      end
-
-      class Argv
-        def initialize(args)
-          @ptrs = args.map do |e|
-            if e.include?("\0")
-              raise ArgumentError, "argument cannot contain null bytes: #{e.inspect}"
-            end
-
-            FFI::MemoryPointer.from_string(e.to_s)
-          end
-
-          @ptrs << FFI::Pointer.new(0)
-        end
-
-        def to_ptr
-          argv = FFI::MemoryPointer.new(:pointer, @ptrs.size)
-          argv.put_array_of_pointer(0, @ptrs)
-
-          argv
-        end
-      end # Argv
-
-      class Envp
-        def initialize(env)
-          @ptrs = env.map do |key, val|
-            next if val.nil?
-
-            if key =~ /=|\0/ || val.include?("\0")
-              raise InvalidEnvironmentVariable, "#{key.inspect} => #{val.inspect}"
-            end
-
-            FFI::MemoryPointer.from_string("#{key}=#{val}")
-          end.compact
-
-          @ptrs << FFI::Pointer.new(0)
-        end
-
-        def to_ptr
-          env = FFI::MemoryPointer.new(:pointer, @ptrs.size)
-          env.put_array_of_pointer(0, @ptrs)
-
-          env
-        end
-      end # Envp
-
-    end
-  end
-end
+require 'ffi'
+require 'thread'
+
+module ChildProcess
+  module Unix
+    class PosixSpawnProcess < Process
+      private
+
+      @@cwd_lock = Mutex.new
+
+      def launch_process
+        pid_ptr = FFI::MemoryPointer.new(:pid_t)
+        actions = Lib::FileActions.new
+        attrs   = Lib::Attrs.new
+
+        if io.stdout
+          actions.add_dup fileno_for(io.stdout), fileno_for(STDOUT)
+        else
+          actions.add_open fileno_for(STDOUT), "/dev/null", File::WRONLY, 0644
+        end
+
+        if io.stderr
+          actions.add_dup fileno_for(io.stderr), fileno_for(STDERR)
+        else
+          actions.add_open fileno_for(STDERR), "/dev/null", File::WRONLY, 0644
+        end
+
+        if duplex?
+          reader, writer = ::IO.pipe
+          actions.add_dup fileno_for(reader), fileno_for(STDIN)
+          actions.add_close fileno_for(writer)
+        end
+
+        attrs.pgroup = 0 if leader?
+        attrs.flags |= Platform::POSIX_SPAWN_USEVFORK if defined? Platform::POSIX_SPAWN_USEVFORK
+
+        # wrap in helper classes in order to avoid GC'ed pointers
+        argv = Argv.new(@args)
+        envp = Envp.new(ENV.to_hash.merge(@environment))
+
+        ret = 0
+        @@cwd_lock.synchronize do
+          Dir.chdir(@cwd || Dir.pwd) do
+            if ChildProcess.jruby?
+              # on JRuby, the current working directory is for some reason not inherited.
+              # We'll work around it by making a chdir call through FFI.
+              # TODO: report this to JRuby
+              Lib.chdir Dir.pwd
+            end
+
+            ret = Lib.posix_spawnp(
+              pid_ptr,
+              @args.first, # TODO: not sure this matches exec() behaviour
+              actions,
+              attrs,
+              argv,
+              envp
+            )
+          end
+        end
+
+        if duplex?
+          io._stdin = writer
+          reader.close
+        end
+
+        actions.free
+        attrs.free
+
+        if ret != 0
+          raise LaunchError, "#{Lib.strerror(ret)} (#{ret})"
+        end
+
+        @pid = pid_ptr.read_int
+        ::Process.detach(@pid) if detach?
+      end
+
+      if ChildProcess.jruby?
+        def fileno_for(obj)
+          ChildProcess::JRuby.posix_fileno_for(obj)
+        end
+      else
+        def fileno_for(obj)
+          obj.fileno
+        end
+      end
+
+      class Argv
+        def initialize(args)
+          @ptrs = args.map do |e|
+            if e.include?("\0")
+              raise ArgumentError, "argument cannot contain null bytes: #{e.inspect}"
+            end
+
+            FFI::MemoryPointer.from_string(e.to_s)
+          end
+
+          @ptrs << FFI::Pointer.new(0)
+        end
+
+        def to_ptr
+          argv = FFI::MemoryPointer.new(:pointer, @ptrs.size)
+          argv.put_array_of_pointer(0, @ptrs)
+
+          argv
+        end
+      end # Argv
+
+      class Envp
+        def initialize(env)
+          @ptrs = env.map do |key, val|
+            next if val.nil?
+
+            if key =~ /=|\0/ || val.to_s.include?("\0")
+              raise InvalidEnvironmentVariable, "#{key.inspect} => #{val.to_s.inspect}"
+            end
+
+            FFI::MemoryPointer.from_string("#{key}=#{val.to_s}")
+          end.compact
+
+          @ptrs << FFI::Pointer.new(0)
+        end
+
+        def to_ptr
+          env = FFI::MemoryPointer.new(:pointer, @ptrs.size)
+          env.put_array_of_pointer(0, @ptrs)
+
+          env
+        end
+      end # Envp
+
+    end
+  end
+end

data/lib/childprocess/unix/process.rb

@@ -1,89 +1,90 @@
-module ChildProcess
-  module Unix
-    class Process < AbstractProcess
-      attr_reader :pid
-
-      def io
-        @io ||= Unix::IO.new
-      end
-
-      def stop(timeout = 3)
-        assert_started
-        send_term
-
-        begin
-          return poll_for_exit(timeout)
-        rescue TimeoutError
-          # try next
-        end
-
-        send_kill
-        wait
-      rescue Errno::ECHILD, Errno::ESRCH
-        # handle race condition where process dies between timeout
-        # and send_kill
-        true
-      end
-
-      def exited?
-        return true if @exit_code
-
-        assert_started
-        pid, status = ::Process.waitpid2(_pid, ::Process::WNOHANG | ::Process::WUNTRACED)
-        pid = nil if pid == 0 # may happen on jruby
-
-        log(:pid => pid, :status => status)
-
-        if pid
-          set_exit_code(status)
-        end
-
-        !!pid
-      rescue Errno::ECHILD
-        # may be thrown for detached processes
-        true
-      end
-
-      def wait
-        assert_started
-
-        if exited?
-          exit_code
-        else
-          _, status = ::Process.waitpid2 _pid
-          set_exit_code(status)
-        end
-      end
-
-      private
-
-      def send_term
-        send_signal 'TERM'
-      end
-
-      def send_kill
-        send_signal 'KILL'
-      end
-
-      def send_signal(sig)
-        assert_started
-
-        log "sending #{sig}"
-        ::Process.kill sig, _pid
-      end
-
-      def set_exit_code(status)
-        @exit_code = status.exitstatus || status.termsig
-      end
-
-      def _pid
-        if leader?
-          -@pid # negative pid == process group
-        else
-          @pid
-        end
-      end
-
-    end # Process
-  end # Unix
-end # ChildProcess
+module ChildProcess
+  module Unix
+    class Process < AbstractProcess
+      attr_reader :pid
+
+      def io
+        @io ||= Unix::IO.new
+      end
+
+      def stop(timeout = 3)
+        assert_started
+        send_term
+
+        begin
+          return poll_for_exit(timeout)
+        rescue TimeoutError
+          # try next
+        end
+
+        send_kill
+        wait
+      rescue Errno::ECHILD, Errno::ESRCH
+        # handle race condition where process dies between timeout
+        # and send_kill
+        true
+      end
+
+      def exited?
+        return true if @exit_code
+
+        assert_started
+        pid, status = ::Process.waitpid2(@pid, ::Process::WNOHANG | ::Process::WUNTRACED)
+        pid = nil if pid == 0 # may happen on jruby
+
+        log(:pid => pid, :status => status)
+
+        if pid
+          set_exit_code(status)
+        end
+
+        !!pid
+      rescue Errno::ECHILD
+        # may be thrown for detached processes
+        true
+      end
+
+      def wait
+        assert_started
+
+        if exited?
+          exit_code
+        else
+          _, status = ::Process.waitpid2(@pid)
+
+          set_exit_code(status)
+        end
+      end
+
+      private
+
+      def send_term
+        send_signal 'TERM'
+      end
+
+      def send_kill
+        send_signal 'KILL'
+      end
+
+      def send_signal(sig)
+        assert_started
+
+        log "sending #{sig}"
+        ::Process.kill sig, _pid
+      end
+
+      def set_exit_code(status)
+        @exit_code = status.exitstatus || status.termsig
+      end
+
+      def _pid
+        if leader?
+          -@pid # negative pid == process group
+        else
+          @pid
+        end
+      end
+
+    end # Process
+  end # Unix
+end # ChildProcess

data/lib/childprocess/unix.rb

@@ -1,9 +1,9 @@
-module ChildProcess
-  module Unix
-  end
-end
-
-require "childprocess/unix/io"
-require "childprocess/unix/process"
-require "childprocess/unix/fork_exec_process"
-# PosixSpawnProcess + ffi is required on demand.
+module ChildProcess
+  module Unix
+  end
+end
+
+require "childprocess/unix/io"
+require "childprocess/unix/process"
+require "childprocess/unix/fork_exec_process"
+# PosixSpawnProcess + ffi is required on demand.

data/lib/childprocess/version.rb

@@ -1,3 +1,3 @@
-module ChildProcess
-  VERSION = '0.8.0'
-end
+module ChildProcess
+  VERSION = '2.0.0'
+end

data/lib/childprocess/windows/handle.rb

@@ -1,91 +1,91 @@
-module ChildProcess
-  module Windows
-    class Handle
-
-      class << self
-        private :new
-
-        def open(pid, access = PROCESS_ALL_ACCESS)
-          handle = Lib.open_process(access, false, pid)
-
-          if handle.null?
-            raise Error, Lib.last_error_message
-          end
-
-          h = new(handle, pid)
-          return h unless block_given?
-
-          begin
-            yield h
-          ensure
-            h.close
-          end
-        end
-      end
-
-      attr_reader :pointer
-
-      def initialize(pointer, pid)
-        unless pointer.kind_of?(FFI::Pointer)
-          raise TypeError, "invalid handle: #{pointer.inspect}"
-        end
-
-        if pointer.null?
-          raise ArgumentError, "handle is null: #{pointer.inspect}"
-        end
-
-        @pid     = pid
-        @pointer = pointer
-        @closed  = false
-      end
-
-      def exit_code
-        code_pointer = FFI::MemoryPointer.new :ulong
-        ok = Lib.get_exit_code(@pointer, code_pointer)
-
-        if ok
-          code_pointer.get_ulong(0)
-        else
-          close
-          raise Error, Lib.last_error_message
-        end
-      end
-
-      def send(signal)
-        case signal
-        when 0
-          exit_code == PROCESS_STILL_ALIVE
-        when WIN_SIGINT
-          Lib.generate_console_ctrl_event(CTRL_C_EVENT, @pid)
-        when WIN_SIGBREAK
-          Lib.generate_console_ctrl_event(CTRL_BREAK_EVENT, @pid)
-        when WIN_SIGKILL
-          ok = Lib.terminate_process(@pointer, @pid)
-          Lib.check_error ok
-        else
-          thread_id     = FFI::MemoryPointer.new(:ulong)
-          module_handle = Lib.get_module_handle("kernel32")
-          proc_address  = Lib.get_proc_address(module_handle, "ExitProcess")
-
-          thread = Lib.create_remote_thread(@pointer, 0, 0, proc_address, 0, 0, thread_id)
-          check_error thread
-
-          Lib.wait_for_single_object(thread, 5)
-          true
-        end
-      end
-
-      def close
-        return if @closed
-
-        Lib.close_handle(@pointer)
-        @closed = true
-      end
-
-      def wait(milliseconds = nil)
-        Lib.wait_for_single_object(@pointer, milliseconds || INFINITE)
-      end
-
-    end # Handle
-  end # Windows
-end # ChildProcess
+module ChildProcess
+  module Windows
+    class Handle
+
+      class << self
+        private :new
+
+        def open(pid, access = PROCESS_ALL_ACCESS)
+          handle = Lib.open_process(access, false, pid)
+
+          if handle.null?
+            raise Error, Lib.last_error_message
+          end
+
+          h = new(handle, pid)
+          return h unless block_given?
+
+          begin
+            yield h
+          ensure
+            h.close
+          end
+        end
+      end
+
+      attr_reader :pointer
+
+      def initialize(pointer, pid)
+        unless pointer.kind_of?(FFI::Pointer)
+          raise TypeError, "invalid handle: #{pointer.inspect}"
+        end
+
+        if pointer.null?
+          raise ArgumentError, "handle is null: #{pointer.inspect}"
+        end
+
+        @pid     = pid
+        @pointer = pointer
+        @closed  = false
+      end
+
+      def exit_code
+        code_pointer = FFI::MemoryPointer.new :ulong
+        ok = Lib.get_exit_code(@pointer, code_pointer)
+
+        if ok
+          code_pointer.get_ulong(0)
+        else
+          close
+          raise Error, Lib.last_error_message
+        end
+      end
+
+      def send(signal)
+        case signal
+        when 0
+          exit_code == PROCESS_STILL_ALIVE
+        when WIN_SIGINT
+          Lib.generate_console_ctrl_event(CTRL_C_EVENT, @pid)
+        when WIN_SIGBREAK
+          Lib.generate_console_ctrl_event(CTRL_BREAK_EVENT, @pid)
+        when WIN_SIGKILL
+          ok = Lib.terminate_process(@pointer, @pid)
+          Lib.check_error ok
+        else
+          thread_id     = FFI::MemoryPointer.new(:ulong)
+          module_handle = Lib.get_module_handle("kernel32")
+          proc_address  = Lib.get_proc_address(module_handle, "ExitProcess")
+
+          thread = Lib.create_remote_thread(@pointer, 0, 0, proc_address, 0, 0, thread_id)
+          check_error thread
+
+          Lib.wait_for_single_object(thread, 5)
+          true
+        end
+      end
+
+      def close
+        return if @closed
+
+        Lib.close_handle(@pointer)
+        @closed = true
+      end
+
+      def wait(milliseconds = nil)
+        Lib.wait_for_single_object(@pointer, milliseconds || INFINITE)
+      end
+
+    end # Handle
+  end # Windows
+end # ChildProcess