module Puppet::Util

# File lib/puppet/util.rb, line 224
def absolute_path?(path, platform=nil)
  # Ruby only sets File::ALT_SEPARATOR on Windows and the Ruby standard
  # library uses that to test what platform it's on.  Normally in Puppet we
  # would use Puppet.features.microsoft_windows?, but this method needs to
  # be called during the initialization of features so it can't depend on
  # that.
  platform ||= Puppet::Util::Platform.windows? ? :windows : :posix
  regex = case platform
          when :windows
            AbsolutePathWindows
          when :posix
            AbsolutePathPosix
          else
            raise Puppet::DevError, "unknown platform #{platform} in absolute_path"
          end

  !! (path =~ regex)
end

# File lib/puppet/util.rb, line 26
def self.activerecord_version
  if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
    ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
  else
    0
  end
end

# File lib/puppet/util.rb, line 137
def benchmark(*args)
  msg = args.pop
  level = args.pop
  object = nil

  if args.empty?
    if respond_to?(level)
      object = self
    else
      object = Puppet
    end
  else
    object = args.pop
  end

  raise Puppet::DevError, "Failed to provide level to :benchmark" unless level

  unless level == :none or object.respond_to? level
    raise Puppet::DevError, "Benchmarked object does not respond to #{level}"
  end

  # Only benchmark if our log level is high enough
  if level != :none and Puppet::Util::Log.sendlevel?(level)
    seconds = Benchmark.realtime {
      yield
    }
    object.send(level, msg + (" in %0.2f seconds" % seconds))
    return seconds
  else
    yield
  end
end

# File lib/puppet/util.rb, line 344
def binread(file)
  Puppet.deprecation_warning("Puppet::Util.binread is deprecated. Read the file without this method as it will be removed in a future version.")
  File.open(file, 'rb') { |f| f.read }
end

# File lib/puppet/util.rb, line 65
def self.chuser
  if group = Puppet[:group]
    begin
      Puppet::Util::SUIDManager.change_group(group, true)
    rescue => detail
      Puppet.warning "could not change to group #{group.inspect}: #{detail}"
      $stderr.puts "could not change to group #{group.inspect}"

      # Don't exit on failed group changes, since it's
      # not fatal
      #exit(74)
    end
  end

  if user = Puppet[:user]
    begin
      Puppet::Util::SUIDManager.change_user(user, true)
    rescue => detail
      $stderr.puts "Could not change to user #{user}: #{detail}"
      exit(74)
    end
  end
end

# File lib/puppet/util.rb, line 115
def self.classproxy(klass, objmethod, *methods)
  classobj = class << klass; self; end
  methods.each do |method|
    classobj.send(:define_method, method) do |*args|
      obj = self.send(objmethod)

      obj.send(method, *args)
    end
  end
end

# File lib/puppet/util.rb, line 514
def deterministic_rand(seed,max)
  if defined?(Random) == 'constant' && Random.class == Class
    Random.new(seed).rand(max).to_s
  else
    srand(seed)
    result = rand(max).to_s
    srand()
    result
  end
end

# File lib/puppet/util.rb, line 537
def execfail(command, exception)
  Puppet.deprecation_warning("Puppet::Util.execfail is deprecated; please use Puppet::Util::Execution.execfail")
  Puppet::Util::Execution.execfail(command, exception)
end

# File lib/puppet/util.rb, line 531
def execpipe(command, failonfail = true, &block)
  Puppet.deprecation_warning("Puppet::Util.execpipe is deprecated; please use Puppet::Util::Execution.execpipe")
  Puppet::Util::Execution.execpipe(command, failonfail, &block)
end

# File lib/puppet/util.rb, line 543
def execute(*args)
  Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")

  Puppet::Util::Execution.execute(*args)
end

# File lib/puppet/util.rb, line 495
def exit_on_fail(message, code = 1)
  yield
# First, we need to check and see if we are catching a SystemExit error.  These will be raised
#  when we daemonize/fork, and they do not necessarily indicate a failure case.
rescue SystemExit => err
  raise err

# Now we need to catch *any* other kind of exception, because we may be calling third-party
#  code (e.g. webrick), and we have no idea what they might throw.
rescue Exception => err
  ## NOTE: when debugging spec failures, these two lines can be very useful
  #puts err.inspect
  #puts Puppet::Util.pretty_backtrace(err.backtrace)
  Puppet.log_exception(err, "Could not #{message}: #{err}")
  Puppet::Util::Log.force_flushqueue()
  exit(code)
