yugui-chkbuild 0.1.2

data/lib/misc/gdb.rb

@@ -0,0 +1,74 @@
+# Copyright (C) 2005,2006,2009 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+require 'find'
+require 'tempfile'
+
+require 'escape'
+
+module GDB
+  module_function
+
+  def check_core(dir)
+    binaries = {}
+    core_info = []
+    Find.find(dir.to_s) {|f|
+      stat = File.stat(f)
+      basename = File.basename(f)
+      binaries[basename] = f if stat.file? && stat.executable?
+      next if /\bcore\b/ !~ basename
+      next if /\.chkbuild\.\d+\z/ =~ basename
+      guess = `file #{f} 2>&1`
+      next if /\bcore\b.*from '(.*?)'/ !~ guess.sub(/\A.*?:/, '')
+      core_info << [f, $1]
+    }
+    gdb_command = nil
+    core_info.each {|core_path, binary|
+      next unless binary_path = binaries[binary]
+      core_path = rename_core(core_path)
+      unless gdb_command
+        gdb_command = Tempfile.new("gdb-bt")
+        gdb_command.puts "bt"
+        gdb_command.close
+      end
+      puts
+      puts "binary: #{binary_path}"
+      puts "core: #{core_path}"
+      command = %W[gdb -batch -n -x #{gdb_command.path} #{binary_path} #{core_path}]
+      gdb_output = `#{Escape.shell_command command}`
+      puts gdb_output
+      puts "gdb status: #{$?}"
+    }
+  end
+
+  def rename_core(core_path)
+    suffix = ".chkbuild."
+    n = 1
+    while File.exist?(new_path = "#{core_path}.chkbuild.#{n}")
+      n += 1
+    end
+    File.rename(core_path, new_path)
+    new_path
+  end
+end

data/lib/misc/timeoutcom.rb

@@ -0,0 +1,174 @@
+# Copyright (C) 2005,2006,2007,2008,2009 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+class CommandTimeout < StandardError
+end
+
+module TimeoutCommand
+
+  module_function
+
+  def parse_timespan(arg)
+    case arg
+    when Integer, Float
+      timeout = arg
+    when Time
+      timeout = arg - Time.now
+    when /\A\d+(\.\d+)?(?:s|sec)?\z/
+      timeout = $&.to_f
+    when /\A\d+(\.\d+)?(?:m|min)\z/
+      timeout = $&.to_f * 60
+    when /\A\d+(\.\d+)?(?:h|hour)\z/
+      timeout = $&.to_f * 60 * 60
+    when /\A\d+(\.\d+)?(?:d|day)\z/
+      timeout = $&.to_f * 60 * 60 * 24
+    else
+      raise ArgumentError, "invalid time span: #{arg.inspect}"
+    end
+    timeout
+  end
+
+  def kill_processgroup(pgid, msgout)
+    begin
+      Process.kill('INT', -pgid)
+      msgout.puts "timeout: INT signal sent." if msgout
+      signals = ['INT', 'TERM', 'TERM', 'KILL']
+      signals.each {|sig|
+        Process.kill(0, -pgid); sleep 0.1
+        Process.kill(0, -pgid); sleep 0.2
+        Process.kill(0, -pgid); sleep 0.3
+        Process.kill(0, -pgid); sleep 0.4
+        Process.kill(0, -pgid)
+        4.times {
+          sleep 1
+          Process.kill(0, -pgid)
+        }
+        Process.kill(sig, -pgid)
+        msgout.puts "timeout: #{sig} signal sent." if msgout
+      }
+    rescue Errno::ESRCH # no process i.e. success to kill
+    end
+  end
+
+  def process_alive?(pid)
+    begin
+      Process.kill(0, pid)
+    rescue Errno::ESRCH # no process
+      return false
+    end
+    return true
+  end
+
+  def processgroup_alive?(pgid)
+    process_alive?(-pgid)
+  end
+
+  def last_output_time
+    last_output_time = [STDOUT, STDERR].map {|f|
+      s = f.stat
+      if s.file?
+        s.mtime
+      else
+        nil
+      end
+    }.compact
+    if last_output_time.empty?
+      nil
+    else
+      last_output_time.max
+    end
+  end
+
+  def timeout_command(command_timeout, msgout=STDERR, opts={})
+    command_timeout = parse_timespan(command_timeout)
+    output_interval_timeout = nil
+    if opts[:output_interval_timeout]
+      output_interval_timeout = parse_timespan(opts[:output_interval_timeout])
+    end
+    if command_timeout < 0
+      raise CommandTimeout, 'no time to run a command'
+    end
+    pid = fork {
+      Process.setpgid($$, $$)
+      yield
+    }
+    begin
+      Process.setpgid(pid, pid)
+    rescue Errno::EACCES # already execed.
+    rescue Errno::ESRCH # already exited. (setpgid for a zombie fails on OpenBSD)
+    end
+    wait_thread = Thread.new {
+      Process.wait2(pid)[1]
+    }
+    begin
+      start_time = Time.now
+      limit_time = start_time + command_timeout
+      command_status = nil
+      while true
+        join_timeout = limit_time - Time.now
+        if join_timeout < 0
+          timeout_reason = "command execution time exceeds #{command_timeout} seconds."
+          break 
+        end
+        if output_interval_timeout and
+           t = last_output_time and
+           (tmp_join_timeout = t + output_interval_timeout - Time.now) < join_timeout
+          join_timeout = tmp_join_timeout
+          if join_timeout < 0
+            timeout_reason = "output interval exceeds #{output_interval_timeout} seconds."
+            break
+          end
+        end
+        if wait_thread.join(join_timeout)
+          command_status = wait_thread.value
+          break
+        end
+      end
+      if command_status
+        return command_status
+      else
+        msgout.puts "timeout: #{timeout_reason}" if msgout
+        begin
+          Process.kill(0, -pid)
+          msgout.puts "timeout: the process group #{pid} is alive." if msgout
+          kill_processgroup(pid, msgout)
+        rescue Errno::ESRCH # no process
+        end
+        raise CommandTimeout, timeout_reason
+      end
+    rescue Interrupt
+      Process.kill("INT", -pid)
+      raise
+    rescue SignalException
+      Process.kill($!.message, -pid)
+      raise
+    ensure
+      if processgroup_alive?(pid)
+        msgout.puts "some descendant process in process group #{pid} remain." if msgout
+        kill_processgroup(pid, msgout)
+      end
+    end
+  end
+end
+

data/lib/misc/udiff.rb

@@ -0,0 +1,244 @@
+# Copyright (C) 2005,2006,2007,2008 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+require 'escape'
+require 'tempfile'
+
+class UDiff
+  def UDiff.diff(path1, path2, out, header="--- #{path1}\n+++ #{path2}\n")
+    UDiff.new(path1, path2, out, header).diff
+  end
+
+  def initialize(path1, path2, out, header)
+    @path1 = path1
+    @path2 = path2
+    @out = out
+    @header = header
+    @context = 3
+    @beginning = true
+    @l1 = 0
+    @l2 = 0
+    @hunk_beg = [@l1, @l2]
+    @hunk = []
+    @lines_hash = {}
+    @lines_ary = []
+  end
+
+  def puts_line(line)
+    @hunk << line
+    if /\n\z/ !~ line
+      @hunk << "\n\\n"
+    end
+    @beginning = false
+  end
+
+  def puts_del_line(line)
+    line = /\A_/ =~ line ? $' : @lines_ary[line.to_i]
+    puts_line "-#{line}"
+  end
+
+  def puts_add_line(line)
+    line = /\A_/ =~ line ? $' : @lines_ary[line.to_i]
+    puts_line "+#{line}"
+  end
+
+  def puts_common_line(line)
+    line = /\A_/ =~ line ? $' : @lines_ary[line.to_i]
+    puts_line " #{line}"
+  end
+
+  def encdump(str)
+    d = str.dump
+    if str.respond_to? :encoding
+      "#{d}.force_encoding(#{str.encoding.name.dump})"
+    else
+      d
+    end
+  end
+
+  def gets_common_line(f1, f2)
+    v1 = f1.gets
+    v2 = f2.gets
+    if v1 != v2
+      raise "[bug] diff error: #{encdump v1} != #{encdump v2}"
+    end
+    if v1
+      @l1 += 1
+      @l2 += 1
+    end
+    return v1
+  end
+
+  def copy_common_part(f1, f2, n)
+    n.times {|i|
+      v = gets_common_line(f1, f2)
+      raise "[bug] diff error: unexpected EOF" unless v
+      puts_common_line(v)
+    }
+  end
+
+  def skip_common_part(f1, f2, n)
+    n.times {|i|
+      v = gets_common_line(f1, f2)
+      raise "[bug] diff error: unexpected EOF" unless v
+    }
+  end
+
+  def output_hunk
+    if @header
+      @out.print @header
+      @header = nil
+    end
+    l1_beg, l2_beg = @hunk_beg
+    @out.print "@@ -#{l1_beg+1},#{@l1-l1_beg} +#{l2_beg+1},#{@l2-l2_beg} @@\n"
+    @hunk.each {|s|
+      @out.print s
+    }
+  end
+
+  def output_common_part(f1, f2, common_num)
+    if @beginning
+      if common_num <= @context
+        copy_common_part(f1, f2, common_num)
+      else
+        skip_common_part(f1, f2, common_num-@context)
+        copy_common_part(f1, f2, @context)
+      end
+    elsif common_num <= @context * 2
+      copy_common_part(f1, f2, common_num)
+    else
+      copy_common_part(f1, f2, @context)
+      output_hunk
+      skip_common_part(f1, f2, common_num-@context*2)
+      @hunk_beg = [@l1, @l2]
+      @hunk = []
+      copy_common_part(f1, f2, @context)
+    end
+  end
+
+  def output_common_tail(f1, f2)
+    return if @beginning
+    @context.times {
+      v = gets_common_line(f1, f2)
+      break unless v
+      puts_common_line(v)
+    }
+    output_hunk
+  end
+
+  def process_commands(f1, f2, d)
+    has_diff = false
+    l1 = 0
+    while com = d.gets
+      case com
+      when /\Ad(\d+) (\d+)/
+        line = $1.to_i
+        num = $2.to_i
+        output_common_part(f1, f2, line-l1-1)
+        num.times {
+          v = f1.gets
+          @l1 += 1
+          puts_del_line(v)
+          has_diff = true
+        }
+        l1 = line + num - 1
+      when /\Aa(\d+) (\d+)/
+        line = $1.to_i
+        num = $2.to_i
+        common_num = line-l1
+        output_common_part(f1, f2, line-l1)
+        l1 = line
+        num.times {
+          v1 = d.gets
+          v2 = f2.gets
+          if v1 != v2
+            raise "[bug] diff error: #{encdump v1} != #{encdump v2}"
+          end
+          @l2 += 1
+          v = v1
+          puts_add_line(v)
+          has_diff = true
+        }
+      else
+        raise "[bug] unexpected diff line: #{com.inspect}"
+      end
+    end
+    has_diff
+  end
+
+  def run_diff(path1, path2)
+    has_diff = false
+    open(path1) {|f1|
+      f1.set_encoding "ascii-8bit" if f1.respond_to? :set_encoding
+      open(path2) {|f2|
+        f2.set_encoding "ascii-8bit" if f2.respond_to? :set_encoding
+        command = Escape.shell_command(%W[diff -n #{path1} #{path2}]).to_s
+	command = "LC_ALL='C' LANG='C' #{command}"
+        IO.popen(command) {|d|
+          d.set_encoding "ascii-8bit" if d.respond_to? :set_encoding
+          has_diff = process_commands(f1, f2, d)
+        }
+        output_common_tail(f1, f2)
+      }
+    }
+    has_diff
+  end
+
+  SAFE_LINE = /\A[\t -~]*\n\z/
+  def diff
+    t1 = Tempfile.new("udiff")
+    File.foreach(@path1) {|l|
+      if SAFE_LINE =~ l
+        l = "_" + l
+      else
+        if !@lines_hash[l]
+          @lines_ary[@lines_hash.size] = l
+          @lines_hash[l] = @lines_hash.size 
+        end
+        l = @lines_hash[l].to_s + "\n"
+      end
+      t1.puts l
+    }
+    t2 = Tempfile.new("udiff")
+    File.foreach(@path2) {|l|
+      if SAFE_LINE =~ l
+        l = "_" + l
+      else
+        if !@lines_hash[l]
+          @lines_ary[@lines_hash.size] = l
+          @lines_hash[l] = @lines_hash.size 
+        end
+        l = @lines_hash[l].to_s + "\n"
+      end
+      t2.puts l
+    }
+    t1.close
+    t2.close
+    run_diff(t1.path, t2.path)
+  end
+end
+
+if $0 == __FILE__
+  UDiff.diff(ARGV[0], ARGV[1], STDOUT)
+end