hawatel_ps 0.1.1

data/lib/hawatel_ps/linux/proc_fetch.rb

@@ -0,0 +1,405 @@
+module HawatelPS
+  module Linux
+    class ProcFetch
+      class << self
+
+        # Genererate ProcInfo objects list
+        #
+        # @example
+        #  get_process.each do |process|
+        #   p process.pid
+        #  end
+        #
+        # @return [Array<ProcInfo>] - list current running processes
+        def get_process
+          proc_table = Array.new
+          memtotal   = memory_total
+          sockets    = open_ports
+          Dir.foreach("/proc").each do |pid|
+             if is_numeric?(pid)
+               attrs = Hash.new
+               attrs[:pid] = pid.to_i
+               attrs[:cwd] = process_cwd(pid)
+               attrs[:username] = process_username(pid)
+               attrs[:cmdline]  = process_cmdline(pid)
+               attrs[:ctime]    = process_ctime(pid)
+               attrs[:limits]   = process_limits(pid)
+               attrs[:environ]  = process_env(pid)
+               attrs[:childs]   = Array.new
+               process_io(attrs)
+               process_files(attrs, sockets)
+               process_status(attrs)
+               process_stat(attrs)
+               attrs[:memory_percent] = memory_percent(attrs, memtotal)
+               proc_table << attrs
+             end
+          end
+          return proc_table
+        end
+
+        private
+        # @see https://www.kernel.org/doc/Documentation/filesystems/proc.txt Table 1-2
+        # Get process attributes from /proc/<pid>/status file and save in Hash container
+        #
+        # @example
+        #  process_status(Hash)
+        # @param attrs [Hash] hash list contains process attributes
+        def process_status(attrs)
+          status_file = "/proc/#{attrs[:pid]}/status"
+          File.foreach(status_file).each do |attr|
+            if attr =~ /Name:/
+              attrs[:name] = attr.split(' ')[1]
+            elsif attr =~ /PPid:/
+              attrs[:ppid] = attr.split(' ')[1].to_i
+            elsif attr =~ /State:/
+              attrs[:state] = attr.split(' ')[2].to_s.chop[1..-1]
+            elsif attr =~ /Uid:/
+              attrs[:ruid] = attr.split(' ')[1].to_i
+              attrs[:euid] = attr.split(' ')[2].to_i
+              attrs[:suid] = attr.split(' ')[3].to_i
+              attrs[:fsuid] = attr.split(' ')[4].to_i
+            elsif attr =~ /Gid:/
+              attrs[:gid] = attr.split(' ')[1].to_i
+              attrs[:egid] = attr.split(' ')[2].to_i
+              attrs[:sgid] = attr.split(' ')[3].to_i
+              attrs[:fsgid] = attr.split(' ')[4].to_i
+            elsif attr =~ /Threads:/
+              attrs[:threads] = attr.split(' ')[1].to_i
+            elsif attr =~ /VmSize:/
+              attrs[:vmsize] = attr.split(' ')[1].to_i
+            elsif attr =~ /VmRSS:/
+              attrs[:vmrss] = attr.split(' ')[1].to_i
+            elsif attr =~ /VmData:/
+              attrs[:vmdata] = attr.split(' ')[1].to_i
+            elsif attr =~ /VmSwap:/
+              attrs[:vmswap] = attr.split(' ')[1].to_i
+            elsif attr =~ /VmLib:/
+              attrs[:vmlib] = attr.split(' ')[1].to_i
+            end
+          end
+        end
+
+        # @note read access to io file are restricted only to owner of process
+        # Read I/O attributes from /proc/<pid>/io file and save in attrs container
+        #
+        # @example
+        #  attrs = Hash.new
+        #  process_io(Hash)
+        #  p attrs[:wchar]
+        #
+        # @param attrs [Hash] hash list contains process attributes
+        def process_io(attrs)
+          process_io_set_nil(attrs)
+          io_file = "/proc/#{attrs[:pid]}/io"
+          if File.readable?(io_file)
+            File.foreach(io_file).each do |attr|
+              name = attr.split(' ')[0].chop
+              attrs[:"#{name}"] = attr.split(' ')[1].to_i
+            end
+          end
+        end
+
+        # Set default value for i/o attributes in attrs container
+        #
+        # @param attrs [Hash] hash list contains process attributes
+        def process_io_set_nil(attrs)
+          ['rchar','wchar','syscr','syscw','read_bytes','write_bytes','cancelled_write_bytes'].each do |attr|
+            attrs[:"#{attr}"] = 'Permission denied'
+          end
+        end
+
+        # @see https://www.kernel.org/doc/Documentation/filesystems/proc.txt
+        # Read statistics from /proc/<pid>/stat file and save in attrs container
+        #
+        # @example
+        #  container = Hash.new
+        #  process_stat(container)
+        #
+        # @param attrs [Hash] hash list contains process attributes
+        def process_stat(attrs)
+          stat_file = "/proc/#{attrs[:pid]}/stat"
+          if File.readable?  (stat_file)
+            File.foreach(stat_file).each do |line|
+              attr = line.split(' ')
+              attrs[:utime] = attr[13].to_i
+              attrs[:stime] = attr[14].to_i
+              attrs[:cpu_time] = (attrs[:utime] +  attrs[:stime])
+              attrs[:cpu_percent] = cpu_percent({:cpu_time => attrs[:cpu_time], :proc_uptime => attr[21].to_i })
+            end
+          end
+        end
+
+        # Get ctime of process from pid file timestamp
+        #
+        # @example
+        #  process_ctime(122)
+        #
+        # @param pid [Fixnum] process pid
+        # @return [aTime]
+        def process_ctime(pid)
+          pid_dir = "/proc/#{pid}"
+          (Dir.exist?(pid_dir)) ? File.ctime(pid_dir) : 0
+        end
+
+        # @note read access to cwd file are restricted only to owner of process
+        # Get current work directory
+        #
+        # @example
+        #  process_cwd(323)
+        #
+        # @param pid [Fixnum] process pid
+        # @return [String]
+        def process_cwd(pid)
+          cwd_file = "/proc/#{pid}/cwd"
+          (File.readable?(cwd_file)) ? File.readlink(cwd_file) : 'Permission denied'
+        end
+
+        # @note read access to io file are restricted only to owner of process
+        # Get command line arguments
+        #
+        # @example
+        #  process_cmdline(312)
+        #
+        # @param pid [Fixnum] process pid
+        # @return [String]
+        def process_cmdline(pid)
+          cmdline_file = "/proc/#{pid}/cmdline"
+          if File.readable? (cmdline_file)
+            File.foreach(cmdline_file).each do |line|
+              return line
+            end
+          else
+            'Permission denied'
+          end
+        end
+
+        # Get soft and hard limits for process from limits file
+        #
+        # @example
+        #  p = process_limits('312')
+        #
+        #  p.limits.each do |limit|
+        #    puts "#{limit[name]} #{limit[:soft]} #{limit[:hard]}"
+        #  end
+        #
+        # @param pid [Fixnum] process pid
+        # @return [Array<Hash>]
+        def process_limits(pid)
+          limits_file = "/proc/#{pid}/limits"
+          limits_list = Array.new
+          if File.readable?(limits_file)
+            File.foreach(limits_file).each do |line|
+              next if (line =~ /Limit/)
+              line_split = line.split(' ')
+              if line.split(' ')[1] == 'processes'
+                lname = "#{line_split[1]}"
+                lsoft = "#{line_split[2]} #{line_split[4]}"
+                lhard = "#{line_split[3]} #{line_split[4]}"
+              else
+                lname = "#{line_split[1]}_#{line_split[2]}"
+                if line.split(' ')[5]
+                  lsoft = "#{line_split[3]} #{line_split[5]}"
+                  lhard = "#{line_split[4]} #{line_split[5]}"
+                else
+                  lsoft = "#{line_split[3]}"
+                  lhard = "#{line_split[4]}"
+                end
+              end
+              limits_attrs = { :name => "#{lname}", :soft => "#{lsoft}", :hard => "#{lhard}" }
+              limits_list << limits_attrs
+            end
+          else
+            limits_list = ['Permission denied']
+          end
+          limits_list
+        end
+
+        # @note read access to fd directory are restricted only to owner of process
+        # Get & set open files and sockets from fd directory in attrs container
+        #
+        # @param attrs [Hash] hash list contains process attributes
+        # @param sockets [Array<Hash>] list sockets from /proc/net/tcp /proc/net/udp file
+        def process_files(attrs, sockets)
+          fd_dir  = "/proc/#{attrs[:pid]}/fd"
+          files   = Array.new
+          ports   = Array.new
+          if File.readable?(fd_dir)
+            Dir.foreach(fd_dir).each do |fd|
+              if is_numeric?(fd)
+                file = File.readlink("#{fd_dir}/#{fd}")
+                attrs[:tty] = file if fd == '0'
+                if file =~ /^\// && file !~ /^\/(dev|proc)/
+                  files << file
+                elsif file =~ /socket/
+                  net_listen = compare_socket(file, sockets)
+                  if net_listen; ports << net_listen end
+                end
+              end
+            end
+            attrs[:open_files] = files
+            attrs[:listen_ports] = ports
+          else
+            attrs[:open_files] = 'Permission denied'
+            attrs[:listen_ports] = 'Permission denied'
+            attrs[:tty] = 'Permission denied'
+          end
+        end
+
+        # Match socket id from /proc/<pid>/fd with /proc/net/(tcp|udp)
+        #
+        # @return [String] containing matched protocol,ip and port (example: tcp:127.0.0.1:8080)
+        def compare_socket(file, sockets)
+          sockets.each do |socket|
+            return "#{socket[:protocol]}:#{socket[:address]}:#{socket[:port]}" if file =~ /#{socket[:id]}/
+          end
+          return nil
+        end
+
+        # @note read access to fd directory are restricted only to owner of process
+        # Get environment variables from environ file
+        #
+        # @example
+        #  process_cmdline(312)
+        #
+        # @param pid [Fixnum] process pid
+        # @return [String]
+        def process_env(pid)
+          environ_file = "/proc/#{pid}/environ"
+          if File.readable? (environ_file)
+            File.foreach(environ_file).each do |line|
+              return line.split("\x0")
+            end
+          else
+            'Permission denied'
+          end
+        end
+
+        # Calculate %CPU usage per process
+        #
+        # @param attrs [Hash] hash list contains process attributes
+        #  @option proc_uptime [Integer] - process uptime
+        #  @option cpu_time [Integer] total cpu time spend in kernel and user mode
+        # @return [Float] average process cpu usage from start
+        def cpu_percent(attrs)
+          hertz = cpu_tck
+          sec = uptime - attrs[:proc_uptime] / hertz
+          if attrs[:cpu_time] > 0 && sec > 0
+            cpu = (attrs[:cpu_time] * 1000 / hertz) / sec
+            "#{cpu / 10}.#{cpu % 10}".to_f
+          else
+            return 0.0
+          end
+        end
+
+        # Check if object is numeric
+        #
+        # @example
+        #  is_numeric?('2323')
+        #
+        # @return [Boolen]
+        def is_numeric?(obj)
+          obj.to_s.match(/\A[+-]?\d+?(\.\d+)?\Z/) == nil ? false : true
+        end
+
+        # Return the number of clock ticks
+        #
+        # @example
+        #  cpu_tck()
+        #
+        # @return [Integer]
+        def cpu_tck
+          `getconf CLK_TCK`.to_i
+        rescue
+          return 100
+        end
+
+        # Get process uid and return username from passwd file
+        #
+        # @example
+        #  process_username(132)
+        #
+        # @param pid [Fixnum] process pid
+        # @return [String]
+        def process_username(pid)
+          uid = File.stat("/proc/#{pid}").uid
+          File.foreach('/etc/passwd').each do |line|
+            if line.split(':')[2] == "#{uid}"
+              return line.split(':')[0]
+            end
+          end
+        end
+
+        # Get list open tcp/upd ports from net/tcp and net/udp file and replace to decimal
+        #
+        # @example
+        #  sockets = open_ports()
+        #  sockets.each do |socket|
+        #     puts "#{socket[:address]} #{socket[:port]}"
+        #  end
+        #
+        # @return [Array<Hash>] list all used tcp/udp sockets
+        def open_ports
+          socket_list  = Array.new
+          ['tcp','udp'].each do |protocol|
+            File.foreach("/proc/net/#{protocol}").each do |line|
+              hex_port = line.split(' ')[1].split(':')[1]
+              hex_ip   = line.split(' ')[1].split(':')[0].scan(/../)
+              socketid = line.split(' ')[9]
+              if hex_port =~ /$$$$/
+                hex_ip.map! { |e| e = e.to_i(16) }
+                socket_attrs = { :address => "#{hex_ip[3]}.#{hex_ip[2]}.#{hex_ip[1]}.#{hex_ip[0]}",
+                                 :port => hex_port.to_i(16),
+                                 :protocol => protocol,
+                                 :id => socketid }
+                socket_list << socket_attrs
+              end
+            end
+          end
+          return socket_list
+        end
+
+        # Return system uptime in second
+        #
+        # @example
+        #  uptime()
+        #
+        # @return [Integer]
+        def uptime
+          File.foreach('/proc/uptime').each do |line|
+            return line.split[0].to_i
+          end
+        end
+
+        # Calculate percent of memory usage by process
+        #
+        # @example
+        #  memory_percent(container,'')
+        #
+        # @param attrs [Hash] hash list contains process attributes
+        # @option :vmrss [Fixnum] rss memory allocated by process
+        # @param memtotal [Integer] total usable RAM
+        # @return [Float]
+        def memory_percent(attrs, memtotal)
+          if attrs[:vmrss]
+            return (attrs[:vmrss].to_f / memtotal.to_f * 100).round(2)
+          else
+            nil
+          end
+        end
+
+        # Get total physical memory (RAM) size
+        #
+        # @example
+        #  memory_total
+        #
+        # @return [Integer]
+        def memory_total
+          File.foreach('/proc/meminfo').each do |line|
+            return line.split(' ')[1].to_i if line =~ /MemTotal:/
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hawatel_ps/linux/proc_info.rb

