linux_stat 0.3.3 → 0.6.1

data/lib/linux_stat/process_info.rb

@@ -0,0 +1,381 @@
+module LinuxStat
+	module ProcessInfo
+		class << self
+			# total_io(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the total read/write caused by a process.
+			# The output is Hash. For example, a sample output:
+			#    {:read_bytes=>0, :write_bytes=>0}
+			#
+			# The output is only based on the total disk IO the process has done.
+			#
+			# If the info isn't available it will return an empty Hash.
+			def total_io(pid = $$)
+				return {} unless File.readable?("/proc/#{pid}/io".freeze)
+				out = {}
+
+				IO.readlines("/proc/#{pid}/io".freeze).each { |x|
+					x.strip!
+
+					if x[/^(read|write)_bytes:\s*\d*$/]
+						splitted = x.split
+						out.merge!(splitted[0].split(?:)[0].to_sym => splitted[-1].to_i)
+					end
+				}
+
+				out
+			end
+
+			# cmdline(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the total command of the process.
+			# The output is String. For example, a sample output:
+			#    "ruby -r linux_stat -e p LinuxStat::ProcessInfo.cmdline"
+			#
+			# If the info isn't available it will return an empty frozen String.
+			def cmdline(pid = $$)
+				file = "/proc/#{pid}/cmdline".freeze
+				return ''.freeze unless File.readable?(file)
+
+				_cmdline = IO.read(file)
+				_cmdline.gsub!(?\u0000, ?\s)
+				_cmdline.tap(&:strip!)
+			end
+
+			# command_name(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the total command name of the process.
+			# The output is String. For example, a sample output:
+			#    "ruby"
+			#
+			# If the info isn't available it will return an empty frozen String.
+			def command_name(pid = $$)
+				# Do note that the /proc/ppid/comm may not contain the full name
+				file = "/proc/#{pid}/cmdline".freeze
+				return ''.freeze unless File.readable?(file)
+
+				_cmdline = IO.read(file)
+				_cmdline.gsub!(?\u0000, ?\s)
+				File.split(_cmdline.tap(&:strip!).split[0])[-1]
+			end
+
+			# mem_stat(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the memory, virtual memory, and resident memory of the process.
+			# All values are in Kilobytes.
+			#
+			# The output is a Hash. For example, a sample output:
+			#    {:memory=>8656, :virtual_memory=>78272, :resident_memory=>14072}
+			#
+			# Note:
+			# If you need only memory usage of a process, run LinuxStat::ProcessInfo.memory(pid)
+			# If you need only virtual memory for a process, run LinuxStat::ProcessInfo.virtual_memory(pid)
+			# If you need only resident memory of a process, run LinuxStat::ProcessInfo.resident_memory(pid)
+			#
+			# This method opens opens multiple files.
+			# But if you need all of the info, then running this method once is efficient.
+			#
+			# If the info isn't available it will return an empty Hash.
+			def mem_stat(pid = $$)
+				stat_file = "/proc/#{pid}/stat".freeze
+				status_file = "/proc/#{pid}/status".freeze
+
+				stat = if File.readable?(stat_file)
+					IO.read(stat_file).split
+				else
+					[]
+				end
+
+				status = if File.readable?(status_file)
+					IO.readlines(status_file)
+				else
+					[]
+				end
+
+				_rss_anon = status.find { |x| x.start_with?('RssAnon') }
+				rss_anon = _rss_anon ? _rss_anon.split[1].to_i : nil
+
+				_virtual_memory = stat[22]
+				vm = _virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
+
+				_vm_rss = status.find { |x| x.start_with?('VmRSS') }
+				vm_rss = _vm_rss ? _vm_rss.split[1].to_i : nil
+
+				{
+					memory: rss_anon,
+					virtual_memory: vm,
+					resident_memory: vm_rss
+				}
+			end
+
+			# memory(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the memory of the process.
+			# The value is in Kilobytes.
+			# The output is an Integer. For example, a sample output:
+			#    8664
+			#
+			# If the info isn't available it will return nil.
+			def memory(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				_rss_anon = IO.readlines(file).find { |x| x.start_with?('RssAnon') }
+				_rss_anon ? _rss_anon.split[1].to_i : nil
+			end
+
+			# virtual_memory(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the virtual memory for the process.
+			# The value is in Kilobytes.
+			# The output is an Integer. For example, a sample output:
+			#    78376
+			#
+			# If the info isn't available it will return nil.
+			def virtual_memory(pid = $$)
+				file = "/proc/#{pid}/stat".freeze
+				return nil unless File.readable?(file)
+
+				_virtual_memory = IO.read(file).split[22]
+				_virtual_memory ? _virtual_memory.to_i.fdiv(1024).to_i : nil
+			end
+
+			# resident_memory(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the resident memory for the process.
+			# The value is in Kilobytes.
+			# The output is an Integer. For example, a sample output:
+			#    14012
+			#
+			# If the info isn't available it will return nil.
+			def resident_memory(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				_vm_rss = IO.readlines(file)
+					.find { |x| x.start_with?('VmRSS') }
+
+				_vm_rss ? _vm_rss.split[1].to_i : nil
+			end
+
+			# cpu_stat(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# 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.
+			#
+			# Note 1:
+			# Do note that the sleep time can slow down your application.
+			# And it's only needed for the cpu usage calculation.
+			#
+			# It retuns the CPU usage, threads, and the last executed CPU in Hash.
+			# For example:
+			#    {:cpu_usage=>0.0, :threads=>1, :last_executed_cpu=>1}
+			#
+			# But if the info isn't available, it will return an empty Hash.
+			#
+			# The :cpu_usage is in percentage. It's also divided with the number
+			# of CPU. :cpu_usage for example, will return 25.0 if the CPU count
+			# is 4, and the process is using 100% of a thread / core.
+			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# The :threads returns the number of threads for the process.
+			# The value is a Integer.
+			#
+			# Note 2:
+			# If you just need the CPU usage run LinuxStat::ProcessInfo.cpu_usage(pid = $$)
+			# If you just need the threads run LinuxStat::ProcessInfo.threads(pid = $$)
+			# If you just need the last executed CPU run LinuxStat::ProcessInfo.last_executed_cpu(pid = $$)
+			# Running this method is slower and it opens multiple files at once
+			#
+			# 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)
+				file = "/proc/#{pid}/stat"
+				return {} unless File.readable?(file)
+
+				ticks = get_ticks
+
+				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)
+				stat = IO.read(file).split
+
+				utime2, stime2, starttime2 = stat.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)
+				cpu = totald.-(idle2 - idle1).fdiv(totald).*(100).round(2).abs./(LinuxStat::CPU.count)
+
+				{
+					cpu_usage: cpu,
+					threads: stat[19].to_i,
+					last_executed_cpu: stat[38].to_i
+				}
+			end
+
+			# cpu_usage(pid: $$, sleep: 1.0 / LinuxStat::Sysconf.sc_clk_tck)
+			# 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
+			# The smallest amount of available sleep time is LinuxStat::Sysconf.sc_clk_tck.
+			#
+			# It retuns the CPU usage in Float.
+			# For example:
+			#    10.0
+			# A value of 100.0 indicates it is using 100% processing power.
+			#
+			# 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)
+				file = "/proc/#{pid}/stat"
+				return nil unless File.readable?(file)
+
+				ticks = get_ticks
+
+				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)
+
+				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)
+			end
+
+			# threads(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the threads for the current process in Integer.
+			# For example:
+			#    1
+			# But if the info isn't available, it will return nil.
+			#
+			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
+			def threads(pid = $$)
+				file = "/proc/#{pid}/stat".freeze
+				return nil unless File.readable?(file)
+
+				IO.read(file).split[19].to_i
+			end
+
+			# last_executed_cpu(pid = $$)
+			# Where pid is the process ID.
+			# By default it is the id of the current process ($$)
+			#
+			# It retuns the last executed CPU in Integer.
+			# For example:
+			#    2
+			# But if the info isn't available, it will return nil.
+			#
+			# This method is way more efficient than running LinuxStat::ProcessInfo.cpu_stat()
+			def last_executed_cpu(pid = $$)
+				file = "/proc/#{pid}/stat".freeze
+				return nil unless File.readable?(file)
+
+				IO.read(file).split[38].to_i
+			end
+
+			# uid(pid = $$)
+			# returns the UIDs of the process as an Array of Integers.
+			#
+			# If the info isn't available it returns an empty Array.
+			def uid(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				data = IO.readlines(file.freeze).find { |x|
+					x[/Uid.*\d*/]
+				}.to_s.split.drop(1)
+
+				{
+					real: data[0].to_i,
+					effective: data[1].to_i,
+					saved_set: data[2].to_i,
+					filesystem_uid: data[3].to_i
+				}
+			end
+
+			# gid(pid = $$)
+			# returns the GIDs of the process as an Hash containing the following data:
+			# :real, :effective, :saved_set, :filesystem_uid
+			#
+			# If the info isn't available it returns an empty Hash.
+			def gid(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return nil unless File.readable?(file)
+
+				data = IO.readlines(file.freeze).find { |x|
+					x[/Gid.*\d*/]
+				}.split.drop(1)
+
+				{
+					real: data[0].to_i,
+					effective: data[1].to_i,
+					saved_set: data[2].to_i,
+					filesystem_uid: data[3].to_i
+				}
+			end
+
+			# owner(pid = $$)
+			# Returns the owner of the process
+			# But if the status is not available, it will return an empty frozen String.
+			def owner(pid = $$)
+				file = "/proc/#{pid}/status".freeze
+				return ''.freeze unless File.readable?(file)
+
+				gid = IO.readlines(file.freeze).find { |x|
+					x[/Gid.*\d*/]
+				}.split.drop(1)[2].to_i
+
+				LinuxStat::User.username_by_gid(gid)
+			end
+
+			private
+			def get_ticks
+				@@ticks ||= Sysconf.sc_clk_tck
+			end
+
+			# Just to avoid multiple calculations!...
+			def ticks_to_ms
+				@@ms ||= 1.0 / get_ticks
+			end
+		end
+	end
+end

data/lib/linux_stat/swap.rb

@@ -21,6 +21,7 @@ module LinuxStat
 
 			# Show aggregated used and available swap.
 			# The values are in kilobytes.
+			#
 			# The return type is Hash.
 			# If the info isn't available, the return type is an empty Hash.
 			def stat
@@ -44,6 +45,7 @@ module LinuxStat
 
 			# Show total amount of swap.
 			# The value is in kilobytes.
+			#
 			# The return type is a Integer but if the info isn't available, it will return nil.
 			def total
 				return nil unless swaps_readable?
@@ -52,6 +54,7 @@ module LinuxStat
 
 			# Show total amount of available swap.
 			# The value is in kilobytes.
+			#
 			# The return type is a Integer but if the info isn't available, it will return nil.
 			def available
 				return nil unless swaps_readable?
@@ -61,6 +64,7 @@ module LinuxStat
 
 			# Show total amount of used swap.
 			# The value is in kilobytes.
+			#
 			# The return type is a Integer but if the info isn't available, it will return nil.
 			def used
 				return nil unless swaps_readable?
@@ -79,7 +83,8 @@ module LinuxStat
 				values_t[-1].sum.*(100).fdiv(total).round(2)
 			end
 
-			# Show percentage of swap available.
+			# Shows the percentage of swap available.
+			#
 			# The return type is a Float but if the info isn't available, it will return nil.
 			def percent_available
 				return nil unless swaps_readable?

data/lib/linux_stat/user.rb

@@ -0,0 +1,298 @@
+module LinuxStat
+	module User
+		class << self
+			# Returns an array of users as string
+			# For example:
+			#    ["root", "bin", "daemon", "mail", "ftp", "http", "nobody"]
+			# But if the status isn't available it will return an empty Array.
+			def list
+				return [] unless passwd_readable?
+				passwd.map { |x| x[/.+?:/][0..-2].freeze }
+			end
+
+			# Returns all the Group ids directories as Hash.
+			# For example:
+			#    {:root=>{:uid=>0, :gid=>0}, :bin=>{:uid=>1, :gid=>1}, :daemon=>{:uid=>2, :gid=>2}, :mail=>{:uid=>8, :gid=>12}, :ftp=>{:uid=>14, :gid=>11}}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def ids
+				return {} unless passwd_readable?
+				passwd_splitted.reduce({}) { |h, x|
+					h.merge!(x[0].to_sym => {
+						uid: x[2].to_i, gid: x[3].to_i
+					})
+				}
+			end
+
+			# Returns all the user IDs as Hash.
+			# For example:
+			#    LinuxStat::User.uids
+			#    => {:root=>0, :bin=>1, :daemon=>2, :mail=>8, :ftp=>14}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def uids
+				return {} unless passwd_readable?
+				passwd_splitted.reduce({}) { |h, x|
+					h.merge!(x[0].to_sym => x[2].to_i)
+				}
+			end
+
+			# Returns all the Group identifiers as Hash.
+			# For example:
+			#    LinuxStat::User.gids
+			#    => {:root=>0, :bin=>1, :daemon=>2, :mail=>12, :ftp=>11}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def gids
+				return {} unless passwd_readable?
+				passwd_splitted.reduce({}) { |h, x|
+					h.merge!(x[0].to_sym => x[3].to_i)
+				}
+			end
+
+			# Returns all the home directories as Hash.
+			# For example:
+			#    LinuxStat::User.home_directories
+			#    => {:root=>"/root", :bin=>"/", :daemon=>"/", :mail=>"/var/spool/mail", :ftp=>"/srv/ftp", :http=>"/srv/http", :nobody=>"/"}
+			#
+			# But if the status isn't available it will return an empty Hash.
+			def home_directories
+				return {} unless passwd_readable?
+				passwd.reduce({}) { |h, x|
+					splitted = x.split(?:)
+					h.merge!(splitted[0].to_sym => splitted[5])
+				}
+			end
+
+			# Returns the user ID as integer
+			# It directly calls LinuxStat::Sysconf.get_uid and LinuxStat::Sysconf.get_gid
+			# and then reads /etc/passwd and matches the values with UID and GID.
+			#
+			# It doesn't get affected with the assignment of USER environment variable
+			# If either /etc/passwd is readable or LinuxStat::Sysconf.get_login() is not empty.
+			#
+			# But if /etc/passwd isn't readable (which is weird), it will fall back to sysconf.h's get_login()
+			# It that's not available, like in docker, falls back to ENV['USER].to_s
+			#
+			# Note that this is not cached or memoized so use this at your own processing expense.
+			# It should return the username under most robust circumstances.
+			# But if nothing is available for some reason, it will return an empty String.
+			def get_user
+				unless passwd_readable?
+					_l = LinuxStat::Sysconf.get_login().freeze
+					return _l.empty? ? ENV['USER'.freeze].to_s : _l
+				end
+
+				uid, gid = LinuxStat::Sysconf.get_uid, LinuxStat::Sysconf.get_gid
+
+				username = ''
+				passwd.each { |x|
+					splitted = x.split(?:).freeze
+					if splitted[2].to_i == uid && splitted[3].to_i == gid
+						username = splitted[0]
+						break
+					end
+				}
+				username
+			end
+
+			# Returns the user ID as integer
+			# It directly calls LinuxStat::Sysconf.get_uid
+			def get_uid
+				LinuxStat::Sysconf.get_uid
+			end
+
+			# Returns the group ID as integer
+			# It directly calls LinuxStat::Sysconf.get_uid
+			def get_gid
+				LinuxStat::Sysconf.get_gid
+			end
+
+			# Returns the effective user ID as integer
+			# It directly calls LinuxStat::Sysconf.get_euid
+			def get_euid
+				LinuxStat::Sysconf.get_euid
+			end
+
+			# Calls LinuxStat::Sysconf.get_login()
+			# The username is returned as a String.
+			# It doesn't get affected by ENV['USER]
+			#
+			# But if the name isn't available (say inside a container), it will return an empty String.
+			# This is meant for speed but not for reliability.
+			# To get more reliable output, you might try LinuxStat::User.get_user()
+			def get_login
+				LinuxStat::Sysconf.get_login
+			end
+
+			# def usernames_by_uid(gid = get_uid)
+			# Where uid is the group id of the user. By default it's the uid of the current user.
+			#
+			# It returns an Array containing the username corresponding to the uid.
+			#
+			# For example:
+			#    LinuxStat::User.usernames_by_uid(1001)
+			#    => ["userx", "usery"]
+			#
+			# But if the info isn't available it will return an empty Array.
+			def usernames_by_uid(uid = get_uid)
+				return [] unless passwd_readable?
+
+				usernames = []
+				passwd_splitted.each { |x|
+					usernames << x[0] if x[2].to_i == uid
+				}
+				usernames
+			end
+
+			# def username_by_gid(gid = get_gid)
+			# Where gid is the group id of the user. By default it's the gid of the current user.
+			#
+			# It returns a String cotaining the username corresponding to the gid
+			# But if the info isn't available it will return an empty frozen String.
+			def username_by_gid(gid = get_gid)
+				return ''.freeze unless passwd_readable?
+
+				username = ''
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					if splitted[2].to_i == gid
+						username = splitted[0]
+						break
+					end
+				end
+				username
+			end
+
+			# gid_by_username(username = get_user)
+			# Where username is the username to look for, by default it is the current user.
+			#
+			# It returns the gid by the username.
+			# For example:
+			#    LinuxStat::User.gid_by_username('root')
+			#    => "0"
+			#
+			# The return type is Integer.
+			# But if user passed doesn't exist or if the info isn't available, it will return nil.
+			def gid_by_username(username = get_user)
+				return nil unless passwd_readable?
+
+				gid = nil
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					if splitted[0] == username
+						gid = splitted[3].to_i
+						break
+					end
+				end
+				gid
+			end
+
+			# uid_by_username(username = get_user)
+			# Where username is the username to look for, by default it is the current user.
+			#
+			# It returns the uid by the username.
+			# For example:
+			#    LinuxStat::User.uid_by_username('root')
+			#    => 0
+			#
+			# The return type is Integer.
+			# But if user passed doesn't exist or if the info isn't available, it will return nil.
+			def uid_by_username(username = get_user)
+				return nil unless passwd_readable?
+
+				uid = nil
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					if splitted[0] == username
+						uid = splitted[2].to_i
+						break
+					end
+				end
+				uid
+			end
+
+			# home_by_username(user = get_user)
+			# Where user is the name of the user.
+			# Returns the user's home. By default it returns the home of the current user.
+			#
+			# If the info isn't available, it will return ENV['HOME].to_s.freeze
+			def home_by_username(user = get_user)
+				return ENV['HOME'].to_s.freeze unless passwd_readable?
+
+				home = ''
+				passwd.each { |x|
+					splitted = x.split(?:)
+					if splitted[0] == user
+						home = splitted[5]
+						break
+					end
+				}
+				home
+			end
+
+			# home_by_uid(id = get_uid)
+			# Gets all the users home directory with user id.
+			# It returns an Array in this format:
+			#    LinuxStat::User.homes_by_uid(1001)
+			#    => ["/home/userx", "/home/usery"]
+			#
+			# Assuming both the users share same UID.
+			#
+			# If the info isn't available, it will return an empty Array.
+			def homes_by_uid(id = get_uid)
+				return [] unless passwd_readable?
+
+				home = []
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+					home << splitted[5] if splitted[2].to_i == id
+				end
+				home
+			end
+
+			# home_by_gid(id = get_uid)
+			# Gets the home of the user corresponding to the GID.
+			# It returns a String in this format:
+			#
+			# Assuming both the users share same UID.
+			#
+			# If the info isn't available, it will return an empty frozen String.
+			def home_by_gid(id = get_gid)
+				return ''.freeze unless passwd_readable?
+
+				home = ''
+				passwd.each do |x|
+					splitted = x.split(?:.freeze)
+
+					if splitted[3].to_i == id
+						home = splitted[5]
+						break
+					end
+				end
+				home
+			end
+
+			alias get_current_user get_user
+
+			private
+			def passwd
+				@@passwd_file ||= '/etc/passwd'.freeze
+				IO.readlines(@@passwd_file)
+			end
+
+			# Only use this method where we are sure that the whole array is going to be used.
+			# In cases like find() or a loop with `break` this is a lot of overhead.
+			# In cases like reduce({}) or select, this is not helpful.
+			def passwd_splitted
+				@@passwd_file ||= '/etc/passwd'.freeze
+				IO.readlines(@@passwd_file).map { |x| x.split(?:.freeze) }
+			end
+
+			def passwd_readable?
+				@@passwd_file ||= '/etc/passwd'.freeze
+				@@passwd_readable ||= File.readable?(@@passwd_file)
+			end
+		end
+	end
+end