Module: Bluepill::System
Overview
This class represents the system that bluepill is running on.. It’s mainly used to memoize results of running ps auxx etc so that every watch in the every process will not result in a fork
Constant Summary collapse
- APPEND_MODE =
"a"
- IDX_MAP =
The position of each field in ps output
{ :pid => 0, :ppid => 1, :pcpu => 2, :rss => 3 }
Instance Method Summary collapse
- #can_write_pid_file(pid_file, logger) ⇒ Object
- #cpu_usage(pid) ⇒ Object
-
#daemonize(cmd, options = {}) ⇒ Object
Returns the pid of the child that executes the cmd.
-
#drop_privileges(uid, gid, supplementary_groups) ⇒ Object
be sure to call this from a fork otherwise it will modify the attributes of the bluepill daemon.
-
#execute_blocking(cmd, options = {}) ⇒ Object
Returns the stdout, stderr and exit code of the cmd.
- #get_children(parent_pid) ⇒ Object
- #memory_usage(pid) ⇒ Object
- #pid_alive?(pid) ⇒ Boolean
- #ps_axu ⇒ Object
- #redirect_io(io_in, io_out, io_err) ⇒ Object
- #reset_data ⇒ Object
- #store ⇒ Object
Instance Method Details
#can_write_pid_file(pid_file, logger) ⇒ Object
214 215 216 217 218 219 220 221 222 223 |
# File 'lib/bluepill/system.rb', line 214 def can_write_pid_file(pid_file, logger) FileUtils.touch(pid_file) File.unlink(pid_file) return true rescue Exception => e logger.warning "%s - %s" % [e.class.name, e.] e.backtrace.each {|l| logger.warning l} return false end |
#cpu_usage(pid) ⇒ Object
29 30 31 |
# File 'lib/bluepill/system.rb', line 29 def cpu_usage(pid) ps_axu[pid] && ps_axu[pid][IDX_MAP[:pcpu]].to_f end |
#daemonize(cmd, options = {}) ⇒ Object
Returns the pid of the child that executes the cmd
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 |
# File 'lib/bluepill/system.rb', line 46 def daemonize(cmd, = {}) rd, wr = IO.pipe if child = Daemonize.safefork # we do not wanna create zombies, so detach ourselves from the child exit status ::Process.detach(child) # parent wr.close daemon_id = rd.read.to_i rd.close return daemon_id if daemon_id > 0 else # child rd.close drop_privileges([:uid], [:gid], [:supplementary_groups]) # if we cannot write the pid file as the provided user, err out exit unless can_write_pid_file([:pid_file], [:logger]) to_daemonize = lambda do # Setting end PWD env emulates bash behavior when dealing with symlinks Dir.chdir(ENV["PWD"] = [:working_dir]) if [:working_dir] [:environment].each { |key, value| ENV[key.to_s] = value.to_s } if [:environment] redirect_io(*.values_at(:stdin, :stdout, :stderr)) ::Kernel.exec(*Shellwords.shellwords(cmd)) exit end daemon_id = Daemonize.call_as_daemon(to_daemonize, nil, cmd) File.open([:pid_file], "w") {|f| f.write(daemon_id)} wr.write daemon_id wr.close exit end end |
#drop_privileges(uid, gid, supplementary_groups) ⇒ Object
be sure to call this from a fork otherwise it will modify the attributes of the bluepill daemon
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 |
# File 'lib/bluepill/system.rb', line 195 def drop_privileges(uid, gid, supplementary_groups) if ::Process::Sys.geteuid == 0 uid_num = Etc.getpwnam(uid).uid if uid gid_num = Etc.getgrnam(gid).gid if gid supplementary_groups ||= [] group_nums = supplementary_groups.map do |group| Etc.getgrnam(group).gid end ::Process.groups = [gid_num] if gid ::Process.groups |= group_nums unless group_nums.empty? ::Process::Sys.setgid(gid_num) if gid ::Process::Sys.setuid(uid_num) if uid ENV['HOME'] = Etc.getpwuid(uid_num).try(:dir) || ENV['HOME'] if uid end end |
#execute_blocking(cmd, options = {}) ⇒ Object
Returns the stdout, stderr and exit code of the cmd
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 |
# File 'lib/bluepill/system.rb', line 93 def execute_blocking(cmd, = {}) rd, wr = IO.pipe if child = Daemonize.safefork # parent wr.close cmd_status = rd.read rd.close ::Process.waitpid(child) cmd_status.strip != '' ? Marshal.load(cmd_status) : {:exit_code => 0, :stdout => '', :stderr => ''} else # child rd.close # create a child in which we can override the stdin, stdout and stderr cmd_out_read, cmd_out_write = IO.pipe cmd_err_read, cmd_err_write = IO.pipe pid = fork { # grandchild drop_privileges([:uid], [:gid], [:supplementary_groups]) Dir.chdir(ENV["PWD"] = [:working_dir]) if [:working_dir] [:environment].each { |key, value| ENV[key.to_s] = value.to_s } if [:environment] # close unused fds so ancestors wont hang. This line is the only reason we are not # using something like popen3. If this fd is not closed, the .read call on the parent # will never return because "wr" would still be open in the "exec"-ed cmd wr.close # we do not care about stdin of cmd STDIN.reopen("/dev/null") # point stdout of cmd to somewhere we can read cmd_out_read.close STDOUT.reopen(cmd_out_write) cmd_out_write.close # same thing for stderr cmd_err_read.close STDERR.reopen(cmd_err_write) cmd_err_write.close # finally, replace grandchild with cmd ::Kernel.exec(*Shellwords.shellwords(cmd)) } # we do not use these ends of the pipes in the child cmd_out_write.close cmd_err_write.close # wait for the cmd to finish executing and acknowledge it's death ::Process.waitpid(pid) # collect stdout, stderr and exitcode result = { :stdout => cmd_out_read.read, :stderr => cmd_err_read.read, :exit_code => $?.exitstatus } # We're done with these ends of the pipes as well cmd_out_read.close cmd_err_read.close # Time to tell the parent about what went down wr.write Marshal.dump(result) wr.close exit end end |
#get_children(parent_pid) ⇒ Object
37 38 39 40 41 42 43 |
# File 'lib/bluepill/system.rb', line 37 def get_children(parent_pid) child_pids = Array.new ps_axu.each_pair do |pid, chunks| child_pids << chunks[IDX_MAP[:pid]].to_i if chunks[IDX_MAP[:ppid]].to_i == parent_pid.to_i end child_pids end |
#memory_usage(pid) ⇒ Object
33 34 35 |
# File 'lib/bluepill/system.rb', line 33 def memory_usage(pid) ps_axu[pid] && ps_axu[pid][IDX_MAP[:rss]].to_f end |
#pid_alive?(pid) ⇒ Boolean
20 21 22 23 24 25 26 27 |
# File 'lib/bluepill/system.rb', line 20 def pid_alive?(pid) begin ::Process.kill(0, pid) true rescue Errno::ESRCH false end end |
#ps_axu ⇒ Object
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 |
# File 'lib/bluepill/system.rb', line 177 def ps_axu # TODO: need a mutex here store[:ps_axu] ||= begin # BSD style ps invocation lines = `ps axo pid,ppid,pcpu,rss`.split("\n") lines.inject(Hash.new) do |mem, line| chunks = line.split(/\s+/) chunks.delete_if {|c| c.strip.empty? } pid = chunks[IDX_MAP[:pid]].strip.to_i mem[pid] = chunks mem end end end |
#redirect_io(io_in, io_out, io_err) ⇒ Object
225 226 227 228 229 230 231 232 233 234 235 236 |
# File 'lib/bluepill/system.rb', line 225 def redirect_io(io_in, io_out, io_err) $stdin.reopen(io_in) if io_in if !io_out.nil? && !io_err.nil? && io_out == io_err $stdout.reopen(io_out, APPEND_MODE) $stderr.reopen($stdout) else $stdout.reopen(io_out, APPEND_MODE) if io_out $stderr.reopen(io_err, APPEND_MODE) if io_err end end |
#reset_data ⇒ Object
173 174 175 |
# File 'lib/bluepill/system.rb', line 173 def reset_data store.clear unless store.empty? end |
#store ⇒ Object
169 170 171 |
# File 'lib/bluepill/system.rb', line 169 def store @store ||= Hash.new end |