Module: Sys

Defined in:
lib/epitools/sys/os.rb,
lib/epitools/sys/ps.rb,
lib/epitools/sys/mem.rb,
lib/epitools/sys/net.rb,
lib/epitools/sys/misc.rb,
lib/epitools/sys/mounts.rb

Defined Under Namespace

Classes: Mount, ProcessInfo, ProcessNotFound

Constant Summary collapse

PS_FIELD_TABLE = 
[
  [:pid,    :to_i],
  [:ppid,   :to_i],
  [:pcpu,   :to_f],
  [:pmem,   :to_f],
  [:stat,   :to_s],
  [:rss,    :to_i],
  [:vsz,    :to_i],
  [:user,   :to_s],
  [:majflt, :to_i],
  [:minflt, :to_i],
  [:command,:to_s],
]
PS_FIELDS = 
PS_FIELD_TABLE.map { |name, func| name }
PS_FIELD_TRANSFORMS = 





Class Method Summary
collapse





Instance Method Summary
collapse






Class Method Details





.bsd? ⇒ Boolean







Is this BSD?








Returns:


    

  • 
(Boolean)

    • 










61
62
63




# File 'lib/epitools/sys/os.rb', line 61

def self.bsd?
  os == "BSD" or os == "Darwin"
end












.cross_platform_method(name) ⇒ Object







A metaprogramming helper that allows you to write platform-specific methods which the user can call with one name. Here’s how to use it:


Define these methods:


reboot_linux, reboot_darwin, reboot_windows



Call the magic method:


cross_platform_method(:reboot)



Now the user can execute “reboot” on any platform!


(Note: If you didn’t create a method for a specific platform, then you’ll get NoMethodError exception when the “reboot” method is called on that platform.)















81
82
83
84
85
86
87
88
89
90
91
92




# File 'lib/epitools/sys/os.rb', line 81

def self.cross_platform_method(name)
  platform_method_name = "#{name}_#{os.downcase}"
  metaclass.instance_eval do
    define_method(name) do |*args|
      begin
        self.send(platform_method_name, *args)
      rescue NoMethodError
        raise NotImplementedError.new("#{name} is not yet supported on #{os}.")
      end
    end
  end
end












.darwin? ⇒ Boolean







Is this Darwin?








Returns:


    

  • 
(Boolean)

    • 










49
50
51




# File 'lib/epitools/sys/os.rb', line 49

def self.darwin?
  os == "Darwin"
end












.hostname_linux ⇒ Object










7
8
9




# File 'lib/epitools/sys/net.rb', line 7

def self.hostname_linux
  `uname -n`.strip
end












.hostname_mac ⇒ Object










11
12
13




# File 'lib/epitools/sys/net.rb', line 11

def self.hostname_mac
  `uname -n`.strip.gsub(/\.local$/, '')
end












.hostname_windows ⇒ Object













Raises:


    

  • 
(NotImplementedError)

    • 










15
16
17




# File 'lib/epitools/sys/net.rb', line 15

def self.hostname_windows
  raise NotImplementedError
end












.interfaces_bsd ⇒ Object







BSD: Return a hash of (device, IP address) pairs.


eg: “en0”=>“192“en0”=>“192.168“en0”=>“192.168.1“en0”=>“192.168.1.101”















28
29
30
31
32
33
34
35
36
37
38
39
40




# File 'lib/epitools/sys/net.rb', line 28

def self.interfaces_bsd
  sections = `ifconfig`.split(/^(?=[^\t])/)
  sections_with_relevant_ip = sections.select {|i| i =~ /inet/ }

  device_ips = {}
  sections_with_relevant_ip.each do |section|
    device  = section[/[^:]+/]
    ip      = section[/inet ([^ ]+)/, 1]
    device_ips[device] = ip
  end

  device_ips
end












.interfaces_darwin ⇒ Object







Darwin: Do whatever BSD does















45
46
47




# File 'lib/epitools/sys/net.rb', line 45

def self.interfaces_darwin
  interfaces_bsd
end












.interfaces_linux ⇒ Object







