module Puppet::Util

# File lib/puppet/util.rb, line 241
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 28
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 154
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)
    result = nil
    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 360
def binread(file)
  File.open(file, 'rb') { |f| f.read }
end

# File lib/puppet/util.rb, line 81
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 131
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 535
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 529
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 541
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 503
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 108
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 327
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 262
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}"
  end
end

# File lib/puppet/util.rb, line 367
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 143
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 400
def replace_file(file, default_mode, &block)
  raise Puppet::DevError, "replace_file requires a block" unless block_given?

  file     = Pathname(file)
  tempfile = Tempfile.new(file.basename.to_s, file.dirname.to_s)

  file_exists = file.exist?

  # 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.
  unless Puppet.features.microsoft_windows?
    # Grab the current file mode, and fall back to the defaults.
    stat = file.lstat rescue OpenStruct.new(:mode => default_mode,
                                            :uid  => Process.euid,
                                            :gid  => Process.egid)

    # 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(stat.mode & 07777)
    tempfile.chown(stat.uid, stat.gid)
  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?
    # This will appropriately clone the file, but only if the file we are
    # replacing exists.  Which is kind of annoying; thanks Microsoft.
    #
    # So, to avoid getting into an infinite loop we will retry once if the
    # file doesn't exist, but only the once...
    have_retried = false

    begin
      # Yes, the arguments are reversed compared to the rename in the rest
      # of the world.
      Puppet::Util::Windows::File.replace_file(file, tempfile.path)
    rescue Puppet::Util::Windows::Error => e
      # This might race, but there are enough possible cases that there
      # isn't a good, solid "better" way to do this, and the next call
      # should fail in the same way anyhow.
      raise if have_retried or File.exist?(file)
      have_retried = true

      # OK, so, we can't replace a file that doesn't exist, so let us put
      # one in place and set the permissions.  Then we can retry and the
      # magic makes this all work.
      #
      # This is the least-worst option for handling Windows, as far as we
      # can determine.
      File.open(file, 'a') do |fh|
        # this space deliberately left empty for auto-close behaviour,
        # append mode, and not actually changing any of the content.
      end

      # Set the permissions to what we want.
      Puppet::Util::Windows::Security.set_mode(default_mode, file.to_s)

      # ...and finally retry the operation.
      retry
    end
  else
    File.rename(tempfile.path, file)
  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 306
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)

    3.upto(256){|fd| IO::new(fd).close rescue nil}

    block.call if block
  end
  child_pid
end

# File lib/puppet/util.rb, line 338
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 66
def self.synchronize_on(x,type)
  sync_object,users = 0,1
  begin
    @@sync_objects.synchronize {
      (@@sync_objects[x] ||= [Sync.new,0])[users] += 1
    }
    @@sync_objects[x][sync_object].synchronize(type) { yield }
  ensure
    @@sync_objects.synchronize {
      @@sync_objects.delete(x) unless (@@sync_objects[x][users] -= 1) > 0
    }
  end
end

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

  seconds
end

# File lib/puppet/util.rb, line 289
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 195
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 39
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 55
def self.withumask(mask)
  cur = File.umask(mask)

  begin
    yield
  ensure
    File.umask(cur)
  end
end

# File lib/puppet/util.rb, line 321
def threadlock(resource, type = Sync::EX)
  Puppet::Util.synchronize_on(resource,type) { yield }
end