epitools 0.5.106 → 0.5.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e62d7058f8223acc7bf84eb7c77fc32e78c94735
-  data.tar.gz: c9b8d58d8dd39c12e78ccf29aeacc5a0c109edfc
+  metadata.gz: b2acadccead525875804ab124cff3c74f5557c49
+  data.tar.gz: 1f845c9016e66d67fe845d5760ecb648396bf579
 SHA512:
-  metadata.gz: 89a89b7b72de4c1c71f46af1a2b27e2dc02811d82034c8e17cd84a36e44c0a14fb28ead350509f150b3ec6f258175d2a3714a5f9455409a84924735a659cf794
-  data.tar.gz: 4962e60b4daf5eb39c623d606a04bc08846e24aae70f2e003028c96c2f4f6a76874d030adfb8972079bbd485de06d4bf2afac931e1fdbfe3d3b70113ed1f93d7
+  metadata.gz: 2091b4e7fa2c94c9b41da8ce0ba02b38f04fc5eeb7e40407ac5c8b2d5a0d7ad86c2a8be33109e9301fa8f75324114ae42058b3e266e9e11d7144789b2eaf948e
+  data.tar.gz: e96f90fa44265d05785d51fdd576c57d9ee792cd517d0f52f729cdce5c6dc794c849e74ace66196f561c9623f0e4adb5ffba9b42a38bf4f0fb826be0cf0065ee

data/VERSION

@@ -1 +1 @@
-0.5.106
+0.5.107

data/lib/epitools/core_ext/enumerable.rb

@@ -190,7 +190,7 @@ module Enumerable
     queue = Queue.new
     each { |e| queue.push e }
 
-    Enumerator.new do |y|
+    Enumerator.new(queue.size) do |y|
       workers = (0...num_workers).map do
         Thread.new do
           begin
@@ -569,7 +569,7 @@ class Enumerator
   def +(other)
     raise "Can only concatenate Enumerable things to Enumerators" unless Enumerable === other
 
-    Enumerator.new do |yielder|
+    Enumerator.new(count + other.count) do |yielder|
       each { |e| yielder << e }
       other.each { |e| yielder << e }
     end
@@ -601,7 +601,7 @@ class Enumerator
   # returning a new Enumerator. (The argument must be some kind of Enumerable.)
   #
   def cross_product(other)
-    Enumerator.new do |yielder|
+    Enumerator.new(count + other.count) do |yielder|
       each { |a| other.each { |b| yielder << [a,b] } }
     end
   end

data/lib/epitools/core_ext/string.rb

@@ -222,6 +222,14 @@ class String
     URI.unescape(self)
   end
 
+  #
+  # URI.parse the string and return an URI object
+  #
+  def to_uri
+    URI.parse self
+  end
+  alias_method :to_URI, :to_uri
+
   #
   # Convert a query string to a hash of params
   #

data/lib/epitools/path.rb

@@ -364,7 +364,9 @@ class Path
   end
 
   def size
-    File.size path
+    File.size(path)
+  rescue Errno::ENOENT
+    -1
   end
 
   def lstat

data/lib/epitools/sys.rb

@@ -4,494 +4,7 @@ require 'epitools/minimal'
 # Cross-platform operating system functions.
 # Includes: process listing, platform detection, etc.
 #
