childprocess 0.8.0 → 3.0.0

data/lib/childprocess/jruby/pump.rb

@@ -1,53 +1,53 @@
-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
+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

data/lib/childprocess/tools/generator.rb

@@ -1,146 +1,146 @@
-require 'fileutils'
-
-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
+require 'fileutils'
+
+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

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/unix/fork_exec_process.rb

@@ -1,70 +1,78 @@
-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
+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
+
+          if stdout
+            STDOUT.reopen(stdout)
+          else
+            STDOUT.reopen("/dev/null", "a+")
+          end
+          if stderr
+            STDERR.reopen(stderr)
+          else
+            STDERR.reopen("/dev/null", "a+")
+          end
+
+          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