mool 2.0.1 → 3.0.0

data/lib/mool/memory.rb

@@ -1,21 +1,54 @@
-class MoolMemory
-  PATH_PROC_MEMORY = "/proc/meminfo"
+module Mool
+  class Memory
 
-  attr_accessor :unity, :mem_used
+    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}
+    def initialize
+      Mool::Command.meminfo_command.scan(/(\S+):\s+(\d+)/).each do |meminfo|
+        var = meminfo[0].tr('(', '_').tr(')', '').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
-    @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
+    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
 end

data/lib/mool/process.rb

@@ -0,0 +1,129 @@
+module Mool
+  class Process
+    attr_reader :messures, :pattern
+
+    STATUS_PROCESS = {
+      'D' => :uninterruptible_sleep,
+      'R' => :running,
+      'S' => :sleeping,
+      'T' => :stopped_by_job_control_signal,
+      't' => :stopped_by_debugger_during_trace,
+      'Z' => :zombie
+    }
+
+    def initialize(name, pattern, opt = {})
+      if name.class != String || pattern.class != String
+        raise 'Please only use string types!'
+      end
+
+      @messures = []
+      @pattern = pattern
+
+      result = opt[:result] ||
+               Mool::Process.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
+        @messures << {
+          name: name,
+          pattern: pattern,
+          ruser: res[0], # The real user ID of the process.
+          user: res[1], # The effective user ID of the process.
+          rgroup: res[2], #  The real group ID of the process.
+          group: res[3], # The effective group ID of the process.
+          pid: res[4], # The decimal value of the process ID.
+          ppid: res[5], # The decimal value of the parent process ID.
+          pgid: res[6], # The decimal value of the process group ID.
+          pcpu: res[7], # The ratio of CPU time used recently to CPU time available in the same period, expressed as a percentage.
+          vsz: res[8], # The size of the process in (virtual) memory in 1024 byte units as a decimal integer.
+          nice: res[9], # The decimal value of the nice value of the process; see nice.
+          etime: res[10], # In the POSIX locale, the elapsed time since the process was started, in the form: [[dd-]hh:]mm:ss
+          time: res[11], # In the POSIX locale, the cumulative CPU time of the process in the form:  [dd-]hh:mm:ss
+          tty: res[12], # The name of the controlling terminal of the process (if any) in the same format used by the who utility.
+          comm: res[13], # The name of the command being executed (argv[0] value) as a string.
+          args: res[14], # The command with all its arguments as a string.
+          priority: res[15], # Priority: The scheduling priority of the task.
+          virt: res[17], # Virtual Memory Size (KiB) The total amount of virtual memory used by the task
+          res: res[18], # Resident Memory Size (KiB), A subset of the virtual address space (VIRT)
+          shr: res[19], # Shared Memory Size (KiB), A subset of resident memory (RES) that may be used by other processes
+          status: Mool::Process::STATUS_PROCESS[res[20]],
+          cpu_percentage: res[21], # CPU Usage The task's share of the elapsed CPU
+          mem_percentage: res[22], # Memory Usage (RES) A task's currently resident share of available physical memory.
+          time_plus: res[22] # CPU Time, hundredths The same as TIME, but reflecting more granularity through hundredths of a second
+        }
+      end
+    end
+
+    def self.all(services)
+      raise 'Please only use Array type!' if services.class != Array
+      result = {}
+
+      services_data = Mool::Process.services_status(services)
+
+      services.each do |service|
+        result[service[:name]] = Mool::Process.new(
+          service[:name],
+          service[:pattern],
+          result: services_data[service[:name]]
+        )
+      end
+
+      result
+    end
+
+    def self.services_status(services)
+      command_ps = Mool::Command.ps_command
+      command_top = Mool::Command.top_command
+
+      result = {}
+
+      services.each do |service|
+        ps_parsed = Mool::Process.ps_parser(
+          command_ps,
+          service[:pattern]
+        )
+
+        result[service[:name]] = ps_parsed.collect do |data|
+          data + Mool::Process.top_parser(command_top, data[4])
+        end
+      end
+
+      result
+    end
+
+    private
+
+    def self.ps_parser(command, pattern)
+      pattern = pattern.gsub('/', '\/')
+
+      results = []
+
+      # ruser,user,rgroup,group,pid,ppid,pgid,pcpu,vsz,nice,etime,time,tty,comm,args
+      command.split("\n").each do |comm|
+        match = comm.scan(/^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(#{pattern})\s+(.*)/).flatten
+        next if match.empty?
+        results << match
+      end
+      results
+    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+.*/)
+      results = []
+      #          15 16  17  18   19 20  21   22   23    24
+      # PID USER PR NI VIRT RES SHR  S %CPU %MEM TIME+ COMMAND
+      command.split("\n").each do |comm|
+        match = comm.strip.scan(/#{pid}\s+\S+\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.*)/).flatten
+        next if match.empty?
+        results = match
+        break
+      end
+      results
+    end
+  end
+end

data/lib/mool/system.rb

@@ -1,42 +1,60 @@
-class MoolSystem
-  attr_reader :kernel, :current_loadavg, :last_5min_loadavg, :last_15min_loadavg, :thread_entities_exec, :total_thread_entities, :last_pid_process_created, :uptime_day, :uptime_hour, :uptime_minute, :uptime_second
+module Mool
+  class System
+    attr_reader :kernel,
+                :current_loadavg,
+                :last_5min_loadavg,
+                :last_15min_loadavg,
+                :thread_entities_exec,
+                :total_thread_entities,
+                :last_pid_process_created,
+                :uptime_day,
+                :uptime_hour,
+                :uptime_minute,
+                :uptime_second
 
-  def initialize
-    @kernel = `uname -r`.chomp
-    load_avg = File.read("/proc/loadavg").chomp.split(" ")
-    @current_loadavg          = load_avg[0].to_f
-    @last_5min_loadavg        = load_avg[1].to_f
-    @last_15min_loadavg       = load_avg[2].to_f
-    @thread_entities_exec     = load_avg[3].split("/").first.to_i # Currently executing kernel scheduling entities
-    @total_thread_entities    = load_avg[3].split("/").last.to_i # Number of kernel scheduling entities that currently exist on the system
-    @last_pid_process_created = load_avg[4].to_i
-    time = `cat /proc/uptime`.split(" ").first.to_f
-    mm, ss = time.divmod(60)
-    hh, mm = mm.divmod(60)
-    dd, hh = hh.divmod(24)
-    @uptime_day    = dd.to_i
-    @uptime_hour   = hh.to_i
-    @uptime_minute = mm.to_i
-    @uptime_second = ss.to_i
-  end
+    def initialize
+      @kernel = Mool::Command.uname_command
+      load_avg = Mool::Command.loadavg_command.split(' ')
+      @current_loadavg          = load_avg[0].to_f
+      @last_5min_loadavg        = load_avg[1].to_f
+      @last_15min_loadavg       = load_avg[2].to_f
+      # Currently executing kernel scheduling entities
+      @thread_entities_exec     = load_avg[3].split('/').first.to_i
+      # Number of kernel scheduling entities that currently exist on the system
+      @total_thread_entities    = load_avg[3].split('/').last.to_i
+      @last_pid_process_created = load_avg[4].to_i
+      time = Mool::Command.uptime_command.split(' ').first.to_f
+      mm, ss = time.divmod(60)
+      hh, mm = mm.divmod(60)
+      dd, hh = hh.divmod(24)
+      @uptime_day    = dd.to_i
+      @uptime_hour   = hh.to_i
+      @uptime_minute = mm.to_i
+      @uptime_second = ss.to_i
+    end
 
-  def load_average
-    { :current_loadavg => @current_loadavg,
-      :last_5min_loadavg => @last_5min_loadavg,
-      :last_15min_loadavg => @last_15min_loadavg,
-      :thread_entities_exec => @thread_entities_exec,
-      :total_thread_entities => @total_thread_entities,
-      :last_pid_process_created => @last_pid_process_created }
-  end
+    def load_average
+      {
+        current_loadavg: @current_loadavg,
+        last_5min_loadavg: @last_5min_loadavg,
+        last_15min_loadavg: @last_15min_loadavg,
+        thread_entities_exec: @thread_entities_exec,
+        total_thread_entities: @total_thread_entities,
+        last_pid_process_created: @last_pid_process_created
+      }
+    end
 
-  def uptime
-    { :day => @uptime_day,
-      :hour => @uptime_hour,
-      :minute => @uptime_minute,
-      :second =>  @uptime_second }
-  end
+    def uptime
+      {
+        day: @uptime_day,
+        hour: @uptime_hour,
+        minute: @uptime_minute,
+        second:  @uptime_second
+      }
+    end
 
-  def kernel_version
-    @kernel
+    def kernel_version
+      @kernel
+    end
   end
 end

data/lib/mool/version.rb

@@ -1,3 +1,3 @@
 module Mool
-  VERSION = "2.0.1"
+  VERSION = "3.0.0"
 end

data/mool.gemspec

@@ -1,21 +1,36 @@
-lib = File.expand_path('../lib', __FILE__)
+
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'mool/version'
+require "mool/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mool"
+  spec.version       = Mool::VERSION
+  spec.authors       = ["g.edera"]
+  spec.email         = ["gab.edera@gmail.com"]
+
+  spec.summary       = %q{Get operative system information (Linux).}
+  spec.description   = %q{Get operative system information: Disk, Memory, Cpu, Load-average, Processes.}
+  spec.homepage      = "https://github.com/gedera/mool"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = 'https://rubygems.org'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
 
-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.required_ruby_version = '>= 1.8.6'
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  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"]
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
 end

metadata

@@ -1,86 +1,105 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: mool
-version: !ruby/object:Gem::Version 
-  hash: 13
-  prerelease: 
-  segments: 
-  - 2
-  - 0
-  - 1
-  version: 2.0.1
+version: !ruby/object:Gem::Version
+  version: 3.0.0
 platform: ruby
-authors: 
+authors:
 - g.edera
-- eserdio
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-
-date: 2016-08-02 00:00:00 -03:00
-default_executable: 
-dependencies: []
-
-description: "Get operative system information: Disk, Memory, Cpu, Load-average, Processes"
-email: 
+date: 2018-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 'Get operative system information: Disk, Memory, Cpu, Load-average, Processes.'
+email:
 - gab.edera@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- .gitignore
+files:
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console
+- bin/setup
 - lib/locales/en.mool.yml
 - lib/locales/es.mool.yml
 - lib/mool.rb
+- lib/mool/command.rb
 - lib/mool/cpu.rb
 - lib/mool/disk.rb
-- lib/mool/load_average.rb
 - lib/mool/memory.rb
-- lib/mool/service.rb
+- lib/mool/process.rb
 - lib/mool/system.rb
 - lib/mool/version.rb
 - mool.gemspec
-has_rdoc: true
 homepage: https://github.com/gedera/mool
-licenses: 
+licenses:
 - MIT
+metadata:
+  allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 59
-      segments: 
-      - 1
-      - 8
-      - 6
-      version: 1.8.6
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 2.6.11
 signing_key: 
-specification_version: 3
-summary: Get operative system information (Linux)
+specification_version: 4
+summary: Get operative system information (Linux).
 test_files: []
-