linux_stat 0.2.1 → 0.4.0

data/ext/fs_stat/fs_stat.c

@@ -0,0 +1,31 @@
+#include <sys/statvfs.h>
+#include "ruby.h"
+#pragma GCC optimize ("O3")
+#pragma clang optimize on
+
+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")), INT2FIX(buf.f_bsize)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("fragment_size")), INT2FIX(buf.f_frsize)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("blocks")), INT2FIX(buf.f_blocks)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_free")), INT2FIX(buf.f_bfree)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("block_avail_unpriv")), INT2FIX(buf.f_bavail)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("inodes")), INT2FIX(buf.f_files)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("free_inodes")), INT2FIX(buf.f_ffree)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("filesystem_id")), INT2FIX(buf.f_fsid)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("mount_flags")), INT2FIX(buf.f_flag)) ;
+	rb_hash_aset(hash, ID2SYM(rb_intern("max_filename_length")), INT2FIX(buf.f_namemax)) ;
+
+	return hash ;
+}
+
+void Init_fs_stat() {
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE fs = rb_define_module_under(_linux_stat, "FS") ;
+	rb_define_module_function(fs, "stat", statfs, 1) ;
+}

data/ext/sysconf/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+unless (have_header('sys/unistd.h') && have_header('ruby.h'))
+	abort('Missing header')
+end
+
+create_makefile 'linux_stat/sysconf'

data/ext/sysconf/sysconf.c

@@ -0,0 +1,53 @@
+#include <unistd.h>
+#include "ruby.h"
+
+static VALUE getTick(VALUE obj) {
+	return INT2FIX(sysconf(_SC_CLK_TCK)) ;
+}
+
+static VALUE getChildMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_CHILD_MAX)) ;
+}
+
+static VALUE getHostnameMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_HOST_NAME_MAX)) ;
+}
+
+static VALUE getLoginNameMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_LOGIN_NAME_MAX)) ;
+}
+
+static VALUE getOpenMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_OPEN_MAX)) ;
+}
+
+static VALUE getPageSizeMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_PAGESIZE)) ;
+}
+
+static VALUE getStreamMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_STREAM_MAX)) ;
+}
+
+static VALUE getTTYNameMax(VALUE obj) {
+	return INT2FIX(sysconf(_SC_TTY_NAME_MAX)) ;
+}
+
+static VALUE getPosixVersion(VALUE obj) {
+	return INT2FIX(sysconf(_SC_VERSION)) ;
+}
+
+void Init_sysconf() {
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _sysconf = rb_define_module_under(_linux_stat, "Sysconf") ;
+
+	rb_define_module_function(_sysconf, "sc_clk_tck", getTick, 0) ;
+	rb_define_module_function(_sysconf, "child_max", getChildMax, 0) ;
+	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, "stream_max", getStreamMax, 0) ;
+	rb_define_module_function(_sysconf, "tty_name_max", getTTYNameMax, 0) ;
+	rb_define_module_function(_sysconf, "posix_version", getPosixVersion, 0) ;
+}

data/ext/utsname/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+unless (have_header('sys/utsname.h') && have_header('ruby.h'))
+	abort('Missing header')
+end
+
+create_makefile 'linux_stat/utsname'

data/ext/utsname/utsname.c

