aggkit 0.2.5

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

@@ -0,0 +1,161 @@
+require "java"
+
+module Aggkit
+module ChildProcess
+  module JRuby
+    class Process < AbstractProcess
+      def initialize(args)
+        super(args)
+
+        @pumps = []
+      end
+
+      def io
+        @io ||= JRuby::IO.new
+      end
+
+      def exited?
+        return true if @exit_code
+
+        assert_started
+        @exit_code = @process.exitValue
+        stop_pumps
+
+        true
+      rescue java.lang.IllegalThreadStateException => ex
+        log(ex.class => ex.message)
+        false
+      ensure
+        log(:exit_code => @exit_code)
+      end
+
+      def stop(timeout = nil)
+        assert_started
+
+        @process.destroy
+        wait # no way to actually use the timeout here..
+      end
+
+      def wait
+        if exited?
+          exit_code
+        else
+          @process.waitFor
+
+          stop_pumps
+          @exit_code = @process.exitValue
+        end
+      end
+
+      #
+      # Only supported in JRuby on a Unix operating system, thanks to limitations
+      # in Java's classes
+      #
+      # @return [Integer] the pid of the process after it has started
+      # @raise [NotImplementedError] when trying to access pid on non-Unix platform
+      #
+      def pid
+        if @process.getClass.getName != "java.lang.UNIXProcess"
+          raise NotImplementedError, "pid is only supported by JRuby child processes on Unix"
+        end
+
+        # About the best way we can do this is with a nasty reflection-based impl
+        # Thanks to Martijn Courteaux
+        # http://stackoverflow.com/questions/2950338/how-can-i-kill-a-linux-process-in-java-with-sigkill-process-destroy-does-sigter/2951193#2951193
+        field = @process.getClass.getDeclaredField("pid")
+        field.accessible = true
+        field.get(@process)
+      end
+
+      private
+
+      def launch_process(&blk)
+        pb = java.lang.ProcessBuilder.new(@args)
+
+        pb.directory java.io.File.new(@cwd || Dir.pwd)
+        set_env pb.environment
+
+        begin
+          @process = pb.start
+        rescue java.io.IOException => ex
+          raise LaunchError, ex.message
+        end
+
+        setup_io
+      end
+
+      def setup_io
+        if @io
+          redirect(@process.getErrorStream, @io.stderr)
+          redirect(@process.getInputStream, @io.stdout)
+        else
+          @process.getErrorStream.close
+          @process.getInputStream.close
+        end
+
+        if duplex?
+          io._stdin = create_stdin
+        else
+          @process.getOutputStream.close
+        end
+      end
+
+      def redirect(input, output)
+        if output.nil?
+          input.close
+          return
+        end
+
+        @pumps << Pump.new(input, output.to_outputstream).run
+      end
+
+      def stop_pumps
+        @pumps.each { |pump| pump.stop }
+      end
+
+      def set_env(env)
+        merged = ENV.to_hash
+
+        @environment.each { |k, v| merged[k.to_s] = v }
+
+        merged.each do |k, v|
+          if v
+            env.put(k, v.to_s)
+          elsif env.has_key? k
+            env.remove(k)
+          end
+        end
+
+        removed_keys = env.key_set.to_a - merged.keys
+        removed_keys.each { |k| env.remove(k) }
+      end
+
+      def create_stdin
+        output_stream = @process.getOutputStream
+
+        stdin = output_stream.to_io
+        stdin.sync = true
+        stdin.instance_variable_set(:@childprocess_java_stream, output_stream)
+
+        class << stdin
+          # The stream provided is a BufferedeOutputStream, so we
+          # have to flush it to make the bytes flow to the process
+          def __childprocess_flush__
+            @childprocess_java_stream.flush
+          end
+
+          [:flush, :print, :printf, :putc, :puts, :write, :write_nonblock].each do |m|
+            define_method(m) do |*args|
+              super(*args)
+              self.__childprocess_flush__
+            end
+          end
+        end
+
+        stdin
+      end
+
+    end # Process
+  end # JRuby
+end # ChildProcess
+end

data/lib/aggkit/childprocess/jruby/pump.rb

