class PhusionPassenger::AdminTools::MemoryStats

def apache_processes
  @apache_processes ||= begin
    if PlatformInfo.httpd
      processes = list_processes(:exe => PlatformInfo.httpd)
      if processes.empty?
        # On some Linux distros, the Apache worker processes
        # are called "httpd.worker"
        processes = list_processes(:exe => "#{PlatformInfo.httpd}.worker")
      end
      processes
    else
      nil
    end
  end
end

def determine_private_dirty_rss(pid)
  total = 0
  File.read("/proc/#{pid}/smaps").split("\n").each do |line|
    line =~ /^(Private)_Dirty: +(\d+)/
    if $2
      total += $2.to_i
    end
  end
  if total == 0
    return nil
  else
    return total
  end
rescue Errno::EACCES, Errno::ENOENT
  return nil
end

def list_processes(options)
  if options[:exe]
    name = options[:exe].sub(/.*\/(.*)/, '\1')
    if os_name =~ /linux/
      ps = "ps -C '#{name}'"
    else
      ps = "ps -A"
      options[:match] = Regexp.new(Regexp.escape(name))
    end
  elsif options[:name]
    if os_name =~ /linux/
      ps = "ps -C '#{options[:name]}'"
    else
      ps = "ps -A"
      options[:match] = Regexp.new(" #{Regexp.escape(options[:name])}")
    end
  elsif options[:match]
    ps = "ps -A"
  else
    raise ArgumentError, "Invalid options."
  end
  processes = []
  case os_name
  when /solaris/
    list = `#{ps} -o pid,ppid,nlwp,vsz,rss,pcpu,comm`.split("\n")
    threads_known = true
  when /macosx/
    list = `#{ps} -w -o pid,ppid,vsz,rss,%cpu,command`.split("\n")
    threads_known = false
  else
    list = `#{ps} -w -o pid,ppid,nlwp,vsz,rss,%cpu,command`.split("\n")
    threads_known = true
  end
  list.shift
  list.each do |line|
    line.gsub!(/^ */, '')
    line.gsub!(/ *$/, '')
    p = Process.new
    if threads_known
      p.pid, p.ppid, p.threads, p.vm_size, p.rss, p.cpu, p.name = line.split(/ +/, 7)
    else
      p.pid, p.ppid, p.vm_size, p.rss, p.cpu, p.name = line.split(/ +/, 6)
    end
    p.name.sub!(/\Aruby: /, '')
    p.name.sub!(/ \(ruby\)\Z/, '')
    if p.name !~ /^ps/ && (!options[:match] || p.name.match(options[:match]))
      # Convert some values to integer.
      [:pid, :ppid, :vm_size, :rss].each do |attr|
        p.send("#{attr}=", p.send(attr).to_i)
      end
      p.threads = p.threads.to_i if threads_known
      if platform_provides_private_dirty_rss_information?
        p.private_dirty_rss = determine_private_dirty_rss(p.pid)
      end
      processes << p
    end
  end
  return processes
end

def nginx_processes
  @nginx_processes ||= list_processes(:exe => "nginx")
end

def os_name
  return PlatformInfo.os_name
end

def passenger_processes
  @passenger_processes ||= list_processes(:match =>
    /((^| )Passenger|(^| )Rails:|(^| )Rack:|wsgi-loader.py)/)
end

def platform_provides_private_dirty_rss_information?
  return os_name == "linux"
end

def root_privileges_required_for_private_dirty_rss?
  all_processes = (apache_processes || []) + nginx_processes + passenger_processes
  return all_processes.any?{ |p| p.private_dirty_rss.nil? }
end

def should_show_private_dirty_rss?
  return platform_provides_private_dirty_rss_information? &&
    (::Process.euid == 0 || root_privileges_required_for_private_dirty_rss?)
end

def sum_memory_usage(processes)
  total = 0
  if should_show_private_dirty_rss?
    accurate = true
    processes.each do |p|
      if p.private_dirty_rss.is_a?(Numeric)
        total += p.private_dirty_rss
      else
        accurate = true
      end
    end
    return [total, accurate]
  else
    processes.each do |p|
      total += p.rss
    end
    return [total, true]
  end
end

def system_ram_usage
  @total_system_ram ||= begin
    case os_name
    when /linux/
      free_text = `free -k`
      free_text =~ %r{Mem:(.+)$}
      line = $1.strip
      total = line.split(/ +/).first.to_i
      free_text =~ %r{buffers/cache:(.+)$}
      line = $1.strip
      used = line.split(/ +/).first.to_i
      [total, used]
    when /macosx/
      vm_stat = `vm_stat`
      vm_stat =~ /page size of (\d+) bytes/
      page_size = $1
      vm_stat =~ /Pages free: +(\d+)/
      free = $1
      vm_stat =~ /Pages active: +(\d+)/
      active = $1
      vm_stat =~ /Pages inactive: +(\d+)/
      inactive = $1
      vm_stat =~ /Pages wired down: +(\d+)/
      wired = $1
      if page_size && free && active && inactive && wired
        page_size = page_size.to_i
        free = free.to_i * page_size / 1024
        active = active.to_i * page_size / 1024
        inactive = inactive.to_i * page_size / 1024
        wired = wired.to_i * page_size / 1024
        used = active + wired
        [free + inactive + used, used]
      else
        nil
      end
    else
      `top` =~ /(\d+)(K|M) Active, (\d+)(K|M) Inact, (\d+)(K|M) Wired,.*?(\d+)(K|M) Free/
      if $1 && $2 && $3 && $4 && $5 && $6 && $7 && $8
        to_kb = lambda do |number, unit|
          if unit == 'K'
            number.to_i
          else
            number.to_i * 1024
          end
        end
        active = to_kb.call($1, $2)
        inactive = to_kb.call($3, $4)
        wired = to_kb.call($5, $6)
        free = to_kb.call($7, $8)
        used = active + wired
        [free + inactive + used, used]
      else
        nil
      end
    end
  end
end