Module: LinuxStat::Net

Defined in:
lib/linux_stat/net.rb

Overview

Shows various Net related information of the current system.

Constant Summary collapse

DEV = 
'/proc/net/dev'.freeze

Class Method Summary collapse

Class Method Details

.ipv4_private ⇒ Object

Returns the local IP address of the system as a String.

If the information isn’t available, it will a frozen empty string.



12
13
14
15
16
 
# File 'lib/linux_stat/net.rb', line 12

def ipv4_private
	require 'socket' unless defined?(Socket)
	ip = Socket.ip_address_list.find(&:ipv4_private?)
	ip ? ip.ip? ? ip.ip_unpack[0].freeze : ''.freeze : ''.freeze
end

.total_bytes ⇒ Object

Returns the total bytes received and transmitted as Hash.

For example:

LinuxStat::Net.usage

=> {:received=>56602867, :transmitted=>6940922}

But if the status isn’t available it will return an empty Hash.



27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/linux_stat/net.rb', line 27

def total_bytes
	return {} unless File.readable?(DEV)

	data = IO.readlines(DEV).drop(2)
	indices = find_index_of_bytes
	data.reject! { |x| x.strip.start_with?('lo:') }
	r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }

	{
		received: r,
		transmitted: t
	}
end

.total_bytes_received ⇒ Object

Returns the total bytes received as Integer.

But if the status isn’t available it will return nil.



45
46
47
48
49
50
51
52
 
# File 'lib/linux_stat/net.rb', line 45

def total_bytes_received
	return nil unless File.readable?(DEV)

	data = IO.readlines(DEV).drop(2)
	index = find_index_of_bytes[0]
	data.reject! { |x| x.strip.start_with?('lo:') }
	data.map { |x| x.split[index].to_i }.reduce(:+)
end

.total_bytes_transmitted ⇒ Object

Returns the total bytes transmitted as Integer.

But if the status isn’t available it will return nil.



58
59
60
61
62
63
64
65
 
# File 'lib/linux_stat/net.rb', line 58

def total_bytes_transmitted
	return nil unless File.readable?(DEV)

	data = IO.readlines(DEV).drop(2)
	index = find_index_of_bytes[-1]
	data.reject! { |x| x.strip.start_with?('lo:') }
	data.map { |x| x.split[index].to_i }.reduce(:+)
end

.usage(interval = 0.1) ⇒ Object Also known as: current_usage

usage(interval = 0.1)

Where interval is the time between polling in seconds. The default is 0.1 seconds.

The return type is a Hash, containg the current internet usage (received, transmit) in B/s.

For example:

LinuxStat::Net.usage

=> {:received=>436060.0, :transmitted=>50350.0}

If the system transmits 100 kb in the interval,

this method will return 1000 kb/s. That is, it estimates

the data it will transmit in one second. Thus, a good and reliable interval is 1 second

It will return an empty Hash if the info (/proc/net/dev) isn’t available.



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/linux_stat/net.rb', line 86

def usage(interval = 0.1)
	return {} unless File.readable?(DEV)

	data = IO.readlines(DEV).drop(2)
	indices = find_index_of_bytes
	data.reject! { |x| x.strip.start_with?('lo:'.freeze) }
	r, t = data.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }

	sleep(interval)

	data2 = IO.readlines(DEV).drop(2)
	data2.reject! { |x| x.strip.start_with?('lo:'.freeze) }
	r2, t2 = data2.map { |x| x.split.values_at(*indices).map(&:to_i) }.transpose.map { |x| x.reduce(:+) }

	# Measure the difference
	dr, dt = r2.-(r).fdiv(interval), t2.-(t).fdiv(interval)

	{
		received: dr,
		transmitted: dt
	}
end