@@ -0,0 +1,49 @@
+#include <sys/utsname.h>
+#include "ruby.h"
+#pragma GCC optimize ("O3")
+#pragma clang optimize on
+
+static struct utsname buf ;
+static short status ;
+
+void init_buf() {
+	status = uname(&buf) ;
+}
+
+static VALUE getSysname(VALUE obj) {
+	VALUE sysname = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.sysname) ;
+	return sysname ;
+}
+
+static VALUE getNodename(VALUE obj) {
+	VALUE nodename = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.nodename) ;
+	return nodename ;
+}
+
+static VALUE getRelease(VALUE obj) {
+	VALUE release = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.release) ;
+	return release ;
+}
+
+static VALUE getVersion(VALUE obj) {
+	VALUE version = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.version) ;
+	return version ;
+}
+
+static VALUE getMachine(VALUE obj) {
+	VALUE machine = status < 0 ? rb_str_new_cstr("") : rb_str_new_cstr(buf.machine) ;
+	return machine ;
+}
+
+void Init_utsname() {
+	init_buf() ;
+
+	VALUE _linux_stat = rb_define_module("LinuxStat") ;
+	VALUE _uname = rb_define_module_under(_linux_stat, "Uname") ;
+
+	rb_define_module_function(_uname, "sysname", getSysname, 0) ;
+	rb_define_module_function(_uname, "nodename", getNodename, 0) ;
+	rb_define_module_function(_uname, "release", getRelease, 0) ;
+	rb_define_module_function(_uname, "version", getVersion, 0) ;
+	rb_define_module_function(_uname, "machine", getMachine, 0) ;
+}

data/lib/linux_stat.rb

@@ -1,14 +1,20 @@
 require "linux_stat/version"
-
-module LinuxStat
-end
-
 require "linux_stat/battery"
 require "linux_stat/bios"
 require "linux_stat/cpu"
-require "linux_stat/kernel"
 require "linux_stat/memory"
 require "linux_stat/net"
+
+require 'linux_stat/utsname'
 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"
+
+require "linux_stat/sysconf"
+require "linux_stat/kernel"
+require "linux_stat/process_info"

data/lib/linux_stat/battery.rb

@@ -9,7 +9,7 @@ module LinuxStat
 			end
 
 			# Returns the details of the battery.
-			#If the battery is not present it will return an empty Hash.
+			# If the battery is not present it will return an empty Hash.
 			def stat
 				st = status.downcase
 				return {} unless present?
@@ -27,7 +27,7 @@ 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.
+			# 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!)

data/lib/linux_stat/bios.rb

@@ -3,9 +3,10 @@ module LinuxStat
 		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.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def model
-				# Cached ; as changing the value in runtime is unexpected
+				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@model ||= if File.readable?('/sys/devices/virtual/dmi/id/product_name')
 					IO.read('/sys/devices/virtual/dmi/id/product_name').tap(&:strip!)
 				elsif File.readable?('/sys/firmware/devicetree/base/model')
@@ -17,9 +18,10 @@ module LinuxStat
 
 			# 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.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def vendor
-				# Cached ; as changing the value in runtime is unexpected
+				# cached (memoized) ; as changing the value in runtime is unexpected
 				@@vendor ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_vendor')
 					IO.read('/sys/devices/virtual/dmi/id/bios_vendor').tap(&:strip!)
 				else
@@ -29,7 +31,8 @@ module LinuxStat
 
 			# 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.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def version
 				@@version ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_version')
 					IO.read('/sys/devices/virtual/dmi/id/bios_version').tap(&:strip!)
@@ -40,7 +43,8 @@ module LinuxStat
 
 			# 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.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def date
 				@@date ||= if File.readable?('/sys/devices/virtual/dmi/id/bios_date')
 					IO.read('/sys/devices/virtual/dmi/id/bios_date').tap(&:strip!)

data/lib/linux_stat/cpu.rb

@@ -1,7 +1,9 @@
 module LinuxStat
 	module CPU
 		class << self
-			# Returns the cpu usage of all threads.
+			# stat(sleep = 0.075)
+			# Where sleep is the delay to gather the data.
+			# This method 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.
@@ -17,7 +19,14 @@ module LinuxStat
 				sleep(sleep)
 				data2 = IO.readlines('/proc/stat').select! { |x| x[/^cpu\d*/] }.map! { |x| x.split.map!(&:to_f) }
 
-				data.size.times.reduce({}) do |h, x|
+				# On devices like android, the core count can change anytime.
+				# I had crashes on Termux.
+				# So better just count the min number of CPU and iterate over that
+				# If data.length is smaller than data2.length, we don't have enough data to compare.
+				dl, d2l = data.length, data2.length
+				min = dl > d2l ? d2l : dl
+
+				min.times.reduce({}) do |h, x|
 					user, nice, sys, idle, iowait, irq, softirq, steal = *data[x].drop(1)
 					user2, nice2, sys2, idle2, iowait2, irq2, softirq2, steal2 = *data2[x].drop(1)
 
