mool 2.0.1 → 3.0.0

data/Rakefile

@@ -1 +1,10 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mool"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mool.rb

@@ -1,30 +1,36 @@
-mydir = File.expand_path(File.dirname(__FILE__))
-
-require 'i18n'
-I18n.load_path += Dir[File.join(mydir, 'locales', '*.yml')]
-
-require 'mool/version'
-require 'mool/service'
-require 'mool/cpu'
-require 'mool/disk'
-require 'mool/memory'
-require 'mool/system'
+%w[command
+   cpu
+   disk
+   memory
+   system
+   process
+   version].each do |file|
+  require "mool/#{file}"
+end
 
 module Mool
   BLOCK_SIZE = 512
-  BYTES = "Bytes"
-  KBYTES = "KBytes"
-  MBYTES = "MBytes"
-  GBYTES = "GBytes"
-  PARSE_TYPES = { BYTES => 1, KBYTES => 2**10, MBYTES => 2**20, GBYTES => 2**30 }
+
+  BYTES = 'Bytes'.freeze
+  KBYTES = 'KBytes'.freeze
+  MBYTES = 'MBytes'.freeze
+  GBYTES = 'GBytes'.freeze
+
+  PARSE_TYPES = {
+    BYTES => 1,
+    KBYTES => 2**10,
+    MBYTES => 2**20,
+    GBYTES => 2**30
+  }.freeze
 
   def self.parse_to(obj, vars, parse)
     vars.each do |var|
-      value = ((obj.instance_variable_get(var).to_f * PARSE_TYPES[obj.unity]) / PARSE_TYPES[parse])
+      value = (obj.instance_variable_get(var).to_f *
+               PARSE_TYPES[obj.unity]) /
+              PARSE_TYPES[parse]
       obj.instance_variable_set(var, value)
     end
     obj.unity = parse
     obj
   end
-
 end

data/lib/mool/command.rb

