RubyGems - mool - Versions diffs - 1.0.1 - Mend

mool 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (16) hide show

data/.gitignore ADDED Viewed

@@ -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 ADDED Viewed

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

data/LICENSE.txt ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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

data/lib/locales/en.mool.yml ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

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

data/lib/mool.rb ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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: []