@@ -0,0 +1,55 @@
+module Aggkit
+module ChildProcess
+  module JRuby
+    class Pump
+      BUFFER_SIZE = 2048
+
+      def initialize(input, output)
+        @input  = input
+        @output = output
+        @stop   = false
+      end
+
+      def stop
+        @stop = true
+        @thread && @thread.join
+      end
+
+      def run
+        @thread = Thread.new { pump }
+
+        self
+      end
+
+      private
+
+      def pump
+        buffer = Java.byte[BUFFER_SIZE].new
+
+        until @stop && (@input.available == 0)
+          read, avail = 0, 0
+
+          while read != -1
+            avail = [@input.available, 1].max
+            avail = BUFFER_SIZE if avail > BUFFER_SIZE
+            read = @input.read(buffer, 0, avail)
+
+            if read > 0
+              @output.write(buffer, 0, read)
+              @output.flush
+            end
+          end
+
+          sleep 0.1
+        end
+
+        @output.flush
+      rescue java.io.IOException => ex
+        ChildProcess.logger.debug ex.message
+        ChildProcess.logger.debug ex.backtrace
+      end
+
+    end # Pump
+  end # JRuby
+end # ChildProcess
+end

data/lib/aggkit/childprocess/jruby.rb

@@ -0,0 +1,58 @@
+require 'java'
+require 'jruby'
+
+class Java::SunNioCh::FileChannelImpl
+  field_reader :fd
+end
+
+class Java::JavaIo::FileDescriptor
+  if ChildProcess.os == :windows
+    field_reader :handle
+  end
+
+  field_reader :fd
+end
+
+module Aggkit
+module ChildProcess
+  module JRuby
+    def self.posix_fileno_for(obj)
+      channel = ::JRuby.reference(obj).channel
+      begin
+        channel.getFDVal
+      rescue NoMethodError
+        fileno = channel.fd
+        if fileno.kind_of?(Java::JavaIo::FileDescriptor)
+          fileno = fileno.fd
+        end
+
+        fileno == -1 ? obj.fileno : fileno
+      end
+    rescue
+      # fall back
+      obj.fileno
+    end
+
+    def self.windows_handle_for(obj)
+      channel = ::JRuby.reference(obj).channel
+      fileno = obj.fileno
+
+      begin
+        fileno = channel.getFDVal
+      rescue NoMethodError
+        fileno = channel.fd if channel.respond_to?(:fd)
+      end
+
+      if fileno.kind_of? Java::JavaIo::FileDescriptor
+        fileno.handle
+      else
+        Windows::Lib.handle_for fileno
+      end
+    end
+  end
+end
+end
+
+require "aggkit/childprocess/jruby/pump"
+require "aggkit/childprocess/jruby/io"
+require "aggkit/childprocess/jruby/process"

data/lib/aggkit/childprocess/tools/generator.rb