@@ -0,0 +1,86 @@
+module Mool
+  module Command
+
+    def self.cpuinfo_command
+      File.read('/proc/cpuinfo')
+    end
+
+    def self.mpstat_command
+      File.read('|mpstat -P ALL 1 1')
+    end
+
+    def self.df_command
+      `df`
+    end
+
+    def self.mount_command
+      File.read('/proc/mounts')
+    end
+
+    def self.file_system_command
+      Dir.glob('/sys/fs/**/*')
+    end
+
+    def self.logical_name_command(path)
+      File.exist?("#{path}/dm/name") ? File.read("#{path}/dm/name").chomp : nil
+    end
+
+    def self.uevent_command(path)
+      File.read("#{path}/uevent")
+    end
+
+    def self.swap_command(lname = nil)
+      result = File.read('/proc/swaps')
+      lname.present? ? result[/#{lname} /] : result
+    end
+
+    def self.capacity_partition_command(path)
+      File.read("#{path}/size")
+    end
+
+    def self.partitions_command(path, devname)
+      Dir.glob("#{path}/#{devname}*")
+    end
+
+    def self.dev_block_command
+      Dir.glob('/sys/dev/block/*')
+    end
+
+    def self.real_path_block_command(entry)
+      `readlink -f #{entry}`.chomp
+    end
+
+    def self.real_path_command_exist?(real_path)
+      File.exist?("#{real_path}/partition")
+    end
+
+    def self.slaves_command(real_path)
+      Dir.glob("#{real_path}/slaves/*")
+    end
+
+    def self.meminfo_command
+      File.read('/proc/meminfo')
+    end
+
+    def self.ps_command
+      # `ps --no-headers -o pid,user,pcpu,pmem,rss,priority,time,stat,nice,args -A`
+      `ps --no-headers -o ruser,user,rgroup,group,pid,ppid,pgid,pcpu,vsz,nice,etime,time,tty,comm,args=HEADER -A`
+    end
+
+    def self.top_command
+      `top -c -b -n1`
+    end
+
+    def self.uname_command
+      `uname -r`.chomp
+    end
+
+    def self.uptime_command
+      `cat /proc/uptime`.chomp
+    end
+
+    def self.loadavg_command
+      File.read('/proc/loadavg').chomp
+    end
+  end
+end

data/lib/mool/cpu.rb

@@ -1,56 +1,83 @@
-class MoolCpu
-  PATH_PROC_CPUINFO = "/proc/cpuinfo"
-  PROCESSORS = File.read(PATH_PROC_CPUINFO).scan(/processor\t*: (\d+)/).flatten + ["all"]
-
-  attr_reader :cpu_name, :model_name, :cores, :usr, :nice, :sys, :iowait, :irq, :soft, :steal, :guest, :gnice, :idle, :total
-
-  # ["all", "1", "2"]
-  def initialize(process_number, opt={})
-    raise "Cpu name incorrect!. Posible values: #{MoolCpu::PROCESSORS.join(",")}" unless MoolCpu::PROCESSORS.include?(process_number.to_s)
-    result = opt.empty? ? MoolCpu.cpu_info[process_number.to_s] : opt
-    @cpu_name = "cpu_#{process_number.to_s}"
-    @model_name = result["model_name"]
-    @cores      = result["cpu_cores"].to_i
-    @usr        = result["%usr"].to_f
-    @nice       = result["%nice"].to_f
-    @sys        = result["%sys"].to_f # This is kernel %
-    @iowait     = result["%iowait"].to_f
-    @irq        = result["%irq"].to_f
-    @soft       = result["%soft"].to_f
-    @steal      = result["%steal"].to_f
-    @guest      = result["%guest"].to_f
-    @gnice      = result["%gnice"].to_f
-    @idle       = result["%idle"].to_f
-    @total      = @usr + @nice + @sys + @iowait + @irq + @soft + @steal + @guest
-  end
+module Mool
+  class Cpu
+    attr_reader :cpu_name,
+                :model_name,
+                :cores,
+                :usr,
+                :nice,
+                :sys,
+                :iowait,
+                :irq,
+                :soft,
+                :steal,
+                :guest,
+                :gnice,
+                :idle,
+                :total
 
-  def self.cpu_info
-    cpu_info = {}
-
-    mpstat = File.read("|mpstat -P ALL 1 1").split("\n\n")[2].split("\n").map{|i| i.gsub(/^\S+:/, '').strip.split(/\s+/) }
-    mpstat_vars = mpstat.shift
-    mpstat_vars.shift
-    mpstat.each do |data|
-      res = {}
-      core_name = data.shift
-      data.each_with_index { |d, i| res.merge!(mpstat_vars[i] => d) }
-      cpu_info.merge!(core_name => res)
-    end
+    # ["all", "1", "2"]
+    def initialize(process_number, opt={})
+      result = Mool::Cpu.processors
 
-    File.read(PATH_PROC_CPUINFO).gsub(/([^\n])\n([^\n])/, '\1 \2').scan(/processor\t*: (\d+).*model name\t*: (.*) stepping.*cpu cores\t*: (\d+)/).each do |v|
-      cpu_info[v[0]]["model_name"] = v[1]
-      cpu_info[v[0]]["cpu_cores"] = v[2]
+      unless result.include?(process_number.to_s)
+        raise "Cpu name incorrect!. Posible values: #{result.join(', ')}"
+      end
+      result = opt.empty? ? Mool::Command.cpuinfo[process_number.to_s] : opt
+      @cpu_name = "cpu_#{process_number}"
+      @model_name = result['model_name']
+      @cores      = result['cpu_cores'].to_i
+      @usr        = result['%usr'].to_f
+      @nice       = result['%nice'].to_f
+      @sys        = result['%sys'].to_f # This is kernel %
+      @iowait     = result['%iowait'].to_f
+      @irq        = result['%irq'].to_f
+      @soft       = result['%soft'].to_f
+      @steal      = result['%steal'].to_f
+      @guest      = result['%guest'].to_f
+      @gnice      = result['%gnice'].to_f
+      @idle       = result['%idle'].to_f
+      @total      = [@usr,
+                     @nice,
+                     @sys,
+                     @iowait,
+                     @irq,
+                     @soft,
+                     @steal,
+                     @guest].sum
     end
 
-    cpu_info
-  end
+    def self.cpuinfo
+      cpu_info = {}
 
-  def self.processors
-    File.read(PATH_PROC_CPUINFO).scan(/processor\t*: (\d+)/).flatten + ["all"]
-  end
+      mpstat = Mool::Command.mpstat_command.split("\n\n")[2].split("\n").map do |i|
+        i.gsub(/^\S+:/, '').strip.split(/\s+/)
+      end
+
+      mpstat_vars = mpstat.shift
+      mpstat_vars.shift
+
+      mpstat.each do |data|
+        res = {}
+        core_name = data.shift
+        data.each_with_index { |d, i| res.merge!(mpstat_vars[i] => d) }
+        cpu_info.merge!(core_name => res)
+      end
 
+      Mool::Command.cpuinfo_command.gsub(/([^\n])\n([^\n])/,
+                                         '\1 \2').scan(/processor\t*: (\d+).*model name\t*: (.*) stepping.*cpu cores\t*: (\d+)/).each do |v|
+        cpu_info[v[0]]['model_name'] = v[1]
+        cpu_info[v[0]]['cpu_cores'] = v[2]
+      end
 
-  def self.all
-    MoolCpu.cpu_info.map{ |key, value| MoolCpu.new(key, value) }
+      cpu_info
+    end
+
+    def self.processors
+      Mool::Command.cpuinfo_command.scan(/processor\t*: (\d+)/).flatten + ['all']
+    end
+
+    def self.all
+      Mool::Cpu.cpuinfo.map { |key, value| Mool::Cpu.new(key, value) }
+    end
   end
 end

data/lib/mool/disk.rb

@@ -1,117 +1,189 @@
-class MoolDisk
-  PATH_DEV_BLOCK = Dir.glob('/sys/dev/block/*')
-
-  attr_accessor :path, :major, :minor, :devname, :devtype, :size, :swap, :mount_point, :file_system, :total_block, :block_used, :block_free, :partitions, :slaves, :unity
-
-  def initialize(dev_name)
-    @path = PATH_DEV_BLOCK.select{ |entry| ( File.read("#{entry}/dev").include?(dev_name)) ||
-                                           ( File.read("#{entry}/uevent").include?(dev_name)) ||
-                                           ( File.exist?("#{entry}/dm/name") &&
-                                             File.read("#{entry}/dm/name").include?(dev_name)) }.first
-    raise "Does't exist #{dev_name}!" if @path.nil?
-    read_uevent
-    logical_name
-    swap
-    capacity
-    @unity = Mool::BYTES
-    mounting_point
-    file_system
-  end
+module Mool
+  class Disk
+    attr_accessor :path,
+                  :major,
+                  :minor,
+                  :devname,
+                  :devtype,
+                  :size,
+                  :swap,
+                  :mount_point,
+                  :file_system,
+                  :total_block,
+                  :block_used,
+                  :block_free,
+                  :partitions,
+                  :slaves,
+                  :unity
+
+    def initialize(dev_name)
+      paths = Mool::Command.dev_block_command.select do |entry|
+        Mool::Disk.dev_name_command(entry).include?(dev_name) ||
+          Mool::Disk.uevent_command(entry).include?(dev_name) ||
+          Mool::Disk.logical_name_command(entry)
+      end
 
-  def mounting_point
-    @mount_point ||= File.read("/proc/mounts").scan(/#{@logical_name} (\S+)/).flatten.first if File.read("/proc/mounts").include?(@logical_name)
-  end
+      @path = paths.first
 
-  def file_system
-    @file_system ||= (Dir.glob("/sys/fs/**/*").select{|a| a.include?(@devname)}.first.split("/")[3] rescue nil)
-  end
+      raise "Does't exist #{dev_name}!" if @path.nil?
+      read_uevent
+      logical_name
+      swap
+      capacity
+      @unity = Mool::BYTES
+      mounting_point
+      file_system
+    end
 
-  def logical_name
-    @logical_name ||= File.exists?("#{@path}/dm/name")? File.read("#{@path}/dm/name").chomp : @devname
-  end
+    def mounting_point
+      Mool::Command.mount_command.include?(@logical_name) &&
+        @mount_point ||= Mool::Command.mount_command.scan(
+        /#{@logical_name} (\S+)/
+      ).flatten.first
+    end
 
-  def read_uevent
-    @major, @minor, @devname, @devtype = File.read("#{@path}/uevent").scan(/.*=(\d+)\n.*=(\d+)\n.*=(\S+)\n.*=(\w+)\n/).flatten
-  end
+    def file_system
+      files = Mool::Command.file_system_command.select do |a|
+        a.include?(@devname)
+      end
+
+      files.first.present? &&
+        @file_system ||= files.first.split('/')[3]
+    end
+
+    def logical_name
+      lname = Mool::Command.logical_name_command(@path)
+      @logical_name = lname.present? ? lname : @devname
+    end
+
+    def read_uevent
+      @major,
+      @minor,
+      @devname,
+      @devtype = Mool::Command.uevent_command(@path).scan(
+        /.*=(\d+)\n.*=(\d+)\n.*=(\S+)\n.*=(\w+)\n/
+      ).flatten
+    end
 
-  def dev; @major + @minor; end
+    def dev
+      @major + @minor
+    end
 
-  def is_disk?; @devtype == "disk"; end
+    def is_disk?
+      @devtype == 'disk'
+    end
 
-  def is_partition?; @devtype == "partition"; end
+    def is_partition?
+      @devtype == 'partition'
+    end
 
-  def swap; @swap ||= File.read("/proc/swaps")[/#{@logical_name} /].present?; end
+    def swap
+      @swap ||= Mool::Command.swap_command(@logical_name).present?
+    end
 
-  def capacity
-    unless (defined?(@total_block) && defined?(@block_used) && defined?(@block_free))
-      result = `df`.scan(/(#{@logical_name}|#{@devname})\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/).flatten
-      @total_block = File.read("#{@path}/size").chomp.to_f * Mool::BLOCK_SIZE
+    def capacity
+      return if defined?(@total_block) && defined?(@block_used) && defined?(@block_free)
+      result = Mool::Command.df_command.scan(
+        /(#{@logical_name}|#{@devname})\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)/
+      ).flatten
+      @total_block = Mool::Command.capacity_partition_command(@path).chomp.to_f *
+                     Mool::BLOCK_SIZE
       @block_used  = result[2].to_f * Mool::BLOCK_SIZE
       @block_free  = @total_block - @block_used
     end
-  end
 
-  def partitions
-    unless defined? @partitions
-      @partitions = []
-      if is_disk?
-        Dir.glob("#{@path}/#{@devname}*").each do |part|
-          @partitions << MoolDisk.new(part.split("/").last)
-        end
+    def partitions
+      return @partitions if defined? @partitions
+      return unless is_disk?
+      @partitions = Mool::Command.partitions_command(
+        @path,
+        @devname
+      ).map do |part|
+        MoolDisk.new(part.split('/').last)
       end
     end
-    @partitions
-  end
 
-  def slaves
-    unless defined? @slaves
-      @slaves = []
-      PATH_DEV_BLOCK.select{ |entry| File.directory?("#{entry}/slaves/#{@devname}") }.each do |slave|
-        @slaves << MoolDisk.new(slave.split("/").last)
+    def slaves
+      return @slaves if defined? @slaves
+      blocks = Mool::Command.dev_block_command.select do |entry|
+        File.directory?("#{entry}/slaves/#{@devname}")
+      end
+
+      @slaves = blocks.map do |slave|
+        MoolDisk.new(slave.split('/').last)
       end
     end
-    @slaves
-  end
 
-  def used_percent
-    @block_used / @total_block
-  end
+    def used_percent
+      @block_used / @total_block
+    end
 
-  def free_percent
-    @block_free / @total_block
-  end
+    def free_percent
+      @block_free / @total_block
+    end
 
-  def self.all
-    disks = []
+    def to_b
+      Mool.parse_to(self,
+                    ['@total_block',
+                     '@block_used',
+                     '@block_free'],
+                    Mool::BYTES)
+    end
 
-    PATH_DEV_BLOCK.each do |entry|
-      real_path = `readlink -f #{entry}`.chomp
-      disks << MoolDisk.new(entry.split("/").last) if (not real_path.include?("virtual")) &&
-                                                      (not real_path.include?("/sr")) &&
-                                                      (not File.exist?("#{real_path}/partition")) &&
-                                                      Dir.glob("#{real_path}/slaves/*").empty?
+    def to_kb
+      Mool.parse_to(self,
+                    ['@total_block',
+                     '@block_used',
+                     '@block_free'],
+                    Mool::KBYTES)
     end
 
-    disks.each{ |disk| disk.partitions.each { |part| part.partitions and part.slaves }}
-    disks.each{ |disk| disk.slaves.each { |part| part.partitions and part.slaves }}
-    disks
-  end
+    def to_mb
+      Mool.parse_to(self,
+                    ['@total_block',
+                     '@block_used',
+                     '@block_free'],
+                    Mool::MBYTES)
+    end
 
-  def to_b;  Mool.parse_to(self, ["@total_block", "@block_used", "@block_free"], Mool::BYTES);  end
-  def to_kb; Mool.parse_to(self, ["@total_block", "@block_used", "@block_free"], Mool::KBYTES); end
-  def to_mb; Mool.parse_to(self, ["@total_block", "@block_used", "@block_free"], Mool::MBYTES); end
-  def to_gb; Mool.parse_to(self, ["@total_block", "@block_used", "@block_free"], Mool::GBYTES); end
+    def to_gb
+      Mool.parse_to(self,
+                    ['@total_block',
+                     '@block_used',
+                     '@block_free'],
+                    Mool::GBYTES)
+    end
 
-  def self.swap
-    result = File.read("/proc/swaps").scan(/.*\n\/dev\/(\S+)/).flatten.first
-    MoolDisk.new(result) unless result.nil?
-  end
+    def self.all
+      disks = []
+
+      Mool::Command.dev_block_command.each do |entry|
+        real_path = Mool::Command.real_path_block_command(entry)
+        next unless !real_path.include?('virtual') &&
+                    !real_path.include?('/sr') &&
+                    !Mool::Command.real_path_command_exist?(real_path) &&
+                    Mool::Command.slaves_command(real_path).empty?
+        disks << Mool::Disk.new(entry.split('/').last)
+      end
 
-  def self.all_usable
-    result = MoolDisk.all
-    result.each do |disk|
-      result += (disk.partitions + disk.slaves + (disk.partitions + disk.slaves).collect{|p| p.partitions + p.slaves }.flatten)
+      disks.each { |disk| disk.partitions.each { |part| part.partitions && part.slaves }}
+      disks.each { |disk| disk.slaves.each { |part| part.partitions && part.slaves }}
+      disks
+    end
+
+    def self.swap
+      result = Mool::Command.swap_command.scan(%r{/.*\n\/dev\/(\S+)/}).flatten.first
+      Mool::Disk.new(result) unless result.nil?
+    end
+
+    def self.all_usable
+      result = MoolDisk.all
+      result.each do |disk|
+        result += (disk.partitions +
+                   disk.slaves +
+                   (disk.partitions + disk.slaves).collect { |p| p.partitions + p.slaves }.flatten)
+      end
+      result.reject(&:blank?).select { |d| (d.partitions + d.slaves).blank? }
     end
-    result.reject(&:blank?).select{|d| (d.partitions + d.slaves).blank? }
   end
 end