linux_stat 0.7.4 → 1.0.0

data/lib/linux_stat/os.rb

@@ -121,7 +121,7 @@ module LinuxStat
 					hour: h,
 					minute: m,
 					second: s
-				}
+				}.freeze
 			end
 
 			private
@@ -143,7 +143,7 @@ module LinuxStat
 			end
 
 			def uptime_readable?
-				@@uptime_readable = File.readable?('/proc/uptime')
+				@@uptime_readable ||= File.readable?('/proc/uptime')
 			end
 		end
 	end

data/lib/linux_stat/prettify_bytes.rb

@@ -100,10 +100,7 @@ module LinuxStat
 
 			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
+				sprintf("%.#{mantissa_length}f".freeze, n)
 			end
 		end
 	end

data/lib/linux_stat/process.rb

@@ -6,7 +6,7 @@ module LinuxStat
 			#
 			# The return type is an Array of Integers.
 			def list
-				Dir['/proc/*'].select! { |x|
+				Dir['/proc/*'].select { |x|
 					pid = File.split(x)[1]
 					pid.to_i.to_s == pid
 				}.map! { |x| File.split(x)[-1].to_i }

data/lib/linux_stat/process_info.rb

@@ -203,13 +203,13 @@ module LinuxStat
 			end
 
 			##
-			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# 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 LinuxStat::Sysconf.sc_clk_tck
 			#
-			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck.
+			# The smallest amount of available sleep time is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5.
 			#
 			# * Note 1:
 			# 1. Do note that the sleep time can slow down your application.
@@ -244,20 +244,22 @@ module LinuxStat
 			# Only use this method if you need all of the data at once, in such case, it's more efficient to use this method.
 			#
 			# The :last_executed_cpu also returns an Integer indicating the last executed cpu of the process.
-			def cpu_stat(pid: $$, sleep: ticks_to_ms)
+			def cpu_stat(pid: $$, sleep: ticks_to_ms_t5)
 				file = "/proc/#{pid}/stat"
-				return {} unless File.readable?(file)
-
 				ticks = get_ticks
 
+				return {} unless File.readable?(file)
 				utime, stime, starttime = IO.read(file)
 					.split.values_at(13, 14, 21).map(&:to_f)
+
 				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
 
 				total_time = utime + stime
 				idle1 = uptime - starttime - total_time
 
 				sleep(sleep)
+
+				return {} unless File.readable?(file)
 				stat = IO.read(file).split
 
 				utime2, stime2, starttime2 = stat.values_at(13, 14, 21).map(&:to_f)
@@ -267,25 +269,25 @@ module LinuxStat
 				idle2 = uptime - starttime2 - total_time2
 
 				totald = idle2.+(total_time2).-(idle1 + total_time)
-				cpu = totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+				cpu_u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
 
 				{
-					cpu_usage: cpu,
+					cpu_usage: cpu_u > 100 ? 100.0 : cpu_u.round(2),
 					threads: stat[19].to_i,
 					last_executed_cpu: stat[38].to_i
 				}
 			end
 
 			##
-			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# = cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
 			#
 			# 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 1.0 / LinuxStat::Sysconf.sc_clk_tck
+			# By default it is the id of the current process ($$), and sleep is 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
 			#
 			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
 			#
-			# It retuns the CPU usage in Float.
+			# It retuns the CPU usage as Float.
 			#
 			# For example:
 			#
@@ -293,19 +295,75 @@ module LinuxStat
 			#
 			#    => 10.0
 			#
+			# 10.0 means it's using 10% of the total processing power of the system.
+			#
+			# The value is divided with the configured number of CPU and not online CPU.
+			#
 			# A value of 100.0 indicates it is using 100% processing power available to the system.
 			#
 			# 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: ticks_to_ms)
+			def cpu_usage(pid: $$, sleep: ticks_to_ms_t5)
 				file = "/proc/#{pid}/stat"
+				ticks = get_ticks
+
 				return nil unless File.readable?(file)
+				utime, stime, starttime = IO.read(file)
+					.split.values_at(13, 14, 21).map(&:to_f)
+
+				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+
+				total_time = utime + stime
+				idle1 = uptime - starttime - total_time
+
+				sleep(sleep)
 
+				return nil unless File.readable?(file)
+				utime2, stime2, starttime2 = IO.read(file)
+					.split.values_at(13, 14, 21).map(&:to_f)
+
+				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
+
+				total_time2 = utime2 + stime2
+				idle2 = uptime - starttime2 - total_time2
+
+				totald = idle2.+(total_time2).-(idle1 + total_time)
+
+				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)./(cpu_count)
+				u > 100 ? 100.0 : u.round(2)
+			end
+
+			##
+			# = thread_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5)
+			#
+			# 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 1.0 / LinuxStat::Sysconf.sc_clk_tck * 5
+			#
+			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
+			#
+			# It retuns the per core CPU usage as Float.
+			#
+			# For example:
+			#
+			#    LinuxStat::ProcessInfo.core_usage
+			#
+			#    => 200.0
+			#
+			# A value of 100.0 indicates it is using 100% processing power of a core.
+			#
+			# The value could be 0 to (100 * the number of CPU threads (including hyperthreading) in the system)
+			#
+			# But if the info isn't available, it will return nil.
+			def thread_usage(pid: $$, sleep: ticks_to_ms_t5)
+				file = "/proc/#{pid}/stat"
 				ticks = get_ticks
 
