linux_stat 0.4.2 → 0.6.3

data/lib/linux_stat/prettify_bytes.rb

@@ -0,0 +1,75 @@
+module LinuxStat
+	module PrettifyBytes
+		class << self
+			# Converts a number to decimal byte units and outputs with the metric prefix
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_decimal(1000)    # => "1.0 kilobyte"
+			# LinuxStat::PrettifyBytes.convert_decimal(1000 ** 3)    # => "1.0 gigabyte"
+			# LinuxStat::PrettifyBytes.convert_decimal(1024 ** 3)   # => "1.07 gigabytes"
+			def convert_decimal(n)
+				@@d_units ||= %W(#{''} kilo mega giga tera peta exa zetta)
+					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
+				unit = @@d_units.find { |x| n < x[1] } || ['yotta'.freeze, 10 ** 27]
+
+				converted = n.fdiv(unit[1] / 1000).round(2)
+				"#{pad_left(converted)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+			end
+
+			# Converts a number to binary byte units and outputs with the IEC prefix
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_binary(1000)    # => "1000.0 bytes"
+			# LinuxStat::PrettifyBytes.convert_binary(1000 ** 3)    # => "953.67 mebibytes"
+			# LinuxStat::PrettifyBytes.convert_binary(1024 ** 3)   # => "1.0 gibibyte"
+			def convert_binary(n)
+				@@b_units ||= %W(#{''} kibi mebi gibi tebi pebi exbi zebi)
+					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
+				unit = @@b_units.find { |x| n < x[1] } || ['yobi'.freeze, 10 ** 27]
+
+				converted = n.fdiv(unit[1] / 1024).round(2)
+				"#{pad_left(converted)} #{unit[0]}byte#{?s.freeze if converted != 1}"
+			end
+
+			# Converts a number to decimal byte units
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_short_decimal(1000)    # => "1.0 kB"
+			# LinuxStat::PrettifyBytes.convert_short_decimal(1000 ** 3)   # => "1.0 GB"
+			# LinuxStat::PrettifyBytes.convert_short_decimal(1024 ** 3)    # => "1.07 GB"
+			def convert_short_decimal(n)
+				@@sd_units ||= %W(#{''} k M G T P E Z)
+					.map.with_index { |x, i| [x, 1000.**(i + 1)] }
+				unit = @@sd_units.find { |x| n < x[1] } || [?Y.freeze, 10 ** 27]
+
+				converted = n.fdiv(unit[1] / 1000).round(2)
+				"#{pad_left(converted)} #{unit[0]}B"
+			end
+
+			# Converts a number to binary byte units
+			# For example,
+			#
+			# LinuxStat::PrettifyBytes.convert_short_binary(1000)    # => "1000 B"
+			# LinuxStat::PrettifyBytes.convert_short_binary(1000 ** 3)   # => "953.67 MiB"
+			# LinuxStat::PrettifyBytes.convert_short_binary(1024 ** 3)    # => "1.0 GiB"
+			def convert_short_binary(n)
+				return "#{n} B" if n < 1024
+
+				@@sb_units ||= %W(#{''} K M G T P E Z)
+					.map.with_index { |x, i| [x, 1024.**(i + 1)] }
+				unit = @@sb_units.find { |x| n < x[1] } || [?Y.freeze, 1024 ** 9]
+
+				converted = n.fdiv(unit[1] / 1024).round(2)
+				"#{pad_left(converted)} #{unit[0]}iB"
+			end
+
+			private
+			def pad_left(n, mantissa_length = 2)
+				n = n.round(mantissa_length)
+				exp, mant = n.to_s.split(?..freeze)
+				m = mant.length < mantissa_length ? mant + ?0.freeze * (mantissa_length - mant.length) : mant
+				exp + ?..freeze + m
+			end
+		end
+	end
+end

data/lib/linux_stat/process_info.rb

@@ -70,10 +70,10 @@ module LinuxStat
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the memory, virtual memory, and resident memory of the process.
-			# All values are in Kilobytes.
+			# All values are in kilobytes.
 			#
 			# The output is a Hash. For example, a sample output:
-			#    {:memory=>8656, :virtual_memory=>78272, :resident_memory=>14072}
+			#    {:memory=>8515.584, :virtual_memory=>79781.888, :resident_memory=>13955.072}
 			#
 			# Note:
 			# If you need only memory usage of a process, run LinuxStat::ProcessInfo.memory(pid)
@@ -85,34 +85,19 @@ module LinuxStat
 			#
 			# If the info isn't available it will return an empty Hash.
 			def mem_stat(pid = $$)
-				stat_file = "/proc/#{pid}/stat".freeze
-				status_file = "/proc/#{pid}/status".freeze
+				statm = "/proc/#{pid}/statm".freeze
+				return {} unless File.readable?(statm)
 
-				stat = if File.readable?(stat_file)
-					IO.read(stat_file).split
-				else
-					[]
-				end
+				data = IO.read(statm).split
 
-				status = if File.readable?(status_file)
-					IO.readlines(status_file)
-				else
-					[]
-				end
-
-				_rss_anon = status.find { |x| x.start_with?('RssAnon') }
-				rss_anon = _rss_anon ? _rss_anon.split[1].to_i : nil
-
-				_virtual_memory = stat[22]
-				vm = _virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
-
-				_vm_rss = status.find { |x| x.start_with?('VmRSS') }
-				vm_rss = _vm_rss ? _vm_rss.split[1].to_i : nil
+				_rss_anon = (data[1] && data[2]) ? data[1].to_i.-(data[2].to_i).*(pagesize).fdiv(1000) : nil
+				_virtual_memory = data[0] ? data[0].to_i*(pagesize).fdiv(1000) : nil
+				_resident_memory = data[1] ? data[1].to_i.*(pagesize).fdiv(1000) : nil
 
 				{
-					memory: rss_anon,
-					virtual_memory: vm,
-					resident_memory: vm_rss
+					memory: _rss_anon,
+					virtual_memory: _virtual_memory,
+					resident_memory: _resident_memory
 				}
 			end
 
@@ -121,16 +106,17 @@ module LinuxStat
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the memory of the process.
-			# The value is in Kilobytes.
+			# The value is in kilobytes.
 			# The output is an Integer. For example, a sample output:
-			#    8664
+			#    8523.776
 			#
 			# If the info isn't available it will return nil.
 			def memory(pid = $$)
-				_rss_anon = IO.readlines("/proc/#{pid}/status")
-					.find { |x| x.start_with?('RssAnon') }
+				file = "/proc/#{pid}/statm".freeze
+				return nil unless File.readable?(file)
 
-				_rss_anon ? _rss_anon.split[1].to_i : nil
+				data = IO.read(file).split
+				(data[1] && data[2]) ? data[1].to_i.-(data[2].to_i).*(pagesize).fdiv(1000) : nil
 			end
 
 			# virtual_memory(pid = $$)
@@ -138,14 +124,17 @@ module LinuxStat
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the virtual memory for the process.
-			# The value is in Kilobytes.
+			# The value is in kilobytes.
 			# The output is an Integer. For example, a sample output:
-			#    78376
+			#    79781.888
 			#
 			# If the info isn't available it will return nil.
 			def virtual_memory(pid = $$)
-				_virtual_memory = IO.read("/proc/#{pid}/stat".freeze).split[22]
-				_virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
+				file = "/proc/#{pid}/statm".freeze
+				return nil unless File.readable?(file)
+
+				_virtual_memory = IO.read(file).split[0]
+				_virtual_memory ? _virtual_memory.to_i.*(pagesize).fdiv(1000) : nil
 			end
 
 			# resident_memory(pid = $$)
@@ -153,21 +142,24 @@ module LinuxStat
 			# By default it is the id of the current process ($$)
 			#
 			# It retuns the resident memory for the process.
-			# The value is in Kilobytes.
+			# The value is in kilobytes.
 			# The output is an Integer. For example, a sample output:
-			#    14012
+			#    13996.032
 			#
 			# If the info isn't available it will return nil.
 			def resident_memory(pid = $$)
-				_vm_rss = IO.readlines("/proc/#{pid}/status")
-					.find { |x| x.start_with?('VmRSS') }
+				file = "/proc/#{pid}/statm".freeze
+				return nil unless File.readable?(file)
 
-				_vm_rss ? _vm_rss.split[1].to_i : nil
+				_vm_rss = IO.read(file).split[1]
+				_vm_rss ? _vm_rss.to_i.*(pagesize).fdiv(1000) : nil
 			end
 
-			# cpu_stat(pid: $$, sleep: 0.05)
+			# cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
 			# Where pid is the process ID and sleep time is the interval between measurements.
-			# By default it is the id of the current process ($$), and sleep is 0.05
+			#
+			# By default it is the id of the current process ($$), and sleep is LinuxStat::Sysconf.sc_clk_tck
+			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck.
 			#
 			# Note 1:
 			# Do note that the sleep time can slow down your application.
@@ -197,7 +189,7 @@ module LinuxStat
 			#
 			# The :last_executed_cpu also returns an Integer indicating
 			# the last executed cpu of the process.
-			def cpu_stat(pid: $$, sleep: 0.05)
+			def cpu_stat(pid: $$, sleep: ticks_to_ms)
 				file = "/proc/#{pid}/stat"
 				return {} unless File.readable?(file)
 
@@ -229,9 +221,11 @@ module LinuxStat
 				}
 			end
 
-			# cpu_usage(pid: $$, sleep: 0.05)
+			# cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
 			# Where pid is the process ID and sleep time is the interval between measurements.
-			# By default it is the id of the current process ($$), and sleep is 0.05
+			#
+			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
 			#
 			# It retuns the CPU usage in Float.
 			# For example:
@@ -241,7 +235,7 @@ module LinuxStat
 			# But if the info isn't available, it will return nil.
 			#
 			# This method is more efficient than running LinuxStat::ProcessInfo.cpu_stat()
-			def cpu_usage(pid: $$, sleep: 0.05)
+			def cpu_usage(pid: $$, sleep: ticks_to_ms)
 				file = "/proc/#{pid}/stat"
 				return nil unless File.readable?(file)
 
@@ -281,7 +275,8 @@ module LinuxStat
 				file = "/proc/#{pid}/stat".freeze
 				return nil unless File.readable?(file)
 
-				IO.read(file).split[19].to_i
+				data = IO.read(file).split[19]
+				data ? data.to_i : nil
 			end
 
 			# last_executed_cpu(pid = $$)
@@ -298,13 +293,77 @@ module LinuxStat
 				file = "/proc/#{pid}/stat".freeze
 				return nil unless File.readable?(file)
 
-				IO.read("/proc/#{pid}/stat".freeze).split[38].to_i
+				IO.read(file).split[38].to_i
+			end
+
+			# uid(pid = $$)
+			# returns the UIDs of the process as an Array of Integers.
+			#
+			# If the info isn't available it returns an empty Array.
+			def uid(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				data = IO.readlines(file.freeze).find { |x|
+					x[/Uid.*\d*/]
+				}.to_s.split.drop(1)
+
+				{
+					real: data[0].to_i,
+					effective: data[1].to_i,
+					saved_set: data[2].to_i,
+					filesystem_uid: data[3].to_i
+				}
+			end
+
+			# gid(pid = $$)
+			# returns the GIDs of the process as an Hash containing the following data:
+			# :real, :effective, :saved_set, :filesystem_uid
+			#
+			# If the info isn't available it returns an empty Hash.
+			def gid(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				data = IO.readlines(file.freeze).find { |x|
+					x[/Gid.*\d*/]
+				}.split.drop(1)
+
+				{
+					real: data[0].to_i,
+					effective: data[1].to_i,
+					saved_set: data[2].to_i,
+					filesystem_uid: data[3].to_i
+				}
+			end
+
+			# owner(pid = $$)
+			# Returns the owner of the process
+			# But if the status is not available, it will return an empty frozen String.
+			def owner(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return ''.freeze unless File.readable?(file)
+
+				gid = IO.readlines(file.freeze).find { |x|
+					x[/Gid.*\d*/]
+				}.split.drop(1)[2].to_i
+
+				LinuxStat::User.username_by_gid(gid)
 			end
 
 			private
 			def get_ticks
 				@@ticks ||= Sysconf.sc_clk_tck
 			end
+
+			# Just to avoid multiple calculations!...
+			def ticks_to_ms
+				@@ms ||= 1.0 / get_ticks
+			end
+
+			def pagesize
+				@@pagesize ||= LinuxStat::Sysconf.pagesize
+			end
 		end
 	end
 end

data/lib/linux_stat/user.rb

@@ -0,0 +1,298 @@
+module LinuxStat
+	module User
+		class << self
+			# Returns an array of users as string
+			# For example:
+			#    ["root", "bin", "daemon", "mail", "ftp", "http", "nobody"]
+			# But if the status isn't available it will return an empty Array.
+			def list
+				return [] unless passwd_readable?
+				passwd.map { |x| x[/.+?:/][0..-2].freeze }
+			end
+
+			# Returns all the Group ids directories as Hash.
+			# For example:
+			#    {:root=>{:uid=>0, :gid=>0}, :bin=>{:uid=>1, :gid=>1}, :daemon=>{:uid=>2, :gid=>2}, :mail=>{:uid=>8, :gid=>12}, :ftp=>{:uid=>14, :gid=>11}}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def ids
+				return {} unless passwd_readable?
+				passwd_splitted.reduce({}) { |h, x|
+					h.merge!(x[0].to_sym => {
+						uid: x[2].to_i, gid: x[3].to_i
+					})
+				}
+			end
+
+			# Returns all the user IDs as Hash.
+			# For example:
+			#    LinuxStat::User.uids
+			#    => {:root=>0, :bin=>1, :daemon=>2, :mail=>8, :ftp=>14}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def uids
+				return {} unless passwd_readable?
+				passwd_splitted.reduce({}) { |h, x|
+					h.merge!(x[0].to_sym => x[2].to_i)
+				}
+			end
+
+			# Returns all the Group identifiers as Hash.
+			# For example:
+			#    LinuxStat::User.gids
+			#    => {:root=>0, :bin=>1, :daemon=>2, :mail=>12, :ftp=>11}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def gids
+				return {} unless passwd_readable?
+				passwd_splitted.reduce({}) { |h, x|
+					h.merge!(x[0].to_sym => x[3].to_i)
+				}
+			end
+
+			# Returns all the home directories as Hash.
+			# For example:
+			#    LinuxStat::User.home_directories
+			#    => {:root=>"/root", :bin=>"/", :daemon=>"/", :mail=>"/var/spool/mail", :ftp=>"/srv/ftp", :http=>"/srv/http", :nobody=>"/"}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def home_directories
+				return {} unless passwd_readable?
+				passwd.reduce({}) { |h, x|
+					splitted = x.split(?:)
+					h.merge!(splitted[0].to_sym => splitted[5])
+				}
+			end
+
+			# Returns the user ID as integer
+			# It directly calls LinuxStat::Sysconf.get_uid and LinuxStat::Sysconf.get_gid
+			# and then reads /etc/passwd and matches the values with UID and GID.
+			#
+			# It doesn't get affected with the assignment of USER environment variable
+			# If either /etc/passwd is readable or LinuxStat::Sysconf.get_login() is not empty.
+			#
+			# But if /etc/passwd isn't readable (which is weird), it will fall back to sysconf.h's get_login()
+			# It that's not available, like in docker, falls back to ENV['USER].to_s
+			#
+			# Note that this is not cached or memoized so use this at your own processing expense.
+			# It should return the username under most robust circumstances.
+			# But if nothing is available for some reason, it will return an empty String.
+			def get_user
+				unless passwd_readable?
+					_l = LinuxStat::Sysconf.get_login().freeze
+					return _l.empty? ? ENV['USER'.freeze].to_s : _l
+				end
+
+				uid, gid = LinuxStat::Sysconf.get_uid, LinuxStat::Sysconf.get_gid
+
+				username = ''
+				passwd.each { |x|
+					splitted = x.split(?:).freeze
+					if splitted[2].to_i == uid && splitted[3].to_i == gid
+						username = splitted[0]
+						break
+					end
+				}
+				username
+			end
+
+			# Returns the user ID as integer
+			# It directly calls LinuxStat::Sysconf.get_uid
+			def get_uid
+				LinuxStat::Sysconf.get_uid
+			end
+
+			# Returns the group ID as integer
+			# It directly calls LinuxStat::Sysconf.get_uid
+			def get_gid
+				LinuxStat::Sysconf.get_gid
+			end
+
+			# Returns the effective user ID as integer
+			# It directly calls LinuxStat::Sysconf.get_euid
+			def get_euid
+				LinuxStat::Sysconf.get_euid
+			end
+
+			# Calls LinuxStat::Sysconf.get_login()
+			# The username is returned as a String.
+			# It doesn't get affected by ENV['USER]
+			#
+			# But if the name isn't available (say inside a container), it will return an empty String.
+			# This is meant for speed but not for reliability.
+			# To get more reliable output, you might try LinuxStat::User.get_user()
+			def get_login
+				LinuxStat::Sysconf.get_login
+			end
+
+			# def usernames_by_uid(gid = get_uid)
+			# Where uid is the group id of the user. By default it's the uid of the current user.
+			#
+			# It returns an Array containing the username corresponding to the uid.
+			#
+			# For example:
+			#    LinuxStat::User.usernames_by_uid(1001)
+			#    => ["userx", "usery"]
+			#
+			# But if the info isn't available it will return an empty Array.
+			def usernames_by_uid(uid = get_uid)
+				return [] unless passwd_readable?
+
+				usernames = []
+				passwd_splitted.each { |x|
+					usernames << x[0] if x[2].to_i == uid
+				}
+				usernames
+			end
+
+			# def username_by_gid(gid = get_gid)
+			# Where gid is the group id of the user. By default it's the gid of the current user.
+			#
+			# It returns a String cotaining the username corresponding to the gid
+			# But if the info isn't available it will return an empty frozen String.
+			def username_by_gid(gid = get_gid)
+				return ''.freeze unless passwd_readable?
+
+				username = ''
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					if splitted[2].to_i == gid
+						username = splitted[0]
+						break
+					end
+				end
+				username
+			end
+
+			# gid_by_username(username = get_user)
+			# Where username is the username to look for, by default it is the current user.
+			#
+			# It returns the gid by the username.
+			# For example:
+			#    LinuxStat::User.gid_by_username('root')
+			#    => "0"
+			#
+			# The return type is Integer.
+			# But if user passed doesn't exist or if the info isn't available, it will return nil.
+			def gid_by_username(username = get_user)
+				return nil unless passwd_readable?
+
+				gid = nil
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					if splitted[0] == username
+						gid = splitted[3].to_i
+						break
+					end
+				end
+				gid
+			end
+
+			# uid_by_username(username = get_user)
+			# Where username is the username to look for, by default it is the current user.
+			#
+			# It returns the uid by the username.
+			# For example:
+			#    LinuxStat::User.uid_by_username('root')
+			#    => 0
+			#
+			# The return type is Integer.
+			# But if user passed doesn't exist or if the info isn't available, it will return nil.
+			def uid_by_username(username = get_user)
+				return nil unless passwd_readable?
+
+				uid = nil
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					if splitted[0] == username
+						uid = splitted[2].to_i
+						break
+					end
+				end
+				uid
+			end
+
+			# home_by_username(user = get_user)
+			# Where user is the name of the user.
+			# Returns the user's home. By default it returns the home of the current user.
+			#
+			# If the info isn't available, it will return ENV['HOME].to_s.freeze
+			def home_by_username(user = get_user)
+				return ENV['HOME'].to_s.freeze unless passwd_readable?
+
+				home = ''
+				passwd.each { |x|
+					splitted = x.split(?:)
+					if splitted[0] == user
+						home = splitted[5]
+						break
+					end
+				}
+				home
+			end
+
+			# home_by_uid(id = get_uid)
+			# Gets all the users home directory with user id.
+			# It returns an Array in this format:
+			#    LinuxStat::User.homes_by_uid(1001)
+			#    => ["/home/userx", "/home/usery"]
+			#
+			# Assuming both the users share same UID.
+			#
+			# If the info isn't available, it will return an empty Array.
+			def homes_by_uid(id = get_uid)
+				return [] unless passwd_readable?
+
+				home = []
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					home << splitted[5] if splitted[2].to_i == id
+				end
+				home
+			end
+
+			# home_by_gid(id = get_uid)
+			# Gets the home of the user corresponding to the GID.
+			# It returns a String in this format:
+			#
+			# Assuming both the users share same UID.
+			#
+			# If the info isn't available, it will return an empty frozen String.
+			def home_by_gid(id = get_gid)
+				return ''.freeze unless passwd_readable?
+
+				home = ''
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+
+					if splitted[3].to_i == id
+						home = splitted[5]
+						break
+					end
+				end
+				home
+			end
+
+			alias get_current_user get_user
+
+			private
+			def passwd
+				@@passwd_file ||= '/etc/passwd'.freeze
+				IO.readlines(@@passwd_file)
+			end
+
+			# Only use this method where we are sure that the whole array is going to be used.
+			# In cases like find() or a loop with `break` this is a lot of overhead.
+			# In cases like reduce({}) or select, this is not helpful.
+			def passwd_splitted
+				@@passwd_file ||= '/etc/passwd'.freeze
+				IO.readlines(@@passwd_file).map { |x| x.split(?:.freeze) }
+			end
+
+			def passwd_readable?
+				@@passwd_file ||= '/etc/passwd'.freeze
+				@@passwd_readable ||= File.readable?(@@passwd_file)
+			end
+		end
+	end
+end