alib 0.4.0 → 0.5.0

data/lib/{alib-0.4.0 → alib-0.5.0}/util.rb

@@ -5,7 +5,8 @@
 #
 module ALib::Util
 #--{{{
-  class << self
+
+  module Exporter
 #--{{{
     def export(*syms)
 #--{{{
@@ -16,12 +17,23 @@ module ALib::Util
       end
 #--}}}
     end
+    def self.included other
+      other.extend self
+    end
+#--}}}
+  end
+
+  class << self
+#--{{{
+    include Exporter
+
     def append_features c
 #--{{{
       super
       c.extend self 
 #--}}}  
     end
+    alias_method "included", "append_features"
 #--}}}
   end
 #
@@ -482,9 +494,17 @@ module ALib::Util
   def tmpnam(*argv)
 #--{{{
     args, opts = argv_split argv
-    dirname = argv.shift || getopt(%w(dir base prefix), opts, '.')
+    dirname = (argv.shift || getopt(%w(dir base prefix), opts, '.')).to_s
     seed = getopt 'seed', opts, prognam
     reap = getopt 'reap', opts, true
+    dot = getopt 'dot', opts, true 
+    nodot = getopt 'nodot', opts, false 
+
+    dot = false if nodot
+
+#p 'nodot' => nodot
+#p 'dot' => dot
+#p dirname
 
     dirname = File.expand_path dirname
 
@@ -493,16 +513,26 @@ module ALib::Util
 
     if reap
       begin
-        baseglob = "%s__*__*__*__%s" % [ host, seed ] 
-        glob = File.join(dirname, baseglob)
-        host_re = %r/^#{ host }$/
-        candidates = Dir[glob]
-        candidates.each do |candidate|
+        baseglob =
+          if nodot
+            "%s__*__*__*__%s" % [ host, seed ] 
+          else
+            ".%s__*__*__*__%s" % [ host, seed ] 
+          end
+        host_re = 
+          if nodot
+            %r/^#{ host }$/
+          else
+            %r/^\.#{ host }$/
+          end
+        g = File.join dirname, baseglob
+        Dir.glob(g).each do |candidate|
           basename = File.basename candidate
           parts = basename.split %r/__/, 5
           if parts[0] =~ host_re
             pid = Integer parts[1]
             unless alive? pid
+#STDERR.puts "FileUtils.rm_rf #{ candidate }"
               FileUtils.rm_rf candidate
             end
           end
@@ -513,13 +543,23 @@ module ALib::Util
     end
 
     basename = 
-      "%s__%s__%s__%s__%s" % [
-        host, 
-        Process::pid, 
-        timestamp('nospace' => true),
-        rand,
-        seed,
-      ] 
+      if nodot
+        "%s__%s__%s__%s__%s" % [
+          host, 
+          Process::pid, 
+          timestamp('nospace' => true),
+          rand,
+          seed,
+        ] 
+      else
+        ".%s__%s__%s__%s__%s" % [
+          host, 
+          Process::pid, 
+          timestamp('nospace' => true),
+          rand,
+          seed,
+        ] 
+      end
 
     File.join(dirname, basename)
 #--}}}
@@ -754,7 +794,7 @@ module ALib::Util
 #
   def splitpath path
 #--{{{
-    path = "#{ path }"
+    path = path.to_s 
     dirname, basename = File::split path
     [ dirname, (%r/^([^\.]*)(.*)$/).match(basename)[1,2] ].flatten
 #--}}}
@@ -765,6 +805,7 @@ module ALib::Util
 #
   def unzipped path, z_pat = %r/\.(?:z|gz)$/io
 #--{{{
+    path = path.to_s 
     zipped = zipped?(path, z_pat)
     unless zipped
       yield path
@@ -784,6 +825,7 @@ module ALib::Util
 #
   def zip path, z_ext = nil 
 #--{{{
+    path = path.to_s 
     z_ext ||= '.gz'
     z_ext.gsub! %r/^\s*\.+/, '.'
     spawn "gzip --suffix #{ z_ext } --force #{ path }"
@@ -804,6 +846,7 @@ module ALib::Util
 #
   def zipped_name path, z_ext = nil 
 #--{{{
+    path = path.to_s 
     z_ext ||= '.gz'
     z_ext.gsub! %r/^\s*\.+/, '.'
     "#{ path }#{ z_ext }"
@@ -815,6 +858,7 @@ module ALib::Util
 #
   def unzip path, z_pat = nil 
 #--{{{
+    path = path.to_s 
     z_pat ||= %r/\.(?:z|gz)$/io
     spawn "gzip --force --decompress #{ path }" if zipped?(path, z_pat)
     #spawn "gzip --force --decompress #{ path }"
@@ -834,6 +878,7 @@ module ALib::Util
 #
   def unzipped_name path, z_pat = nil 
 #--{{{