Linux: Return a hash of (device, IP address) pairs.


eg: “eth0”=>“192“eth0”=>“192.168“eth0”=>“192.168.1“eth0”=>“192.168.1.101”















54
55
56
57
58
59
60
61
62
63
64
65
66




# File 'lib/epitools/sys/net.rb', line 54

def self.interfaces_linux
  sections = `/sbin/ifconfig`.split(/^(?=Link encap:Ethernet)/)
  sections_with_relevant_ip = sections.select {|i| i =~ /inet/ }

  device_ips = {}
  sections_with_relevant_ip.each do |section|
    device  = section[/([\w\d]+)\s+Link encap:Ethernet/, 1]
    ip      = section[/inet addr:([^\s]+)/, 1]
    device_ips[device] = ip
  end

  device_ips
end












.interfaces_windows ⇒ Object







Windows: Return a hash of (device name, IP address) pairs.















71
72
73
74
75
76
77
78
79
80
81
82
83




# File 'lib/epitools/sys/net.rb', line 71

def self.interfaces_windows
  result = {}
  `ipconfig`.split_before(/^\w.+:/).each do |chunk|
    chunk.grep(/^Ethernet adapter (.+):\s*$/) do
      name = $1
      chunk.grep(/IPv[46] Address[\.\ ]+: (.+)$/) do
        address = $1.strip
        result[name] = address
      end
    end
  end
  result
end












.linux? ⇒ Boolean







Is this Linux?








Returns:


    

  • 
(Boolean)

    • 










35
36
37




# File 'lib/epitools/sys/os.rb', line 35

def self.linux?
  os == "Linux"
end












.mac? ⇒ Boolean







Is this a Mac? (aka. Darwin?)








Returns:


    

  • 
(Boolean)

    • 










56




# File 'lib/epitools/sys/os.rb', line 56

def self.mac?; darwin?; end












.memstat_darwin ⇒ Object










18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36




# File 'lib/epitools/sys/mem.rb', line 18

def self.memstat_darwin
  #$ vm_stat
  #Mach Virtual Memory Statistics: (page size of 4096 bytes)
  #Pages free:                         198367.
  #Pages active:                       109319.
  #Pages inactive:                      61946.
  #Pages speculative:                   18674.
  #Pages wired down:                    70207.
  #"Translation faults":            158788687.
  #Pages copy-on-write:              17206973.
  #Pages zero filled:                54584525.
  #Pages reactivated:                    8768.
  #Pageins:                            176076.
  #Pageouts:                             3757.
  #Object cache: 16 hits of 255782 lookups (0% hit rate)

  #$ iostat
  raise "Not implemented"
end












.memstat_linux ⇒ Object










7
8
9
10
11
12
13
14
15
16




# File 'lib/epitools/sys/mem.rb', line 7

def self.memstat_linux
  #$ free
  #             total       used       free     shared    buffers     cached
  #Mem:       4124380    3388548     735832          0     561888     968004
  #-/+ buffers/cache:    1858656    2265724
  #Swap:      2104504     166724    1937780

  #$ vmstat
  raise "Not implemented"
end












.mounts ⇒ Object







Get an array of mounted filesystems (as fancy objects)















6
7
8
9
10
11
12




# File 'lib/epitools/sys/mounts.rb', line 6

def self.mounts
  if linux?
    IO.popen(["findmnt", "--raw"]) { |io| io.drop(1).map { |line| Mount.new line } }
  else
    raise NotImplementedError.new("I dunno, how do you find mounts on #{os}?")
  end
end












.os ⇒ Object







Return the current operating system: Darwin, Linux, or Windows.















6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30




# File 'lib/epitools/sys/os.rb', line 6

def self.os
  return @os if @os

  require 'rbconfig'
  if defined? RbConfig
    host_os = RbConfig::CONFIG['host_os']
  else
    host_os = Config::CONFIG['host_os']
  end

  case host_os
    when /darwin/
      @os = "Darwin"
    when /bsd/
      @os = "BSD"
    when /linux/
      @os = "Linux"
    when /mingw|mswin|cygwin/
      @os = 'Windows'
  else
    #raise "Unknown OS: #{host_os.inspect}"
  end

  @os
