linux_stat 0.1.3 → 0.3.0

data/{run_all_methods.rb → bin/linuxstat.rb}

@@ -1,20 +1,34 @@
 #!/usr/bin/env ruby
-require 'bundler/setup'
-require 'linux_stat'
-require 'io/console'
+begin
+	require 'linux_stat'
+rescue LoadError
+	require 'bundler/setup'
+	require 'linux_stat'
+end
+
+$-v = true
 
 # 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$/] }
 
-$-v = true
+%w(--markdown -md --no-time -nt).each(&ARGV.method(:delete))
+
+# Run only desired classes / modules
+constants = LinuxStat.constants
+
+execute = constants.map(&:downcase).map.with_index { |x, i|
+	constants[i] if ARGV.find { |y| y.downcase.to_sym == x }
+}.compact
+
+execute.replace(constants) if execute.empty?
 
-LinuxStat.constants.sort.each do |c|
+execute.sort.each do |c|
 	e = eval("LinuxStat::#{c}")
 
 	next if e.class != Module && e.class != Class
 
-	meths = e.methods(false)
+	meths = e.methods(false).sort
 
 	if meths.length > 0
 		if MARKDOWN
@@ -26,9 +40,11 @@ LinuxStat.constants.sort.each do |c|
 
 	meths.each do |meth|
 		time = Time.now
-		v = e.send(meth).to_s
-		time = Time.now.-(time).*(1000).round(3)
+		v = e.send(meth)
+		time2 = Time.now
+		time = time2.-(time).*(1_000_000).round(3)
 
+		v = v.inspect
 		dis = v.length > 253 ? v[0..250].strip + '...'.freeze : v
 
 		if MARKDOWN
@@ -38,13 +54,13 @@ LinuxStat.constants.sort.each do |c|
 		end
 
 		puts( "(" +
-			if time > 10
-				"\e[1;38;2;255;80;80m"
-			elsif time > 5
+			if time > 10_000
+				"\e[1;38;2;255;50;50m"
+			elsif time > 5_000
 				"\e[1;38;2;255;170;0m"
 			else
 				"\e[1;38;2;0;170;0m"
-			end + "Time taken: #{time}ms\e[0m)"
+			end + "Time taken: #{time}\u03BCs\e[0m)"
 		) if PRINT_TIME
 
 		puts

data/ext/fs_stat/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+create_makefile 'linux_stat/fs_stat'
+
+# abort 'missing'

data/ext/fs_stat/fs_stat.c

@@ -0,0 +1,28 @@
+#include <sys/statvfs.h>
+#include "ruby.h"
+
+static VALUE statfs(VALUE obj, VALUE dir) {
+	struct statvfs buf ;
+	char *d = StringValuePtr(dir) ;
+	VALUE hash = rb_hash_new() ;
+
+	if(statvfs(d, &buf) < 0) return hash ;
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_size")), INT2NUM(buf.f_bsize)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("fragment_size")), INT2NUM(buf.f_frsize)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("blocks")), INT2NUM(buf.f_blocks)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_free")), INT2NUM(buf.f_bfree)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_avail_unpriv")), INT2NUM(buf.f_bavail)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("inodes")), INT2NUM(buf.f_files)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("free_inodes")), INT2NUM(buf.f_ffree)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("filesystem_id")), INT2NUM(buf.f_fsid)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("mount_flags")), INT2NUM(buf.f_flag)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("max_filename_length")), INT2NUM(buf.f_namemax)) ;
+
+	return hash ;
+}
+
+void Init_fs_stat() {
+	VALUE fs = rb_define_module("FS") ;
+	rb_define_module_function(fs, "stat", statfs, 1) ;
+}

data/lib/linux_stat.rb

@@ -1,10 +1,4 @@
 require "linux_stat/version"
-
-module LinuxStat
-	class StatUnavailable < StandardError
-	end
-end
-
 require "linux_stat/battery"
 require "linux_stat/bios"
 require "linux_stat/cpu"
@@ -14,3 +8,6 @@ require "linux_stat/net"
 require "linux_stat/os"
 require "linux_stat/process"
 require "linux_stat/swap"
+require "linux_stat/mounts"
+require "linux_stat/fs_stat"
+require "linux_stat/filesystem"

data/lib/linux_stat/battery.rb

