linux_stat 0.4.0 → 0.6.2

data/bin/console

@@ -1,4 +1,4 @@
 #!/usr/bin/env ruby
 $-v = true
-%w(bundler/setup linux_stat irb).each(&method(:require))
+%w(linux_stat irb).each(&method(:require))
 IRB.start(__FILE__)

data/bin/setup

@@ -4,5 +4,3 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
-
-# Do any other automated setup that you need to do here

data/{bin → exe}/linuxstat.rb

@@ -1,18 +1,43 @@
 #!/usr/bin/env ruby
+$-v = true
+
 begin
 	require 'linux_stat'
 rescue LoadError
-	require 'bundler/setup'
-	require 'linux_stat'
+	abort "The Gem needs to be installed before this test can be run!"
 end
 
-$-v = true
+# Check which conflicting argument (e.g., `-md -html` together) is passed last
+# Always use the last argument
+conflicting, hash = [
+	"markdown|html", /^\-(\-markdown|md)$/, /^\-(\-html|html)$/
+].each_slice(3).to_a, {}
+
+conflicting.each do |x, y, z|
+	o1, o2 = *x.split(?|.freeze).map(&:to_sym)
+	m1, m2 = ARGV.any? { |_x| _x[y] }, ARGV.any? { |_x| _x[z] }
+
+	if m1 && m2
+		rev = ARGV.reverse
+
+		if rev.index { |_x| _x[y] } < rev.index { |_x| _x[z] }
+			hash.merge!(o1 => true)
+		else
+			hash.merge!(o2 => true)
+		end
+	elsif m1
+		hash.merge!(o1 => true)
+	elsif m2
+		hash.merge!(o2 => true)
+	end
+end
+
+MARKDOWN, HTML = hash[:markdown], hash[:html]
 
 # Print time each method takes unless --no-time or -nt option is passed
-MARKDOWN = ARGV.any? { |x| x[/^\-\-markdown$/] || x[/^\-md$/] }
-PRINT_TIME = MARKDOWN ? false : !ARGV.any? { |x| x[/^\-\-no-time$/] || x[/^\-nt$/] }
+PRINT_TIME = (MARKDOWN || HTML) ? false : !ARGV.any? { |x| x[/^\-\-no-time$/] || x[/^\-nt$/] }
 
-%w(--markdown -md --no-time -nt).each(&ARGV.method(:delete))
+%w(--markdown -md --no-time -nt --html -html).each(&ARGV.method(:delete))
 
 # Run only desired classes / modules
 constants = LinuxStat.constants
@@ -34,6 +59,8 @@ execute.sort.each do |c|
 	if meths.length > 0
 		if MARKDOWN
 			puts "### LinuxStat::#{c}\n```"
+		elsif HTML
+			puts "<h3>LinuxStat::#{c}</h3>\n<pre>"
 		else
 			puts "\e[1;4;38;2;255;240;0mLinuxStat::#{c}\e[0m"
 		end
@@ -50,6 +77,8 @@ execute.sort.each do |c|
 
 		if MARKDOWN
 			puts "#{e}.#{meth}\n=> #{dis}"
+		elsif HTML
+			puts "#{e}.#{meth}\n=> #{dis}"
 		else
 			puts "\e[1;38;2;80;80;255m#{e}.#{meth}\e[0m\n=> #{dis}"
 		end
@@ -67,5 +96,11 @@ execute.sort.each do |c|
 		puts
 	end
 
-	puts "```\n\n" if MARKDOWN && meths.length > 0
+	if meths.length > 0
+		if MARKDOWN
+			puts "```\n\n"
+		elsif HTML
+			puts "</pre>"
+		end
+	end
 end

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)) ;
 }
@@ -21,7 +25,7 @@ static VALUE getOpenMax(VALUE obj) {
 	return INT2FIX(sysconf(_SC_OPEN_MAX)) ;
 }
 
-static VALUE getPageSizeMax(VALUE obj) {
+static VALUE getPageSize(VALUE obj) {
 	return INT2FIX(sysconf(_SC_PAGESIZE)) ;
 }
 
@@ -37,6 +41,23 @@ static VALUE getPosixVersion(VALUE obj) {
 	return INT2FIX(sysconf(_SC_VERSION)) ;
 }
 
+static VALUE getUser(VALUE obj) {
+	char *name = getlogin() ;
+	return name ? rb_str_new_cstr(name) : rb_str_new_cstr("") ;
+}
+
+static VALUE getUID(VALUE obj) {
+	return INT2FIX(getuid()) ;
+}
+
+static VALUE getGID(VALUE obj) {
+	return INT2FIX(getgid()) ;
+}
+
+static VALUE getEUID(VALUE obj) {
+	return INT2FIX(geteuid()) ;
+}
+
 void Init_sysconf() {
 	VALUE _linux_stat = rb_define_module("LinuxStat") ;
 	VALUE _sysconf = rb_define_module_under(_linux_stat, "Sysconf") ;
@@ -46,8 +67,15 @@ void Init_sysconf() {
 	rb_define_module_function(_sysconf, "hostname_max", getHostnameMax, 0) ;
 	rb_define_module_function(_sysconf, "login_name_max", getLoginNameMax, 0) ;
 	rb_define_module_function(_sysconf, "open_max", getOpenMax, 0) ;
-	rb_define_module_function(_sysconf, "page_size_max", getPageSizeMax, 0) ;
+	rb_define_module_function(_sysconf, "pagesize", getPageSize, 0) ;
 	rb_define_module_function(_sysconf, "stream_max", getStreamMax, 0) ;
 	rb_define_module_function(_sysconf, "tty_name_max", getTTYNameMax, 0) ;
 	rb_define_module_function(_sysconf, "posix_version", getPosixVersion, 0) ;
+
+	rb_define_module_function(_sysconf, "get_uid", getUID, 0) ;
+	rb_define_module_function(_sysconf, "get_gid", getGID, 0) ;
+	rb_define_module_function(_sysconf, "get_euid", getEUID, 0) ;
+
+	rb_define_module_function(_sysconf, "get_user", getUser, 0) ;
+	rb_define_module_function(_sysconf, "get_login", getUser, 0) ;
 }

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,20 +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/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/kernel.rb

@@ -133,8 +133,6 @@ module LinuxStat
 				end
 			end
 
-			alias release version
-
 			# Reads maximum 1024 bytes from /proc/version and returns the string.
 			# The output is also cached ; as changing the value in runtime is unexpected.
 			def string
@@ -148,6 +146,7 @@ module LinuxStat
 				@@tick ||= LinuxStat::Sysconf.sc_clk_tck
 			end
 
+			alias release version
 			alias clk_tck ticks
 
 			private

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