-module Sys
-
-  #-----------------------------------------------------------------------------
-
-  #
-  # Return the current operating system: Darwin, Linux, or Windows.
-  #
-  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
-
-  #
-  # Is this Linux?
-  #
-  def self.linux?
-    os == "Linux"
-  end
-
-  #
-  # Is this Windows?
-  #
-  def self.windows?
-    os == "Windows"
-  end
-
-  #
-  # Is this Darwin?
-  #
-  def self.darwin?
-    os == "Darwin"
-  end
-
-  #
-  # Is this a Mac? (aka. Darwin?)
-  #
-  def self.mac?; darwin?; end
-
-  #
-  # Is this BSD?
-  #
-  def self.bsd?
-    os == "BSD" or os == "Darwin"
-  end
-
-  #-----------------------------------------------------------------------------
-
-  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   = Hash[ *PS_FIELD_TABLE.flatten ]
-
-  class ProcessNotFound < Exception; end
-
-  #
-  # Contains all the information that PS can report about a process for
-  # the current platform.
-  #
-  # The following attribute accessor methods are available:
-  #
-  #    pid     (integer)
-  #    command (string -- the 'ps' name)
-  #    name    (alias for 'command')
-  #    pcpu    (float)
-  #    pmem    (float)
-  #    stat    (string)
-  #    rss     (integer)
-  #    vsz     (integer)
-  #    user    (string)
-  #    majflt  (integer)
-  #    minflt  (integer)
-  #    state   (array of symbols; see DARWIN_STATES or LINUX_STATES)
-  #
-  # Only on linux:
-  #    exename (string -- path to the binary)
-  #    fds     (array -- list of open file descriptors)
-  #
-  class ProcessInfo < Struct.new(*PS_FIELDS+[:state])
-
-    DARWIN_STATES = {
-      "R"=>:running,
-      "S"=>:sleeping,
-      "I"=>:idle,
-      "T"=>:stopped,
-      "U"=>:wait,
-      "Z"=>:zombie,
-      "W"=>:swapped,
-
-      "s"=>:session_leader,
-      "X"=>:debugging,
-      "E"=>:exiting,
-      "<"=>:high_priority,
-      "N"=>:low_priority,
-      "+"=>:foreground,
-      "L"=>:locked_pages,
-    }
-
-    LINUX_STATES = {
-      "R"=>:running,
-      "S"=>:sleeping,
-      "T"=>:stopped,
-      "D"=>:wait,
-      "Z"=>:zombie,
-      "W"=>:swapped,
-      "X"=>:dead,
-
-      "s"=>:session_leader,
-      "<"=>:high_priority,
-      "N"=>:low_priority,
-      "+"=>:foreground,
-      "L"=>:locked_pages,
-      "l"=>:multithreaded,
-    }
-
-    def initialize(*args)
-      @dead = false
-      args << stat_to_state(args[PS_FIELDS.index(:stat)])
-      super(*args)
-    end
-
-    def parent
-      Sys.ps(ppid).first unless ppid < 1
-    end
-
-    def children
-      @@parents ||= Sys.ps.group_by(&:ppid)
-      @@parents[pid]
-    end
-
-    #
-    # Convert all the process information to a hash.
-    #
-    def to_hash
-      Hash[ *members.zip(values).flatten(1) ]
-    end
-
-    #
-    # Send the TERM signal to this process.
-    #
-    def kill!(signal="TERM")
-      puts "Killing #{pid} (#{signal})"
-      Process.kill(signal, pid)
-      # TODO: handle exception Errno::ESRCH (no such process)
-    end
-
-    #
-    # Has this process been killed?
-    #
-    def dead?
-      @dead ||= Sys.pid(pid).empty?
-    end
-
-    #
-    # Refresh this process' statistics.
-    #
-    def refresh
-      processes = Sys.ps(pid)
-
-      if processes.empty?
-        @dead = true
-        raise ProcessNotFound
-      end
-
-      updated_process = processes.first
-      members.each { |member| self[member] = updated_process[member] }
-      self
-    end
-
-    alias_method :name, :command
-
-    # Linux-specific methods
-    if Sys.linux?
-
-      def exename
-        @exename ||= File.readlink("/proc/#{pid}/exe") rescue :unknown
-        @exename == :unknown ? nil : @exename
-      end
-
-      def fds
-        Dir["/proc/#{pid}/fd/*"].map { |fd| File.readlink(fd) rescue nil }
-      end
-
-    end
-
-    private
-
-    def stat_to_state(str)
-      states = case Sys.os
-        when "Linux"  then LINUX_STATES
-        when "Darwin" then DARWIN_STATES
-        else raise "Unsupported platform: #{Sys.os}"
-      end
-
-      str.scan(/./).map { |char| states[char] }.compact
-    end
-  end
-
-  #-----------------------------------------------------------------------------
-
-  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
-
-  #
-  # List all (or specified) processes, and return ProcessInfo objects.
-  # (Takes an optional list of pids as arguments.)
-  #
-  def self.ps(*pids)
-    #return @@cache if @@cache
-
-    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
-
-  #-----------------------------------------------------------------------------
-
-  def self.refresh
-    @@cache = nil
-  end
-
-  #
-  # Trap signals!
-  #
-  # usage: trap("EXIT", "HUP", "ETC", :ignore=>["VTALRM"]) { |signal| puts "Got #{signal}!" }
-  # (Execute Signal.list to see what's available.)
-  #
-  # No paramters defaults to all signals except VTALRM, CHLD, CLD, and EXIT.
-  #
-  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
-
-  #-----------------------------------------------------------------------------
-
-  #
-  # 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.)
-  #
-  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
-
-  #-----------------------------------------------------------------------------
-
-  cross_platform_method :hostname
-
-  def self.hostname_linux
-    `uname -n`.strip
-  end
-
-  def self.hostname_mac
-    `uname -n`.strip.gsub(/\.local$/, '')
-  end
-
-  def self.hostname_windows
-    raise NotImplementedError
-  end
-
-  #-----------------------------------------------------------------------------
-
-  cross_platform_method :interfaces
-
-  #
-  # Darwin: Return a hash of (device, IP address) pairs.
-  #
-  # eg: {"en0"=>"192.168.1.101"}
-  #
-  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
-
-  def self.interfaces_darwin; interfaces_bsd; end
-
-  #
-  # Linux: Return a hash of (device, IP address) pairs.
-  #
-  # eg: {"eth0"=>"192.168.1.101"}
-  #
-  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
-
-  #
-  # Windows: Return a hash of (device name, IP address) pairs.
-  #
-  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
-
-  #-----------------------------------------------------------------------------
-
-  cross_platform_method :browser_open
-
-  #
-  # Linux: Open an URL in the default browser (using "gnome-open").
-  #
-  def browser_open_linux(url)
-    system("gnome-open", url)
-  end
-
-  #
-  # Darwin: Open the webpage in a new chrome tab.
-  #
-  def browser_open_darwin(url)
-    system("open", "-a", "chrome", url)
-  end
-
-  #-----------------------------------------------------------------------------
-
-  cross_platform_method :memstat
-
-  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
-
-  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
-
-  #-----------------------------------------------------------------------------
-
-  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 "Not implemented"
-  end
-
-end
-
-if $0 == __FILE__
-  require 'pp'
-  procs = Sys.ps
-  p [:processes, procs.size]
-#  some = procs[0..3]
-#  some.each{|ps| pp ps}
-#  some.first.kill!
-#  pp some.first.to_hash
-#  p [:total_cpu, procs.map{|ps| ps.pcpu}.sum]
-#  p [:total_mem, procs.map{|ps| ps.pmem}.sum]
-
-  pp Sys.interfaces
-end
+require 'epitools/sys/ps'
+require 'epitools/sys/mounts'
+require 'epitools/sys/misc'
+require 'epitools/sys/net'