@@ -0,0 +1,53 @@
+module HawatelPS
+  module Linux
+    class ProcInfo < ProcControl
+
+      # Process instance with attributes of that process
+      # @param proc_attrs [Hash] attributes of the process
+      # @return [void]
+      def initialize(proc_attrs)
+        @proc_attrs = proc_attrs
+        define_attributes(proc_attrs)
+      end
+
+      # Make attributes of public.
+      # Access to process attribute from an object instance by index of array.
+      # @example
+      #   p = ProcInfo.new(proc_attrs)
+      #   puts p['processid']
+      def [](key)
+        @proc_attrs[key.downcase]
+      end
+
+      # Calls the given block once for each element in self, passing that element as a parameter.
+      # @param &block
+      # @example print all attributes of process
+      #   p = ProcInfo.new(proc_attrs)
+      #   proc.each {|key, val| puts "#{key} - #{val}"}
+      # @return An Enumerator is returned if no block is given.
+      def each(&block)
+        @proc_attrs.each(&block)
+      end
+
+      # @see ProcInfo#define_attributes
+      def metaclasses
+        class << self; self; end
+      end
+
+      private
+      # Make attributes of public.
+      # Access  to process attribute from an object instance by public method where names of attributes are methods.
+      # @example
+      #   p = ProcInfo.new(proc_attrs)
+      #   puts p.processid
+      def define_attributes(hash)
+        hash.each_pair do |key, value|
+          metaclasses.send(:attr_reader, key.to_sym)
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/hawatel_ps/linux/proc_table.rb