@@ -3,10 +3,13 @@ module LinuxStat
 		PATH = "/sys/class/power_supply/BAT0"
 
 		class << self
+			# Returns true or false based on the presence of the battery.
 			def present?
 				@@present ||= Dir.exist?(PATH)
 			end
 
+			# Returns the details of the battery.
+			#If the battery is not present it will return an empty Hash.
 			def stat
 				st = status.downcase
 				return {} unless present?
@@ -23,40 +26,60 @@ module LinuxStat
 				}
 			end
 
+			# Returns the model of the battery.
+			#If the battery is not present or the information isn't available it will return an empty String.
 			def model
 				return ''.freeze unless model_readable?
 				IO.read(File.join(PATH, 'model_name')).tap(&:strip!)
 			end
 
+			# Returns the manufacturer of the battery.
+			# If the battery is not present or the information is not available, it will return an empty String.
 			def manufacturer
 				return ''.freeze unless manufacturer_readable?
 				IO.read(File.join(PATH, 'manufacturer')).tap(&:strip!)
 			end
 
+			# Returns the technology of the battery.
+			# If the battery is not present or the information is not available, it will return an empty String.
 			def technology
 				return ''.freeze unless tech_readable?
 				IO.read(File.join(PATH, 'technology')).tap(&:strip!)
 			end
 
+			# Returns the status of the battery.
+			# If the battery is not present or the information is not available, it will return an empty String.
+			# The status generally includes either of the full, charging, discharging and unknown states in most cases.
 			def status
 				return ''.freeze unless status_readable?
 				IO.read(File.join(PATH, 'status')).tap(&:strip!)
 			end
 
+			# Returns true if the battery is charging, false if the battery is not charging.
+			# If the battery is not present or the information is not available, it will return nil.
 			def charging?
+				return nil if status.empty?
 				%w(full charging unknown).each(&:freeze).include?(status.downcase)
 			end
 
+			# Returns true if the battery is discharging, false if the battery is not discharging.
+			# If the battery is not present or the information is not available, it will return nil.
 			def discharging?
+				return nil if status.empty?
 				status.downcase == 'discharging'
 			end
 
+			# Returns true if the battery status if full, false if the battery status is not full.
+			# If the battery is not present or the information is not available, it will return nil.
 			def full?
+				return nil if status.empty?
 				status.downcase == 'full'
 			end
 
+			# Returns the charge of the battery.
+			# If the battery is not present or the information is not available, it will return nil.
 			def charge
-				return 0.0 unless charge_now_readable?
+				return nil unless charge_now_readable?
 				charge_now = IO.read(File.join(PATH, 'charge_now')).to_i
 				charge_full = IO.read(File.join(PATH, 'charge_full')).to_i
 

data/lib/linux_stat/bios.rb

@@ -1,6 +1,9 @@
 module LinuxStat
 	module BIOS
 		class << self
+			# Returns the model of the BIOS.
+			# If the information is not available it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def model
 				# Cached ; as changing the value in runtime is unexpected
 				@@model ||= if File.readable?('/sys/devices/virtual/dmi/id/product_name')
@@ -12,6 +15,9 @@ module LinuxStat
 				end
 			end
 
+			# Returns the vendor of the BIOS.
+			# If the information is not available it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def vendor
 				# Cached ; as changing the value in runtime is unexpected
 				@@vendor ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_vendor')
@@ -21,8 +27,10 @@ module LinuxStat
 				end
 			end
 
+			# Returns the version of the BIOS.
+			# If the information is not available it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def version
-				# Cached ; as changing the value in runtime is unexpected
 				@@version ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_version')
 					IO.read('/sys/devices/virtual/dmi/id/bios_version').tap(&:strip!)
 				else
@@ -30,8 +38,10 @@ module LinuxStat
 				end
 			end
 
+			# Returns the date of the BIOS.
+			# If the information is not available it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def date
-				# Cached ; as changing the value in runtime is unexpected
 				@@date ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_date')
 					IO.read('/sys/devices/virtual/dmi/id/bios_date').tap(&:strip!)
 				else

data/lib/linux_stat/cpu.rb

@@ -1,6 +1,15 @@
 module LinuxStat
 	module CPU
 		class << self
+			# Returns the cpu usage of all threads.
+			#
+			# The first one is aggregated CPU usage reported by the Linux kernel.
+			# And the consecutive ones are the real core usages.
+			#
+			# On a system with 4 threads, the output will be like::
+			# {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)
 				return {} unless stat?
 