data/lib/epitools/sys/mem.rb

@@ -0,0 +1,38 @@
+module Sys
+
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :memstat
+
+  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
+
+  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
+
+end

data/lib/epitools/sys/misc.rb

@@ -0,0 +1,60 @@
+module Sys
+
+  #
+  # Trap signals!
+  #
+  # usage: trap("EXIT", "HUP", "ETC", :ignore=>["VTALRM"]) { |signal| puts "Got #{signal}!" }
+  # (Execute Signal.list to see what's available.)
+  #
+  # No paramters defaults to all signals except VTALRM, CHLD, CLD, and EXIT.
+  #
+  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
+
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :browser_open
+
+  #
+  # Linux: Open an URL in the default browser (using "xdg-open").
+  #
+  def browser_open_linux(url)
+    system("xdg-open", url)
+  end
+
+  #
+  # Darwin: Open the webpage in a new chrome tab.
+  #
+  def browser_open_darwin(url)
+    system("open", "-a", "chrome", url)
+  end
+
+  #-----------------------------------------------------------------------------
+
+  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
+
+end

data/lib/epitools/sys/mounts.rb

@@ -0,0 +1,45 @@
+module Sys
+
+  #
+  # Get an array of mounted filesystems (as fancy objects)
+  #
+  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
+
+
+  class Mount
+    attr_accessor :dev, :type, :options
+
+    def initialize(line)
+      @path, @dev, @type, @options = line.strip.split(' ')
+      @options = @options.split(",")
+    end
+
+    def system?
+      (path =~ %r{^/(sys|dev|proc|run/user|tmp)}) or dev == "systemd-1"
+    end
+
+    def inspect
+      "#{type}: #{path} (#{dev})"
+    end
+
+    def to_s
+      "#{path} (#{dev})"
+    end
+
+    def path
+      # Unescape findmnt's hex codes
+      Path.new "#{eval %{"#{@path}"}}/"
+    end
+
+    def dirname
+      path.dirs.last
+    end
+  end
+
+end

