module Eye::Process::System

Public Instance Methods

clear_pid_file(check_content = false) click to toggle source
# File lib/eye/process/system.rb, line 20
def clear_pid_file(check_content = false)
  return if check_content && self.pid && load_pid_from_file != self.pid
  info "delete pid_file: #{self[:pid_file_ex]}"
  File.unlink(self[:pid_file_ex])
  true
rescue
  nil
end
compare_identity(pid = self.pid) click to toggle source
# File lib/eye/process/system.rb, line 39
def compare_identity(pid = self.pid)
  return :ok unless self[:check_identity]
  return :no_pid unless pid
  id = get_identity
  return :no_pid_file unless id
  st = Eye::SystemResources.start_time(pid)
  return :no_start_time unless st
  st1 = st.to_i
  id1 = id.to_i
  if (id1 - st1).abs > self[:check_identity_grace]
    args = Eye::SystemResources.args(pid)
    msg = "pid_file: '#{Eye::Utils.human_time2(id)}', process: '#{Eye::Utils.human_time2(st)}' (#{args})"
    res = id1 < st1 ? :fail : :touched
    warn "compare_identity: #{res}, #{msg}"
    res
  else
    :ok
  end
end
daemonize(cmd, cfg = {}) click to toggle source
# File lib/eye/process/system.rb, line 97
def daemonize(cmd, cfg = {})
  Eye::System.daemonize(cmd, cfg)
end
execute(cmd, cfg = {}) click to toggle source
# File lib/eye/process/system.rb, line 91
def execute(cmd, cfg = {})
  defer { Eye::System.execute cmd, cfg }.tap do |res|
    notify(:debug, "Bad exit status of command #{cmd.inspect}(#{res[:exitstatus].inspect})") if res[:exitstatus] != 0
  end
end
execute_async(cmd, opts = {}) click to toggle source
# File lib/eye/process/system.rb, line 107
def execute_async(cmd, opts = {})
  daemonize(cmd, self.config.merge(opts)).tap do |res|
    info "execute_async `#{cmd}` with res: #{res}"
  end
end
execute_sync(cmd, opts = { timeout: 1.second }) click to toggle source
# File lib/eye/process/system.rb, line 101
def execute_sync(cmd, opts = { timeout: 1.second })
  execute(cmd, self.config.merge(opts)).tap do |res|
    info "execute_sync `#{cmd}` with res: #{res}"
  end
end
expand_path(path) click to toggle source
# File lib/eye/process/system.rb, line 132
def expand_path(path)
  File.expand_path(path, self[:working_dir])
end
failsafe_load_pid() click to toggle source
# File lib/eye/process/system.rb, line 113
def failsafe_load_pid
  pid = load_pid_from_file

  unless pid # this is can be symlink changed case
    sleep 0.1
    pid = load_pid_from_file
  end

  pid if pid && pid > 0
end
failsafe_save_pid() click to toggle source
# File lib/eye/process/system.rb, line 124
def failsafe_save_pid
  save_pid_to_file
  true
rescue => ex
  log_ex(ex)
  false
end
get_identity() click to toggle source
# File lib/eye/process/system.rb, line 33
def get_identity
  File.mtime(self[:pid_file_ex])
rescue Errno::ENOENT
  nil
end
load_pid_from_file() click to toggle source
# File lib/eye/process/system.rb, line 5
def load_pid_from_file
  File.read(self[:pid_file_ex]).to_i rescue nil
end
pid_file_ctime() click to toggle source
# File lib/eye/process/system.rb, line 29
def pid_file_ctime
  File.ctime(self[:pid_file_ex]) rescue Time.now
end
process_pid_running?(pid) click to toggle source
# File lib/eye/process/system.rb, line 63
def process_pid_running?(pid)
  Eye::System.pid_alive?(pid)
end
process_really_running?() click to toggle source
# File lib/eye/process/system.rb, line 59
def process_really_running?
  process_pid_running?(self.pid)
end
save_pid_to_file() click to toggle source
# File lib/eye/process/system.rb, line 9
def save_pid_to_file
  if self.pid
    File.open(self[:pid_file_ex], 'w') do |f|
      f.write self.pid
    end
    true
  else
    false
  end
end
send_signal(code) click to toggle source
# File lib/eye/process/system.rb, line 67
def send_signal(code)
  res = Eye::System.send_signal(self.pid, code)

  msg = "send_signal #{code} to <#{self.pid}>"
  msg += ", error<#{res[:error]}>" if res[:error]
  info msg

  res[:result] == :ok
end
wait_for_condition(timeout, step = 0.1) { || ... } click to toggle source
# File lib/eye/process/system.rb, line 77
def wait_for_condition(timeout, step = 0.1, &_block)
  res = nil
  sumtime = 0

  loop do
    tm = Time.now
    res = yield # note that yield can block actor here and timeout can be overhead
    return res if res
    sleep step.to_f
    sumtime += (Time.now - tm)
    return false if sumtime > timeout
  end
end