@@ -21,35 +30,56 @@ module LinuxStat
 				end
 			end
 
+			# Returns the total cpu usage.
+			# 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)
+				return nil unless stat?
+
+				data = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
+				sleep(sleep)
+				data2 = IO.foreach('/proc/stat').first.split.tap(&:shift).map!(&:to_f)
+
+				user, nice, sys, idle, iowait, irq, softirq, steal = *data
+				user2, nice2, sys2, idle2, iowait2, irq2, softirq2, steal2 = *data2
+
+				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)
+				totald.-(idle_now - idle_then).fdiv(totald).*(100).round(2).abs
+			end
+
+			# Returns the total number of CPU threads.
+			# If the information isn't available, it will return 0.
 			def count
 				# CPU count can change during the program runtime
 				cpuinfo.count { |x| x.start_with?('processor') }
 			end
 
+			# Returns the model of processor.
+			# If the information isn't available, it will return en empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def model
-				# Cached ; as changing the value in runtime is unexpected ; nobody is going
-				# to add/remove CPUs during program runtime
 				@@name ||= cpuinfo.find { |x| x.start_with?('model name') }.to_s.split(?:)[-1].to_s.strip
 			end
 
-			# Returns an array with current core frequencies corresponding to the usages
+			# Returns an array with current core frequencies corresponding to the usages.
+			# If the information isn't available, it will return an empty array.
 			def cur_freq
-				# Cached ; as changing the value in runtime is unexpected ; nobody is going
-				# to add/remove CPUs during program runtime
-
 				@@cpu_freqs ||= Dir["/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq"]
 				@@cpu_freqs.map { |x| IO.read(x).to_i }
 			end
 
-			# Returns an array with max core frequencies corresponding to the usages
+			# Returns an array with max core frequencies corresponding to the usages.
+			# If the information isn't available, it will return an empty array.
 			def max_freq
-				# Cached ; as changing the value in runtime is unexpected ; nobody is going
-				# to add/remove CPUs during program runtime
-
 				@@max_freqs ||= Dir["/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_max_freq"]
 				@@max_freqs.map { |x| IO.read(x).to_i }
 			end
 
+			alias usages stat
+			alias usage total_usage
+
 			private
 			def cpuinfo
 				File.readable?('/proc/cpuinfo') ? IO.readlines('/proc/cpuinfo') : []

data/lib/linux_stat/filesystem.rb

@@ -0,0 +1,97 @@
+# require 'linux_stat/fs_stat'
+
+module LinuxStat
+	module Filesystem
+		extend FS
+
+		class << self
+			# stat(fs = '/')
+			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
+			#
+			# It returns a Hash with the following info:
+			# 1. total size of the device (in bytes)
+			# 2. free space (in kilobytes)
+			# 3. used space (in kilobytes)
+			#
+			# In a hash format:
+			# {:total=>119981191168, :free=>43155574784, :used=>76825616384, :available=>43155574784}
+			#
+			# If the stat can't be acquired, this method will return an empty Hash.
+
+			def stat(fs = ?/.freeze)
+				s = stat_raw(fs)
+				return {} if s.empty?
+				s.default = 0
+
+				{
+					total: s[:block_size] * s[:blocks],
+					free: s[:block_size] * s[:block_free],
+					used: s[:blocks].-(s[:block_free]) * s[:block_size],
+				}
+			end
+
+			# stat(fs = '/')
+			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
+			# It returns the total size of a given disk in bytes.
+			#
+			# If the stat can't be acquired, this method will return nil.
+			def total(fs = ?/.freeze)
+				s = stat_raw(fs)
+				return nil if s.empty?
+				s.default = 0
+				s[:block_size] * s[:blocks]
+			end
+
+			# stat(fs = '/')
+			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
+			# It returns the total free space in a disk in bytes.
+			# It is to be noted that free is not same as available.
+			# Free returns the size of free blocks.
+			#
+			# If the stat can't be acquired, this method will return an empty Hash.
+			def free(fs = ?/.freeze)
+				s = stat_raw(fs)
+				return nil if s.empty?
+				s.default = 0
+				s[:block_size] * s[:block_free]
+			end
+
+			# stat(fs = '/')
+			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
+			# It returns the used space of a given disk in bytes.
+			#
+			# If the stat can't be acquired, this method will return nil.
+			def used(fs = ?/.freeze)
+				s = stat_raw(fs)
+				return nil if s.empty?
+				s.default = 0
+				s[:blocks].-(s[:block_free]) * s[:block_size]
+			end
+
+			# stat(fs = '/')
+			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
+			# It returns the total free space in a disk in bytes.
+			# It is to be noted that free is not same as available.
+			# Available returns the size of free blocks for unpriviledged users.
+			#
+			# If the stat can't be acquired, this method will return an empty Hash.
+			def available(fs = ?/.freeze)
+				s = stat_raw(fs)
+				return nil if s.empty?
+				s.default = 0
+				s[:block_size] * s[:block_avail_unpriv]
+			end
+
+			# stat(fs = '/')
+			# Where fs is the directory of the file system (like / or /tmp/ or /run/media/thumbdrive).
+			#
+			# It returns a Hash with the following data (for example):
+			# {:block_size=>4096, :fragment_size=>4096, :blocks=>29292283, :block_free=>10535967, :block_avail_unpriv=>10535967, :inodes=>58612160, :free_inodes=>56718550, :filesystem_id=>2050, :mount_flags=>1024, :max_filename_length=>255}
+			#
+			# If the stat can't be acquired, this method will return an empty Hash.
+			def stat_raw(fs = '/'.freeze)
+				FS.stat(fs)
+			end
+		end
+	end
+end