data/lib/epitools/sys/net.rb

@@ -0,0 +1,85 @@
+module Sys
+
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :hostname
+
+  def self.hostname_linux
+    `uname -n`.strip
+  end
+
+  def self.hostname_mac
+    `uname -n`.strip.gsub(/\.local$/, '')
+  end
+
+  def self.hostname_windows
+    raise NotImplementedError
+  end
+
+  #-----------------------------------------------------------------------------
+
+  cross_platform_method :interfaces
+
+  #
+  # BSD: Return a hash of (device, IP address) pairs.
+  #
+  # eg: {"en0"=>"192.168.1.101"}
+  #
+  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
+
+  #
+  # Darwin: Do whatever BSD does
+  #
+  def self.interfaces_darwin
+    interfaces_bsd
+  end
+
+  #
+  # Linux: Return a hash of (device, IP address) pairs.
+  #
+  # eg: {"eth0"=>"192.168.1.101"}
+  #
+  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
+
+  #
+  # Windows: Return a hash of (device name, IP address) pairs.
+  #
+  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
+
+end

data/lib/epitools/sys/os.rb

@@ -0,0 +1,94 @@
+module Sys
+
+  #
+  # Return the current operating system: Darwin, Linux, or Windows.
+  #
+  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
+
+  #
+  # Is this Linux?
+  #
+  def self.linux?
+    os == "Linux"
+  end
+
+  #
+  # Is this Windows?
+  #
+  def self.windows?
+    os == "Windows"
+  end
+
+  #
+  # Is this Darwin?
+  #
+  def self.darwin?
+    os == "Darwin"
+  end
+
+  #
+  # Is this a Mac? (aka. Darwin?)
+  #
+  def self.mac?; darwin?; end
+
+  #
+  # Is this BSD?
+  #
+  def self.bsd?
+    os == "BSD" or os == "Darwin"
+  end
+
+
+  #
+  # 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.)
+  #
+  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
+
+end

data/lib/epitools/sys/ps.rb