@@ -30,7 +39,10 @@ module LinuxStat
 				end
 			end
 
-			# Returns the total cpu usage.
+			# total_usage(sleep = 0.075)
+			# Where sleep is the delay to gather the data.
+			# 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.
@@ -58,7 +70,8 @@ module LinuxStat
 
 			# 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.
+			#
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def model
 				@@name ||= cpuinfo.find { |x| x.start_with?('model name') }.to_s.split(?:)[-1].to_s.strip
 			end
@@ -67,14 +80,26 @@ module LinuxStat
 			# If the information isn't available, it will return an empty array.
 			def cur_freq
 				@@cpu_freqs ||= Dir["/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq"]
-				@@cpu_freqs.map { |x| IO.read(x).to_i }
+				@@cur_freqs_readable ||= @@cpu_freqs.all?(&File.method(:readable?))
+
+				if @@cur_freqs_readable
+					@@cpu_freqs.map { |x| IO.read(x).to_i }
+				else
+					[]
+				end
 			end
 
 			# 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
 				@@max_freqs ||= Dir["/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_max_freq"]
-				@@max_freqs.map { |x| IO.read(x).to_i }
+				@@max_freqs_readable ||= @@max_freqs.all?(&File.method(:readable?))
+
+				if @@max_freqs_readable
+					@@max_freqs.map { |x| IO.read(x).to_i }
+				else
+					[]
+				end
 			end
 
 			alias usages stat

data/lib/linux_stat/filesystem.rb

@@ -0,0 +1,92 @@
+module LinuxStat
+	module Filesystem
+		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
+
+			# total(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
+
+			# free(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
+
+			# used(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
+
+			# available(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_raw(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)
+				LinuxStat::FS.stat(fs)
+			end
+		end
+	end
+end

data/lib/linux_stat/kernel.rb

@@ -3,7 +3,7 @@ module LinuxStat
 		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.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def version
 				return ''.freeze if string.empty?
 				@@version ||= splitted[2]
@@ -11,7 +11,7 @@ module LinuxStat
 
 			# 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.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def build_user
 				@@build_user ||= string.split(/(\(.+\))/).each(&:strip!)
 					.reject(&:empty?).find { |x| x[/^\(.+\)$/] }.to_s
@@ -20,7 +20,7 @@ module LinuxStat
 
 			# 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.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def compiler
 				return ''.freeze if string.empty?
 
@@ -39,7 +39,7 @@ module LinuxStat
 
 			# 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.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def compiler_version
 				@@compiler_version ||= string.split(/(\(.+?\))/).each(&:strip!)
 					.reject(&:empty?)[2..4].to_a
@@ -62,7 +62,7 @@ module LinuxStat
 			# 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.
+			# The output is also cached  (memoized) ; as changing the value in runtime is unexpected.
 			def build_date
 				return nil if splitted.empty?
 
@@ -107,7 +107,7 @@ module LinuxStat
 			# 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.
+			# The output is also cached (memoized) ; as changing the value in runtime is unexpected.
 			def build_date_string
 				return nil if splitted.empty?
 
@@ -133,12 +133,23 @@ 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
 				@@string ||= File.readable?('/proc/version') ? IO.read('/proc/version', 1024).tap(&:strip!) : ''
 			end
 
+			# Returns the sc_clk_tck or the same output from command `getconf CLK_TCK`.
+			# Also, clk_tck is an alias of this method.
+			# The output is also cached ; as changing the value in runtime is unexpected.
+			def ticks
+				@@tick ||= LinuxStat::Sysconf.sc_clk_tck
+			end
+
+			alias clk_tck ticks
+
 			private
 			def splitted
 				@@string_splitted ||= string.split