end












.ps(*pids) ⇒ Object







List all (or specified) processes, and return ProcessInfo objects. (Takes an optional list of pids as arguments.)















9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34




# File 'lib/epitools/sys/ps.rb', line 9

def self.ps(*pids)
  raise "that's too many pids!" if pids.size > 999_999

  options = PS_FIELDS.join(',')

  pids = pids.map(&:to_i)

  if pids.any?
    command = "ps -p #{pids.join(',')} -o #{options}"
  else
    command = "ps awx -o #{options}"
  end

  lines = `#{command}`.lines.to_a

  lines[1..-1].map do |line|
    fields = line.split
    if fields.size > PS_FIELDS.size
      fields = fields[0..PS_FIELDS.size-2] + [fields[PS_FIELDS.size-1..-1].join(" ")]
    end

    fields = PS_FIELDS.zip(fields).map { |name, value| value.send(PS_FIELD_TRANSFORMS[name]) }

    ProcessInfo.new(*fields)
  end
end












.temperatures ⇒ Object















Raises:


    

  • 
(NotImplementedError)

    • 










47
48
49
50
51
52
53
54
55
56
57
58




# File 'lib/epitools/sys/misc.rb', line 47

def self.temperatures
  #/Applications/Utilities/TemperatureMonitor.app/Contents/MacOS/tempmonitor -a -l
  #CPU Core 1: 28 C
  #CPU Core 2: 28 C
  #SMART Disk Hitachi HTS543216L9SA02 (090831FBE200VCGH3D5F): 40 C
  #SMC CPU A DIODE: 41 C
  #SMC CPU A HEAT SINK: 42 C
  #SMC DRIVE BAY 1: 41 C
  #SMC NORTHBRIDGE POS 1: 46 C
  #SMC WLAN CARD: 45 C
  raise NotImplementedError.new("Sorry")
end












.trap(*args, &block) ⇒ Object







Trap signals!


usage: trap(“EXIT”, “HUP”, “ETC”, :ignore=>) { |signal| puts “Got #signal!” } (Execute Signal.list to see what’s available.)


No paramters defaults to all signals except VTALRM, CHLD, CLD, and EXIT.















11
12
13
14
15
16
17
18
19
20
21
22
23
24
25




# File 'lib/epitools/sys/misc.rb', line 11

def self.trap(*args, &block)
  options = if args.last.is_a?(Hash) then args.pop else Hash.new end
  args = [args].flatten
  signals = if args.any? then args else Signal.list.keys end

  ignore = %w[ VTALRM CHLD CLD EXIT ] unless ignore = options[:ignore]
  ignore = [ignore] unless ignore.is_a? Array

  signals = signals - ignore

  signals.each do |signal|
    p [:sig, signal]
    Signal.trap(signal) { yield signal }
  end
end












.tree ⇒ Object






















38
39
40
41
42
43
44




# File 'lib/epitools/sys/ps.rb', line 38

def self.tree
  tree = Sys.ps.group_by(&:ppid)
  Hash[tree.map do |ppid, children|
    kvs = children.map { |child| [child.pid, tree.delete(child.pid)] }
    [ppid, Hash[kvs]]
  end]
end












.windows? ⇒ Boolean







Is this Windows?








Returns:


    

  • 
(Boolean)

    • 










42
43
44




# File 'lib/epitools/sys/os.rb', line 42

def self.windows?
  os == "Windows"
end













Instance Method Details





#browser_open_darwin(url) ⇒ Object







Darwin: Open the webpage in a new chrome tab.















41
42
43




# File 'lib/epitools/sys/misc.rb', line 41

def browser_open_darwin(url)
  system("open", "-a", "chrome", url)
end












#browser_open_linux(url) ⇒ Object







Linux: Open an URL in the default browser (using “xdg-open”).















34
35
36




# File 'lib/epitools/sys/misc.rb', line 34

def browser_open_linux(url)
  system("xdg-open", url)
end