+				return nil unless File.readable?(file)
 				utime, stime, starttime = IO.read(file)
 					.split.values_at(13, 14, 21).map(&:to_f)
+
 				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
 
 				total_time = utime + stime
@@ -313,15 +371,21 @@ module LinuxStat
 
 				sleep(sleep)
 
+				return nil unless File.readable?(file)
 				utime2, stime2, starttime2 = IO.read(file)
 					.split.values_at(13, 14, 21).map(&:to_f)
+
 				uptime = IO.read('/proc/uptime'.freeze).to_f * ticks
 
 				total_time2 = utime2 + stime2
 				idle2 = uptime - starttime2 - total_time2
 
 				totald = idle2.+(total_time2).-(idle1 + total_time)
-				totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+
+				u = totald.-(idle2 - idle1).fdiv(totald).abs.*(100)
+
+				cpu_count_t100 = cpu_count * 100
+				u > cpu_count_t100 ? cpu_count_t100 : u.round(2)
 			end
 
 			##
@@ -491,7 +555,9 @@ module LinuxStat
 			# For example:
 			#    LinuxStat::ProcessInfo.running_time 14183
 			#
-			#    => 1947.619999999999
+			#    => 1947.61
+			#
+			# It always rounds the float number upto 2 decimal places
 			#
 			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
 			def running_time(pid = $$)
@@ -501,7 +567,8 @@ module LinuxStat
 				@@u_readable ||= File.readable?(uptime)
 				return nil unless @@u_readable && File.readable?(stat_file)
 
-				IO.foreach(uptime, ' '.freeze).next.to_f - (IO.read(stat_file).split[21].to_i / get_ticks)
+				IO.foreach(uptime, ' '.freeze).next.to_f
+					.-(IO.read(stat_file).split[21].to_f / get_ticks).round(2)
 			end
 
 			##
@@ -544,18 +611,57 @@ module LinuxStat
 				IO.foreach(file, ' ').first(19)[-1].to_i
 			end
 
+			##
+			# = nproc(pid = $$)
+			# Returns the cpu allocated to the process.
+			#
+			# The output value is an Integer.
+			#
+			# For example:
+			#    $ taskset -c 0 irb
+			#
+			#    irb(main):001:0> require 'linux_stat'
+			#
+			#    => true
+			#
+			#    irb(main):002:0> LinuxStat::ProcessInfo.nproc
+			#
+			#    => 1
+			#
+			#    irb(main):003:0> LinuxStat::ProcessInfo.nproc 11562
+			#
+			#    => 3
+			#
+			#    irb(main):004:0> LinuxStat::ProcessInfo.nproc 12513
+			#
+			#    => 4
+			#
+			# If the info isn't available or the argument passed doesn't exist as a process ID, it will return nil.
+			def nproc(pid = $$)
+				LinuxStat::Nproc.count_cpu_for_pid(pid)
+			end
+
+			alias count_cpu nproc
+
 			private
 			def get_ticks
-				@@ticks ||= Sysconf.sc_clk_tck
+				@@sc_clk_tck ||= LinuxStat::Sysconf.sc_clk_tck
+				@@ticks ||= @@sc_clk_tck < 1 ? 100 : @@sc_clk_tck
 			end
 
 			# Just to avoid multiple calculations!...
