aggkit 0.2.5

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

@@ -0,0 +1,418 @@
+module Aggkit
+module ChildProcess
+  module Windows
+    FORMAT_MESSAGE_FROM_SYSTEM            = 0x00001000
+    FORMAT_MESSAGE_ARGUMENT_ARRAY         = 0x00002000
+
+    PROCESS_ALL_ACCESS                    = 0x1F0FFF
+    PROCESS_QUERY_INFORMATION             = 0x0400
+    PROCESS_VM_READ                       = 0x0010
+    PROCESS_STILL_ACTIVE                  = 259
+
+    INFINITE                              = 0xFFFFFFFF
+
+    WIN_SIGINT                            = 2
+    WIN_SIGBREAK                          = 3
+    WIN_SIGKILL                           = 9
+
+    CTRL_C_EVENT                          = 0
+    CTRL_BREAK_EVENT                      = 1
+
+    CREATE_BREAKAWAY_FROM_JOB             = 0x01000000
+    DETACHED_PROCESS                      = 0x00000008
+
+    STARTF_USESTDHANDLES                  = 0x00000100
+    INVALID_HANDLE_VALUE                  = -1
+    HANDLE_FLAG_INHERIT                   = 0x00000001
+
+    DUPLICATE_SAME_ACCESS                 = 0x00000002
+    CREATE_UNICODE_ENVIRONMENT            = 0x00000400
+
+    JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE    = 0x2000
+    JOB_OBJECT_LIMIT_BREAKAWAY_OK         = 0x00000800
+    JOB_OBJECT_EXTENDED_LIMIT_INFORMATION = 9
+    JOB_OBJECT_BASIC_LIMIT_INFORMATION    = 2
+
+    module Lib
+      enum :wait_status, [
+        :wait_object_0,  0,
+        :wait_timeout,   0x102,
+        :wait_abandoned, 0x80,
+        :wait_failed,    0xFFFFFFFF
+      ]
+
+      #
+      # BOOL WINAPI CreateProcess(
+      #   __in_opt     LPCTSTR lpApplicationName,
+      #   __inout_opt  LPTSTR lpCommandLine,
+      #   __in_opt     LPSECURITY_ATTRIBUTES lpProcessAttributes,
+      #   __in_opt     LPSECURITY_ATTRIBUTES lpThreadAttributes,
+      #   __in         BOOL bInheritHandles,
+      #   __in         DWORD dwCreationFlags,
+      #   __in_opt     LPVOID lpEnvironment,
+      #   __in_opt     LPCTSTR lpCurrentDirectory,
+      #   __in         LPSTARTUPINFO lpStartupInfo,
+      #   __out        LPPROCESS_INFORMATION lpProcessInformation
+      # );
+      #
+
+      attach_function :create_process, :CreateProcessA, [
+        :pointer,
+        :pointer,
+        :pointer,
+        :pointer,
+        :bool,
+        :ulong,
+        :pointer,
+        :pointer,
+        :pointer,
+        :pointer], :bool
+
+      #
+      #   DWORD WINAPI FormatMessage(
+      #   __in      DWORD dwFlags,
+      #   __in_opt  LPCVOID lpSource,
+      #   __in      DWORD dwMessageId,
+      #   __in      DWORD dwLanguageId,
+      #   __out     LPTSTR lpBuffer,
+      #   __in      DWORD nSize,
+      #   __in_opt  va_list *Arguments
+      # );
+      #
+
+      attach_function :format_message, :FormatMessageA, [
+        :ulong,
+        :pointer,
+        :ulong,
+        :ulong,
+        :pointer,
+        :ulong,
+        :pointer], :ulong
+
+
+      attach_function :close_handle, :CloseHandle, [:pointer], :bool
+
+      #
+      # HANDLE WINAPI OpenProcess(
+      #   __in  DWORD dwDesiredAccess,
+      #   __in  BOOL bInheritHandle,
+      #   __in  DWORD dwProcessId
+      # );
+      #
+
+      attach_function :open_process, :OpenProcess, [:ulong, :bool, :ulong], :pointer
+
+      #
+      # HANDLE WINAPI CreateJobObject(
+      #   _In_opt_  LPSECURITY_ATTRIBUTES lpJobAttributes,
+      #   _In_opt_  LPCTSTR lpName
+      # );
+      #
+
+      attach_function :create_job_object, :CreateJobObjectA, [:pointer, :pointer], :pointer
+
+      #
+      # BOOL WINAPI AssignProcessToJobObject(
+      #   _In_  HANDLE hJob,
+      #   _In_  HANDLE hProcess
+      # );
+
+      attach_function :assign_process_to_job_object, :AssignProcessToJobObject, [:pointer, :pointer], :bool
+
+      #
+      # BOOL WINAPI SetInformationJobObject(
+      #   _In_  HANDLE hJob,
+      #   _In_  JOBOBJECTINFOCLASS JobObjectInfoClass,
+      #   _In_  LPVOID lpJobObjectInfo,
+      #   _In_  DWORD cbJobObjectInfoLength
+      # );
+      #
+
+      attach_function :set_information_job_object, :SetInformationJobObject, [:pointer, :int, :pointer, :ulong], :bool
+
+      #
+      #
+      # DWORD WINAPI WaitForSingleObject(
+      #   __in  HANDLE hHandle,
+      #   __in  DWORD dwMilliseconds
+      # );
+      #
+
+      attach_function :wait_for_single_object, :WaitForSingleObject, [:pointer, :ulong], :wait_status, :blocking => true
+
+      #
+      # BOOL WINAPI GetExitCodeProcess(
+      #   __in   HANDLE hProcess,
+      #   __out  LPDWORD lpExitCode
+      # );
+      #
+
+      attach_function :get_exit_code, :GetExitCodeProcess, [:pointer, :pointer], :bool
+
+      #
+      # BOOL WINAPI GenerateConsoleCtrlEvent(
+      #   __in  DWORD dwCtrlEvent,
+      #   __in  DWORD dwProcessGroupId
+      # );
+      #
+
+      attach_function :generate_console_ctrl_event, :GenerateConsoleCtrlEvent, [:ulong, :ulong], :bool
+
+      #
+      # BOOL WINAPI TerminateProcess(
+      #   __in  HANDLE hProcess,
+      #   __in  UINT uExitCode
+      # );
+      #
+
+      attach_function :terminate_process, :TerminateProcess, [:pointer, :uint], :bool
+
+      #
+      # intptr_t _get_osfhandle(
+      #    int fd
+      # );
+      #
+
+      attach_function :get_osfhandle, :_get_osfhandle, [:int], :intptr_t
+
+      #
+      # int _open_osfhandle (
+      #    intptr_t osfhandle,
+      #    int flags
+      # );
+      #
+
+      attach_function :open_osfhandle, :_open_osfhandle, [:pointer, :int], :int
+
+      # BOOL WINAPI SetHandleInformation(
+      #   __in  HANDLE hObject,
+      #   __in  DWORD dwMask,
+      #   __in  DWORD dwFlags
+      # );
+
+      attach_function :set_handle_information, :SetHandleInformation, [:pointer, :ulong, :ulong], :bool
+
+      # BOOL WINAPI GetHandleInformation(
+      #   __in   HANDLE hObject,
+      #   __out  LPDWORD lpdwFlags
+      # );
+
+      attach_function :get_handle_information, :GetHandleInformation, [:pointer, :pointer], :bool
+
+      # BOOL WINAPI CreatePipe(
+      #   __out     PHANDLE hReadPipe,
+      #   __out     PHANDLE hWritePipe,
+      #   __in_opt  LPSECURITY_ATTRIBUTES lpPipeAttributes,
+      #   __in      DWORD nSize
+      # );
+
+      attach_function :create_pipe, :CreatePipe, [:pointer, :pointer, :pointer, :ulong], :bool
+
+      #
+      # HANDLE WINAPI GetCurrentProcess(void);
+      #
+
+      attach_function :current_process, :GetCurrentProcess, [], :pointer
+
+      #
+      # BOOL WINAPI DuplicateHandle(
+      #   __in   HANDLE hSourceProcessHandle,
+      #   __in   HANDLE hSourceHandle,
+      #   __in   HANDLE hTargetProcessHandle,
+      #   __out  LPHANDLE lpTargetHandle,
+      #   __in   DWORD dwDesiredAccess,
+      #   __in   BOOL bInheritHandle,
+      #   __in   DWORD dwOptions
+      # );
+      #
+
+      attach_function :_duplicate_handle, :DuplicateHandle, [
+        :pointer,
+        :pointer,
+        :pointer,
+        :pointer,
+        :ulong,
+        :bool,
+        :ulong
+      ], :bool
+
+      class << self
+        def kill(signal, *pids)
+          case signal
+          when 'SIGINT', 'INT', :SIGINT, :INT
+            signal = WIN_SIGINT
+          when 'SIGBRK', 'BRK', :SIGBREAK, :BRK
+            signal = WIN_SIGBREAK
+          when 'SIGKILL', 'KILL', :SIGKILL, :KILL
+            signal = WIN_SIGKILL
+          when 0..9
+            # Do nothing
+          else
+            raise Error, "invalid signal #{signal.inspect}"
+          end
+
+          pids.map { |pid| pid if Lib.send_signal(signal, pid) }.compact
+        end
+
+        def waitpid(pid, flags = 0)
+          wait_for_pid(pid, no_hang?(flags))
+        end
+
+        def waitpid2(pid, flags = 0)
+          code = wait_for_pid(pid, no_hang?(flags))
+
+          [pid, code] if code
+        end
+
+        def dont_inherit(file)
+          unless file.respond_to?(:fileno)
+            raise ArgumentError, "expected #{file.inspect} to respond to :fileno"
+          end
+
+          set_handle_inheritance(handle_for(file.fileno), false)
+        end
+
+        def last_error_message
+          errnum = FFI.errno
+
+          buf = FFI::MemoryPointer.new :char, 512
+
+          size = format_message(
+            FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+            nil, errnum, 0, buf, buf.size, nil
+          )
+
+          str = buf.read_string(size).strip
+          if errnum == 0
+            "Unknown error (Windows says #{str.inspect}, but it did not.)"
+          else
+            "#{str} (#{errnum})"
+          end
+        end
+
+        def each_child_of(pid, &blk)
+          raise NotImplementedError
+
+          # http://stackoverflow.com/questions/1173342/terminate-a-process-tree-c-for-windows?rq=1
+
+          # for each process entry
+          #  if pe.th32ParentProcessID == pid
+          #    Handle.open(pe.pe.th32ProcessId, &blk)
+          #  end
+          #
+        end
+
+        def handle_for(fd_or_io)
+          if fd_or_io.kind_of?(IO) || fd_or_io.respond_to?(:fileno)
+            if ChildProcess.jruby?
+              handle = ChildProcess::JRuby.windows_handle_for(fd_or_io)
+            else
+              handle = get_osfhandle(fd_or_io.fileno)
+            end
+          elsif fd_or_io.kind_of?(Integer)
+            handle = get_osfhandle(fd_or_io)
+          elsif fd_or_io.respond_to?(:to_io)
+            io = fd_or_io.to_io
+
+            unless io.kind_of?(IO)
+              raise TypeError, "expected #to_io to return an instance of IO"
+            end
+
+            handle = get_osfhandle(io.fileno)
+          else
+            raise TypeError, "invalid type: #{fd_or_io.inspect}"
+          end
+
+          if handle == INVALID_HANDLE_VALUE
+            raise Error, last_error_message
+          end
+
+          FFI::Pointer.new handle
+        end
+
+        def io_for(handle, flags = File::RDONLY)
+          fd = open_osfhandle(handle, flags)
+          if fd == -1
+            raise Error, last_error_message
+          end
+
+          FFI::IO.for_fd fd, flags
+        end
+
+        def duplicate_handle(handle)
+          dup  = FFI::MemoryPointer.new(:pointer)
+          proc = current_process
+
+          ok = Lib._duplicate_handle(
+            proc,
+            handle,
+            proc,
+            dup,
+            0,
+            false,
+            DUPLICATE_SAME_ACCESS
+          )
+
+          check_error ok
+
+          dup.read_pointer
+        ensure
+          close_handle proc
+        end
+
+        def set_handle_inheritance(handle, bool)
+          status = set_handle_information(
+            handle,
+            HANDLE_FLAG_INHERIT,
+            bool ? HANDLE_FLAG_INHERIT : 0
+          )
+
+          check_error status
+        end
+
+        def get_handle_inheritance(handle)
+          flags = FFI::MemoryPointer.new(:uint)
+
+          status = get_handle_information(
+            handle,
+            flags
+          )
+
+          check_error status
+
+          flags.read_uint
+        end
+
+        def check_error(bool)
+          bool or raise Error, last_error_message
+        end
+
+        def alive?(pid)
+          handle = Lib.open_process(PROCESS_ALL_ACCESS, false, pid)
+          if handle.null?
+            false
+          else
+            ptr = FFI::MemoryPointer.new :ulong
+            Lib.check_error Lib.get_exit_code(handle, ptr)
+            ptr.read_ulong == PROCESS_STILL_ACTIVE
+          end
+        end
+
+        def no_hang?(flags)
+          (flags & Process::WNOHANG) == Process::WNOHANG
+        end
+
+        def wait_for_pid(pid, no_hang)
+          code = Handle.open(pid) { |handle|
+            handle.wait unless no_hang
+            handle.exit_code
+          }
+
+          code if code != PROCESS_STILL_ACTIVE
+        end
+      end
+
+    end # Lib
+  end # Windows
+end # ChildProcess
+end

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