@@ -0,0 +1,148 @@
+require 'fileutils'
+
+module Aggkit
+module ChildProcess
+  module Tools
+    class Generator
+      EXE_NAME         = "childprocess-sizeof-generator"
+      TMP_PROGRAM      = "childprocess-sizeof-generator.c"
+      DEFAULT_INCLUDES = %w[stdio.h stddef.h]
+
+      def self.generate
+        new.generate
+      end
+
+      def initialize
+        @cc        = ENV['CC'] || 'gcc'
+        @out       = File.expand_path("../../unix/platform/#{ChildProcess.platform_name}.rb", __FILE__)
+        @sizeof    = {}
+        @constants = {}
+      end
+
+      def generate
+        fetch_size 'posix_spawn_file_actions_t', :include => "spawn.h"
+        fetch_size 'posix_spawnattr_t', :include => "spawn.h"
+        fetch_size 'sigset_t', :include => "signal.h"
+
+        fetch_constant 'POSIX_SPAWN_RESETIDS',   :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETPGROUP',  :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETSIGDEF',  :include  => 'spawn.h'
+        fetch_constant 'POSIX_SPAWN_SETSIGMASK', :include  => 'spawn.h'
+
+        if ChildProcess.linux?
+          fetch_constant 'POSIX_SPAWN_USEVFORK', :include => 'spawn.h', :define => {'_GNU_SOURCE' => nil}
+        end
+
+        write
+      end
+
+      def write
+        FileUtils.mkdir_p(File.dirname(@out))
+        File.open(@out, 'w') do |io|
+          io.puts result
+        end
+
+        puts "wrote #{@out}"
+      end
+
+      def fetch_size(type_name, opts = {})
+        print "sizeof(#{type_name}): "
+        src = <<-EOF
+int main() {
+  printf("%d", (unsigned int)sizeof(#{type_name}));
+  return 0;
+}
+        EOF
+
+        output = execute(src, opts)
+
+        if output.to_i < 1
+          raise "sizeof(#{type_name}) == #{output.to_i} (output=#{output})"
+        end
+
+        size = output.to_i
+        @sizeof[type_name] = size
+
+        puts size
+      end
+
+      def fetch_constant(name, opts)
+        print "#{name}: "
+        src = <<-EOF
+int main() {
+  printf("%d", (unsigned int)#{name});
+  return 0;
+}
+        EOF
+
+        output = execute(src, opts)
+        value  = Integer(output)
+        @constants[name] = value
+
+        puts value
+      end
+
+
+      def execute(src, opts)
+        program = Array(opts[:define]).map do |key, value|
+          <<-SRC
+#ifndef #{key}
+#define #{key} #{value}
+#endif
+          SRC
+        end.join("\n")
+        program << "\n"
+
+        includes = Array(opts[:include]) + DEFAULT_INCLUDES
+        program << includes.map { |include| "#include <#{include}>" }.join("\n")
+        program << "\n#{src}"
+
+        File.open(TMP_PROGRAM, 'w') do |file|
+          file << program
+        end
+
+        cmd = "#{@cc} #{TMP_PROGRAM} -o #{EXE_NAME}"
+        system cmd
+        unless $?.success?
+          raise "failed to compile program: #{cmd.inspect}\n#{program}"
+        end
+
+        output = `./#{EXE_NAME} 2>&1`
+
+        unless $?.success?
+          raise "failed to run program: #{cmd.inspect}\n#{output}"
+        end
+
+        output.chomp
+      ensure
+        File.delete TMP_PROGRAM if File.exist?(TMP_PROGRAM)
+        File.delete EXE_NAME if File.exist?(EXE_NAME)
+      end
+
+      def result
+        if @sizeof.empty? && @constants.empty?
+          raise "no data collected, nothing to do"
+        end
+
+        out =  ['module ChildProcess::Unix::Platform']
+        out << '  SIZEOF = {'
+
+        max = @sizeof.keys.map { |e| e.length }.max
+        @sizeof.each_with_index do |(type, size), idx|
+          out << "     :#{type.ljust max} => #{size}#{',' unless idx == @sizeof.size - 1}"
+        end
+        out << '  }'
+
+        max = @constants.keys.map { |e| e.length }.max
+        @constants.each do |name, val|
+          out << "  #{name.ljust max} = #{val}"
+        end
+        out << 'end'
+
+        out.join "\n"
+      end
+
+    end
+  end
+end
+end

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

@@ -0,0 +1,72 @@
+module Aggkit
+module ChildProcess
+  module Unix
+    class ForkExecProcess < Process
+      private
+
+      def launch_process
+        if @io
+          stdout = @io.stdout
+          stderr = @io.stderr
+        end
+
+        # pipe used to detect exec() failure
+        exec_r, exec_w = ::IO.pipe
+        ChildProcess.close_on_exec exec_w
+
+        if duplex?
+          reader, writer = ::IO.pipe
+        end
+
+        @pid = Kernel.fork {
+          # Children of the forked process will inherit its process group
+          # This is to make sure that all grandchildren dies when this Process instance is killed
+          ::Process.setpgid 0, 0 if leader?
+
+          if @cwd
+            Dir.chdir(@cwd)
+          end
+
+          exec_r.close
+          set_env
+
+          STDOUT.reopen(stdout || "/dev/null")
+          STDERR.reopen(stderr || "/dev/null")
+
+          if duplex?
+            STDIN.reopen(reader)
+            writer.close
+          end
+
+          executable, *args = @args
+
+          begin
+            Kernel.exec([executable, executable], *args)
+          rescue SystemCallError => ex
+            exec_w << ex.message
+          end
+        }
+
+        exec_w.close
+
+        if duplex?
+          io._stdin = writer
+          reader.close
+        end
+
+        # if we don't eventually get EOF, exec() failed
+        unless exec_r.eof?
+          raise LaunchError, exec_r.read || "executing command with #{@args.inspect} failed"
+        end
+
+        ::Process.detach(@pid) if detach?
+      end
+
+      def set_env
+        @environment.each { |k, v| ENV[k.to_s] = v.nil? ? nil : v.to_s }
+      end
+
+    end # Process
+  end # Unix
+end # ChildProcess
+end

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

@@ -0,0 +1,22 @@
+module Aggkit
+module ChildProcess
+  module Unix
+    class IO < AbstractIO
+      private
+
+      def check_type(io)
+        unless io.respond_to? :to_io
+          raise ArgumentError, "expected #{io.inspect} to respond to :to_io"
+        end
+
+        result = io.to_io
+        unless result && result.kind_of?(::IO)
+          raise TypeError, "expected IO, got #{result.inspect}:#{result.class}"
+        end
+      end
+
+    end # IO
+  end # Unix
+end # ChildProcess
+end
+

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

@@ -0,0 +1,188 @@
+module Aggkit
+module ChildProcess
+  module Unix
+    module Lib
+      extend FFI::Library
+      ffi_lib FFI::Library::LIBC
+
+      if ChildProcess.os == :macosx
+        attach_function :_NSGetEnviron, [], :pointer
+        def self.environ
+          _NSGetEnviron().read_pointer
+        end
+      elsif respond_to? :attach_variable
+        attach_variable :environ, :pointer
+      end
+
+      attach_function :strerror, [:int], :string
+      attach_function :chdir, [:string], :int
+      attach_function :fcntl, [:int, :int, :int], :int # fcntl actually takes varags, but we only need this version.
+
+      # int posix_spawnp(
+      #   pid_t *restrict pid,
+      #   const char *restrict file,
+      #   const posix_spawn_file_actions_t *file_actions,
+      #   const posix_spawnattr_t *restrict attrp,
+      #   char *const argv[restrict],
+      #   char *const envp[restrict]
+      # );
+
+      attach_function :posix_spawnp, [
+        :pointer,
+        :string,
+        :pointer,
+        :pointer,
+        :pointer,
+        :pointer
+      ], :int
+
+      # int posix_spawn_file_actions_init(posix_spawn_file_actions_t *file_actions);
+      attach_function :posix_spawn_file_actions_init, [:pointer], :int
+
+      # int posix_spawn_file_actions_destroy(posix_spawn_file_actions_t *file_actions);
+      attach_function :posix_spawn_file_actions_destroy, [:pointer], :int
+
+      # int posix_spawn_file_actions_addclose(posix_spawn_file_actions_t *file_actions, int filedes);
+      attach_function :posix_spawn_file_actions_addclose, [:pointer, :int], :int
+
+      # int posix_spawn_file_actions_addopen(
+      #   posix_spawn_file_actions_t *restrict file_actions,
+      #   int filedes,
+      #   const char *restrict path,
+      #   int oflag,
+      #   mode_t mode
+      # );
+      attach_function :posix_spawn_file_actions_addopen, [:pointer, :int, :string, :int, :mode_t], :int
+
+      # int posix_spawn_file_actions_adddup2(
+      #   posix_spawn_file_actions_t *file_actions,
+      #   int filedes,
+      #   int newfiledes
+      # );
+      attach_function :posix_spawn_file_actions_adddup2, [:pointer, :int, :int], :int
+
+      # int posix_spawnattr_init(posix_spawnattr_t *attr);
+      attach_function :posix_spawnattr_init, [:pointer], :int
+
+      # int posix_spawnattr_destroy(posix_spawnattr_t *attr);
+      attach_function :posix_spawnattr_destroy, [:pointer], :int
+
+      # int posix_spawnattr_setflags(posix_spawnattr_t *attr, short flags);
+      attach_function :posix_spawnattr_setflags, [:pointer, :short], :int
+
+      # int posix_spawnattr_getflags(const posix_spawnattr_t *restrict attr, short *restrict flags);
+      attach_function :posix_spawnattr_getflags, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_setpgroup(posix_spawnattr_t *attr, pid_t pgroup);
+      attach_function :posix_spawnattr_setpgroup, [:pointer, :pid_t], :int
+
+      # int posix_spawnattr_getpgroup(const posix_spawnattr_t *restrict attr, pid_t *restrict pgroup);
+      attach_function :posix_spawnattr_getpgroup, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_setsigdefault(posix_spawnattr_t *restrict attr, const sigset_t *restrict sigdefault);
+      attach_function :posix_spawnattr_setsigdefault, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_getsigdefault(const posix_spawnattr_t *restrict attr, sigset_t *restrict sigdefault);
+      attach_function :posix_spawnattr_getsigdefault, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_setsigmask(posix_spawnattr_t *restrict attr, const sigset_t *restrict sigmask);
+      attach_function :posix_spawnattr_setsigmask, [:pointer, :pointer], :int
+
+      # int posix_spawnattr_getsigmask(const posix_spawnattr_t *restrict attr, sigset_t *restrict sigmask);
+      attach_function :posix_spawnattr_getsigmask, [:pointer, :pointer], :int
+
+      def self.check(errno)
+        if errno != 0
+          raise Error, Lib.strerror(FFI.errno)
+        end
+      end
+
+      class FileActions
+        def initialize
+          @ptr = FFI::MemoryPointer.new(1, Platform::SIZEOF.fetch(:posix_spawn_file_actions_t), false)
+          Lib.check Lib.posix_spawn_file_actions_init(@ptr)
+        end
+
+        def add_close(fileno)
+          Lib.check Lib.posix_spawn_file_actions_addclose(
+            @ptr,
+            fileno
+          )
+        end
+
+        def add_open(fileno, path, oflag, mode)
+          Lib.check Lib.posix_spawn_file_actions_addopen(
+            @ptr,
+            fileno,
+            path,
+            oflag,
+            mode
+          )
+        end
+
+        def add_dup(fileno, new_fileno)
+          Lib.check Lib.posix_spawn_file_actions_adddup2(
+            @ptr,
+            fileno,
+            new_fileno
+          )
+        end
+
+        def free
+          Lib.check Lib.posix_spawn_file_actions_destroy(@ptr)
+          @ptr = nil
+        end
+
+        def to_ptr
+          @ptr
+        end
+      end # FileActions
+
+      class Attrs
+        def initialize
+          @ptr = FFI::MemoryPointer.new(1, Platform::SIZEOF.fetch(:posix_spawnattr_t), false)
+          Lib.check Lib.posix_spawnattr_init(@ptr)
+        end
+
+        def free
+          Lib.check Lib.posix_spawnattr_destroy(@ptr)
+          @ptr = nil
+        end
+
+        def flags=(flags)
+          Lib.check Lib.posix_spawnattr_setflags(@ptr, flags)
+        end
+
+        def flags
+          ptr = FFI::MemoryPointer.new(:short)
+          Lib.check Lib.posix_spawnattr_getflags(@ptr, ptr)
+
+          ptr.read_short
+        end
+
+        def pgroup=(pid)
+          self.flags |= Platform::POSIX_SPAWN_SETPGROUP
+          Lib.check Lib.posix_spawnattr_setpgroup(@ptr, pid)
+        end
+
+        def to_ptr
+          @ptr
+        end
+      end # Attrs
+
+    end
+  end
+end
+end
+
+# missing on rubinius
+class FFI::MemoryPointer
+  unless method_defined?(:from_string)
+    def self.from_string(str)
+      ptr = new(1, str.bytesize + 1)
+      ptr.write_string("#{str}\0")
+
+      ptr
+    end
+  end
+end if defined?(FFI)