+    path = path.to_s 
     z_pat ||= %r/\.(?:z|gz)$/io
     path.gsub z_pat, ''
 #--}}}
@@ -844,6 +889,7 @@ module ALib::Util
 #
   def zipped? path, z_pat = %r/\.(?:z|gz)$/io
 #--{{{
+    path = path.to_s 
     path =~ z_pat
 #--}}}
   end
@@ -938,12 +984,13 @@ module ALib::Util
     loop do
       changed = false
       vars.each do |var, value|
+        var = var.to_s
         var.gsub! %r/[^a-zA-Z0-9_]/, ''
         [ 
           %r/\$#{ var }\b/, 
           %r/\@#{ var }\b/, 
-          %r/\${\s*#{ var }\s*}/, 
-          %r/\@{\s*#{ var }\s*}/ 
+          %r/\$\{\s*#{ var }\s*\}/, 
+          %r/\@\{\s*#{ var }\s*\}/ 
         ].each do |pat|
           changed = string.gsub! pat, "#{ value }"
         end
@@ -1008,30 +1055,46 @@ module ALib::Util
   def parse_timespec spec
 #--{{{
   ret = nil
-  pat = %r/(\d+(?:\.\d+)?)\s*([sSmMhHdD][^\d]*)?/
-  begin
-    "#{ spec }".scan(pat) do |m|
-      n = Float m[0]
-      unit = m[1]
-      if unit
-        factor =
-          case unit
-            when %r/^m/i
-              60
-            when %r/^h/i
-              60 * 60
-            when %r/^d/i
-              60 * 60 * 24
-            else
-              1
-          end
-        n *= factor
+  if((m = %r/^ (\d+(?:\.\d+)?) : (\d+(?:\.\d+)?) : (\d+(?:\.\d+)?) $/iox.match(spec.to_s)))
+    m, h, m, s, ignored = m.to_a
+    h, m, s = Float(h), Float(m), Float(s)
+    #ret = h.hours + m.minutes + s.seconds
+    ret = (h * 60 * 60) + (m * 60) + (s) 
+  else
+    pat = %r/(\d+(?:\.\d+)?)\s*([sSmMhHdDwWyY][^\d]*)?/
+    begin
+      "#{ spec }".scan(pat) do |m|
+        n = Float m[0]
+        unit = m[1]
+        if unit
+          factor =
+            case unit
+              when %r/^m/i
+                case unit
+                  when %r/^mo/i
+                    7 * (60 * 60 * 24)
+                  else
+                    60
+                end
+              when %r/^h/i
+                60 * 60
+              when %r/^d/i
+                60 * 60 * 24
+              when %r/^w/i
+                7 * (60 * 60 * 24)
+              when %r/^y/i
+                365 * 7 * (60 * 60 * 24)
+              else
+                1
+            end
+          n *= factor
+        end
+        ret ||= 0.0
+        ret += n
       end
-      ret ||= 0.0
-      ret += n
+    rescue
+      raise "bad time spec <#{ spec }>"
     end
-  rescue
-    raise "bad time spec <#{ spec }>"
   end
   ret
 #--}}}
@@ -1056,36 +1119,104 @@ module ALib::Util
   end
   export 'camel_case'
 
-  def atomic_copy src, dst
+  def __atomic_op op, src, dst, opts = {}
 #--{{{
     f, fu = File, FileUtils
     src_dirname, src_basename = f.split src
+    src_stat = File.stat src
 
     dst = f.join dst, src_basename if test ?d, dst
-
     dst_dirname, dst_basename = f.split dst
 
-    tmp = f.join dst_dirname, ".#{ src_basename }.#{ hostname }.tmp"
+    pid = Process.pid
+    tmp = f.join dst_dirname, ".#{ dst_basename }.#{ hostname }.#{ pid }.#{ rand(4242) }.alib.tmp"
+
+    timeout = getopt 'timeout', opts, 42
+    utime = getopt 'utime', opts
+    mtime = getopt 'mtime', opts
+    atime = getopt 'atime', opts
+
+    safe_cp = lambda do |a, b|
+      4.times do
+        begin
+          break(fu.cp_r(a, b, :preserve => true))
+        rescue => e
+          STDERR.puts(errmsg(e))
+          uncache a rescue nil
+          uncache b rescue nil
+          sleep timeout 
+        end
+      end
+    end
+
+    safe_mv = lambda do |a, b|
+      4.times do
+        begin
+          break(fu.mv(a, b))
+        rescue => e
+          STDERR.puts(errmsg(e))
+          uncache a rescue nil
+          uncache b rescue nil
+          sleep timeout 
+        end
+      end
+    end
+
+    safe_rm = lambda do |a|
+      4.times do
+        begin
+          break(fu.rm_rf(a))
+        rescue => e
+          STDERR.puts(errmsg(e))
+          uncache a rescue nil
+          sleep timeout 
+        end
+      end
+    end
 
     begin
-      fu.cp_r src, tmp, :preserve => true
-      begin 
-        fu.mv tmp, dst
-      rescue
-        uncache tmp rescue nil
-        uncache dst rescue nil
-        sleep 42
-        fu.mv tmp, dst
+      case op
+        when 'cp'
+          safe_cp[src, tmp]
+          safe_mv[tmp, dst]
+        when 'mv'
+          safe_cp[src, tmp]
+          safe_mv[tmp, dst]
+          safe_rm[src]
+        else
+          raise ArgumentError, op.to_s
       end
     ensure
-      fu.rm_f tmp
+      safe_rm[tmp]
+    end
+
+    if utime or mtime or atime
+      a = (atime or utime or src_stat.atime) 
+      m = (mtime or utime or src_stat.mtime) 
+      a = src_stat.atime unless Time === a 
+      m = src_stat.mtime unless Time === m 
+      ALib::Util::find(dst){|e| File.utime a, m, e} 
     end
 
     dst
 #--}}}
   end
+  export '__atomic_op'
+
+  def atomic_copy src, dst, opts = {}
+    __atomic_op 'cp', src, dst, opts
+  end
+  alias_method "atomic_cp", "atomic_copy"
+  export 'atomic_cp'
   export 'atomic_copy'
 
+  def atomic_move src, dst, opts = {}
+    __atomic_op 'mv', src, dst, opts
+  end
+  alias_method "atomic_mv", "atomic_move"
+  export 'atomic_mv'
+  export 'atomic_move'
+
   def child_object
 #--{{{
     r, w = IO.pipe
@@ -1163,5 +1294,275 @@ module ALib::Util
       export '#{ m }'
     code
   end
+
+#
+# setup lspawn method/state
+#
+#--{{{
+  __cmdno = 0 # static var
+
+  __c = Class.new{
+    def initialize io, prefix
+      @io, @prefix = io, prefix
+    end
+    def << buf
+      @io << "#{ @prefix }__ "
+      @io << buf
+    end
+  }
+
+  __logger = lambda{|io, prefix| __c.new io, prefix}
+
+  __lspawn = lambda do |cmd, *a|
+    begin
+      Thread.critical = true
+      log = a.shift
+      log = (logger rescue (@logger || Logger.new(STDERR)))
+
+      stdout = __logger[STDOUT, :o]
+      stderr = __logger[STDERR, :e]
+
+      log.info{ "cmd[#{ __cmdno }] <#{ cmd }>" }
+
+      status = Alib::Util::spawn(cmd, 'quiet'=>true, 'raise'=>false, 'stdout'=>stdout, 'stderr'=>stderr)
+
+      if status and status == 0
+        log.info{ "status[#{ __cmdno }] <#{ status }>" }
+      else
+        log.warn{ "status[#{ __cmdno }] <#{ status || 127 }>" }
+      end
+
+      if status and status.signaled?
+        if status.termsig
+          log.warn{ "termsig[#{ __cmdno }] <#{ status.termsig }>" }
+        end
+        if status.stopsig
+          log.warn{ "stopsig[#{ __cmdno }] <#{ status.stopsig }>" }
+        end
+      end
+
+      status ? status.exitstatus : 127
+    ensure
+      __cmdno += 1
+      Thread.critical = false
+    end
+  end
+
+  define_method 'lspawn', &__lspawn
+
+  LSPAWN_CMDNO = [0]
+  LSPAWN_LOG = Hash.new{|h,k| h[k] = alib.logging.default_logger}
+  LSPAWN_IO = Class.new do
+    def initialize log, prefix, io
+      @log, @prefix, @io = log, prefix, io
+    end
+    def << buf
+      @log << " #{ @prefix }__ #{ buf.chomp }\n"
+      #@log << "#{ buf.chomp }\n"
+      @io << buf if @io
+    end
+  end
+#--}}}
+
+  def lspawn cmd, opts = {}
+#--{{{
+    begin
+      Thread.critical = true
+
+      stdin = ALib::Util::getopt ['stdin', 'i', 'in', '0', 0], opts 
+      stdout = ALib::Util::getopt ['stdout', 'o', 'out', '1', 1], opts
+      stderr = ALib::Util::getopt ['stderr', 'e', 'err', '2', 2], opts
+      expect = ALib::Util::getopt ['expect', 'status', 'success'], opts, 0
+      log = Alib::Util::getopt ['logger', 'log'], opts 
+
+      log ||= (self.logger rescue (defined?(@logger) ? @logger : LSPAWN_LOG[0]))
+
+      stdout = LSPAWN_IO.new log, :o, stdout
+      stderr = LSPAWN_IO.new log, :e, stderr
+
+      cmdno = LSPAWN_CMDNO[0]
+
+      log.info{ "cmd[#{ cmdno }] <#{ cmd }>" }
+
+      status = Alib::Util::spawn(cmd, 'quiet'=>true, 'raise'=>false, 'stdin'=>stdin, 'stdout'=>stdout, 'stderr'=>stderr)
+
+      exitstatus = ( (status ? (status.exitstatus || 127) : 127) rescue 127 )
+
+      log.send(exitstatus == 0 ? 'info' : 'warn'){ "status[#{ cmdno }] <#{ exitstatus }>" }
+
+      if expect
+        codes = [*expect].flatten.compact.map{|code| Integer code}
+        success = codes.detect{|code| exitstatus == code}
+        unless success
+          log.fatal{ "cmd[#{ cmdno }] failure" }
+          exit exitstatus
+        end
+      end
+
+      if status and status.signaled?
+        if status.termsig
+          log.warn{ "termsig[#{ cmdno }] <#{ status.termsig }>" }
+        end
+        if status.stopsig
+          log.warn{ "stopsig[#{ cmdno }] <#{ status.stopsig }>" }
+        end
+      end
+
+      exitstatus
+    ensure
+      LSPAWN_CMDNO[0] = LSPAWN_CMDNO[0] + 1
+      Thread.critical = false
+    end
+#--}}}
+  end
+  export 'lspawn'
+
+  def sweep hash
+#--{{{
+    srcdir, dstdir, ignored = hash.to_a.first
+    Dir.glob(File.join(srcdir, '*')) do |src|
+      dirname, basename = File.split src
+      dst = File.join dstdir, basename
+      FileUtils.mv src, dst
+    end
+#--}}}
+  end
+  export 'sweep'
+
+
+  def threadify list, n = 4, &b
+#--{{{
+    n = Integer n
+    done = Object.new.freeze
+    jobs = Queue.new
+
+    list.each_with_index{|elem, i| jobs.push [elem, i]}
+    n.times{ jobs.push done} # mark the end
+
+    consumers = Array.new n
+
+    n.times do |i|
+      consumers[i] = Thread.new do
+        this = Thread.current
+        this.abort_on_exception = true
+
+        loop{
+          job = jobs.pop
+          this.exit if job == done
+          jobs << (job << bcall(b, job))
+        }
+      end
+    end
+
+    consumers.map{|t| t.join}
+    jobs.push done
+
+    #sleep 5
+
+    ret = Array.new list.size
+    while((job = jobs.pop) != done)
+      elem, i, value = job
+      ret[i] = value
+    end
+    ret
+#--}}}
+  end
+  export 'threadify'
+
+  def block_argv b, argv
+#--{{{
+    arity = b.arity
+    if arity >= 0
+      argv[0,arity]
+    else
+      head = []
+      tail = []
+      n = arity.abs - 1
+      head = argv[0...n]
+      tail = argv[n..-1]
+      [*(head + tail)]
+    end
+#--}}}
+  end
+  export 'block_argv'
+
+  def bcall b, argv
+#--{{{
+    a = block_argv b, argv
+    b[*a]
+#--}}}
+  end
+  export 'bcall'
+
+  #
+  # casting methods 
+  #
+  module Casting
+#--{{{
+    include Exporter
+
+    def int_list *list
+#--{{{
+      list.flatten.compact.map{|i| Util.atoi i}
+#--}}}
+    end
+    def float_list *list
+#--{{{
+      list.flatten.compact.map{|f| Float f}
+#--}}}
+    end
+    def string_list *list
+#--{{{
+      list.flatten.compact.map{|s| String s}
+#--}}}
+    end
+    def string_cast arg
+      arg.to_s
+    end
+    def int_cast arg
+      Integer arg.to_s
+    end
+    def float_cast arg
+      Float arg
+    end
+    def bool_cast arg
+      arg ? true : false
+    end
+    def bool_cast arg
+      case arg
+        when Numeric 
+          not arg.zero?
+        when String 
+          case arg
+            when %r/^(1|t|true)$/i
+              true
+            when %r/^(0|f|false)$/i
+              false
+            else
+              raise ArgumentError, arg.inspect
+          end
+        else
+          arg ? true : false
+      end
+    end
+    def re_cast arg
+      Regexp === arg ? arg : %r/#{ arg }/
+    end
+    def pathname_cast arg, opts = {}
+      expand = opts['expand'] || opts[:expand]
+      pn = (Pathname === arg ? arg : Pathname.new(arg.to_s))
+      expand ? pn.expand_path : pn 
+    end
+
+    instance_methods.each{|m| export m}
+#--}}}
+  end
+
+  # dump methods into Util
+  include Casting
+  Casting.instance_methods.each{|m| export m}
+
+  def self.casting() Casting end
+
 #--}}}
 end # module Util