@@ -0,0 +1,124 @@
+module HawatelPS
+  module Linux
+    class ProcTable
+      class << self
+
+        # Return attributes of searched process based on pid
+        #
+        # @example
+        #  search_by_pid(1761)
+        #
+        # @param [Integer] pid of process
+        # @return [ProcInfo] hash with process attributes
+        def search_by_pid(pid)
+          refresh
+          @proc_table.each do |process|
+            return process if process.pid.to_s == pid.to_s
+          end
+          return nil
+        end
+
+        # Return attributes of searched process based on name or cmdline
+        #
+        # @example
+        #   search_by_name('java')
+        #   search_by_name('/^regex/')
+        #
+        # @param process_name[String] name of process
+        # @return [Array<ProcInfo>] array of ProcInfo objects
+        def search_by_name(process_name)
+          refresh
+          process_list = Array.new
+          if process_name =~ /^\/.*\/$/
+            process_name.slice!(0)
+            process_name = Regexp.new(/#{process_name.chop}/)
+          end
+          @proc_table.each do |process|
+           if process_name.is_a? Regexp
+             process_list << process if process.name =~ process_name || process.cmdline =~ process_name
+           else
+             process_list << process if process.name == "#{process_name}" || process.cmdline == "#{process_name}"
+           end
+          end
+          return process_list
+        end
+
+        # Return attributes of searched process based on specified condition
+        #
+        # @example
+        #   search_by_condition(:attrs => 'vmsize', :oper => '<', value => '10000')
+        #
+        # @param args[Hash] attributes for search condition
+        # @option :attr [String], name of process attribute (first expression for if)
+        # @option :oper [String], operatator, available options: >,<,>=,<=,==,!=
+        # @option :value [String], value comparable (second expression for if)
+        #
+        # @return [Array<ProcInfo>] array of ProcInfo objects
+        def search_by_condition(args)
+          refresh
+          attr = args[:attr]
+          oper  = args[:oper]
+          value = args[:value]
+          process_list = Array.new
+          @proc_table.each do |process|
+            value = value.to_i if process[:"#{attr}"].is_a? Fixnum
+            value = value.to_f if process[:"#{attr}"].is_a? Float
+            if oper == '>'
+              process_list << process if process[:"#{attr}"] > value if process[:"#{attr}"]
+            elsif oper == '<'
+              process_list << process if process[:"#{attr}"] < value if process[:"#{attr}"]
+            elsif oper == '>='
+              process_list << process if process[:"#{attr}"] >= value if process[:"#{attr}"]
+            elsif oper == '<='
+              process_list << process if process[:"#{attr}"] <= value if process[:"#{attr}"]
+            elsif oper == '=='
+              process_list << process if process[:"#{attr}"] == value if process[:"#{attr}"]
+            elsif oper == '!='
+              process_list << process if process[:"#{attr}"] != value if process[:"#{attr}"]
+            end
+          end
+          return process_list
+        end
+
+        # Return all process instances
+        #
+        # @example
+        #   proc_table()
+        #
+        # @return [Array<ProcInfo>] array of ProcInfo objects
+        def proc_table
+          refresh
+          return @proc_table
+        end
+
+        private
+        # Refresh list of current running processes
+        #
+        # @example
+        #   refresh()
+        #
+        # @return [Array<ProcInfo>] array of ProcInfo objects
+        def refresh
+          @proc_table = Array.new
+          ProcFetch.get_process.each do |proc_attrs|
+            @proc_table.push(ProcInfo.new(proc_attrs))
+          end
+          childs_tree
+        end
+
+        # Find and add childs attribute for process
+        #
+        def childs_tree
+          @proc_table.each do |proc_parent|
+            @proc_table.each do |proc_child|
+              if proc_parent.pid == proc_child.ppid
+                proc_parent[:childs].push(proc_child)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hawatel_ps/linux.rb

@@ -0,0 +1,4 @@
+require 'hawatel_ps/linux/proc_control'
+require 'hawatel_ps/linux/proc_fetch'
+require 'hawatel_ps/linux/proc_info'
+require 'hawatel_ps/linux/proc_table'

data/lib/hawatel_ps/shared/hawatelps_exception.rb

@@ -0,0 +1,21 @@
+module HawatelPS
+  class HawatelPSException < Exception
+    # Custom exception
+    # @param args [Hash] the options to create a custom exception message
+    # @option :exception [Exception] Native Exception object
+    # @option :message [String] Custom message
+    # @return [void]
+    def initialize(args = {:exception => nil, :message => nil})
+      super(exception_enrichment(args))
+    end
+
+    private
+    def exception_enrichment(args)
+      error_message = ''
+      error_message += args[:message] unless args[:message].nil?
+      error_message +=
+          "\nNative exception from '#{args[:exception].class}':\n#{args[:exception].message}" unless args[:exception].nil?
+      return error_message
+    end
+  end
+end

data/lib/hawatel_ps/version.rb

@@ -0,0 +1,3 @@
+module HawatelPs
+  VERSION = "0.1.1"
+end

data/lib/hawatel_ps/windows/proc_control.rb

@@ -0,0 +1,67 @@
+module HawatelPS
+  module Windows
+    class ProcControl
+
+      # Check current process status
+      #
+      # @example
+      #   p = HawatelPS.search_by_name('notepad.exe')
+      #   p.status
+      #
+      # @return [String] 'running' or 'not running'
+      def status
+        Process.kill 0, @proc_attrs[:processid].to_i
+        return "running"
+      rescue Errno::ESRCH
+        return "not running"
+      end
+
+      # Suspend process without loss data
+      #
+      # @example
+      #   p = HawatelPS.search_by_pid('1020')
+      #   p.suspend
+      #
+      # @return [String]
+      def suspend
+        # TODO There is no SuspendProcess API function in Windows.
+        # This was described in article: http://www.codeproject.com/Articles/2964/Win-process-suspend-resume-tool
+        # The suspend method isn't not save
+      end
+
+
+      # Resume suspended process
+      # @example
+      #   p = HawatelPS.search_by_pid('1020')
+      #   p.resume
+      # @return [String]
+      def resume
+        # TODO There is no ResumeProcess API function in Windows.
+        # This was described in article: http://www.codeproject.com/Articles/2964/Win-process-suspend-resume-tool
+        # The resume method isn't not save
+      end
+
+
+      # Terminate process
+      # @example
+      #   p = HawatelPS.search_by_pid('1020')
+      #   p.terminate
+      # @return [Integer] return source: https://msdn.microsoft.com/en-us/library/windows/desktop/aa393907
+      #   * Successful completion (0)
+      #   * Process not found (1)
+      #   * Access denied (2)
+      #   * Insufficient privilege (3)
+      #   * Unknown failure (8)
+      #   * Path not found (9)
+      #   * Invalid parameter (21)
+      #   * Other (22–4294967295)
+      def terminate
+        return @proc_attrs[:wmi_object].Terminate if @proc_attrs[:wmi_object].ole_respond_to?('Terminate')
+      rescue WIN32OLERuntimeError => ex
+        #raise HawatelPSException, :exception => ex, :message => "Cannot terminate process by WMI method Terminate()."
+        return 1
+      end
+
+    end
+  end
+end