end

# File lib/puppet/util.rb, line 92
def self.logmethods(klass, useself = true)
  Puppet::Util::Log.eachlevel { |level|
    klass.send(:define_method, level, proc { |args|
      args = args.join(" ") if args.is_a?(Array)
      if useself

        Puppet::Util::Log.create(
          :level => level,
          :source => self,
          :message => args
        )
      else

        Puppet::Util::Log.create(
          :level => level,
          :message => args
        )
      end
    })
  }
end

# File lib/puppet/util.rb, line 311
def memory
  unless defined?(@pmap)
    @pmap = which('pmap')
  end
  if @pmap
    %x{#{@pmap} #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
  else
    0
  end
end

# File lib/puppet/util.rb, line 245
def path_to_uri(path)
  return unless path

  params = { :scheme => 'file' }

  if Puppet.features.microsoft_windows?
    path = path.gsub(/\/, '/')

    if unc = /^\/\/([^\/]+)(\/.+)/.match(path)
      params[:host] = unc[1]
      path = unc[2]
    elsif path =~ /^[a-z]:\//
      path = '/' + path
    end
  end

  params[:path] = URI.escape(path)

  begin
    URI::Generic.build(params)
  rescue => detail
    raise Puppet::Error, "Failed to convert '#{path}' to URI: #{detail}", detail.backtrace
  end
end

# File lib/puppet/util.rb, line 352
def self.pretty_backtrace(backtrace = caller(1))
  backtrace.collect do |line|
    _, path, rest = /^(.*):(\d+.*)$/.match(line).to_a
    # If the path doesn't exist - like in one test, and like could happen in
    # the world - we should just tolerate it and carry on. --daniel 2012-09-05
    # Also, if we don't match, just include the whole line.
    if path
      path = Pathname(path).realpath rescue path
      "#{path}:#{rest}"
    else
      line
    end
  end.join("\n")
end

# File lib/puppet/util.rb, line 127
def self.proxy(klass, objmethod, *methods)
  methods.each do |method|
    klass.send(:define_method, method) do |*args|
      obj = self.send(objmethod)

      obj.send(method, *args)
    end
  end
end

# File lib/puppet/util.rb, line 390
def replace_file(file, default_mode, &block)
  raise Puppet::DevError, "replace_file requires a block" unless block_given?

  if default_mode
    unless valid_symbolic_mode?(default_mode)
      raise Puppet::DevError, "replace_file default_mode: #{default_mode} is invalid"
    end

    mode = symbolic_mode_to_int(normalize_symbolic_mode(default_mode))
  else
    if Puppet.features.microsoft_windows?
      mode = DEFAULT_WINDOWS_MODE
    else
      mode = DEFAULT_POSIX_MODE
    end
  end

  begin
    file     = Puppet::FileSystem.pathname(file)
    tempfile = Puppet::FileSystem::Uniquefile.new(Puppet::FileSystem.basename_string(file), Puppet::FileSystem.dir_string(file))

    # Set properties of the temporary file before we write the content, because
    # Tempfile doesn't promise to be safe from reading by other people, just
    # that it avoids races around creating the file.
    #
    # Our Windows emulation is pretty limited, and so we have to carefully
    # and specifically handle the platform, which has all sorts of magic.
    # So, unlike Unix, we don't pre-prep security; we use the default "quite
    # secure" tempfile permissions instead.  Magic happens later.
    if !Puppet.features.microsoft_windows?
      # Grab the current file mode, and fall back to the defaults.
      effective_mode =
      if Puppet::FileSystem.exist?(file)
        stat = Puppet::FileSystem.lstat(file)
        tempfile.chown(stat.uid, stat.gid)
        stat.mode
      else
        mode
      end

      if effective_mode
        # We only care about the bottom four slots, which make the real mode,
        # and not the rest of the platform stat call fluff and stuff.
        tempfile.chmod(effective_mode & 07777)
      end
    end

    # OK, now allow the caller to write the content of the file.
    yield tempfile

    # Now, make sure the data (which includes the mode) is safe on disk.
    tempfile.flush
    begin
      tempfile.fsync
    rescue NotImplementedError
      # fsync may not be implemented by Ruby on all platforms, but
      # there is absolutely no recovery path if we detect that.  So, we just
      # ignore the return code.
      #
      # However, don't be fooled: that is accepting that we are running in
      # an unsafe fashion.  If you are porting to a new platform don't stub
      # that out.
    end

    tempfile.close

    if Puppet.features.microsoft_windows?
      # Windows ReplaceFile needs a file to exist, so touch handles this
      if !Puppet::FileSystem.exist?(file)
        Puppet::FileSystem.touch(file)
        if mode
          Puppet::Util::Windows::Security.set_mode(mode, Puppet::FileSystem.path_string(file))
        end
      end
      # Yes, the arguments are reversed compared to the rename in the rest
      # of the world.
      Puppet::Util::Windows::File.replace_file(FileSystem.path_string(file), tempfile.path)

    else
      File.rename(tempfile.path, Puppet::FileSystem.path_string(file))
    end
  ensure
    # in case an error occurred before we renamed the temp file, make sure it
    # gets deleted
    if tempfile
      tempfile.close!
    end
  end


  # Ideally, we would now fsync the directory as well, but Ruby doesn't
  # have support for that, and it doesn't matter /that/ much...

  # Return something true, and possibly useful.
  file
end

# File lib/puppet/util.rb, line 289
def safe_posix_fork(stdin=$stdin, stdout=$stdout, stderr=$stderr, &block)
  child_pid = Kernel.fork do
    $stdin.reopen(stdin)
    $stdout.reopen(stdout)
    $stderr.reopen(stderr)

    begin
      Dir.foreach('/proc/self/fd') do |f|
        if f != '.' && f != '..' && f.to_i >= 3
          IO::new(f.to_i).close rescue nil
        end
      end
    rescue Errno::ENOENT # /proc/self/fd not found
      3.upto(256){|fd| IO::new(fd).close rescue nil}
    end

    block.call if block
  end
  child_pid
end

# File lib/puppet/util.rb, line 322
def symbolizehash(hash)
  newhash = {}
  hash.each do |name, val|
    name = name.intern if name.respond_to? :intern
    newhash[name] = val
  end
  newhash
end

# File lib/puppet/util.rb, line 333
def thinmark
  seconds = Benchmark.realtime {
    yield
  }

  seconds
end

# File lib/puppet/util.rb, line 272
def uri_to_path(uri)
  return unless uri.is_a?(URI)

  path = URI.unescape(uri.path)

  if Puppet.features.microsoft_windows? and uri.scheme == 'file'
    if uri.host
      path = "//#{uri.host}" + path # UNC
    else
      path.sub!(/^\//, '')
    end
  end

  path
end

# File lib/puppet/util.rb, line 178
def which(bin)
  if absolute_path?(bin)
    return bin if FileTest.file? bin and FileTest.executable? bin
  else
    ENV['PATH'].split(File::PATH_SEPARATOR).each do |dir|
      begin
        dest = File.expand_path(File.join(dir, bin))
      rescue ArgumentError => e
        # if the user's PATH contains a literal tilde (~) character and HOME is not set, we may get
        # an ArgumentError here.  Let's check to see if that is the case; if not, re-raise whatever error
        # was thrown.
        if e.to_s =~ /HOME/ and (ENV['HOME'].nil? || ENV['HOME'] == "")
          # if we get here they have a tilde in their PATH.  We'll issue a single warning about this and then
          # ignore this path element and carry on with our lives.
          Puppet::Util::Warnings.warnonce("PATH contains a ~ character, and HOME is not set; ignoring PATH element '#{dir}'.")
        elsif e.to_s =~ /doesn't exist|can't find user/
          # ...otherwise, we just skip the non-existent entry, and do nothing.
          Puppet::Util::Warnings.warnonce("Couldn't expand PATH containing a ~ character; ignoring PATH element '#{dir}'.")
        else
          raise
        end
      else
        if Puppet.features.microsoft_windows? && File.extname(dest).empty?
          exts = ENV['PATHEXT']
          exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
          exts.each do |ext|
            destext = File.expand_path(dest + ext)
            return destext if FileTest.file? destext and FileTest.executable? destext
          end
        end
        return dest if FileTest.file? dest and FileTest.executable? dest
      end
    end
  end
  nil
end

# File lib/puppet/util.rb, line 37
def self.withenv(hash)
  saved = ENV.to_hash
  hash.each do |name, val|
    ENV[name.to_s] = val
  end

  yield
ensure
  ENV.clear
  saved.each do |name, val|
    ENV[name] = val
  end
end

# File lib/puppet/util.rb, line 53
def self.withumask(mask)
  cur = File.umask(mask)

  begin
    yield
  ensure
    File.umask(cur)
  end
end