data/lib/linux_stat/kernel.rb

@@ -1,37 +1,147 @@
 module LinuxStat
 	module Kernel
 		class << self
+			# Returns the Linux Kernel version.
+			# If the information isn't available, it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def version
-				return @@version ||= ''.freeze if string.empty?
-				@@version ||= string.split[2]
+				return ''.freeze if string.empty?
+				@@version ||= splitted[2]
 			end
 
+			# Returns the name of the user who built the kernel using KBUILD_FLAGS.
+			# If the information isn't available, it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
+			def build_user
+				@@build_user ||= string.split(/(\(.+\))/).each(&:strip!)
+					.reject(&:empty?).find { |x| x[/^\(.+\)$/] }.to_s
+					.split[0].to_s[1..-2].to_s.freeze
+			end
+
+			# Returns the compiler used to compile the Linux Kernel.
+			# If the information isn't available, it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def compiler
-				return @@compiler ||= ''.freeze if string.empty?
+				return ''.freeze if string.empty?
+
+				@@compiler ||= string.split(/(\(.+\))/).each(&:strip!)
+					.reject(&:empty?)
+					.find { |x| x[/^\(.+\)$/] }.to_s
+					.split.find { |x| !x[/^(.+@.+)$/] }.to_s[/\w+/].to_s.freeze
 
-				@@compiler ||= case string.split[4].to_s
+				@@compiler_val ||= case @@compiler
 					when /gcc/i then [:gcc ]
 					when /clang/i then [:clang]
 					when /icc/i then [:icc]
-				end << string[/\(.*\)/].split.drop(1).find { |x| x[/^\d.*\d/] }[/^\d.*\d/]
+					else [@@compiler &.to_sym]
+				end << compiler_version
+			end
+
+			# Returns the compiler version used to compile the Linux Kernel.
+			# If the information isn't available, it will return a frozen empty string.
+			# The output is also cached ; as changing the value in runtime is unexpected.
+			def compiler_version
+				@@compiler_version ||= string.split(/(\(.+?\))/).each(&:strip!)
+					.reject(&:empty?)[2..4].to_a
+					.find { |x| x[/[\d.]+/] }.to_s[/[\d.]+/].to_s.freeze
 			end
 
+			# Returns the time when the kernel was compiled.
+			# The return value is a Time object.
+			# If the information isn't available, it will return nil
+			#
+			# The time will be searched in specific order.
+			# It will match any date matching any of these formats:
+			# 1. %b %d %H:%M:%S %z %Y
+			# 2. %d %b %Y %H:%M:%S %z
+			# 3. %Y-%m-%d
+			# Most kernels have date in them in this format.
+			#
+			# Do note that Ruby sometimes fails to work with timezones like BST for example.
+			# In such case, the timezone is unrealiable and often returns the local timezone.
+			# You have to use regexp yourself to get the proper zone.
+			# Use LinuxStat::Kernel.build_date_string to get the original string if you need that.
+			#
+			# The output is also cached ; as changing the value in runtime is unexpected.
 			def build_date
