Class/Module Index [+]

Quicksearch

Facter::Memory

Public Class Methods

mem_free(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 80
def self.mem_free(kernel = Facter.value(:kernel))
  output = mem_free_info(kernel)
  scale_mem_free_value output, kernel
end
mem_free_info(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 85
def self.mem_free_info(kernel = Facter.value(:kernel))
  case kernel
  when /OpenBSD/, /SunOS/, /Dragonfly/
    vmstat_find_free_memory()
  when /FreeBSD/
    vmstat_find_free_memory(["-H"])
  when /Darwin/
    vmstat_darwin_find_free_memory()
  when /AIX/
    svmon_aix_find_free_memory()
  end
end
mem_size(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 109
def self.mem_size(kernel = Facter.value(:kernel))
  output = mem_size_info(kernel)
  scale_mem_size_value output, kernel
end
mem_size_info(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 114
def self.mem_size_info(kernel = Facter.value(:kernel))
  case kernel
  when /Dragonfly/, /FreeBSD/, /OpenBSD/
    Facter::Util::POSIX.sysctl("hw.physmem")
  when /Darwin/
    Facter::Util::POSIX.sysctl("hw.memsize")
  when /AIX/
    if Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+(\d+)\s+/
      $1
    end
  end
end
meminfo_number(tag) click to toggle source
# File lib/facter/util/memory.rb, line 8
def self.meminfo_number(tag)
  memsize = ""
  size = [0]
  File.readlines("/proc/meminfo").each do |l|
    size = $1.to_f if l =~ /^#{tag}:\s+(\d+)\s+\S+/
    if tag == "MemFree" &&
        l =~ /^(?:Buffers|Cached):\s+(\d+)\s+\S+/
      size += $1.to_f
    end
  end
  size / 1024.0
end
parse_swap(output, kernel = Facter.value(:kernel), size_or_free = :size) click to toggle source
# File lib/facter/util/memory.rb, line 163
def self.parse_swap (output, kernel = Facter.value(:kernel), size_or_free = :size)
  value_in_mb = 0.0
  value = 0
  is_size = size_or_free == :size
  unless output.nil?
    output.each_line do |line|
      value += parse_swap_line(line, kernel, is_size)
    end
  end      
  value_in_mb = scale_swap_value(value, kernel)
end
parse_swap_line(line, kernel, is_size) click to toggle source

There is a lot of duplication here because of concern over being able to add new platforms in a reasonable manner. For all of these platforms the first regex corresponds to the swap size value and the second corresponds to the swap free value, but this may not always be the case. In Ruby 1.9.3 it is possible to give these names, but sadly 1.8.7 does not support this.

# File lib/facter/util/memory.rb, line 181
def self.parse_swap_line(line, kernel, is_size)
  case kernel
  when /AIX/
    if line =~ /^\/\S+\s.*\s+(\S+)MB\s+(\S+)MB/
      (is_size) ? $1.to_i : $2.to_i
    else
      0
    end
  when /OpenBSD/
    if line =~ /^total: (\d+) (\d+)-blocks allocated, (\d+) used, (\d+) available$/
      (is_size) ? ($1.to_i * $2.to_i) : ($4.to_i * $2.to_i)
    else
      0
    end
  when /FreeBSD/
    if line =~ /\S+\s+(\d+)\s+\d+\s+(\d+)\s+\d+%$/
      (is_size) ? $1.to_i : $2.to_i
    else
      0
    end
  when /Darwin/
    if line =~ /total\s=\s(\S+)M\s+used\s=\s\S+M\s+free\s=\s(\S+)M\s/
      (is_size) ? $1.to_i : $2.to_i
    else
      0
    end
  when /SunOS/
    if line =~ /^\S+\s.*\s+(\d+)\s+(\d+)$/
      (is_size) ? $1.to_i : $2.to_i
    else
      0
    end
  end
end
scale_mem_free_value(value, kernel) click to toggle source
# File lib/facter/util/memory.rb, line 98
 def self.scale_mem_free_value (value, kernel)
   case kernel
   when /OpenBSD/, /FreeBSD/, /SunOS/, /Dragonfly/, /AIX/
     value.to_f / 1024.0
   when /Darwin/
     value.to_f / 1024.0 / 1024.0
   else
     value.to_f
   end
end
scale_mem_size_value(value, kernel) click to toggle source
# File lib/facter/util/memory.rb, line 127
def self.scale_mem_size_value(value, kernel)
  case kernel
  when /OpenBSD/, /FreeBSD/, /Darwin/, /Dragonfly/
    value.to_f / 1024.0 / 1024.0
  when /AIX/
    value.to_f / 1024.0
  else
    value.to_f
  end
end
scale_number(size, multiplier) click to toggle source
# File lib/facter/util/memory.rb, line 21
def self.scale_number(size, multiplier)
  suffixes = ['', 'kB', 'MB', 'GB', 'TB']

  s = suffixes.shift
  while s != multiplier
    s = suffixes.shift
  end

  while size > 1024.0
    size /= 1024.0
    s = suffixes.shift
  end

  "%.2f %s" % [size, s]
end
scale_swap_value(value, kernel) click to toggle source
# File lib/facter/util/memory.rb, line 216
def self.scale_swap_value(value, kernel)
  case kernel
  when /FreeBSD/
    value.to_f / 1024.0
  when /OpenBSD/
    value.to_f / 1024.0 / 1024.0
  when /SunOS/
    value.to_f / 2 / 1024.0
  else
    value.to_f
  end
end
svmon_aix_find_free_memory() click to toggle source

on AIX use svmon to get the free memory: it's the third value on the line starting with memory svmon can be run by non root users

# File lib/facter/util/memory.rb, line 75
def self.svmon_aix_find_free_memory()
  Facter::Core::Execution.exec("/usr/bin/svmon -O unit=KB") =~ /^memory\s+\d+\s+\d+\s+(\d+)\s+/
  $1
end
swap_free(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 143
def self.swap_free(kernel = Facter.value(:kernel))
  output = swap_info(kernel)
  parse_swap output, kernel, :free if output
end
swap_info(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 148
def self.swap_info(kernel = Facter.value(:kernel))
  case kernel
  when /AIX/
    (Facter.value(:id) == "root") ? Facter::Core::Execution.exec('swap -l 2>/dev/null') : nil
  when /OpenBSD/
    Facter::Core::Execution.exec('swapctl -s')
  when /FreeBSD/
    Facter::Core::Execution.exec('swapinfo -k')
  when /Darwin/
    Facter::Util::POSIX.sysctl('vm.swapusage')
  when /SunOS/
    Facter::Core::Execution.exec('/usr/sbin/swap -l 2>/dev/null')
  end
end
swap_size(kernel = Facter.value(:kernel)) click to toggle source
# File lib/facter/util/memory.rb, line 138
def self.swap_size(kernel = Facter.value(:kernel))
  output = swap_info(kernel)
  parse_swap output, kernel, :size if output
end
vmstat_darwin_find_free_memory() click to toggle source

Darwin had to be different. It's generally opaque with how much RAM it is using, and this figure could be improved upon too I fear. Parses the output of "vm_stat", takes the pages free & pages speculative and multiples that by the page size (also given in output). Ties in with what activity monitor outputs for free memory.

# File lib/facter/util/memory.rb, line 51
def self.vmstat_darwin_find_free_memory()

  memfree = 0
  pagesize = 0
  memspecfree = 0

  vmstats = Facter::Core::Execution.exec('vm_stat')
  vmstats.each_line do |vmline|
    case
    when vmline =~ /page\ssize\sof\s(\d+)\sbytes/
      pagesize = $1.to_i
    when vmline =~ /^Pages\sfree:\s+(\d+)\./
      memfree = $1.to_i
    when vmline =~ /^Pages\sspeculative:\s+(\d+)\./
      memspecfree = $1.to_i
    end
  end

  freemem = ( memfree + memspecfree ) * pagesize
end
vmstat_find_free_memory(args = []) click to toggle source
# File lib/facter/util/memory.rb, line 37
def self.vmstat_find_free_memory(args = [])
  cmd = 'vmstat'
  cmd += (' ' + args.join(' ')) unless args.empty?
  row = Facter::Core::Execution.exec(cmd).split("\n")[-1]
  if row =~ /^\s*\d+\s*\d+\s*\d+\s*\d+\s*(\d+)/
    memfree = $1
  end
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.