@@ -0,0 +1,210 @@
+require_relative "os"
+
+module Sys
+
+  #
+  # List all (or specified) processes, and return ProcessInfo objects.
+  # (Takes an optional list of pids as arguments.)
+  #
+  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
+
+  #-----------------------------------------------------------------------------
+
+  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
+
+  #-----------------------------------------------------------------------------
+
+  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   = Hash[ *PS_FIELD_TABLE.flatten ]
+
+  class ProcessNotFound < Exception; end
+
+  #
+  # Contains all the information that PS can report about a process for
+  # the current platform.
+  #
+  # The following attribute accessor methods are available:
+  #
+  #    pid     (integer)
+  #    command (string -- the 'ps' name)
+  #    name    (alias for 'command')
+  #    pcpu    (float)
+  #    pmem    (float)
+  #    stat    (string)
+  #    rss     (integer)
+  #    vsz     (integer)
+  #    user    (string)
+  #    majflt  (integer)
+  #    minflt  (integer)
+  #    state   (array of symbols; see DARWIN_STATES or LINUX_STATES)
+  #
+  # Only on linux:
+  #    exename (string -- path to the binary)
+  #    fds     (array -- list of open file descriptors)
+  #
+  class ProcessInfo < Struct.new(*PS_FIELDS+[:state])
+
+    DARWIN_STATES = {
+      "R"=>:running,
+      "S"=>:sleeping,
+      "I"=>:idle,
+      "T"=>:stopped,
+      "U"=>:wait,
+      "Z"=>:zombie,
+      "W"=>:swapped,
+
+      "s"=>:session_leader,
+      "X"=>:debugging,
+      "E"=>:exiting,
+      "<"=>:high_priority,
+      "N"=>:low_priority,
+      "+"=>:foreground,
+      "L"=>:locked_pages,
+    }
+
+    LINUX_STATES = {
+      "R"=>:running,
+      "S"=>:sleeping,
+      "T"=>:stopped,
+      "D"=>:wait,
+      "Z"=>:zombie,
+      "W"=>:swapped,
+      "X"=>:dead,
+
+      "s"=>:session_leader,
+      "<"=>:high_priority,
+      "N"=>:low_priority,
+      "+"=>:foreground,
+      "L"=>:locked_pages,
+      "l"=>:multithreaded,
+    }
+
+    def initialize(*args)
+      @dead = false
+      args << stat_to_state(args[PS_FIELDS.index(:stat)])
+      super(*args)
+    end
+
+    def parent
+      Sys.ps(ppid).first unless ppid < 1
+    end
+
+    def children
+      @@parents ||= Sys.ps.group_by(&:ppid)
+      @@parents[pid]
+    end
+
+    #
+    # Convert all the process information to a hash.
+    #
+    def to_hash
+      Hash[ *members.zip(values).flatten(1) ]
+    end
+
+    #
+    # Send the TERM signal to this process.
+    #
+    def kill!(signal="TERM")
+      puts "Killing #{pid} (#{signal})"
+      Process.kill(signal, pid)
+      # TODO: handle exception Errno::ESRCH (no such process)
+    end
+
+    #
+    # Has this process been killed?
+    #
+    def dead?
+      @dead ||= Sys.pid(pid).empty?
+    end
+
+    #
+    # Refresh this process' statistics.
+    #
+    def refresh
+      processes = Sys.ps(pid)
+
+      if processes.empty?
+        @dead = true
+        raise ProcessNotFound
+      end
+
+      updated_process = processes.first
+      members.each { |member| self[member] = updated_process[member] }
+      self
+    end
+
+    alias_method :name, :command
+
+    # Linux-specific methods
+    if Sys.linux?
+
+      def exename
+        @exename ||= File.readlink("/proc/#{pid}/exe") rescue :unknown
+        @exename == :unknown ? nil : @exename
+      end
+
+      def fds
+        Dir["/proc/#{pid}/fd/*"].map { |fd| File.readlink(fd) rescue nil }
+      end
+
+    end
+
+    private
+
+    def stat_to_state(str)
+      states = case Sys.os
+        when "Linux"  then LINUX_STATES
+        when "Darwin" then DARWIN_STATES
+        else raise "Unsupported platform: #{Sys.os}"
+      end
+
+      str.scan(/./).map { |char| states[char] }.compact
+    end
+  end
+
+end

data/lib/epitools/wm.rb

@@ -60,6 +60,7 @@ module WM
   class Window < TypedStruct["window_id desktop_id:int pid:int x:int y:int w:int h:int hostname title"]
 
     def self.all
+      # FIXME: Windows owned by linux-namespaced processes (firejail) report their namspaced pid to X11. `window.process` ends up pointing at either nil, or the wrong process.
       `wmctrl -lpG`.lines.map(&:strip).map { |line| Window.from_line(line) }
     end
 

data/spec/core_ext_spec.rb

@@ -674,9 +674,11 @@ describe Enumerator do
   it "concatenates" do
     e = [1,2,3].to_enum + [4,5,6].to_enum
     e.to_a.should == [1,2,3,4,5,6]