-				return @@time ||= Time.new(0) if string.empty?
+				return nil if splitted.empty?
 
 				@@time ||= begin
-					require 'time'
-					Time.strptime(string.split[16..-1].join(' '), "%d %b %Y %H:%M:%S %z")
-				rescue StandardError
-					Time.new(0)
+					require 'time' unless Time.respond_to?(:strptime)
+
+					splitted.each_cons(5).map do |x|
+						joined = x.each(&:strip!).join(?\s.freeze)
+
+						# Match 21 Oct 2020 01:11:20 +0000
+						if joined[/^\d{1,2}\s\w{3}\s\d{4}\s\d{1,2}:\d{1,2}:\d{1,2}\s\+\d*$/]
+							Time.strptime(joined, '%d %b %Y %H:%M:%S %Z') rescue nil
+
+						# Match Aug 25 17:23:54 UTC 2020
+						elsif joined[/^\w{3}\s\d{1,2}\s\d{1,2}:\d{1,2}:\d{2}\s\w+\s\d*$/]
+							Time.strptime(joined, '%b %d %H:%M:%S %z %Y') rescue nil
+
+						# Match 2017-09-19
+						elsif joined[/\d{4}-\d{1,2}-\d{1,2}/]
+							Time.strptime(joined[/\d{4}-\d{2}-\d{2}/] + " +00:00", '%Y-%m-%d %z') rescue nil
+
+						else
+							nil
+						end
+					end.tap(&:compact!)[0]
 				end
 			end
 
+			# Returns the time when the kernel was compiled.
+			# The return value is a String.
+			# If the information isn't available, it will return nil
+			#
+			# The time will be searched in specific order.
+			# It will match any date matching any of these formats:
+			# 1. %b %d %H:%M:%S %z %Y
+			# 2. %d %b %Y %H:%M:%S %z
+			# 3. %Y-%m-%d
+			# Most kernels have date in them in this format.
+			#
+			# Do note that Ruby sometimes fails to work with timezones like BST for example.
+			# In such case, the timezone is unrealiable and often returns the local timezone.
+			# You have to use regexp yourself to get the proper zone.
+			# Use LinuxStat::Kernel.build_date_string to get the original string if you need that.
+			#
+			# The output is also cached ; as changing the value in runtime is unexpected.
+			def build_date_string
+				return nil if splitted.empty?
+
+				@@time2 ||= begin
+					require 'time' unless Time.respond_to?(:strptime)
+
+					splitted.each_cons(5).map do |x|
+						joined = x.each(&:strip!).join(?\s.freeze)
+
+						# Match 21 Oct 2020 01:11:20 +0000
+						if (joined[/^\d{1,2}\s\w{3}\s\d{4}\s\d{1,2}:\d{1,2}:\d{1,2}\s\+\d*$/] && (Time.strptime(joined, '%d %b %Y %H:%M:%S %Z') rescue nil)) ||
+
+						# Match Aug 25 17:23:54 UTC 2020
+						(joined[/^\w{3}\s\d{1,2}\s\d{1,2}:\d{1,2}:\d{1,2}\s\w+\s\d*$/] && (Time.strptime(joined, '%b %d %H:%M:%S %z %Y') rescue nil)) ||
+
+						# Match 2017-09-19
+						(joined[/\d{4}-\d{1,2}-\d{1,2}/] && (Time.strptime(joined[/\d{4}-\d{2}-\d{2}/] + " +00:00", '%Y-%m-%d %z') rescue nil))
+							joined
+						else
+							nil
+						end
+					end.tap(&:compact!)[0]
+				end
+			end
+
+			# 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
-				# Cached ; as changing the value in runtime is unexpected
-				# Hotfix update can be problem, but it's rare and might not
-				# affect the version string during program runtime.
-				@@string ||= File.readable?('/proc/version') ? IO.read('/proc/version').tap(&:strip!) : ''
+				@@string ||= File.readable?('/proc/version') ? IO.read('/proc/version', 1024).tap(&:strip!) : ''
+			end
+
+			private
+			def splitted
+				@@string_splitted ||= string.split
 			end
 		end
 	end