linux_stat 0.5.2 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c68e104d55d755cd1cef1e8901a7dd67b1a901b132d9a7786fabfd75b41cf5a
-  data.tar.gz: 94d102c6244b8da52b5f7aa7b1ea903546b5ef6e615c6317233b510005b6ded7
+  metadata.gz: e6d3a089c2e214eb53f564d64014d6da9b900467e8b8285be6be6516c92fb366
+  data.tar.gz: 6cc0a5b86b5b9163d2ae1d57b761d8cf6900ff2864987c3b2b39a5072e5d8174
 SHA512:
-  metadata.gz: b94d6afea3d307c845f316ce21f66e93944e1b33ad9576ecd8d55e299d6d520732677f99ea8fba3dcb3f6f5c6c8aae98526cc21b2c0218d7a8d49bdd7896cdec
-  data.tar.gz: cecbaee79f9844c5a6ad83720071a7977697edeb958d2336a68fa9f3b19ccb28074641c9620c88574dd0b5074ba6069a3457543a2cad86c11d9c5562d6e83da6
+  metadata.gz: e9d1ce304cec1210fd3cb4f75b36a105b35bc54828106d1d880331b5d8ec6429f120be21200014599a22693950386aa838e03cc20a0fc41c0b819204c6c2da81
+  data.tar.gz: 45ea80ecccb20956945b420bfec45ca0e3f3770233418469fd741f554977c9ab07cb14002f9a887094db0b078f5ae9cc5c1b6a25865e8024a5ade4c278dd7ed8

data/README.md

@@ -103,7 +103,7 @@ LinuxStat::CPU.count
 => 4
 
 LinuxStat::CPU.cur_freq
-=> [2000050, 2000024, 1998134, 1975870]
+=> [1863999, 1934584, 1996927, 1978102]
 
 LinuxStat::CPU.max_freq
 => [2000000, 2000000, 2000000, 2000000]
@@ -112,48 +112,48 @@ LinuxStat::CPU.model
 => "Intel(R) Core(TM) i3-6006U CPU @ 2.00GHz"
 
 LinuxStat::CPU.stat
-=> {0=>3.57, 1=>0.0, 2=>0.0, 3=>0.0, 4=>0.0}
+=> {0=>20.0, 1=>50.0, 2=>0.0, 3=>0.0, 4=>0.0}
 
 LinuxStat::CPU.total_usage
-=> 3.45
+=> 0.0
 
 LinuxStat::CPU.usage
-=> 9.68
+=> 25.0
 
 LinuxStat::CPU.usages
-=> {0=>6.67, 1=>0.0, 2=>25.0, 3=>12.5, 4=>14.29}
+=> {0=>0.0, 1=>0.0, 2=>0.0, 3=>0.0, 4=>0.0}
 
 ```
 
 ### LinuxStat::Filesystem
 ```
 LinuxStat::Filesystem.available
-=> 36234563584
+=> 34612666368
 
 LinuxStat::Filesystem.free
-=> 36234563584
+=> 34612666368
 
 LinuxStat::Filesystem.stat
-=> {:total=>119981191168, :free=>36234563584, :used=>83746627584}
+=> {:total=>119981191168, :free=>34612666368, :used=>85368524800}
 
 LinuxStat::Filesystem.stat_raw