+    e.size.should == 6
 
     e = [1,2,3].to_enum + [4,5,6]
     e.to_a.should == [1,2,3,4,5,6]
+    e.size.should == 6
   end
 
   it "multiplies" do

data/spec/path_spec.rb

@@ -21,6 +21,15 @@ describe Path do
     path2.path.should_not == path.path
   end
 
+  it "sizes" do
+    path = Path.tmpfile
+    path.write("asdfasdf")
+    path.size.should == 8
+
+    nonexistant = Path.new("/i/hope/this/doesn't/exist/man")
+    nonexistant.size.should == -1
+  end
+
   it "works with relative paths" do
     path = Path.new("../hello.mp3/blah")
 

data/spec/sys_spec.rb

@@ -2,7 +2,7 @@ require 'epitools'
 
 describe Sys::ProcessInfo do
 
-  specify "checks OS" do
+  specify "OS type" do
     proc { Sys.os }.should_not raise_error
     proc { Sys.linux? }.should_not raise_error
     proc { Sys.mac? }.should_not raise_error
@@ -12,58 +12,41 @@ describe Sys::ProcessInfo do
 
     %w[Linux Windows Darwin BSD].include?(Sys.os).should == true
 
-    [:linux?, :mac?, :windows?, :bsd?].any?{|os| Sys.send(os)}.should == true
+    [:linux?, :mac?, :windows?, :bsd?].any? { |os| Sys.send(os) }.should == true
   end
 
 
   specify "list all processes" do
-#    procs = Sys.ps
-#
-#    procs.first.state.is_a?(Array).should == true
-#
-#    pids = procs.map{ |process| process.pid }
-#
-#    p2s = Hash[ *Sys.ps(*pids).map { |process| [process.pid, process] }.flatten ]
-#    matches = 0
-#    procs.each do |p1|
-#      if p2 = p2s[p1.pid]
-#        matches += 1
-#        p1.command.should == p2.command
-#      end
-#    end
-#
-#    matches.should > 1
-  end
+    # Sys.ps.should_not be_blank
+    procs = Sys.ps
 
+    procs.first.state.is_a?(Array).should == true
 
-  specify "refresh processes" do
+    pids = procs.map{ |process| process.pid }
 
-#    STDOUT.sync = true
-#
-#    procs = Sys.ps
-#    procs.shuffle!
-#    procs.each do |process|
-#      proc do
-#        begin
-#          process.refresh
-#          print "."
-#        rescue Sys::ProcessNotFound
-#        end
-#      end.should_not raise_error
-#    end
-#
-#    puts
+    p2s = Hash[ *Sys.ps(*pids).map { |process| [process.pid, process] }.flatten ]
+    matches = 0
+    procs.each do |p1|
+      if p2 = p2s[p1.pid]
+        matches += 1
+        p1.command.should == p2.command
+      end
+    end
 
+    matches.should > 1
   end
 
-
-  specify "cross-platform method" do
+  specify "cross-platform methods" do
     Sys.cross_platform_method(:cross_platform_test)
-    proc{ Sys.cross_platform_test }.should raise_error
+    proc { Sys.cross_platform_test }.should raise_error(NotImplementedError)
   end
 
-  specify "interfaces" do
+  specify "network interfaces" do
     Sys.interfaces.should_not be_blank
   end
 
+  specify "mounts" do
+    Sys.mounts.should_not be_blank
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epitools
 version: !ruby/object:Gem::Version
-  version: 0.5.106
+  version: 0.5.107
 platform: ruby
 authors:
 - epitron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -80,6 +80,12 @@ files:
 - lib/epitools/rash.rb
 - lib/epitools/ratio.rb
 - lib/epitools/sys.rb
+- lib/epitools/sys/mem.rb
+- lib/epitools/sys/misc.rb
+- lib/epitools/sys/mounts.rb
+- lib/epitools/sys/net.rb
+- lib/epitools/sys/os.rb
+- lib/epitools/sys/ps.rb
 - lib/epitools/term.rb
 - lib/epitools/trie.rb
 - lib/epitools/typed_struct.rb
@@ -124,7 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 3
 summary: Not utils... METILS!