@@ -0,0 +1,132 @@
+module Aggkit
+module ChildProcess
+  module Windows
+    class Process < AbstractProcess
+
+      attr_reader :pid
+
+      def io
+        @io ||= Windows::IO.new
+      end
+
+      def stop(timeout = 3)
+        assert_started
+
+        log "sending KILL"
+        @handle.send(WIN_SIGKILL)
+
+        poll_for_exit(timeout)
+      ensure
+        close_handle
+        close_job_if_necessary
+      end
+
+      def wait
+        if exited?
+          exit_code
+        else
+          @handle.wait
+          @exit_code = @handle.exit_code
+
+          close_handle
+          close_job_if_necessary
+
+          @exit_code
+        end
+      end
+
+      def exited?
+        return true if @exit_code
+        assert_started
+
+        code   = @handle.exit_code
+        exited = code != PROCESS_STILL_ACTIVE
+
+        log(:exited? => exited, :code => code)
+
+        if exited
+          @exit_code = code
+          close_handle
+          close_job_if_necessary
+        end
+
+        exited
+      end
+
+      private
+
+      def launch_process
+        builder = ProcessBuilder.new(@args)
+        builder.leader      = leader?
+        builder.detach      = detach?
+        builder.duplex      = duplex?
+        builder.environment = @environment unless @environment.empty?
+        builder.cwd         = @cwd
+
+        if @io
+          builder.stdout      = @io.stdout
+          builder.stderr      = @io.stderr
+        end
+
+        @pid = builder.start
+        @handle = Handle.open @pid
+
+        if leader?
+          @job = Job.new
+          @job << @handle
+        end
+
+        if duplex?
+          raise Error, "no stdin stream" unless builder.stdin
+          io._stdin = builder.stdin
+        end
+
+        self
+      end
+
+      def close_handle
+        @handle.close
+      end
+
+      def close_job_if_necessary
+        @job.close if leader?
+      end
+
+
+      class Job
+        def initialize
+          @pointer = Lib.create_job_object(nil, nil)
+
+          if @pointer.nil? || @pointer.null?
+            raise Error, "unable to create job object"
+          end
+
+          basic = JobObjectBasicLimitInformation.new
+          basic[:LimitFlags] = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE | JOB_OBJECT_LIMIT_BREAKAWAY_OK
+
+          extended = JobObjectExtendedLimitInformation.new
+          extended[:BasicLimitInformation] = basic
+
+          ret = Lib.set_information_job_object(
+            @pointer,
+            JOB_OBJECT_EXTENDED_LIMIT_INFORMATION,
+            extended,
+            extended.size
+          )
+
+          Lib.check_error ret
+        end
+
+        def <<(handle)
+          Lib.check_error Lib.assign_process_to_job_object(@pointer, handle.pointer)
+        end
+
+        def close
+          Lib.close_handle @pointer
+        end
+      end
+
+    end # Process
+  end # Windows
+end # ChildProcess
+end

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

