ruby-cute 0.0.1 → 0.0.2

data/lib/cute/configparser.rb

@@ -0,0 +1,404 @@
+require 'pathname'
+require 'fileutils'
+
+module Cute
+  class ParserError < StandardError
+  end
+
+  ###
+  # Sample file:
+  ###
+  # database:
+  #   user: myser
+  #   password: thepassword
+  #   ip: 127.0.0.1
+  # cache:
+  #   size: 1234
+  #   # default directory: /tmp
+  #   # default strict: true
+  # # default values for environments fields
+  #
+  ###
+  # Parser
+  ###
+  # cp = ConfigParser.new(yamlstr)
+  # conf = {:db=>{}, :cache=>{}, :env=>{}, :pxe => {}}
+  # cp.parse('database',true) do
+  #   # String with default value
+  #   conf[:db][:user] = cp.value('user',String,nil,'defaultvalue')
+  #   # Mandatory String
+  #   conf[:db][:password] = cp.value('password',String)
+  #   # String with multiple possible values
+  #   conf[:db][:kind] = cp.value('kind',String,nil,['MySQL','PostGRE','Oracle'])
+  #   # Regexp
+  #   conf[:db][:ip] = cp.value('ip',String,'127.0.0.1',
+  #     /\A\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}\Z/
+  #   )
+  # end
+  # cp.parse('cache',true) do
+  #   # Integer with default value
+  #   conf[:cache][:size] = cp.value('size',Fixnum,nil,100)
+  #   # Directory that need to exist and be r/w
+  #   conf[:cache][:directory] = cp.value('directory',String,'/tmp',
+  #     {
+  #       :type => 'dir',
+  #       :readable => true,
+  #       :writable => true,
+  #       :create => true,
+  #       :mode => 0700
+  #     }
+  #   )
+  #   # Boolean
+  #   conf[:cache][:strict] = cp.value('strict',[TrueClass,FalseClass],true)
+  # end
+  #
+  # # Non-mandatory field
+  # cp.parse('environments') do
+  #   # Specification of a unix path
+  #   conf[:env][:tar_dir] = cp.value('tarball_dir',String,'/tmp',Pathname)
+  #   # Add a prefix to a value
+  #   conf[:env][:user_dir] = cp.value('user_dir',String,'/tmp',
+  #     {:type => 'dir', :prefix => '/home/'}
+  #   )
+  # end
+
+  class ConfigParser
+    attr_reader :basehash
+    PATH_SEPARATOR = '/'
+
+    def initialize(confighash)
+      @basehash = confighash
+      # The current path
+      @path = []
+      # The current value
+      @val = confighash
+    end
+
+    def push(fieldname, val=nil)
+      @path.push(fieldname)
+      @val = (val.nil? ? curval() : val)
+    end
+
+    def pop(val=nil)
+      @path.pop
+      @val = (val.nil? ? curval() : val)
+    end
+
+    def depth
+      @path.size
+    end
+
+    def path(val=nil)
+      ConfigParser.pathstr(@path + [val])
+    end
+
+    def curval
+      ret = @basehash
+      @path.compact.each do |field|
+        begin
+          field = Integer(field)
+        rescue ArgumentError
+        end
+
+        if ret[field]
+          ret = ret[field]
+        else
+          ret = nil
+          break
+        end
+      end
+      ret
+    end
+
+    def self.errmsg(field,message)
+      "#{message} [field: #{field}]"
+    end
+
+    def self.pathstr(array)
+      array.compact.join(PATH_SEPARATOR)
+    end
+
+    def check_field(fieldname,mandatory,type)
+      begin
+        if @val.is_a?(Hash)
+          if !@val[fieldname].nil?
+            if type.is_a?(Class)
+              typeok = @val[fieldname].is_a?(type)
+            elsif type.is_a?(Array)
+              type.each do |t|
+                typeok = @val[fieldname].is_a?(t)
+                break if typeok
+              end
+            else
+              raise 'Internal Error'
+            end
+
+            if typeok
+              yield(@val[fieldname])
+            else
+              $,=','
+              typename = type.to_s
+              $,=nil
+              raise ParserError.new(
+                "The field should have the type #{typename}"
+              )
+            end
+          elsif mandatory
+            raise ParserError.new("The field is mandatory")
+          else
+            yield(nil)
+          end
+        elsif mandatory
+          if @val.nil?
+            raise ParserError.new("The field is mandatory")
+          else
+            raise ParserError.new("The field has to be a Hash")
+          end
+        else
+          yield(nil)
+        end
+      rescue ParserError => pe
+        raise ArgumentError.new(
+          ConfigParser.errmsg(path(fieldname),pe.message)
+        )
+      end
+    end
+
+    def check_array(val, array, fieldname)
+      unless array.include?(val)
+        raise ParserError.new(
+          "Invalid value '#{val}', allowed value"\
+          "#{(array.size == 1 ? " is" : "s are")}: "\
+          "#{(array.size == 1 ? '' : "'#{array[0..-2].join("', '")}' or ")}"\
+          "'#{array[-1]}'"
+        )
+      end
+    end
+
+    def check_hash(val, hash, fieldname)
+      self.send("customcheck_#{hash[:type].downcase}".to_sym,val,fieldname,hash)
+    end
+
+    def check_range(val, range, fieldname)
+      check_array(val, range.entries, fieldname)
+    end
+
+    def check_regexp(val, regexp, fieldname)
+      unless val =~ regexp
+        raise ParserError.new(
+          "Invalid value '#{val}', the value must have the form (ruby-regexp): "\
+          "#{regexp.source}"
+        )
+      end
+    end
+
+    # A file, checking if exists (creating it otherwise) and writable
+    def check_file(val, file, fieldname)
+      if File.exists?(val)
+        unless File.file?(val)
+          raise ParserError.new("The file '#{val}' is not a regular file")
+        end
+      else
+        raise ParserError.new("The file '#{val}' does not exists")
+      end
+    end
+
+    # A directory, checking if exists (creating it otherwise) and writable
+    def check_dir(val, dir, fieldname)
+      if File.exist?(val)
+        unless File.directory?(val)
+          raise ParserError.new("'#{val}' is not a regular directory")
+        end
+      else
+        raise ParserError.new("The directory '#{val}' does not exists")
+      end
+    end
+
+    # A pathname, checking if exists (creating it otherwise) and writable
+    def check_pathname(val, pathname, fieldname)
+      begin
+        Pathname.new(val)
+      rescue
+        raise ParserError.new("Invalid pathname '#{val}'")
+      end
+    end
+
+    def check_string(val, str, fieldname)
+      unless val == str
+        raise ParserError.new(
+          "Invalid value '#{val}', allowed values are: '#{str}'"
+        )
+      end
+    end
+
+    def customcheck_code(val, fieldname, args)
+      begin
+        eval("#{args[:prefix]}#{args[:code]}#{args[:suffix]}")
+      rescue
+        raise ParserError.new("Invalid expression '#{args[:code]}'")
+      end
+    end
+
+    def customcheck_file(val, fieldname, args)
+      return if args[:disable]
+      val = File.join(args[:prefix],val) if args[:prefix]
+      val = File.join(val,args[:suffix]) if args[:suffix]
+      if File.exists?(val)
+        if File.file?(val)
+          if args[:writable]
+            unless File.stat(val).writable?
+              raise ParserError.new("The file '#{val}' is not writable")
+            end
+          end
+
+          if args[:readable]
+            unless File.stat(val).readable?
+              raise ParserError.new("The file '#{val}' is not readable")
+            end
+          end
+        else
+          raise ParserError.new("The file '#{val}' is not a regular file")
+        end
+      else
+        if args[:create]
+          begin
+            puts "The file '#{val}' does not exists, let's create it"
+            tmp = FileUtils.touch(val)
+            raise if tmp.is_a?(FalseClass)
+          rescue
+            raise ParserError.new("Cannot create the file '#{val}'")
+          end
+        else
+          raise ParserError.new("The file '#{val}' does not exists")
+        end
+      end
+    end
+
+    def customcheck_dir(val, fieldname, args)
+      return if args[:disable]
+      val = File.join(args[:prefix],val) if args[:prefix]
+      val = File.join(val,args[:suffix]) if args[:suffix]
+      if File.exist?(val)
+        if File.directory?(val)
+          if args[:writable]
+            unless File.stat(val).writable?
+              raise ParserError.new("The directory '#{val}' is not writable")
+            end
+          end
+
+          if args[:readable]
+            unless File.stat(val).readable?
+              raise ParserError.new("The directory '#{val}' is not readable")
+            end
+          end
+        else
+          raise ParserError.new("'#{val}' is not a regular directory")
+        end
+      else
+        if args[:create]
+          begin
+            puts "The directory '#{val}' does not exists, let's create it"
+            tmp = FileUtils.mkdir_p(val, :mode => (args[:mode] || 0700))
+            raise if tmp.is_a?(FalseClass)
+          rescue
+            raise ParserError.new("Cannot create the directory '#{val}'")
+          end
+        else
+          raise ParserError.new("The directory '#{val}' does not exists")
+        end
+      end
+    end
+
+
+    def parse(fieldname, mandatory=false, type=Hash)
+      check_field(fieldname,mandatory,type) do |curval|
+        oldval = @val
+        push(fieldname, curval)
+
+        if curval.is_a?(Array)
+          curval.each_index do |i|
+            push(i)
+            yield({
+              :val => curval,
+              :empty => curval.nil?,
+              :path => path,
+              :iter => i,
+            })
+            pop()
+          end
+          curval.clear
+        else
+          yield({
+            :val => curval,
+            :empty => curval.nil?,
+            :path => path,
+            :iter => 0,
+          })
+        end
+
+        oldval.delete(fieldname) if curval and curval.empty?
+
+        pop(oldval)
+      end
+    end
+
+    # if no defaultvalue defined, field is mandatory
+    def value(fieldname,type,defaultvalue=nil,expected=nil)
+      ret = nil
+      check_field(fieldname,defaultvalue.nil?,type) do |val|
+        if val.nil?
+          ret = defaultvalue
+        else
+          ret = val
+          @val.delete(fieldname)
+        end
+        #ret = (val.nil? ? defaultvalue : val)
+
+        if expected
+          classname = (
+            expected.class == Class ? expected.name : expected.class.name
+          ).split('::').last
+          self.send(
+            "check_#{classname.downcase}".to_sym,
+            ret,
+            expected,
+            fieldname
+          )
+        end
+      end
+      ret
+    end
+
+    def unused(result = [],curval=nil,curpath=nil)
+      curval = @basehash if curval.nil?
+      curpath = [] unless curpath
+
+      if curval.is_a?(Hash)
+        curval.each do |key,value|
+          curpath << key
+          if value.nil?
+            result << ConfigParser.pathstr(curpath)
+          else
+            unused(result,value,curpath)
+          end
+          curpath.pop
+        end
+      elsif curval.is_a?(Array)
+        curval.each_index do |i|
+          curpath << i
+          if curval[i].nil?
+            result << ConfigParser.pathstr(curpath)
+          else
+            unused(result,curval[i],curpath)
+          end
+          curpath.pop
+        end
+      else
+        result << ConfigParser.pathstr(curpath)
+      end
+
+      result
+    end
+  end
+end
+

