aggkit 0.2.5

data/lib/aggkit/childprocess/unix/platform/i386-linux.rb

@@ -0,0 +1,14 @@
+module Aggkit
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 76,
+     :posix_spawnattr_t          => 336,
+     :sigset_t                   => 128
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+  POSIX_SPAWN_USEVFORK   = 64
+end
+end

data/lib/aggkit/childprocess/unix/platform/i386-solaris.rb

@@ -0,0 +1,13 @@
+module Aggkit
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 4,
+     :posix_spawnattr_t          => 4,
+     :sigset_t                   => 16
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+end
+end

data/lib/aggkit/childprocess/unix/platform/x86_64-linux.rb

@@ -0,0 +1,14 @@
+module Aggkit
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 80,
+     :posix_spawnattr_t          => 336,
+     :sigset_t                   => 128
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+  POSIX_SPAWN_USEVFORK   = 64
+end
+end

data/lib/aggkit/childprocess/unix/platform/x86_64-macosx.rb

@@ -0,0 +1,13 @@
+module Aggkit
+module ChildProcess::Unix::Platform
+  SIZEOF = {
+     :posix_spawn_file_actions_t => 8,
+     :posix_spawnattr_t          => 8,
+     :sigset_t                   => 4
+  }
+  POSIX_SPAWN_RESETIDS   = 1
+  POSIX_SPAWN_SETPGROUP  = 2
+  POSIX_SPAWN_SETSIGDEF  = 4
+  POSIX_SPAWN_SETSIGMASK = 8
+end
+end

data/lib/aggkit/childprocess/unix/posix_spawn_process.rb

@@ -0,0 +1,135 @@
+require 'thread'
+
+module Aggkit
+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
+end

data/lib/aggkit/childprocess/unix/process.rb

@@ -0,0 +1,91 @@
+module Aggkit
+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
+end

data/lib/aggkit/childprocess/unix.rb

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

data/lib/aggkit/childprocess/version.rb

@@ -0,0 +1,5 @@
+module Aggkit
+module ChildProcess
+  VERSION = '0.9.0'
+end
+end

data/lib/aggkit/childprocess/windows/handle.rb

@@ -0,0 +1,93 @@
+module Aggkit
+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
+end

data/lib/aggkit/childprocess/windows/io.rb

@@ -0,0 +1,25 @@
+module Aggkit
+module ChildProcess
+  module Windows
+    class IO < AbstractIO
+      private
+
+      def check_type(io)
+        return if has_fileno?(io)
+        return if has_to_io?(io)
+
+        raise ArgumentError, "#{io.inspect}:#{io.class} must have :fileno or :to_io"
+      end
+
+      def has_fileno?(io)
+        io.respond_to?(:fileno) && io.fileno
+      end
+
+      def has_to_io?(io)
+        io.respond_to?(:to_io) && io.to_io.kind_of?(::IO)
+      end
+
+    end # IO
+  end # Windows
+end # ChildProcess
+end