-			def ticks_to_ms
-				@@ms ||= 1.0 / get_ticks
+			# ticks to ms * 5
+			# If ticks is 100, it will return 0.05
+			def ticks_to_ms_t5
+				@@ms_t5 ||= 1.0 / get_ticks * 5
 			end
 
 			def pagesize
-				@@pagesize ||= LinuxStat::Sysconf.pagesize
+				@@pagesize ||= LinuxStat::Sysconf.pagesize.to_i
+			end
+
+			def cpu_count
+				@@nprocessors_conf ||= LinuxStat::CPU.count
 			end
 		end
 	end

data/lib/linux_stat/swap.rb

@@ -117,7 +117,7 @@ module LinuxStat
 				val = IO.readlines('/proc/swaps').drop(1)
 				return [[], []] if val.empty?
 
-				val.map { |x|
+				val.map! { |x|
 					x.strip.split.values_at(2, 3).map!(&:to_i)
 				}.transpose
 			end

data/lib/linux_stat/usb.rb

@@ -0,0 +1,192 @@
+module LinuxStat
+	module USB
+		class << self
+			##
+			# = devices_stat(hwdata: true)
+			#
+			# Returns details about the devices found in /sys/bus/usb/devices/
+			#
+			# The return value is an Array of multiple Hashes. If there's no info available,
+			# it will rather return an empty Array.
+			#
+			# On Android Termux for example, it can not list the directories because they are
+			# not readable the the regular user.
+			#
+			# It can have information like:
+			#
+			# id, vendor id, product id, manufacturer, serial, bus number, dev number,
+			# b_max_power, b_max_packet_size, etc.
+			#
+			# An example of the returned sample from a test machine is:
+			#    LinuxStat::USB.devices_stat
+			#
+			#    [{:path=>"/sys/bus/usb/devices/1-1.2/", :id=>"04d9:1203", :vendor_id=>"04d9", :product_id=>"1203", :bus_num=>1, :dev_num=>4, :hwdata=>{:vendor=>"Holtek Semiconductor, Inc.", :product=>"Keyboard"}, :authorized=>true, :b_max_power=>"100mA", :b_max_packet_size0=>8}
+			#
+			# Right, it's an array of Hashes.
+			#
+			# It also takes one option. The hwdata, which is true by default.
+			#
+			# Information about usb devices is found inside /usr/share/hwdata/usb.ids
+			#
+			# The data contains the vendor and the product.
+			#
+			# If the option is enabled, it will try look at /usr/share/hwdata/usb.ids
+			#
+			# But the file will be read only once. The consecutive calls to this method
+			# won't open the hwdata all the times.
+			#
+			# But if there's no hwdata, the Hash returned by this method will not contain
+			# hwdata key.
+			#
+			# The data is only populated if it's available. For example, if there's no
+			# manufacturer available for the product, the returned Hash will not contain the
+			# information about the manufacturer.
+			#
+			# Also note that if there's no info available or no USB devices, it will return an empty
+			# Hash.
+			def devices_stat(hwdata: true)
+				@@sys_usb_readable ||= File.readable?('/sys/bus/usb/devices/')
+				return [] unless @@sys_usb_readable
+
+				Dir['/sys/bus/usb/devices/*/'.freeze].sort!.map! { |x|
+					id_vendor_file = File.join(x, 'idVendor'.freeze)
+					next unless File.readable?(id_vendor_file)
+					id_vendor = IO.read(id_vendor_file).strip
+
+					id_product_file = File.join(x, 'idProduct'.freeze)
+					next unless File.readable?(id_vendor_file)
+					id_product = IO.read(id_product_file).strip
+
+					bus_num_file = File.join(x, 'busnum'.freeze)
+					bus_num = File.readable?(bus_num_file) ? IO.read(bus_num_file).strip : ''.freeze
+
+					dev_num_file = File.join(x, 'devnum'.freeze)
+					dev_num = File.readable?(dev_num_file) ? IO.read(dev_num_file).strip : ''.freeze
+
+					serial_file = File.join(x, 'serial'.freeze)
+					serial = File.readable?(serial_file) ? IO.read(serial_file).strip : ''.freeze
+
+					product_file = File.join(x, 'product'.freeze)
+					product = File.readable?(product_file) ? IO.read(product_file).strip : ''.freeze
+
+					manufacturer_file = File.join(x, 'manufacturer'.freeze)
+					manufacturer = File.readable?(manufacturer_file) ? IO.read(manufacturer_file).strip : ''.freeze
+
+					removable_file = File.join(x, 'removable'.freeze)
+					removable = File.readable?(removable_file) ? IO.read(removable_file).strip : ''.freeze
+
+					authorized_file = File.join(x, 'authorized'.freeze)
+					authorized = File.readable?(authorized_file) ? IO.read(authorized_file).to_i : ''.freeze
+
+					b_max_power_file = File.join(x, 'bMaxPower'.freeze)
+					b_max_power = File.readable?(b_max_power_file) ? IO.read(b_max_power_file).strip : ''.freeze
+
+					b_max_packet_size0_file = File.join(x, 'bMaxPacketSize0'.freeze)
+					b_max_packet_size0 = File.readable?(b_max_packet_size0_file) ? IO.read(b_max_packet_size0_file).to_i : ''.freeze
+
+					query = hwdata ? query_hwdata(id_vendor, id_product) : {}
+
+					removable.downcase!
+					is_removable = if removable == 'removable'.freeze
+						true
+					elsif removable == 'unknown'.freeze
+						nil
+					else
+						false
+					end
+
+					ret = {
+						path: x, id: "#{id_vendor}:#{id_product}",
+						vendor_id: id_vendor, product_id: id_product
+					}
+
+					ret.merge!(bus_num: bus_num.to_i) unless bus_num.empty?
+					ret.merge!(dev_num: dev_num.to_i) unless dev_num.empty?
+
+					ret.merge!(serial: serial) unless serial.empty?
+
+					ret.merge!(hwdata: query) unless query.empty?
+					ret.merge!(product: product) unless product.empty?
+					ret.merge!(manufacturer: manufacturer) unless manufacturer.empty?
+
+					ret.merge!(removable: is_removable) unless is_removable.nil?
+					ret.merge!(authorized: authorized == 1)
+
+					ret.merge!(b_max_power: b_max_power) unless b_max_power.empty?
+					ret.merge!(b_max_packet_size0: b_max_packet_size0) if b_max_packet_size0
+				}.tap(&:compact!)
+			end
+
+			##
+			# Opens /sys/bus/usb/devices, and counts the total number of
+			# devices connected to the USB interface.
+			# The return type is an integer.
+			#
+			# It checks for devices with vendor and product id file.
+			# If there's no such file, it will not count them as a USB device.
+			#
+			# It could be also an integrated hub or a webcam, as well as
+			# external hotpluggable devices like printer, USB storage devices,
+			# USB mouse, USB keyboard, USB joypad etc.
+			#
+			# But if the information isn't available, it will return nil.
+			def count
+				@@sys_usb_readable ||= File.readable?('/sys/bus/usb/devices/')
+				return [] unless @@sys_usb_readable
+
+				Dir['/sys/bus/usb/devices/*/'.freeze].count { |x|
+					id_vendor_file = File.join(x, 'idVendor'.freeze)
+					id_product_file = File.join(x, 'idProduct'.freeze)
+					File.readable?(id_vendor_file) && File.readable?(id_product_file)
+				}
+			end
+
+			alias count_devices count
+
+			private
+			def hwdata
+				@@hwdata_file ||= "/usr/share/hwdata/usb.ids"
+
+				@@hwdata ||= if File.readable?(@@hwdata_file)
+					file_data = IO.readlines(@@hwdata_file, encoding: 'ASCII-8BIT')
+					ret, vendor_id = {}, nil
+
+					i = -1
+					file_data_size = file_data.size
+
+					while (i += 1) < file_data_size
+						x = file_data[i]
+
+						_lstripped = x.lstrip
+						next if _lstripped == ?#.freeze || _lstripped.empty?
+
+						if x.start_with?(?\t.freeze)
+							data = x.tap(&:strip!)
+							device_id = data[/\A.*?\s/].to_s.strip
+							device = data[device_id.length..-1].to_s.strip
+							ret[vendor_id][1][device_id] = device
+						else
+							data = x
+							vendor_id = data[/\A.*?\s/].to_s.strip
+							vendor = data[vendor_id.length..-1].to_s.strip
+							ret[vendor_id] = [vendor, {}]
+						end
+					end
+
+					ret.freeze
+				else
+					{}
+				end
+			end
+
+			def query_hwdata(vendor_id, product_id)
+				vendor = hwdata[vendor_id]
+				if vendor
+					{vendor: vendor[0], product: vendor[1][product_id]}
+				else
+					{}
+				end
+			end
+		end
+	end
+end