@@ -0,0 +1,177 @@
+module Aggkit
+module ChildProcess
+  module Windows
+    class ProcessBuilder
+      attr_accessor :leader, :detach, :duplex, :environment, :stdout, :stderr, :cwd
+      attr_reader :stdin
+
+      def initialize(args)
+        @args        = args
+
+        @detach      = false
+        @duplex      = false
+        @environment = nil
+        @cwd         = nil
+
+        @stdout      = nil
+        @stderr      = nil
+        @stdin       = nil
+
+        @flags       = 0
+        @job_ptr     = nil
+        @cmd_ptr     = nil
+        @env_ptr     = nil
+        @cwd_ptr     = nil
+      end
+
+      def start
+        create_command_pointer
+        create_environment_pointer
+        create_cwd_pointer
+
+        setup_flags
+        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?
+
+        strings = []
+
+        ENV.to_hash.merge(@environment).each do |key, val|
+          next if val.nil?
+
+          if key.to_s =~ /=|\0/ || val.to_s.include?("\0")
+            raise InvalidEnvironmentVariable, "#{key.inspect} => #{val.inspect}"
+          end
+
+          strings << "#{key}=#{val}\0"
+        end
+
+        strings << "\0" # terminate the env block
+        env_str = strings.join
+
+        @env_ptr = FFI::MemoryPointer.new(:long, env_str.bytesize)
+        @env_ptr.put_bytes 0, env_str, 0, env_str.bytesize
+      end
+
+      def create_cwd_pointer
+        @cwd_ptr = FFI::MemoryPointer.from_string(@cwd || Dir.pwd)
+      end
+
+      def create_process
+        ok = Lib.create_process(
+          nil,          # application name
+          @cmd_ptr,     # command line
+          nil,          # process attributes
+          nil,          # thread attributes
+          true,         # inherit handles
+          @flags,       # creation flags
+          @env_ptr,     # environment
+          @cwd_ptr,     # 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_flags
+        @flags |= DETACHED_PROCESS if @detach
+        @flags |= CREATE_BREAKAWAY_FROM_JOB if @leader
+      end
+
+      def setup_io
+        startup_info[:dwFlags] ||= 0
+        startup_info[:dwFlags] |= STARTF_USESTDHANDLES
+
+        if @stdout
+          startup_info[:hStdOutput] = std_stream_handle_for(@stdout)
+        end
+
+        if @stderr
+          startup_info[:hStdError] = std_stream_handle_for(@stderr)
+        end
+
+        if @duplex
+          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 @read_pipe, true
+          Lib.set_handle_inheritance @write_pipe, false
+
+          startup_info[:hStdInput] = @read_pipe
+        else
+          startup_info[:hStdInput] = std_stream_handle_for(STDIN)
+        end
+      end
+
+      def std_stream_handle_for(io)
+        handle = Lib.handle_for(io)
+
+        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 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 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
+end