-=> {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>8846329, :block_avail_unpriv=>8846329, :inodes=>58612160, :free_inodes=>56635312, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
+=> {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>8450358, :block_avail_unpriv=>8450358, :inodes=>58612160, :free_inodes=>56582049, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
 
 LinuxStat::Filesystem.total
 => 119981191168
 
 LinuxStat::Filesystem.used
-=> 83746627584
+=> 85368524800
 
 ```
 
 ### LinuxStat::Kernel
 ```
 LinuxStat::Kernel.build_date
-=> 2020-10-21 01:11:20 +0000
+=> 2020-11-20 07:44:55 +0000
 
 LinuxStat::Kernel.build_date_string
-=> "21 Oct 2020 01:11:20 +0000"
+=> "20 Nov 2020 07:44:55 +0000"
 
 LinuxStat::Kernel.build_user
 => "souravgoswami@archlinux"
@@ -168,45 +168,60 @@ LinuxStat::Kernel.compiler_version
 => "10.2.0"
 
 LinuxStat::Kernel.release
-=> "5.9.1-xanmod1-1"
+=> "5.9.9-xanmod1-1"
 
 LinuxStat::Kernel.string
-=> "Linux version 5.9.1-xanmod1-1 (souravgoswami@archlinux) (gcc (GCC) 10.2.0, GNU ld (GNU Binutils) 2.35.1) #1 SMP PREEMPT Wed, 21 Oct 2020 01:11:20 +0000"
+=> "Linux version 5.9.9-xanmod1-1 (souravgoswami@archlinux) (gcc (GCC) 10.2.0, GNU ld (GNU Binutils) 2.35.1) #1 SMP PREEMPT Fri, 20 Nov 2020 07:44:55 +0000"
 
 LinuxStat::Kernel.ticks
 => 100
 
 LinuxStat::Kernel.version
-=> "5.9.1-xanmod1-1"
+=> "5.9.9-xanmod1-1"
 
 ```
 
 ### LinuxStat::Memory
 ```
 LinuxStat::Memory.available
-=> 602148
+=> 185060
 
 LinuxStat::Memory.percent_available
-=> 15.7
+=> 4.82
 
 LinuxStat::Memory.percent_used
-=> 84.3
+=> 95.18
 
 LinuxStat::Memory.stat
-=> {:total=>3836256, :used=>3234108, :available=>602148, :percent_used=>84.3, :percent_available=>15.7}
+=> {:total=>3836228, :used=>3651168, :available=>185060, :percent_used=>95.18, :percent_available=>4.82}
 
 LinuxStat::Memory.total
-=> 3836256
+=> 3836228
 
 LinuxStat::Memory.used
-=> 3234108
+=> 3651168
 
 ```
 
 ### LinuxStat::Mounts
 ```
+LinuxStat::Mounts.device_stat
+=> {:mountpoint=>"/", :total=>119981191168, :free=>34098106368, :available=>34098106368, :used=>85883084800, :percent_used=>71.58, :percent_free=>28.42, :percent_available=>28.42}
+
+LinuxStat::Mounts.devices_stat
+=> {"proc"=>{:mountpoint=>"/proc", :total=>0, :free=>0, :available=>0, :used=>0, :percent_used=>NaN, :percent_free=>NaN, :percent_available=>NaN}, "sys"=>{:mountpoint=>"/sys", :total=>0, :free=>0, :available=>0, :used=>0, :percent_used=>NaN, :percent_fre...
+
 LinuxStat::Mounts.list
-=> ["proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0", "sys /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0", "dev /dev devtmpfs rw,nosuid,relatime,size=1891804k,nr_inodes=472951,mode=755 0 0", "run /run tmpfs rw,nosuid,nodev,relatime,mode=755 0 0", "...
+=> ["proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0", "sys /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0", "dev /dev devtmpfs rw,nosuid,relatime,size=1892904k,nr_inodes=473226,mode=755 0 0", "run /run tmpfs rw,nosuid,nodev,relatime,mode=755 0 0", "...
+
+LinuxStat::Mounts.list_devices
+=> ["proc", "sys", "dev", "run", "/dev/sda2", "securityfs", "tmpfs", "devpts", "tmpfs", "cgroup2", "cgroup", "pstore", "none", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "cgroup", "systemd-1", "deb...
+
+LinuxStat::Mounts.list_devices_mount_point
+=> {"proc"=>"/proc", "sys"=>"/sys", "dev"=>"/dev", "run"=>"/run", "/dev/sda2"=>"/", "securityfs"=>"/sys/kernel/security", "tmpfs"=>"/run/user/1000", "devpts"=>"/dev/pts", "cgroup2"=>"/sys/fs/cgroup/unified", "cgroup"=>"/sys/fs/cgroup/perf_event", "pstore...
+
+LinuxStat::Mounts.mount_point
+=> "/"
 
 LinuxStat::Mounts.root
 => "/dev/sda2"
@@ -225,7 +240,7 @@ LinuxStat::Mounts.tmpfs
 ### LinuxStat::Net
 ```
 LinuxStat::Net.ipv4_private
-=> "192.168.43.107"
+=> "192.168.0.102"
 
 ```
 
@@ -253,17 +268,17 @@ LinuxStat::OS.os_release
 => {:NAME=>"Arch Linux", :PRETTY_NAME=>"Arch Linux", :ID=>"arch", :BUILD_ID=>"rolling", :ANSI_COLOR=>"38;2;23;147;209", :HOME_URL=>"https://www.archlinux.org/", :DOCUMENTATION_URL=>"https://wiki.archlinux.org/", :SUPPORT_URL=>"https://bbs.archlinux.org/"...
 
 LinuxStat::OS.uptime
-=> {:hour=>15, :minute=>19, :second=>34.72}
+=> {:hour=>9, :minute=>21, :second=>17.73}
 
 ```
 
 ### LinuxStat::Process
 ```
 LinuxStat::Process.count
-=> 228
+=> 214
 
 LinuxStat::Process.idle
-=> [3, 4, 6, 9, 12, 23, 30, 37, 39, 49, 102, 103, 104, 106, 107, 108, 109, 110, 117, 118, 119, 121, 131, 134, 140, 152, 153, 174, 176, 178, 182, 183, 187, 188, 189, 190, 191, 192, 225, 231, 280, 327, 329, 335, 5823, 5824, 5825, 5826, 5827, 5828, 43047, 4...
+=> [3, 4, 6, 9, 12, 23, 30, 37, 39, 49, 102, 103, 104, 106, 107, 108, 109, 110, 117, 118, 119, 121, 131, 134, 140, 152, 153, 178, 180, 183, 184, 188, 192, 193, 194, 195, 196, 197, 199, 241, 287, 337, 341, 349, 3799, 3800, 3801, 3802, 3803, 3804, 17865, 2...
 
 LinuxStat::Process.list
 => [1, 2, 3, 4, 6, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 30, 31, 32, 33, 34, 35, 37, 38, 39, 40, 41, 42, 46, 47, 48, 49, 50, 51, 52, 102, 103, 104, 106, 107, 108, 109, 110, 112, 114, 115, 117, 118, 119, 121, 131, 134,...
@@ -272,10 +287,10 @@ LinuxStat::Process.names
 => {1=>"systemd", 2=>"kthreadd", 3=>"rcu_gp", 4=>"rcu_par_gp", 6=>"kworker/0:0H-kblockd", 9=>"mm_percpu_wq", 10=>"ksoftirqd/0", 11=>"rcuc/0", 12=>"rcu_preempt", 13=>"rcub/0", 14=>"migration/0", 15=>"idle_inject/0", 16=>"cpuhp/0", 17=>"cpuhp/1", 18=>"idle...
 
 LinuxStat::Process.running
-=> [49287]
+=> [24893]
 
 LinuxStat::Process.sleeping
-=> [1, 2, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 25, 26, 27, 28, 31, 32, 33, 34, 35, 38, 40, 41, 42, 46, 47, 48, 50, 51, 52, 112, 114, 115, 173, 175, 193, 219, 235, 301, 312, 313, 315, 326, 328, 340, 363, 364, 365, 366, 373, 376, 378, 381, 395,...
+=> [1, 2, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 24, 25, 26, 27, 28, 31, 32, 33, 34, 35, 38, 40, 41, 42, 46, 47, 48, 50, 51, 52, 112, 114, 115, 177, 179, 198, 228, 246, 310, 316, 323, 324, 325, 336, 338, 370, 371, 372, 373, 380, 384, 388, 399, 410,...
 
 LinuxStat::Process.types
 => {1=>:sleeping, 2=>:sleeping, 3=>:idle, 4=>:idle, 6=>:idle, 9=>:idle, 10=>:sleeping, 11=>:sleeping, 12=>:idle, 13=>:sleeping, 14=>:sleeping, 15=>:sleeping, 16=>:sleeping, 17=>:sleeping, 18=>:sleeping, 19=>:sleeping, 20=>:sleeping, 21=>:sleeping, 23=>:i...
@@ -288,37 +303,46 @@ LinuxStat::Process.zombie
 ### LinuxStat::ProcessInfo
 ```
 LinuxStat::ProcessInfo.cmdline
-=> "/usr/bin/ruby /home/sourav/.gem/ruby/2.7.0/bin/linuxstat.rb --html -md"
+=> "ruby exe/linuxstat.rb -md"
 
 LinuxStat::ProcessInfo.command_name
 => "ruby"
 
 LinuxStat::ProcessInfo.cpu_stat
-=> {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>3}
+=> {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>2}
 
 LinuxStat::ProcessInfo.cpu_usage
 => 0.0
 
+LinuxStat::ProcessInfo.gid
+=> {:real=>1000, :effective=>1000, :saved_set=>1000, :filesystem_uid=>1000}
+
 LinuxStat::ProcessInfo.last_executed_cpu
-=> 3
+=> 2
 
 LinuxStat::ProcessInfo.mem_stat
-=> {:memory=>11748, :virtual_memory=>81680, :resident_memory=>17928}
+=> {:memory=>9752, :virtual_memory=>79824, :resident_memory=>15564}
 
 LinuxStat::ProcessInfo.memory
-=> 11748
+=> 9752
+
+LinuxStat::ProcessInfo.owner
+=> "sourav"
 
 LinuxStat::ProcessInfo.resident_memory
-=> 17928
+=> 15564
 
 LinuxStat::ProcessInfo.threads
 => 1
 
 LinuxStat::ProcessInfo.total_io
-=> {:read_bytes=>3932160, :write_bytes=>0}
+=> {:read_bytes=>0, :write_bytes=>0}
+
+LinuxStat::ProcessInfo.uid
+=> {:real=>1000, :effective=>1000, :saved_set=>1000, :filesystem_uid=>1000}
 
 LinuxStat::ProcessInfo.virtual_memory
-=> 81680
+=> 79824
 
 ```
 
@@ -328,25 +352,25 @@ LinuxStat::Swap.any?
 => true
 
 LinuxStat::Swap.available
-=> 3358184
+=> 1929788
 
 LinuxStat::Swap.list
-=> {"/dev/zram0"=>[:partition, 4194300, 836116, -2]}
+=> {"/dev/zram0"=>[:partition, 4194300, 2264512, -2]}
 
 LinuxStat::Swap.percent_available
-=> 80.07
+=> 46.01
 
 LinuxStat::Swap.percent_used
-=> 19.93
+=> 53.99
 
 LinuxStat::Swap.stat
-=> {:total=>4194300, :used=>836116, :available=>3358184, :percent_used=>19.93, :percent_available=>80.07}
+=> {:total=>4194300, :used=>2264512, :available=>1929788, :percent_used=>53.99, :percent_available=>46.01}
 
 LinuxStat::Swap.total
 => 4194300
 
 LinuxStat::Swap.used
-=> 836116
+=> 2264512
 
 ```
 
@@ -405,24 +429,30 @@ LinuxStat::Uname.nodename
 => "archlinux"
 
 LinuxStat::Uname.release
-=> "5.9.1-xanmod1-1"
+=> "5.9.9-xanmod1-1"
 
 LinuxStat::Uname.sysname
 => "Linux"
 
 LinuxStat::Uname.version
-=> "#1 SMP PREEMPT Wed, 21 Oct 2020 01:11:20 +0000"
+=> "#1 SMP PREEMPT Fri, 20 Nov 2020 07:44:55 +0000"
 
 ```
 
 ### LinuxStat::User
 ```
+LinuxStat::User.get_current_user
+=> "sourav"
+
 LinuxStat::User.get_euid
 => 1000
 
 LinuxStat::User.get_gid
 => 1000
 
+LinuxStat::User.get_login
+=> "sourav"
+
 LinuxStat::User.get_uid
 => 1000
 
@@ -627,7 +657,7 @@ irb(main):006:0> LinuxStat::User.home_by_gid(0)
 Or to get the UID/GID by username:
 
 ```
-$ irb 
+$ irb
 irb(main):001:0> require 'linux_stat'
 => true
 
@@ -644,6 +674,81 @@ irb(main):005:0> LinuxStat::User.gid_by_username('InvalidUser')
 => nil
 ```
 
+## Note 5: PrettifyBytes
+Often times we need to work with KB, MB GB, TB, or KiB, MiB, GiB, TiB, etc.
+And we need some work to convert bytes to those units.
+Because LinuxStat provides a lot of data in bytes, and kilobytes, it's quite tedious to convert them all the time.
+To avoid such duplication, it comes with a PrettifyBytes module.
+
+For example, to convert bytes to decimal suffixes:
+
+```
+irb(main):001:0> require 'linux_stat'
+=> true
+
+irb(main):002:0> LinuxStat::PrettifyBytes.convert_decimal(1000)
+=> "1.00 kilobyte"
+
+irb(main):003:0> LinuxStat::PrettifyBytes.convert_decimal(10000)
+=> "10.00 kilobytes"
+
+irb(main):004:0> LinuxStat::PrettifyBytes.convert_decimal(100000)
+=> "100.00 kilobytes"
+
+irb(main):005:0> LinuxStat::PrettifyBytes.convert_decimal(10 ** 13)
+=> "10.00 terabytes"
+```
+
+To convert bytes to binary suffixes:
+
+```
+irb(main):007:0> LinuxStat::PrettifyBytes.convert_binary(1000)
+=> "1000.00 bytes"
+
+irb(main):008:0> LinuxStat::PrettifyBytes.convert_binary(10000)
+=> "9.77 kibibytes"
+
+irb(main):009:0> LinuxStat::PrettifyBytes.convert_binary(100000)
+=> "97.66 kibibytes"
+
+irb(main):010:0> LinuxStat::PrettifyBytes.convert_binary(10 ** 13)
+=> "9.09 tebibytes"
+```
+
+To convert them to short Metric decimal suffixes:
+
+```
+irb(main):017:0> LinuxStat::PrettifyBytes.convert_short_decimal(1000)
+=> "1.00 kB"
+
+irb(main):018:0> LinuxStat::PrettifyBytes.convert_short_decimal(10000)
+=> "10.00 kB"
+
+irb(main):019:0> LinuxStat::PrettifyBytes.convert_short_decimal(100000)
+=> "100.00 kB"
+
+irb(main):020:0> LinuxStat::PrettifyBytes.convert_short_decimal(10 ** 13)
+=> "10.00 TB"
+```
+
+To convert them to short IEC binary suffixes:
+
+```
+irb(main):013:0> LinuxStat::PrettifyBytes.convert_short_binary(1000)
+=> "1000 B"
+
+irb(main):014:0> LinuxStat::PrettifyBytes.convert_short_binary(10000)
+=> "9.77 KiB"
+
+irb(main):015:0> LinuxStat::PrettifyBytes.convert_short_binary(100000)
+=> "97.66 KiB"
+
+irb(main):016:0> LinuxStat::PrettifyBytes.convert_short_binary(10 ** 13)
+=> "9.09 TiB"
+```
+
+It can support values upto hundreds of yottabytes and yobibytes, or yb and yib.
+
 Read the ri documentation for more info.
 
 ---

data/ext/fs_stat/fs_stat.c

@@ -1,7 +1,9 @@
 #include <sys/statvfs.h>
 #include "ruby.h"
+
 #pragma GCC optimize ("O3")
 #pragma clang optimize on
+#pragma once
 
 static VALUE statfs(VALUE obj, VALUE dir) {
 	struct statvfs buf ;

data/ext/sysconf/sysconf.c

@@ -1,6 +1,10 @@
 #include <unistd.h>
 #include "ruby.h"
 
+#pragma GCC optimize ("O3")
+#pragma clang optimize on
+#pragma once
+
 static VALUE getTick(VALUE obj) {
 	return INT2FIX(sysconf(_SC_CLK_TCK)) ;
 }

data/ext/utsname/utsname.c

@@ -1,7 +1,9 @@
 #include <sys/utsname.h>
 #include "ruby.h"
+
 #pragma GCC optimize ("O3")
 #pragma clang optimize on
+#pragma once
 
 static struct utsname buf ;
 static short status ;

data/lib/linux_stat.rb

@@ -1,21 +1,27 @@
+# Independed and LinuxStat specific unrelated modules
 require "linux_stat/version"
+require 'linux_stat/prettify_bytes'
+
+# Independed and LinuxStat related modules
 require "linux_stat/battery"
 require "linux_stat/bios"
 require "linux_stat/cpu"
 require "linux_stat/memory"
 require "linux_stat/net"
+require "linux_stat/process"
+require "linux_stat/swap"
 
+# LinuxStat::Uname dependent modules
 require 'linux_stat/utsname'
 require "linux_stat/os"
 
-require "linux_stat/process"
-require "linux_stat/swap"
-require "linux_stat/mounts"
-
+# LinuxStat::FS dependent modules
 require "linux_stat/fs_stat"
 require "linux_stat/filesystem"
+require "linux_stat/mounts"
 
+# LinuxStat::Sysconf dependent modules
 require "linux_stat/sysconf"
 require "linux_stat/kernel"
-require "linux_stat/process_info"
 require 'linux_stat/user'
+require "linux_stat/process_info"

data/lib/linux_stat/cpu.rb

@@ -1,8 +1,9 @@
 module LinuxStat
 	module CPU
 		class << self
-			# stat(sleep = 0.075)
+			# stat(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck)
 			# Where sleep is the delay to gather the data.
+			# The minimum possible value at anytime is 1.0 / LinuxStat::Sysconf.sc_clk_tck
 			# This method returns the cpu usage of all threads.
 			#
 			# The first one is aggregated CPU usage reported by the Linux kernel.
@@ -12,7 +13,7 @@ module LinuxStat
 			# {0=>84.38, 1=>100.0, 2=>50.0, 3=>87.5, 4=>87.5}
 			#
 			# If the information is not available, it will return an empty Hash
-			def stat(sleep = 0.075)
+			def stat(sleep = ticks_to_ms)
 				return {} unless stat?
 
 				data = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
@@ -33,20 +34,24 @@ module LinuxStat
 					idle_then, idle_now  = idle + iowait, idle2 + iowait2
 					totald = idle_now.+(user2 + nice2 + sys2 + irq2 + softirq2 + steal2) - idle_then.+(user + nice + sys + irq + softirq + steal)
 
+					res = totald.-(idle_now - idle_then).fdiv(totald).*(100).round(2).abs
+					res = 0.0 if res.nan?
+
 					h.merge!(
-						x => totald.-(idle_now - idle_then).fdiv(totald).*(100).round(2).abs
+						x => res
 					)
 				end
 			end
 
-			# total_usage(sleep = 0.075)
+			# total_usage(sleep = 1.0 / LinuxStat::Sysconf.sc_clk_tck)
 			# Where sleep is the delay to gather the data.
+			# The minimum possible value at anytime is 1.0 / LinuxStat::Sysconf.sc_clk_tck
 			# This method returns the cpu usage of all threads.
 			#
 			# It's like running LinuxStat::CPU.stat[0] but it's much more efficient and calculates just the aggregated usage which is available at the top of the /proc/stat file.
 			#
 			# If the information is not available, it will return nil.
-			def total_usage(sleep = 0.075)
+			def total_usage(sleep = ticks_to_ms)
 				return nil unless stat?
 
 				data = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
@@ -113,6 +118,10 @@ module LinuxStat
 			def stat?
 				@@stat_readable ||= File.readable?('/proc/stat')
 			end
+
+			def ticks_to_ms
+				@@ms ||= 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			end
 		end
 	end
 end

data/lib/linux_stat/mounts.rb

@@ -1,7 +1,8 @@
 module LinuxStat
 	module Mounts
 		class << self
-			# Reads /proc/mounts and returns list of devices.
+			# Reads /proc/mounts and returns the output splitted with \n.
+			# In other words, it's same as running IO.readlines('/proc/mounts').each(&:strip!)
 			#
 			# It returns an Array.
 			# If the info isn't available or /proc/mounts is not readable, it will return an empty Array.
@@ -9,6 +10,14 @@ module LinuxStat
 				mounts
 			end
 
+			# Reads /proc/mounts and returns list of devices.
+			#
+			# It returns an Array.
+			# If the info isn't available or /proc/mounts is not readable, it will return an empty Array.
+			def list_devices
+				mounts.map { |x| x.split(?\s.freeze).first }
+			end
+
 			# Reads /proc/mounts and returns partition name of the device mounted at /.
 			#
 			# It returns a String.
@@ -45,6 +54,135 @@ module LinuxStat
 				ret
 			end
 
+			# mount_point(dev = root)
+			# Where device = block device.
+			# The default argument is the root block device.
+			#
+			# It helps you find the mountpoint of a block device.
+			# For example:
+			#    LinuxStat::Mounts.mount_point('/dev/sdb1')
+			#    => "/run/media/sourav/5c2b7af7-d4c3-4ab4-a035-06d18ffc8e6f"
+			#
+			# The return type is String.
+			# But if the status isn't available or the device isn't mounted, it will return an empty String.
+			def mount_point(dev = root)
+				m = ''
+				mounts.each do |x|
+					x.strip!
+
+					unless x.empty?
+						_x = x.split
+						if _x[0] == dev
+							m.replace(_x[1])
+							break
+						end
+					end
+				end
+				m
+			end
+
+			# list_devices_mount_point()
+			#
+			# It shows all the block devices corresponding to mount points.
+			#
+			# For example:
+			#    LinuxStat::Mounts.list_devices_mount_point
+			#    => {"proc"=>"/proc", "sys"=>"/sys", "dev"=>"/dev", "run"=>"/run", "/dev/sda2"=>"/", "securityfs"=>"/sys/kernel/security", "tmpfs"=>"/run/user/1000", "devpts"=>"/dev/pts", "cgroup2"=>"/sys/fs/cgroup/unified", "cgroup"=>"/sys/fs/cgroup/perf_event", "pstore"=>"/sys/fs/pstore", "none"=>"/sys/fs/bpf", "systemd-1"=>"/proc/sys/fs/binfmt_misc", "debugfs"=>"/sys/kernel/debug", "mqueue"=>"/dev/mqueue", "hugetlbfs"=>"/dev/hugepages", "tracefs"=>"/sys/kernel/tracing", "configfs"=>"/sys/kernel/config", "fusectl"=>"/sys/fs/fuse/connections", "gvfsd-fuse"=>"/run/user/1000/gvfs", "/dev/sdb1"=>"/run/media/sourav/5c2b7af7-d4c3-4ab4-a035-06d18ffc8e6f", "binfmt_misc"=>"/proc/sys/fs/binfmt_misc"}
+			#
+			# The return type is Hash.
+			# But if the status isn't available or the device isn't mounted, it will return an empty String.
+			def list_devices_mount_point
+				m = {}
+				mounts.each do |x|
+					x.strip!
+
+					unless x.empty?
+						_x = x.split
+						m.merge!(_x[0] => _x[1])
+					end
+				end
+				m
+			end
+
+			# devices_stat
+			# [ Not to confuse this method with device_stat(dev) which shows only one device's info ]
+			#
+			# It shows all the block devices corresponding to mount points and data from LinuxStat::FS.stat(arg)
+			#
+			# For example:
+			#    LinuxStat::Mounts.devices_stat
+			#    => {"proc"=>{:mountpoint=>"/proc", :total=>0, :free=>0, :available=>0, :used=>0, :percent_used=>NaN, :percent_free=>NaN, :percent_available=>NaN}, "/dev/sdb1"=>{:mountpoint=>"/run/media/sourav/5c2b7af7-d4c3-4ab4-a035-06d18ffc8e6f", :total=>31466008576, :free=>2693931008, :available=>2693931008, :used=>28772077568, :percent_used=>91.44, :percent_free=>8.56, :percent_available=>8.56}}
+			#
+			# The return type is Hash.
+			# But if the status isn't available, it will return an empty Hash.
+			def devices_stat
+				# Code duplication is fine if it gives maximum performance
+				m = {}
+				mounts.each do |x|
+					x.strip!
+
+					unless x.empty?
+						_x = x.split
+						total, free, available, used = fs_info(_x[1])
+
+						m.merge!(_x[0] => {
+							mountpoint: _x[1],
+
+							total: total,
+							free: free,
+							available: available,
+							used: used,
+
+							percent_used: used.*(100).fdiv(total).round(2),
+							percent_free: free.*(100).fdiv(total).round(2),
+							percent_available: available.*(100).fdiv(total).round(2),
+						})
+					end
+				end
+				m
+			end
+
+			# device_stat(dev = root)
+			# [ Not to confuse this method with devices_stat() which shows all devices ]
+			# It shows all the block devices corresponding to mount points and data from LinuxStat::FS.stat(arg)
+			#
+			# For example:
+			#    LinuxStat::Mounts.device_stat('/dev/sda2')
+			#    => {"/dev/sda2"=>{:mountpoint=>"/", :total=>119981191168, :free=>35298562048, :available=>35298562048, :used=>84682629120, :percent_used=>70.58, :percent_free=>29.42, :percent_available=>29.42}}
+			#
+			# The return type is Hash.
+			# But if the status isn't available, it will return an empty Hash.
+			def device_stat(dev = root)
+				# Code duplication is fine if it gives maximum performance
+				m = {}
+				mounts.each do |x|
+					x.strip!
+
+					unless x.empty?
+						_x = x.split
+						next if _x[0] != dev
+
+						total, free, available, used = fs_info(_x[1])
+
+						m.merge!({
+							mountpoint: _x[1],
+
+							total: total,
+							free: free,
+							available: available,
+							used: used,
+
+							percent_used: used.*(100).fdiv(total).round(2),
+							percent_free: free.*(100).fdiv(total).round(2),
+							percent_available: available.*(100).fdiv(total).round(2),
+						})
+
+						break
+					end
+				end
+				m
+			end
+
 			private
 			def mount_readable?
 				@@mount_readable ||= File.readable?('/proc/mounts')
@@ -59,6 +197,19 @@ module LinuxStat
 				return [] unless mount_readable?
 				@@root ||= IO.foreach('/proc/mounts').find { |x| x.split[1] == '/'.freeze }.split
 			end
+
+			def fs_info(dev)
+				# => [total, free, available, used]
+				s = LinuxStat::FS.stat(dev)
+				s.default = 0
+
+				[
+					s[:block_size] * s[:blocks],
+					s[:block_size] * s[:block_free],
+					s[:block_size] * s[:block_avail_unpriv],
+					s[:blocks].-(s[:block_free]) * s[:block_size]
+				]
+			end
 		end
 	end
 end

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

@@ -172,9 +172,11 @@ module LinuxStat
 				_vm_rss ? _vm_rss.split[1].to_i : 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.
@@ -204,7 +206,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)
 
@@ -236,9 +238,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:
@@ -248,7 +252,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)
 
@@ -305,17 +309,73 @@ 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
 
-			# def owned_by
+			# 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
 
-			# end
+				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
 		end
 	end
 end

data/lib/linux_stat/version.rb

@@ -1,3 +1,3 @@
 module LinuxStat
-	VERSION = "0.5.2"
+	VERSION = "0.6.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: linux_stat
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.1
 platform: ruby
 authors:
 - Sourav Goswami
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-06 00:00:00.000000000 Z
+date: 2020-12-08 00:00:00.000000000 Z
 dependencies: []
 description: Linux only, efficient linux system utilization reporting and system monitoring
   gem
@@ -44,6 +44,7 @@ files:
 - lib/linux_stat/mounts.rb
 - lib/linux_stat/net.rb
 - lib/linux_stat/os.rb
+- lib/linux_stat/prettify_bytes.rb
 - lib/linux_stat/process.rb
 - lib/linux_stat/process_info.rb
 - lib/linux_stat/swap.rb