From fcbf63e62c627deae76c1b8cb8c0876c536ed811 Mon Sep 17 00:00:00 2001 From: Jari Vetoniemi Date: Mon, 16 Mar 2020 18:49:26 +0900 Subject: Fresh start --- jni/ruby/lib/shell/builtin-command.rb | 146 +++++++ jni/ruby/lib/shell/command-processor.rb | 667 +++++++++++++++++++++++++++++++ jni/ruby/lib/shell/error.rb | 25 ++ jni/ruby/lib/shell/filter.rb | 137 +++++++ jni/ruby/lib/shell/process-controller.rb | 310 ++++++++++++++ jni/ruby/lib/shell/system-command.rb | 158 ++++++++ jni/ruby/lib/shell/version.rb | 15 + 7 files changed, 1458 insertions(+) create mode 100644 jni/ruby/lib/shell/builtin-command.rb create mode 100644 jni/ruby/lib/shell/command-processor.rb create mode 100644 jni/ruby/lib/shell/error.rb create mode 100644 jni/ruby/lib/shell/filter.rb create mode 100644 jni/ruby/lib/shell/process-controller.rb create mode 100644 jni/ruby/lib/shell/system-command.rb create mode 100644 jni/ruby/lib/shell/version.rb (limited to 'jni/ruby/lib/shell') diff --git a/jni/ruby/lib/shell/builtin-command.rb b/jni/ruby/lib/shell/builtin-command.rb new file mode 100644 index 0000000..8e549dd --- /dev/null +++ b/jni/ruby/lib/shell/builtin-command.rb @@ -0,0 +1,146 @@ +# +# shell/builtin-command.rb - +# $Release Version: 0.7 $ +# $Revision: 47246 $ +# by Keiju ISHITSUKA(keiju@ruby-lang.org) +# +# -- +# +# +# + +require "shell/filter" + +class Shell + class BuiltInCommand + # + def expand_path(path) + @shell.expand_path(path) + end + + # call-seq: + # foreach(path, record_separator) -> Enumerator + # foreach(path, record_separator) { block } + # + # See IO.foreach when +path+ is a file. + # + # See Dir.foreach when +path+ is a directory. + # + def foreach(path = nil, *rs) + path = "." unless path + path = expand_path(path) + + if File.directory?(path) + Dir.foreach(path){|fn| yield fn} + else + IO.foreach(path, *rs){|l| yield l} + end + end + + # call-seq: + # open(path, mode, permissions) -> Enumerator + # open(path, mode, permissions) { block } + # + # See IO.open when +path+ is a file. + # + # See Dir.open when +path+ is a directory. + # + def open(path, mode = nil, perm = 0666, &b) + path = expand_path(path) + if File.directory?(path) + Dir.open(path, &b) + else + if @shell.umask + f = File.open(path, mode, perm) + File.chmod(perm & ~@shell.umask, path) + if block_given? + f.each(&b) + end + f + else + File.open(path, mode, perm, &b) + end + end + end + + # call-seq: + # unlink(path) + # + # See IO.unlink when +path+ is a file. + # + # See Dir.unlink when +path+ is a directory. + # + def unlink(path) + @shell.check_point + + path = expand_path(path) + if File.directory?(path) + Dir.unlink(path) + else + IO.unlink(path) + end + Void.new(@shell) + end + + # See Shell::CommandProcessor#test + alias top_level_test test + # call-seq: + # test(command, file1, file2) -> true or false + # [command, file1, file2] -> true or false + # + # Tests if the given +command+ exists in +file1+, or optionally +file2+. + # + # Example: + # sh[?e, "foo"] + # sh[:e, "foo"] + # sh["e", "foo"] + # sh[:exists?, "foo"] + # sh["exists?", "foo"] + # + def test(command, file1, file2=nil) + file1 = expand_path(file1) + file2 = expand_path(file2) if file2 + command = command.id2name if command.kind_of?(Symbol) + + case command + when Integer + if file2 + top_level_test(command, file1, file2) + else + top_level_test(command, file1) + end + when String + if command.size == 1 + if file2 + top_level_test(command, file1, file2) + else + top_level_test(command, file1) + end + else + if file2 + FileTest.send(command, file1, file2) + else + FileTest.send(command, file1) + end + end + end + end + # See Shell::CommandProcessor#test + alias [] test + + # call-seq: + # mkdir(path) + # + # Same as Dir.mkdir, except multiple directories are allowed. + def mkdir(*path) + @shell.check_point + notify("mkdir #{path.join(' ')}") + + perm = nil + if path.last.kind_of?(Integer) + perm = path.pop + end + for dir in path + d = expand_path(dir) + if perm + Dir.mkdir(d, perm) + else + Dir.mkdir(d) + end + File.chmod(d, 0666 & ~@shell.umask) if @shell.umask + end + Void.new(@shell) + end + + # call-seq: + # rmdir(path) + # + # Same as Dir.rmdir, except multiple directories are allowed. + def rmdir(*path) + @shell.check_point + notify("rmdir #{path.join(' ')}") + + for dir in path + Dir.rmdir(expand_path(dir)) + end + Void.new(@shell) + end + + # call-seq: + # system(command, *options) -> SystemCommand + # + # Executes the given +command+ with the +options+ parameter. + # + # Example: + # print sh.system("ls", "-l") + # sh.system("ls", "-l") | sh.head > STDOUT + # + def system(command, *opts) + if opts.empty? + if command =~ /\*|\?|\{|\}|\[|\]|<|>|\(|\)|~|&|\||\\|\$|;|'|`|"|\n/ + return SystemCommand.new(@shell, find_system_command("sh"), "-c", command) + else + command, *opts = command.split(/\s+/) + end + end + SystemCommand.new(@shell, find_system_command(command), *opts) + end + + # call-seq: + # rehash + # + # Clears the command hash table. + def rehash + @system_commands = {} + end + + def check_point # :nodoc: + @shell.process_controller.wait_all_jobs_execution + end + alias finish_all_jobs check_point # :nodoc: + + # call-seq: + # transact { block } + # + # Executes a block as self + # + # Example: + # sh.transact { system("ls", "-l") | head > STDOUT } + def transact(&block) + begin + @shell.instance_eval(&block) + ensure + check_point + end + end + + # call-seq: + # out(device) { block } + # + # Calls device.print on the result passing the _block_ to + # #transact + def out(dev = STDOUT, &block) + dev.print transact(&block) + end + + # call-seq: + # echo(*strings) -> Echo + # + # Returns a Echo object, for the given +strings+ + def echo(*strings) + Echo.new(@shell, *strings) + end + + # call-seq: + # cat(*filename) -> Cat + # + # Returns a Cat object, for the given +filenames+ + def cat(*filenames) + Cat.new(@shell, *filenames) + end + + # def sort(*filenames) + # Sort.new(self, *filenames) + # end + # call-seq: + # glob(pattern) -> Glob + # + # Returns a Glob filter object, with the given +pattern+ object + def glob(pattern) + Glob.new(@shell, pattern) + end + + def append(to, filter) + case to + when String + AppendFile.new(@shell, to, filter) + when IO + AppendIO.new(@shell, to, filter) + else + Shell.Fail Error::CantApplyMethod, "append", to.class + end + end + + # call-seq: + # tee(file) -> Tee + # + # Returns a Tee filter object, with the given +file+ command + def tee(file) + Tee.new(@shell, file) + end + + # call-seq: + # concat(*jobs) -> Concat + # + # Returns a Concat object, for the given +jobs+ + def concat(*jobs) + Concat.new(@shell, *jobs) + end + + # %pwd, %cwd -> @pwd + def notify(*opts) + Shell.notify(*opts) {|mes| + yield mes if iterator? + + mes.gsub!("%pwd", "#{@cwd}") + mes.gsub!("%cwd", "#{@cwd}") + } + end + + # + # private functions + # + def find_system_command(command) + return command if /^\// =~ command + case path = @system_commands[command] + when String + if exists?(path) + return path + else + Shell.Fail Error::CommandNotFound, command + end + when false + Shell.Fail Error::CommandNotFound, command + end + + for p in @shell.system_path + path = join(p, command) + begin + st = File.stat(path) + rescue SystemCallError + next + else + next unless st.executable? and !st.directory? + @system_commands[command] = path + return path + end + end + @system_commands[command] = false + Shell.Fail Error::CommandNotFound, command + end + + # call-seq: + # def_system_command(command, path) -> Shell::SystemCommand + # + # Defines a command, registering +path+ as a Shell method for the given + # +command+. + # + # Shell::CommandProcessor.def_system_command "ls" + # #=> Defines ls. + # + # Shell::CommandProcessor.def_system_command "sys_sort", "sort" + # #=> Defines sys_sort as sort + # + def self.def_system_command(command, path = command) + begin + eval((d = %Q[def #{command}(*opts) + SystemCommand.new(@shell, '#{path}', *opts) + end]), nil, __FILE__, __LINE__ - 1) + rescue SyntaxError + Shell.notify "warn: Can't define #{command} path: #{path}." + end + Shell.notify "Define #{command} path: #{path}.", Shell.debug? + Shell.notify("Definition of #{command}: ", d, + Shell.debug.kind_of?(Integer) && Shell.debug > 1) + end + + # call-seq: + # undef_system_command(command) -> self + # + # Undefines a command + def self.undef_system_command(command) + command = command.id2name if command.kind_of?(Symbol) + remove_method(command) + Shell.module_eval{remove_method(command)} + Filter.module_eval{remove_method(command)} + self + end + + @alias_map = {} + # Returns a list of aliased commands + def self.alias_map + @alias_map + end + # call-seq: + # alias_command(alias, command, *options) -> self + # + # Creates a command alias at the given +alias+ for the given +command+, + # passing any +options+ along with it. + # + # Shell::CommandProcessor.alias_command "lsC", "ls", "-CBF", "--show-control-chars" + # Shell::CommandProcessor.alias_command("lsC", "ls"){|*opts| ["-CBF", "--show-control-chars", *opts]} + # + def self.alias_command(ali, command, *opts) + ali = ali.id2name if ali.kind_of?(Symbol) + command = command.id2name if command.kind_of?(Symbol) + begin + if iterator? + @alias_map[ali.intern] = proc + + eval((d = %Q[def #{ali}(*opts) + @shell.__send__(:#{command}, + *(CommandProcessor.alias_map[:#{ali}].call *opts)) + end]), nil, __FILE__, __LINE__ - 1) + + else + args = opts.collect{|opt| '"' + opt + '"'}.join(",") + eval((d = %Q[def #{ali}(*opts) + @shell.__send__(:#{command}, #{args}, *opts) + end]), nil, __FILE__, __LINE__ - 1) + end + rescue SyntaxError + Shell.notify "warn: Can't alias #{ali} command: #{command}." + Shell.notify("Definition of #{ali}: ", d) + raise + end + Shell.notify "Define #{ali} command: #{command}.", Shell.debug? + Shell.notify("Definition of #{ali}: ", d, + Shell.debug.kind_of?(Integer) && Shell.debug > 1) + self + end + + # call-seq: + # unalias_command(alias) -> self + # + # Unaliases the given +alias+ command. + def self.unalias_command(ali) + ali = ali.id2name if ali.kind_of?(Symbol) + @alias_map.delete ali.intern + undef_system_command(ali) + end + + # :nodoc: + # + # Delegates File and FileTest methods into Shell, including the following + # commands: + # + # * Shell#blockdev?(file) + # * Shell#chardev?(file) + # * Shell#directory?(file) + # * Shell#executable?(file) + # * Shell#executable_real?(file) + # * Shell#exist?(file)/Shell#exists?(file) + # * Shell#file?(file) + # * Shell#grpowned?(file) + # * Shell#owned?(file) + # * Shell#pipe?(file) + # * Shell#readable?(file) + # * Shell#readable_real?(file) + # * Shell#setgid?(file) + # * Shell#setuid?(file) + # * Shell#size(file)/Shell#size?(file) + # * Shell#socket?(file) + # * Shell#sticky?(file) + # * Shell#symlink?(file) + # * Shell#writable?(file) + # * Shell#writable_real?(file) + # * Shell#zero?(file) + # * Shell#syscopy(filename_from, filename_to) + # * Shell#copy(filename_from, filename_to) + # * Shell#move(filename_from, filename_to) + # * Shell#compare(filename_from, filename_to) + # * Shell#safe_unlink(*filenames) + # * Shell#makedirs(*filenames) + # * Shell#install(filename_from, filename_to, mode) + # + # And also, there are some aliases for convenience: + # + # * Shell#cmp <- Shell#compare + # * Shell#mv <- Shell#move + # * Shell#cp <- Shell#copy + # * Shell#rm_f <- Shell#safe_unlink + # * Shell#mkpath <- Shell#makedirs + # + def self.def_builtin_commands(delegation_class, command_specs) + for meth, args in command_specs + arg_str = args.collect{|arg| arg.downcase}.join(", ") + call_arg_str = args.collect{ + |arg| + case arg + when /^(FILENAME.*)$/ + format("expand_path(%s)", $1.downcase) + when /^(\*FILENAME.*)$/ + # \*FILENAME* -> filenames.collect{|fn| expand_path(fn)}.join(", ") + $1.downcase + '.collect{|fn| expand_path(fn)}' + else + arg + end + }.join(", ") + d = %Q[def #{meth}(#{arg_str}) + #{delegation_class}.#{meth}(#{call_arg_str}) + end] + Shell.notify "Define #{meth}(#{arg_str})", Shell.debug? + Shell.notify("Definition of #{meth}: ", d, + Shell.debug.kind_of?(Integer) && Shell.debug > 1) + eval d + end + end + + # call-seq: + # install_system_commands(prefix = "sys_") + # + # Defines all commands in the Shell.default_system_path as Shell method, + # all with given +prefix+ appended to their names. + # + # Any invalid character names are converted to +_+, and errors are passed + # to Shell.notify. + # + # Methods already defined are skipped. + def self.install_system_commands(pre = "sys_") + defined_meth = {} + for m in Shell.methods + defined_meth[m] = true + end + sh = Shell.new + for path in Shell.default_system_path + next unless sh.directory? path + sh.cd path + sh.foreach do + |cn| + if !defined_meth[pre + cn] && sh.file?(cn) && sh.executable?(cn) + command = (pre + cn).gsub(/\W/, "_").sub(/^([0-9])/, '_\1') + begin + def_system_command(command, sh.expand_path(cn)) + rescue + Shell.notify "warn: Can't define #{command} path: #{cn}" + end + defined_meth[command] = command + end + end + end + end + + def self.add_delegate_command_to_shell(id) # :nodoc: + id = id.intern if id.kind_of?(String) + name = id.id2name + if Shell.method_defined?(id) + Shell.notify "warn: override definition of Shell##{name}." + Shell.notify "warn: alias Shell##{name} to Shell##{name}_org.\n" + Shell.module_eval "alias #{name}_org #{name}" + end + Shell.notify "method added: Shell##{name}.", Shell.debug? + Shell.module_eval(%Q[def #{name}(*args, &block) + begin + @command_processor.__send__(:#{name}, *args, &block) + rescue Exception + $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #` + $@.delete_if{|s| /^\\(eval\\):/ =~ s} + raise + end + end], __FILE__, __LINE__) + + if Shell::Filter.method_defined?(id) + Shell.notify "warn: override definition of Shell::Filter##{name}." + Shell.notify "warn: alias Shell##{name} to Shell::Filter##{name}_org." + Filter.module_eval "alias #{name}_org #{name}" + end + Shell.notify "method added: Shell::Filter##{name}.", Shell.debug? + Filter.module_eval(%Q[def #{name}(*args, &block) + begin + self | @shell.__send__(:#{name}, *args, &block) + rescue Exception + $@.delete_if{|s| /:in `__getobj__'$/ =~ s} #` + $@.delete_if{|s| /^\\(eval\\):/ =~ s} + raise + end + end], __FILE__, __LINE__) + end + + # Delegates File methods into Shell, including the following commands: + # + # * Shell#atime(file) + # * Shell#basename(file, *opt) + # * Shell#chmod(mode, *files) + # * Shell#chown(owner, group, *file) + # * Shell#ctime(file) + # * Shell#delete(*file) + # * Shell#dirname(file) + # * Shell#ftype(file) + # * Shell#join(*file) + # * Shell#link(file_from, file_to) + # * Shell#lstat(file) + # * Shell#mtime(file) + # * Shell#readlink(file) + # * Shell#rename(file_from, file_to) + # * Shell#split(file) + # * Shell#stat(file) + # * Shell#symlink(file_from, file_to) + # * Shell#truncate(file, length) + # * Shell#utime(atime, mtime, *file) + # + def self.install_builtin_commands + # method related File. + # (exclude open/foreach/unlink) + normal_delegation_file_methods = [ + ["atime", ["FILENAME"]], + ["basename", ["fn", "*opts"]], + ["chmod", ["mode", "*FILENAMES"]], + ["chown", ["owner", "group", "*FILENAME"]], + ["ctime", ["FILENAMES"]], + ["delete", ["*FILENAMES"]], + ["dirname", ["FILENAME"]], + ["ftype", ["FILENAME"]], + ["join", ["*items"]], + ["link", ["FILENAME_O", "FILENAME_N"]], + ["lstat", ["FILENAME"]], + ["mtime", ["FILENAME"]], + ["readlink", ["FILENAME"]], + ["rename", ["FILENAME_FROM", "FILENAME_TO"]], + ["split", ["pathname"]], + ["stat", ["FILENAME"]], + ["symlink", ["FILENAME_O", "FILENAME_N"]], + ["truncate", ["FILENAME", "length"]], + ["utime", ["atime", "mtime", "*FILENAMES"]]] + + def_builtin_commands(File, normal_delegation_file_methods) + alias_method :rm, :delete + + # method related FileTest + def_builtin_commands(FileTest, + FileTest.singleton_methods(false).collect{|m| [m, ["FILENAME"]]}) + + end + + end +end diff --git a/jni/ruby/lib/shell/error.rb b/jni/ruby/lib/shell/error.rb new file mode 100644 index 0000000..66520c6 --- /dev/null +++ b/jni/ruby/lib/shell/error.rb @@ -0,0 +1,25 @@ +# +# shell/error.rb - +# $Release Version: 0.7 $ +# $Revision: 31641 $ +# by Keiju ISHITSUKA(keiju@ruby-lang.org) +# +# -- +# +# +# + +require "e2mmap" + +class Shell + module Error + extend Exception2MessageMapper + def_e2message TypeError, "wrong argument type %s (expected %s)" + + def_exception :DirStackEmpty, "Directory stack empty." + def_exception :CantDefine, "Can't define method(%s, %s)." + def_exception :CantApplyMethod, "This method(%s) does not apply to this type(%s)." + def_exception :CommandNotFound, "Command not found(%s)." + end +end + diff --git a/jni/ruby/lib/shell/filter.rb b/jni/ruby/lib/shell/filter.rb new file mode 100644 index 0000000..6960217 --- /dev/null +++ b/jni/ruby/lib/shell/filter.rb @@ -0,0 +1,137 @@ +# +# shell/filter.rb - +# $Release Version: 0.7 $ +# $Revision: 44221 $ +# by Keiju ISHITSUKA(keiju@ruby-lang.org) +# +# -- +# +# +# + +class Shell #:nodoc: + # Any result of command execution is a Filter. + # + # This class includes Enumerable, therefore a Filter object can use all + # Enumerable + # facilities. + # + class Filter + include Enumerable + + def initialize(sh) + @shell = sh # parent shell + @input = nil # input filter + end + + attr_reader :input + + def input=(filter) + @input = filter + end + + # call-seq: + # each(record_separator=nil) { block } + # + # Iterates a block for each line. + def each(rs = nil) + rs = @shell.record_separator unless rs + if @input + @input.each(rs){|l| yield l} + end + end + + # call-seq: + # < source + # + # Inputs from +source+, which is either a string of a file name or an IO + # object. + def < (src) + case src + when String + cat = Cat.new(@shell, src) + cat | self + when IO + self.input = src + self + else + Shell.Fail Error::CantApplyMethod, "<", to.class + end + end + + # call-seq: + # > source + # + # Outputs from +source+, which is either a string of a file name or an IO + # object. + def > (to) + case to + when String + dst = @shell.open(to, "w") + begin + each(){|l| dst << l} + ensure + dst.close + end + when IO + each(){|l| to << l} + else + Shell.Fail Error::CantApplyMethod, ">", to.class + end + self + end + + # call-seq: + # >> source + # + # Appends the output to +source+, which is either a string of a file name + # or an IO object. + def >> (to) + begin + Shell.cd(@shell.pwd).append(to, self) + rescue CantApplyMethod + Shell.Fail Error::CantApplyMethod, ">>", to.class + end + end + + # call-seq: + # | filter + # + # Processes a pipeline. + def | (filter) + filter.input = self + if active? + @shell.process_controller.start_job filter + end + filter + end + + # call-seq: + # filter1 + filter2 + # + # Outputs +filter1+, and then +filter2+ using Join.new + def + (filter) + Join.new(@shell, self, filter) + end + + def to_a + ary = [] + each(){|l| ary.push l} + ary + end + + def to_s + str = "" + each(){|l| str.concat l} + str + end + + def inspect + if @shell.debug.kind_of?(Integer) && @shell.debug > 2 + super + else + to_s + end + end + end +end diff --git a/jni/ruby/lib/shell/process-controller.rb b/jni/ruby/lib/shell/process-controller.rb new file mode 100644 index 0000000..0fed143 --- /dev/null +++ b/jni/ruby/lib/shell/process-controller.rb @@ -0,0 +1,310 @@ +# +# shell/process-controller.rb - +# $Release Version: 0.7 $ +# $Revision: 47284 $ +# by Keiju ISHITSUKA(keiju@ruby-lang.org) +# +# -- +# +# +# +require "forwardable" + +require "thread" +require "sync" + +class Shell + class ProcessController + + @ProcessControllers = {} + @ProcessControllersMonitor = Mutex.new + @ProcessControllersCV = ConditionVariable.new + + @BlockOutputMonitor = Mutex.new + @BlockOutputCV = ConditionVariable.new + + class << self + extend Forwardable + + def_delegator("@ProcessControllersMonitor", + "synchronize", "process_controllers_exclusive") + + def active_process_controllers + process_controllers_exclusive do + @ProcessControllers.dup + end + end + + def activate(pc) + process_controllers_exclusive do + @ProcessControllers[pc] ||= 0 + @ProcessControllers[pc] += 1 + end + end + + def inactivate(pc) + process_controllers_exclusive do + if @ProcessControllers[pc] + if (@ProcessControllers[pc] -= 1) == 0 + @ProcessControllers.delete(pc) + @ProcessControllersCV.signal + end + end + end + end + + def each_active_object + process_controllers_exclusive do + for ref in @ProcessControllers.keys + yield ref + end + end + end + + def block_output_synchronize(&b) + @BlockOutputMonitor.synchronize(&b) + end + + def wait_to_finish_all_process_controllers + process_controllers_exclusive do + while !@ProcessControllers.empty? + Shell::notify("Process finishing, but active shell exists", + "You can use Shell#transact or Shell#check_point for more safe execution.") + if Shell.debug? + for pc in @ProcessControllers.keys + Shell::notify(" Not finished jobs in "+pc.shell.to_s) + for com in pc.jobs + com.notify(" Jobs: %id") + end + end + end + @ProcessControllersCV.wait(@ProcessControllersMonitor) + end + end + end + end + + # for shell-command complete finish at this process exit. + USING_AT_EXIT_WHEN_PROCESS_EXIT = true + at_exit do + wait_to_finish_all_process_controllers unless $@ + end + + def initialize(shell) + @shell = shell + @waiting_jobs = [] + @active_jobs = [] + @jobs_sync = Sync.new + + @job_monitor = Mutex.new + @job_condition = ConditionVariable.new + end + + attr_reader :shell + + def jobs + jobs = [] + @jobs_sync.synchronize(:SH) do + jobs.concat @waiting_jobs + jobs.concat @active_jobs + end + jobs + end + + def active_jobs + @active_jobs + end + + def waiting_jobs + @waiting_jobs + end + + def jobs_exist? + @jobs_sync.synchronize(:SH) do + @active_jobs.empty? or @waiting_jobs.empty? + end + end + + def active_jobs_exist? + @jobs_sync.synchronize(:SH) do + @active_jobs.empty? + end + end + + def waiting_jobs_exist? + @jobs_sync.synchronize(:SH) do + @waiting_jobs.empty? + end + end + + # schedule a command + def add_schedule(command) + @jobs_sync.synchronize(:EX) do + ProcessController.activate(self) + if @active_jobs.empty? + start_job command + else + @waiting_jobs.push(command) + end + end + end + + # start a job + def start_job(command = nil) + @jobs_sync.synchronize(:EX) do + if command + return if command.active? + @waiting_jobs.delete command + else + command = @waiting_jobs.shift + + return unless command + end + @active_jobs.push command + command.start + + # start all jobs that input from the job + for job in @waiting_jobs.dup + start_job(job) if job.input == command + end + end + end + + def waiting_job?(job) + @jobs_sync.synchronize(:SH) do + @waiting_jobs.include?(job) + end + end + + def active_job?(job) + @jobs_sync.synchronize(:SH) do + @active_jobs.include?(job) + end + end + + # terminate a job + def terminate_job(command) + @jobs_sync.synchronize(:EX) do + @active_jobs.delete command + ProcessController.inactivate(self) + if @active_jobs.empty? + command.notify("start_job in terminate_job(%id)", Shell::debug?) + start_job + end + end + end + + # kill a job + def kill_job(sig, command) + @jobs_sync.synchronize(:EX) do + if @waiting_jobs.delete command + ProcessController.inactivate(self) + return + elsif @active_jobs.include?(command) + begin + r = command.kill(sig) + ProcessController.inactivate(self) + rescue + print "Shell: Warn: $!\n" if @shell.verbose? + return nil + end + @active_jobs.delete command + r + end + end + end + + # wait for all jobs to terminate + def wait_all_jobs_execution + @job_monitor.synchronize do + begin + while !jobs.empty? + @job_condition.wait(@job_monitor) + for job in jobs + job.notify("waiting job(%id)", Shell::debug?) + end + end + ensure + redo unless jobs.empty? + end + end + end + + # simple fork + def sfork(command) + pipe_me_in, pipe_peer_out = IO.pipe + pipe_peer_in, pipe_me_out = IO.pipe + + + pid = nil + pid_mutex = Mutex.new + pid_cv = ConditionVariable.new + + Thread.start do + ProcessController.block_output_synchronize do + STDOUT.flush + ProcessController.each_active_object do |pc| + for jobs in pc.active_jobs + jobs.flush + end + end + + pid = fork { + Thread.list.each do |th| + th.kill unless Thread.current == th + end + + STDIN.reopen(pipe_peer_in) + STDOUT.reopen(pipe_peer_out) + + ObjectSpace.each_object(IO) do |io| + if ![STDIN, STDOUT, STDERR].include?(io) + io.close unless io.closed? + end + end + + yield + } + end + pid_cv.signal + + pipe_peer_in.close + pipe_peer_out.close + command.notify "job(%name:##{pid}) start", @shell.debug? + + begin + _pid = nil + command.notify("job(%id) start to waiting finish.", @shell.debug?) + _pid = Process.waitpid(pid, nil) + rescue Errno::ECHILD + command.notify "warn: job(%id) was done already waitpid." + _pid = true + ensure + command.notify("Job(%id): Wait to finish when Process finished.", @shell.debug?) + # when the process ends, wait until the command terminates + if USING_AT_EXIT_WHEN_PROCESS_EXIT or _pid + else + command.notify("notice: Process finishing...", + "wait for Job[%id] to finish.", + "You can use Shell#transact or Shell#check_point for more safe execution.") + redo + end + + @job_monitor.synchronize do + terminate_job(command) + @job_condition.signal + command.notify "job(%id) finish.", @shell.debug? + end + end + end + + pid_mutex.synchronize do + while !pid + pid_cv.wait(pid_mutex) + end + end + + return pid, pipe_me_in, pipe_me_out + end + end +end diff --git a/jni/ruby/lib/shell/system-command.rb b/jni/ruby/lib/shell/system-command.rb new file mode 100644 index 0000000..382a337 --- /dev/null +++ b/jni/ruby/lib/shell/system-command.rb @@ -0,0 +1,158 @@ +# +# shell/system-command.rb - +# $Release Version: 0.7 $ +# $Revision: 46969 $ +# by Keiju ISHITSUKA(keiju@ruby-lang.org) +# +# -- +# +# +# + +require "shell/filter" + +class Shell + class SystemCommand < Filter + def initialize(sh, command, *opts) + if t = opts.find{|opt| !opt.kind_of?(String) && opt.class} + Shell.Fail Error::TypeError, t.class, "String" + end + super(sh) + @command = command + @opts = opts + + @input_queue = Queue.new + @pid = nil + + sh.process_controller.add_schedule(self) + end + + attr_reader :command + alias name command + + def wait? + @shell.process_controller.waiting_job?(self) + end + + def active? + @shell.process_controller.active_job?(self) + end + + def input=(inp) + super + if active? + start_export + end + end + + def start + notify([@command, *@opts].join(" ")) + + @pid, @pipe_in, @pipe_out = @shell.process_controller.sfork(self) { + Dir.chdir @shell.pwd + $0 = @command + exec(@command, *@opts) + } + if @input + start_export + end + start_import + end + + def flush + @pipe_out.flush if @pipe_out and !@pipe_out.closed? + end + + def terminate + begin + @pipe_in.close + rescue IOError + end + begin + @pipe_out.close + rescue IOError + end + end + + def kill(sig) + if @pid + Process.kill(sig, @pid) + end + end + + def start_import + notify "Job(%id) start imp-pipe.", @shell.debug? + _eop = true + Thread.start { + begin + while l = @pipe_in.gets + @input_queue.push l + end + _eop = false + rescue Errno::EPIPE + _eop = false + ensure + if !ProcessController::USING_AT_EXIT_WHEN_PROCESS_EXIT and _eop + notify("warn: Process finishing...", + "wait for Job[%id] to finish pipe importing.", + "You can use Shell#transact or Shell#check_point for more safe execution.") + redo + end + notify "job(%id}) close imp-pipe.", @shell.debug? + @input_queue.push :EOF + @pipe_in.close + end + } + end + + def start_export + notify "job(%id) start exp-pipe.", @shell.debug? + _eop = true + Thread.start{ + begin + @input.each do |l| + ProcessController::block_output_synchronize do + @pipe_out.print l + end + end + _eop = false + rescue Errno::EPIPE, Errno::EIO + _eop = false + ensure + if !ProcessController::USING_AT_EXIT_WHEN_PROCESS_EXIT and _eop + notify("shell: warn: Process finishing...", + "wait for Job(%id) to finish pipe exporting.", + "You can use Shell#transact or Shell#check_point for more safe execution.") + redo + end + notify "job(%id) close exp-pipe.", @shell.debug? + @pipe_out.close + end + } + end + + alias super_each each + def each(rs = nil) + while (l = @input_queue.pop) != :EOF + yield l + end + end + + # ex) + # if you wish to output: + # "shell: job(#{@command}:#{@pid}) close pipe-out." + # then + # mes: "job(%id) close pipe-out." + # yorn: Boolean(@shell.debug? or @shell.verbose?) + def notify(*opts) + @shell.notify(*opts) do |mes| + yield mes if iterator? + + mes.gsub!("%id", "#{@command}:##{@pid}") + mes.gsub!("%name", "#{@command}") + mes.gsub!("%pid", "#{@pid}") + mes + end + end + end +end diff --git a/jni/ruby/lib/shell/version.rb b/jni/ruby/lib/shell/version.rb new file mode 100644 index 0000000..8d3aa7b --- /dev/null +++ b/jni/ruby/lib/shell/version.rb @@ -0,0 +1,15 @@ +# +# version.rb - shell version definition file +# $Release Version: 0.7$ +# $Revision: 38201 $ +# by Keiju ISHITSUKA(keiju@ruby-lang.org) +# +# -- +# +# +# + +class Shell # :nodoc: + @RELEASE_VERSION = "0.7" + @LAST_UPDATE_DATE = "07/03/20" +end -- cgit v1.2.3