mool 1.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mool.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 g.edera
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,326 @@
+# Mool
+**Mool** aims to be as flexible as possible while helping you with powerful components to get all operative system information, such as **CPU**, **Load-Average**, **Disks**, **Memory**, **Service** and **Process**.
+
+The best thing to have this gem is how get the information. The information is obtained from different source but mainly from files and basic commands such as **"top"**, **"mpstat"** and **"df"**.
+
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+    gem 'mool'
+```
+And then execute:
+```console
+    $ bundle
+```
+Or install it yourself as:
+```console
+    $ gem install mool
+```
+
+## Usage
+### CPU
+You can check the posible values to use with:
+```ruby
+    > MoolCpu::PROCESSORS
+    ["0", "1", "2", "4", "all"]
+```
+It's posible get all cpu information:
+```ruby
+    > MoolCpu.all
+    [
+      [0] #<MoolCpu:0x7f82959381a8 @nice=0.0, @gnice=0.0, @total=2.0, @irq=0.0, @usr=2.0, @guest=0.0, @iowait=0.0, @cores=2, @steal=0.0, @sys=0.0, @model_name="Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz", @idle=97.0, @cpu_name="cpu_3", @soft=0.0>,
+      [1] #<MoolCpu:0x7f8295937ca8 @nice=0.0, @gnice=0.0, @total=1.0, @irq=0.0, @usr=1.0, @guest=0.0, @iowait=0.0, @cores=2, @steal=0.0, @sys=0.0, @model_name="Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz", @idle=97.0, @cpu_name="cpu_2", @soft=0.0>,
+      [2] #<MoolCpu:0x7f82959377a8 @nice=0.0, @gnice=0.0, @total=3.0, @irq=0.0, @usr=1.0, @guest=0.0, @iowait=2.0, @cores=2, @steal=0.0, @sys=0.0, @model_name="Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz", @idle=96.0, @cpu_name="cpu_1", @soft=0.0>,
+      [3] #<MoolCpu:0x7f82959372a8 @nice=0.0, @gnice=0.0, @total=4.0, @irq=0.0, @usr=3.0, @guest=0.0, @iowait=0.0, @cores=2, @steal=0.0, @sys=1.0, @model_name="Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz", @idle=95.0, @cpu_name="cpu_0", @soft=0.0>,
+      [4] #<MoolCpu:0x7f8295936da8 @nice=0.0, @gnice=0.0, @total=2.0, @irq=0.0, @usr=2.0, @guest=0.0, @iowait=0.0, @cores=0, @steal=0.0, @sys=0.0, @model_name=nil, @idle=96.0, @cpu_name="cpu_all", @soft=0.0>
+]
+```
+ Or can get a specific cpu information:
+   ```ruby
+     >> MoolCpu.new(0) or MoolCpu.new("0")
+       #<MoolCpu:0x7f82959381a8 @nice=0.0, @gnice=0.0, @total=2.0, @irq=0.0, @usr=2.0, @guest=0.0, @iowait=0.0, @cores=2, @steal=0.0, @sys=0.0, @model_name="Intel(R) Core(TM) i3-3220 CPU @ 3.30GHz", @idle=97.0, @cpu_name="cpu_3", @soft=0.0>
+   ```
+### Load-Average
+```ruby
+     >>  MoolLoadAverage.new
+        #<MoolLoadAverage:0x7f8295931c90 @total_thread_entities=638, @current_loadavg=0.08, @thread_entities_exec=2, @last_15min_loadavg=0.13, @last_pid_process_created=6264, @last_5min_loadavg=0.07>
+```
+### Memory
+```ruby
+     >> MoolMemory.new
+       --- !ruby/object:MoolMemory
+       active: 2906775552.0
+       active_anon: 2175971328.0
+       active_file: 730804224.0
+       anon_huge_pages: 0.0
+       anon_pages: 2174132224.0
+       bounce: 0.0
+       buffers: 73887744.0
+       cached: 1795256320.0
+       commit_limit: 7322968064.0
+       committed_as: 8012181504.0
+       direct_map2_m: 12499025920.0
+       direct_map4k: 280199168.0
+       dirty: 217088.0
+       hardware_corrupted: 0.0
+       huge_pages_free: 0.0
+       huge_pages_rsvd: 0.0
+       huge_pages_surp: 0.0
+       huge_pages_total: 0.0
+       hugepagesize: 2097152.0
+       inactive: 1136472064.0
+       inactive_anon: 573755392.0
+       inactive_file: 562716672.0
+       kernel_stack: 10485760.0
+       mapped: 692449280.0
+       mem_available: 9536376832.0
+       mem_free: 8219561984.0
+       mem_total: 12498477056.0
+       mem_used: 2409771008.0
+       mlocked: 4096.0
+       nfs_unstable: 0.0
+       page_tables: 47812608.0
+       s_reclaimable: 76697600.0
+       s_unreclaim: 34598912.0
+       shmem: 575635456.0
+       slab: 111296512.0
+       swap_cached: 0.0
+       swap_free: 1073729536.0
+       swap_total: 1073729536.0
+       unevictable: 4096.0
+       unity: Bytes
+       vmalloc_chunk: 35183562584064.0
+       vmalloc_total: 35184372087808.0
+       vmalloc_used: 381046784.0
+       writeback: 0.0
+       writeback_tmp: 0.0
+```
+By default the values are in Bytes. So it's posible to changed to different units (Bytes Kbytes, Mbytes, Gbytes).
+```ruby
+      >> MoolMemory.new.to_b
+      >> MoolMemory.new.to_kb
+      >> MoolMemory.new.to_mb
+      >> MoolMemory.new.to_gb
+```
+## Service or Process
+To get process information you can provide two params:
+1) **name**: This name it's used as key.
+2) **pattern**: Used to match with the command top.
+```ruby
+     >> MoolService.new("profanity Process", "profanity")
+        #<MoolService:0x7f4c23f929e8 @messure=[{ :status=>"Sleeping",
+                                                 :command=>"profanity",
+                                                 :time=>"0:08.22",
+                                                 :pattern=>"profanity",
+                                                 :nice=>"0",
+                                                 :pid=>"1764",
+                                                 :memory_in_kb=>"34376",
+                                                 :user=>"mool",
+                                                 :cpu_percentage=>"0,0",
+                                                 :name=>"profanity Process",
+                                                 :mem_percentage=>"0,3",
+                                                 :priority=>"20" }]>
+```
+
+In this case we have only one messure, but exists especial cases, where the pattern match with more than one process. This cases will have more than one messure, such as:
+```ruby
+       >> MoolService.new("Terminal", "urxvt")
+          #<MoolService:0x7f4c23f88f88 @messure=[ { :status=>"Sleeping",
+                                                    :command=>"urxvt",
+                                                    :time=>"0:02.80",
+                                                    :pattern=>"urxvt",
+                                                    :nice=>"0",
+                                                    :pid=>"1672",
+                                                    :memory_in_kb=>"16152",
+                                                    :user=>"mool",
+                                                    :cpu_percentage=>"0,0",
+                                                    :name=>"Terminal",
+                                                    :mem_percentage=>"0,1",
+                                                    :priority=>"20" },
+                                                  { :status=>"Sleeping",
+                                                    :command=>"urxvt",
+                                                    :time=>"0:00.00",
+                                                    :pattern=>"urxvt",
+                                                    :nice=>"0",
+                                                    :pid=>"1673",
+                                                    :memory_in_kb=>"4020",
+                                                    :user=>"mool",
+                                                    :cpu_percentage=>"0,0",
+                                                    :name=>"Terminal",
+                                                    :mem_percentage=>"0,0",
+                                                    :priority=>"20" } ]>
+```
+### Disk
+It's possible to get disk, partition or virtual device information using dev name **MAJOR:MINOR** ("**8:2**"), device name **sda**, **sda1** or virtual device such as "**lvm-sda2**" or "**md0**".
+```ruby
+    >> MoolDisk.new("8:0")
+       #<MoolDisk:0x7fdc6e283f00 @logical_name="sda", @total_block=500107862016.0, @devtype="disk", @mount_point="/boot", @swap=false, @minor="0", @devname="sda", @block_free=0.0, @path="/sys/dev/block/8:0", @major="8", @file_system="ext4", @unity="Bytes", @block_used=0.0>
+    >> MoolDisk.new("sda1")
+       #<MoolDisk:0x7fdc6e266a40 @logical_name="sda1", @total_block=262144000.0, @devtype="partition", @mount_point="/boot", @swap=false, @minor="1", @devname="sda1", @block_free=59062784.0, @path="/sys/dev/block/8:1", @major="8", @file_system="ext4", @unity="Bytes", @block_used=57123840.0>
+    >> MoolDisk.new("sdblvm-homelvm")
+       #<MoolDisk:0x7fdc6e248658 @logical_name="sdblvm-homelvm", @total_block=445602856960.0, @devtype="disk", @mount_point="/boot", @swap=false, @minor="3", @devname="dm-3", @block_free=187429210112.0, @path="/sys/dev/block/252:3", @major="252", @file_system="btrfs", @unity="Bytes", @block_used=34269296640.0>
+```
+It's possible get all partition if the object is `@devtype="disk"`, such as:
+```ruby
+    >> MoolDisk.new("sda").partitions
+    [
+      [0] #<MoolDisk:0x7fdc6eb3cd18 @logical_name="sda1", @total_block=262144000.0, @devtype="partition", @mount_point="/boot", @swap=false, @minor="1", @devname="sda1", @block_free=59062784.0, @path="/sys/dev/block/8:1", @major="8", @file_system="ext4", @unity="Bytes", @block_used=57123840.0>,
+      [1] #<MoolDisk:0x7fdc6e9e7788 @logical_name="sda2", @total_block=1073741824.0, @devtype="partition", @swap=true, @minor="2", @devname="sda2", @block_free=0.0, @path="/sys/dev/block/8:2", @major="8", @file_system="cgroup", @unity="Bytes", @block_used=0.0>,
+      [2] #<MoolDisk:0x7fdc6e8d7f78 @logical_name="sda3", @total_block=498770927616.0, @devtype="partition", @swap=false, @minor="3", @devname="sda3", @block_free=0.0, @path="/sys/dev/block/8:3", @major="8", @file_system=nil, @unity="Bytes", @block_used=0.0>
+   ]
+```
+Otherwise it's possible too get the slaves. The slaves are virtual devices for examples `lvm` or `raid`.
+
+```ruby
+   >> MoolDisk.new("sda3").slaves
+      [
+        [0] #<MoolDisk:0x7fdc6e6bec00 @logical_name="sdblvm-rootlvm", @total_block=32212254720.0, @devtype="disk", @swap=false, @minor="0", @devname="dm-0", @block_free=9739984896.0, @path="/sys/dev/block/252:0", @major="252", @file_system="ext4", @unity="Bytes", @block_used=5232629760.0>,
+        [1] #<MoolDisk:0x7fdc6e672350 @logical_name="sdblvm-tmplvm", @total_block=4294967296.0, @devtype="disk", @mount_point="/boot", @swap=false, @minor="1", @devname="dm-1", @block_free=1926668288.0, @path="/sys/dev/block/252:1", @major="252", @file_system="ext4", @unity="Bytes", @block_used=4227072.0>,
+        [2] #<MoolDisk:0x7fdc6e627ff8 @logical_name="sdblvm-varlvm", @total_block=16106127360.0, @devtype="disk", @mount_point="/boot", @swap=false, @minor="2", @devname="dm-2", @block_free=5497151488.0, @path="/sys/dev/block/252:2", @major="252", @file_system="ext4", @unity="Bytes", @block_used=1951399936.0>,
+        [3] #<MoolDisk:0x7fdc6e5cec78 @logical_name="sdblvm-homelvm", @total_block=445602856960.0, @devtype="disk", @mount_point="/boot", @swap=false, @minor="3", @devname="dm-3", @block_free=187430152192.0, @path="/sys/dev/block/252:3", @major="252", @file_system="btrfs", @unity="Bytes", @block_used=34268366848.0>
+     ]
+```
+
+Other way is get all disk with yours parititons and slaves.
+```ruby
+    >> MoolDisk.all
+       - !ruby/object:MoolDisk
+         block_free: 0.0
+         block_used: 0.0
+         devname: sda
+         evtype: disk
+         file_system: ext4
+         logical_name: sda
+         major: "8"
+         minor: "0"
+         mount_point: /boot
+         swap: false
+         total_block: 500107862016.0
+         unity: Bytes
+         partitions:
+         - !ruby/object:MoolDisk
+           block_free: 59062784.0
+           block_used: 57123840.0
+           devname: sda1
+           devtype: partition
+           file_system: ext4
+           logical_name: sda1
+           major: "8"
+           minor: "1"
+           mount_point: /boot
+           partitions: []
+           path: /sys/dev/block/8:1
+           slaves: []
+           swap: false
+           total_block: 262144000.0
+           unity: Bytes
+         - !ruby/object:MoolDisk
+           block_free: 0.0
+           block_used: 0.0
+           devname: sda2
+           devtype: partition
+           file_system: cgroup
+           logical_name: sda2
+           major: "8"
+           minor: "2"
+           partitions: []
+           path: /sys/dev/block/8:2
+           slaves: []
+           swap: true
+           total_block: 1073741824.0
+           unity: Bytes
+         - !ruby/object:MoolDisk
+           block_free:	0.0
+           block_used:	0.0
+           devname: sda3
+           devtype: partition
+           file_system:
+           logical_name: sda3
+           major: "8"
+           minor: "3"
+           partitions: []
+           path: /sys/dev/block/8:3
+           slaves:
+           - !ruby/object:MoolDisk
+             block_free: 9739984896.0
+             block_used: 5232629760.0
+             devname: dm-0
+             devtype: disk
+             file_system: ext4
+             logical_name: sdblvm-rootlvm
+             major: "252"
+             minor: "0"
+             path: /sys/dev/block/252:0
+             swap: false
+             total_block: 32212254720.0
+             unity: Bytes
+           - !ruby/object:MoolDisk
+             block_free: 1926668288.0
+             block_used: 4227072.0
+             devname: dm-1
+             devtype: disk
+             file_system: ext4
+             logical_name: sdblvm-tmplvm
+             major: "252"
+             minor: "1"
+             mount_point: /boot
+             path: /sys/dev/block/252:1
+             swap: false
+             total_block: 4294967296.0
+             unity: Bytes
+           - !ruby/object:MoolDisk
+             block_free: 5497149440.0
+             block_used: 1951401984.0
+             devname: dm-2
+             devtype: disk
+             file_system: ext4
+             logical_name: sdblvm-varlvm
+             major: "252"
+             minor: "2"
+             mount_point: /boot
+             path: /sys/dev/block/252:2
+             swap: false
+             total_block: 16106127360.0
+             unity: Bytes
+           - !ruby/object:MoolDisk
+             block_free: 187430135808.0
+             block_used: 34268346368.0
+             devname: dm-3
+             devtype: disk
+             file_system: btrfs
+             logical_name: sdblvm-homelvm
+             major: "252"
+             minor: "3"
+             mount_point: /boot
+             path: /sys/dev/block/252:3
+             swap: false
+             total_block: 445602856960.0
+             unity: Bytes
+             swap: false
+             total_block: 498770927616.0
+             unity: Bytes
+             path: /sys/dev/block/8:0
+             slaves: []
+```
+
+Swap partition:
+
+```ruby
+    >> MoolDisk.swap
+       #<MoolDisk:0x7f711644d890 @file_system="cgroup", @unity="Bytes", @block_used=0.0, @logical_name="sda2", @total_block=1073741824.0, @minor="2", @devtype="partition", @path="/sys/dev/block/8:2", @swap=true, @major="8", @devname="sda2", @block_free=1073741824.0>
+```
+
+### Version
+1.0.1
+
+License
+----
+MIT
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/locales/en.mool.yml

@@ -0,0 +1,8 @@
+en:
+  process:
+    status:
+      uninterruptible_sleep: 'Uninterruptible sleep'
+      running: 'Running'
+      sleeping: 'Sleeping'
+      traced_or_stopped: 'Stopped'
+      zombie: 'Zombie'

data/lib/locales/es.mool.yml

@@ -0,0 +1,8 @@
+es:
+  process:
+    status:
+      uninterruptible_sleep: 'Descanso interrumpido'
+      running: 'Corriendo'
+      sleeping: 'Durmiendo'
+      traced_or_stopped: 'Terminado'
+      zombie: 'Zombie'

data/lib/mool/cpu.rb

@@ -0,0 +1,56 @@
+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
+
+  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
+
+    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]
+    end
+
+    cpu_info
+  end
+
+  def self.processors
+    File.read(PATH_PROC_CPUINFO).scan(/processor\t*: (\d+)/).flatten + ["all"]
+  end
+
+
+  def self.all
+    MoolCpu.cpu_info.map{ |key, value| MoolCpu.new(key, value) }
+  end
+end

data/lib/mool/disk.rb

@@ -0,0 +1,117 @@
+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
+
+  def mounting_point
+    @mount_point ||= File.read("/proc/mounts").scan(/#{@logical_name} (\S+)/).flatten.first if File.read("/proc/mounts").include?(@logical_name)
+  end
+
+  def file_system
+    @file_system ||= (Dir.glob("/sys/fs/**/*").select{|a| a.include?(@devname)}.first.split("/")[3] rescue nil)
+  end
+
+  def logical_name
+    @logical_name ||= File.exists?("#{@path}/dm/name")? File.read("#{@path}/dm/name").chomp : @devname
+  end
+
+  def read_uevent
+    @major, @minor, @devname, @devtype = File.read("#{@path}/uevent").scan(/.*=(\d+)\n.*=(\d+)\n.*=(\S+)\n.*=(\w+)\n/).flatten
+  end
+
+  def dev; @major + @minor; end
+
+  def is_disk?; @devtype == "disk"; end
+
+  def is_partition?; @devtype == "partition"; end
+
+  def swap; @swap ||= File.read("/proc/swaps")[/#{@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
+      @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
+      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)
+      end
+    end
+    @slaves
+  end
+
+  def used_percent
+    @block_used / @total_block
+  end
+
+  def free_percent
+    @block_free / @total_block
+  end
+
+  def self.all
+    disks = []
+
+    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?
+    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_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 self.swap
+    result = File.read("/proc/swaps").scan(/.*\n\/dev\/(\S+)/).flatten.first
+    MoolDisk.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
+end

data/lib/mool/load_average.rb

@@ -0,0 +1,13 @@
+class MoolLoadAverage
+  attr_reader :current_loadavg, :last_5min_loadavg, :last_15min_loadavg, :thread_entities_exec, :total_thread_entities, :last_pid_process_created
+
+  def initialize
+    result = File.read("/proc/loadavg").chomp.split(" ")
+    @current_loadavg          = result[0].to_f
+    @last_5min_loadavg        = result[1].to_f
+    @last_15min_loadavg       = result[2].to_f
+    @thread_entities_exec     = result[3].split("/").first.to_i # Currently executing kernel scheduling entities
+    @total_thread_entities    = result[3].split("/").last.to_i # Number of kernel scheduling entities that currently exist on the system
+    @last_pid_process_created = result[4].to_i
+  end
+end

data/lib/mool/memory.rb

@@ -0,0 +1,21 @@
+class MoolMemory
+  PATH_PROC_MEMORY = "/proc/meminfo"
+
+  attr_accessor :unity, :mem_used
+
+  def initialize()
+    File.read(PATH_PROC_MEMORY).scan(/(\S+):\s+(\d+)/).each do |meminfo|
+      var = meminfo[0].gsub("(", "_").gsub(")", "").underscore
+      instance_variable_set("@#{var}", (meminfo[1].to_f * Mool::PARSE_TYPES[Mool::KBYTES]).round(2))
+      class_eval{attr_accessor var.to_sym}
+    end
+    @unity = Mool::BYTES
+    @mem_used = @mem_total - (@mem_free + @cached + @buffers + @swap_cached )
+  end
+
+  def to_b;  Mool.parse_to(self, (instance_variable_names - ["@unity"]), Mool::BYTES); end
+  def to_kb; Mool.parse_to(self, (instance_variable_names - ["@unity"]), Mool::KBYTES); end
+  def to_mb; Mool.parse_to(self, (instance_variable_names - ["@unity"]), Mool::MBYTES); end
+  def to_gb; Mool.parse_to(self, (instance_variable_names - ["@unity"]), Mool::GBYTES); end
+
+end

data/lib/mool/service.rb

@@ -0,0 +1,80 @@
+class MoolService
+  STATUS_PROCESS = { "D" => I18n.t("process.status.uninterruptible_sleep"),
+                     "R" => I18n.t("process.status.running"),
+                     "S" => I18n.t("process.status.sleeping"),
+                     "T" => I18n.t("process.status.traced_or_stopped"),
+                     "Z" => I18n.t("process.status.zombie") }
+
+  attr_reader :messure, :pattern
+
+  def initialize(name, pattern, opt={})
+    raise "Please only use string types!" if (name.class != String or pattern.class != String)
+    @messure = []
+    @pattern = pattern
+
+    result = opt[:result] || MoolService.services_status([{:name => name, :pattern => pattern}])[name]
+
+    result.each do |res|
+      #pid,user,pcpu,pmem,rss,priority,args,nice, memory_in_kb, status, cpu_percetage, men_percentage, time
+      @messure << { :name               => name,
+                    :pattern            => pattern,
+                    :pid                => res[0],
+                    :user               => res[1],
+                    :cpu_average        => res[2],
+                    :mem_average        => res[3],
+                    :resident_set_size  => res[4],
+                    :priority           => res[5],
+                    :time               => res[6],
+                    :status             => MoolService::STATUS_PROCESS[res[7]],
+                    :nice               => res[8],
+                    :args               => res[9],
+                    :memory_in_kb       => res[10],
+                    :cpu_instant        => (res[11] || 0),
+                    :mem_instant        => (res[12] || 0.0)}
+    end
+  end
+
+
+  def self.all(services)
+    raise "Please only use Array type!" if services.class != Array
+    _services = {}
+
+    services_data = MoolService.services_status services
+
+    services.each do |service|
+      _services[service[:name]] = MoolService.new(service[:name],
+                                                  service[:pattern],
+                                                  { :result => services_data[service[:name]] })
+    end
+    _services
+  end
+
+  def self.services_status services
+    command_ps = MoolService.ps
+    command_top = MoolService.top
+    result = {}
+    services.each do |service|
+      result[service[:name]] = MoolService.ps_parser(command_ps, service[:pattern]).collect{ |data| data += MoolService.top_parser(command_top, data[0]) }
+    end
+    result
+  end
+
+  def self.ps; `ps --no-headers -o pid,user,pcpu,pmem,rss,priority,time,stat,nice,args -A`; end
+
+  def self.top; `top -c -b -n1`; end
+
+  private
+
+  def self.ps_parser(command, pattern)
+    pattern = pattern.gsub('/','\/')
+    # pid,user,pcpu,pmem,rss,priority,time,stat,nice,args
+    command.scan(/^\s*(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S)\S*\s+(\S+)\s+.*(#{pattern}).*\n/)
+  end
+
+  def self.top_parser(command, pid)
+    # memory_in_kb, cpu_percetage, men_percentage
+    # command.scan(/[\s+]#{pid}\s+\S+\s+\S+\s+(\S+)\s+\S+\s+(\S+)\s+\S+\s+(\S)\s+(\S+)\s+(\S+)\s+(\S+)\s+.*/)
+    result = command.scan(/#{pid}\s+\S+\s+\S+\s+\S+\s+(\S+)\s+\S+\s+\S+\s+\S+\s+(\S+)\s+(\S+)\s+\S+\s+\S+/).flatten
+  end
+
+end

data/lib/mool/version.rb

@@ -0,0 +1,3 @@
+module Mool
+  VERSION = "1.0.1"
+end

data/lib/mool.rb

@@ -0,0 +1,31 @@
+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/load_average'
+
+
+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 }
+
+  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])
+      obj.instance_variable_set(var, value)
+    end
+    obj.unity = parse
+    obj
+  end
+
+end

data/mool.gemspec

@@ -0,0 +1,20 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mool/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "mool"
+  gem.version       = Mool::VERSION
+  gem.platform      = Gem::Platform::RUBY
+  gem.authors       = ["g.edera", "eserdio"]
+  gem.email         = ["gab.edera@gmail.com"]
+  gem.description   = "Get operative system information: Disk, Memory, Cpu, Load-average, Processes"
+  gem.summary       = "Get operative system information (Linux)"
+  gem.homepage      = "https://github.com/gedera/mool"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: mool
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- g.edera
+- eserdio
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2015-12-18 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: "Get operative system information: Disk, Memory, Cpu, Load-average, Processes"
+email: 
+- gab.edera@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/locales/en.mool.yml
+- lib/locales/es.mool.yml
+- lib/mool.rb
+- lib/mool/cpu.rb
+- lib/mool/disk.rb
+- lib/mool/load_average.rb
+- lib/mool/memory.rb
+- lib/mool/service.rb
+- lib/mool/version.rb
+- mool.gemspec
+has_rdoc: true
+homepage: https://github.com/gedera/mool
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Get operative system information (Linux)
+test_files: []
+