data/lib/cute/execute.rb

@@ -0,0 +1,272 @@
+# To be used as you're using Open3.popen3 in ruby 1.9.2
+module Cute
+
+  class Execute
+    require 'thread'
+    require 'fcntl'
+    attr_reader :command, :exec_pid, :stdout, :stderr, :status,:emptypipes
+    @@forkmutex = Mutex.new
+
+    def initialize(*cmd)
+      @command = *cmd
+
+      @exec_pid = nil
+
+      @stdout = nil
+      @stderr = nil
+      @status = nil
+      @run_thread = nil
+      @killed = false
+
+      @child_io = nil
+      @parent_io = nil
+      @lock = Mutex.new
+      @emptypipes = false
+    end
+
+    # Free the command, stdout stderr string.
+    def free
+      @command = nil
+      @stdout = nil
+      @stderr = nil
+    end
+
+    # Same as new function
+    def self.[](*cmd)
+      self.new(*cmd)
+    end
+
+    # Initialize the pipes and return one array for parent and one array for child.
+    def self.init_ios(opts={:stdin => false})
+      if opts[:stdin]
+        in_r, in_w = IO::pipe
+        in_w.sync = true
+      else
+        in_r, in_w = [nil,nil]
+      end
+
+      out_r, out_w = opts[:stdout] == false ? [nil,nil] : IO::pipe
+      err_r, err_w = opts[:stderr] == false ? [nil,nil] : IO::pipe
+
+      [ [in_r,out_w,err_w], [in_w,out_r,err_r] ]
+    end
+
+    # Launch the command provided by the constructor
+    # @param [Hash] opts run options
+    # @option opts [Boolean] :stdin enable or disable pipe in stdin
+    # @option opts [Boolean] :stdout enable or disable pipe in stdout
+    # @option opts [Boolean] :stderr enable or disable pipe in stderr
+    # @option opts [Fixnum] :stdout_size number to limit the number of byte read by execute stdout
+    # @option opts [Fixnum] :stderr_size number to limit the number of byte read by execute stderr
+    def run(opts={:stdin => false})
+      @lock.synchronize do
+        if @run_thread
+          raise "Already launched"
+        else
+          begin
+          ensure #We can't interrupt this process here before run was launched.
+            @child_io, @parent_io = Execute.init_ios(opts)
+            @@forkmutex.synchronize do
+              @exec_pid = fork do
+                run_fork()
+              end
+            end
+            @run_thread = Thread.new do
+              @child_io.each do |io|
+                io.close if io and !io.closed?
+              end
+              @child_io = nil
+              emptypipes = true
+
+              @stdout,emptypipes = read_parent_io(1,opts[:stdout_size],emptypipes)
+              @stderr,emptypipes = read_parent_io(2,opts[:stderr_size],emptypipes)
+
+              _, @status = Process.wait2(@exec_pid)
+              @exec_pid = nil
+
+              @parent_io.each do |io|
+                io.close if io and !io.closed?
+              end
+
+              @parent_io = nil
+              @emptypipes = emptypipes
+            end
+          end
+        end
+      end
+      [@exec_pid, *@parent_io]
+    end
+
+    # Write to stdin
+    # @param str [String] string passed to process stdin.
+    def write_stdin(str)
+      @lock.synchronize do
+        if @parent_io and @parent_io[0] and !@parent_io[0].closed?
+          @parent_io[0].write(str)
+        else
+          raise "Stdin is closed"
+        end
+      end
+    end
+
+    # Close stdin of programme if it opened.
+    def close_stdin()
+      @lock.synchronize do
+        if @parent_io and @parent_io[0] and !@parent_io[0].closed?
+          @parent_io[0].close
+          @parent_io[0] = nil
+        end
+      end
+    end
+
+    # Run the command and return the Execute object.
+    # @param [Hash] opts
+    def run!(opts={:stdin => false})
+      run(opts)
+      self
+    end
+
+
+    # Wait the end of process
+    # @param [Hash] opts wait options
+    # @option opts [Boolean] :checkstatus if it is true at end of process it raises an exception if the result is not null.
+    # @return [Array] Process::Status, stdout String, stderr String, emptypipe
+    def wait(opts={:checkstatus => true})
+      begin
+        wkilled=true
+        close_stdin()
+        @run_thread.join
+        wkilled=false
+      ensure
+        @lock.synchronize do
+          if wkilled && !@killed
+            kill!()
+          end
+        end
+        @run_thread.join
+        if !@killed
+          # raise SignalException if the process was terminated by a signal and the kill function was not called.
+          raise SignalException.new(@status.termsig) if @status and @status.signaled?
+          raise "Command #{@command.inspect} exited with status #{@status.exitstatus}" if opts[:checkstatus] and !@status.success?
+        end
+      end
+      [ @status, @stdout, @stderr, @emptypipes ]
+    end
+
+    EXECDEBUG = false
+    # kill a tree of processes. The killing is done in three steps:
+    # 1) STOP the target process
+    # 2) recursively kill all children
+    # 3) KILL the target process
+    def self.kill_recursive(pid)
+      puts "Killing PID #{pid} from PID #{$$}" if EXECDEBUG
+
+      # SIGSTOPs the process to avoid it creating new children
+      begin
+        Process.kill('STOP',pid)
+      rescue Errno::ESRCH # "no such process". The process was already killed, return.
+        puts "got ESRCH on STOP" if EXECDEBUG
+        return
+      end
+      # Gather the list of children before killing the parent in order to
+      # be able to kill children that will be re-attached to init
+      children = `ps --ppid #{pid} -o pid=`.split("\n").collect!{|p| p.strip.to_i}
+      children.compact!
+      puts "Children: #{children}" if EXECDEBUG
+      # Check that the process still exists
+      # Directly kill the process not to generate <defunct> children
+      children.each do |cpid|
+        kill_recursive(cpid)
+      end if children
+
+      begin
+        Process.kill('KILL',pid)
+      rescue Errno::ESRCH # "no such process". The process was already killed, return.
+        puts "got ESRCH on KILL" if EXECDEBUG
+        return
+      end
+    end
+
+    #Kill the launched process.
+    def kill()
+      @lock.synchronize{ kill! }
+    end
+
+
+    private
+
+    # Launch kill_recurcive if in launched and it not already killed
+    # killed becomes true.
+    def kill!()
+      if @exec_pid && !@killed
+        @killed = true
+        Execute.kill_recursive(@exec_pid)
+        # This function do not wait the PID since the thread that use wait() is supposed to be running and to do so
+      end
+    end
+
+    # Read pipe and return out and boolean which indicate if pipe are empty.
+    # @param num [Fixnum] number of file descriptor
+    # @param size [Fixnum] Maximum number of bytes must be read 0 is unlimited.
+    # @param emptypipes [Fixnum] Previous value of emptypipe the new value was obtained with logical and.
+    # @return [Array] output: String, emptypipes: Boolean
+    def read_parent_io(num,size,emptypipes)
+      out=''
+      if @parent_io and @parent_io[num]
+        if size and size > 0
+          out = @parent_io[num].read(size) unless @parent_io[num].closed?
+          emptypipes = false if !@parent_io[num].closed? and !@parent_io[num].eof?
+          unless @parent_io[num].closed?
+            @parent_io[num].readpartial(4096) until @parent_io[num].eof?
+          end
+        else
+          out = @parent_io[num].read unless @parent_io[num].closed?
+        end
+      end
+      [out,emptypipes]
+    end
+
+    # This function is made by children.
+    # It redirect the stdin,stdout,stderr
+    # Close another descriptor if we are in ruby < 2.0
+    # And launch the command with exec.
+    def run_fork()
+      begin
+        #stdin
+        STDIN.reopen(@child_io[0] || '/dev/null')
+
+        #stdout
+        STDOUT.reopen(@child_io[1] || '/dev/null')
+
+        #stderr
+        STDERR.reopen(@child_io[2] || '/dev/null')
+
+
+        # Close useless file descriptors.
+        # Since ruby 2.0, FD_CLOEXEC is set when ruby opens a descriptor.
+        # After performing exec(), all file descriptors are closed excepted 0,1,2
+        # https://bugs.ruby-lang.org/issues/5041
+        if RUBY_VERSION < "2.0"
+          Dir.foreach('/proc/self/fd') do |opened_fd|
+            begin
+              fd=opened_fd.to_i
+              if fd>2
+                f_IO=IO.new(fd)
+                f_IO.close if !f_IO.closed?
+              end
+            rescue Exception
+              #Some file descriptor are reserved for the rubyVM.
+              #So the function 'IO.new' raises an exception. We ignore that.
+            end
+          end
+        end
+        exec(*@command)
+      rescue SystemCallError, Exception => e
+        STDERR.puts "Fork Error: #{e.message} (#{e.class.name})"
+        STDERR.puts e.backtrace
+      end
+      exit! 1
+    end
+  end
+
+end