Module: Chef::Mixin::Command
- Included in:
- Provider::Cron, Provider::Deploy, Provider::ErlCall, Provider::Execute, Provider::Git, Provider::Group, Provider::Ifconfig, Provider::Link, Provider::Mdadm, Provider::Mount, Provider::Mount::Mount, Provider::Package, Provider::Package::Yum::YumCache, Provider::Route, Provider::Service, Provider::Subversion, Provider::User
- Defined in:
- lib/chef/mixin/command.rb
Class Method Summary collapse
- .chdir_or_tmpdir(dir, &block) ⇒ Object
- .handle_command_failures(status, command_output, opts = {}) ⇒ Object
-
.not_if(command, args = {}) ⇒ Object
If command is a block, returns false if the block returns true, true if it returns false.
-
.only_if(command, args = {}) ⇒ Object
If command is a block, returns true if the block returns true, false if it returns false.
- .output_of_command(command, args) ⇒ Object
-
.popen4(cmd, args = {}, &b) ⇒ Object
This is taken directly from Ara T Howard’s Open4 library, and then modified to suit the needs of Chef.
-
.run_command(args = {}) ⇒ Object
Parameters args<Hash>: A number of required and optional arguments command<String>, <Array>: A complete command with options to execute or a command and options as an Array creates<String>: The absolute path to a file that prevents the command from running if it exists cwd<String>: Working directory to execute command in, defaults to Dir.tmpdir timeout<String>: How many seconds to wait for the command to execute before timing out returns<String>: The single exit value command is expected to return, otherwise causes an exception ignore_failure<Boolean>: Whether to raise an exception on failure, or just return the status output_on_failure<Boolean>: Return output in raised exception regardless of Log.level.
-
.run_command_with_systems_locale(args = {}) ⇒ Object
Call #run_command but set LC_ALL to the system’s current environment so it doesn’t get changed to C.
Class Method Details
.chdir_or_tmpdir(dir, &block) ⇒ Object
394 395 396 397 398 399 400 401 402 |
# File 'lib/chef/mixin/command.rb', line 394 def chdir_or_tmpdir(dir, &block) dir ||= Dir.tmpdir unless File.directory?(dir) raise Chef::Exceptions::Exec, "#{dir} does not exist or is not a directory" end Dir.chdir(dir) do block.call end end |
.handle_command_failures(status, command_output, opts = {}) ⇒ Object
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 |
# File 'lib/chef/mixin/command.rb', line 170 def handle_command_failures(status, command_output, opts={}) unless opts[:ignore_failure] opts[:returns] ||= 0 unless Array(opts[:returns]).include?(status.exitstatus) # if the log level is not debug, through output of command when we fail output = "" if Chef::Log.level == :debug || opts[:output_on_failure] output << "\n---- Begin output of #{opts[:command]} ----\n" output << command_output.to_s output << "\n---- End output of #{opts[:command]} ----\n" end raise Chef::Exceptions::Exec, "#{opts[:command]} returned #{status.exitstatus}, expected #{opts[:returns]}#{output}" end end end |
.not_if(command, args = {}) ⇒ Object
If command is a block, returns false if the block returns true, true if it returns false. (“Do not run this resource if the block is true”)
If the command is not a block, executes the command. If it returns a 0 exitstatus, returns false. (“Do not run this resource if the command returns 0”)
Parameters
- command<Block>, <String>
-
A block to check, or a string to execute
Returns
- true
-
Returns true if the block is false, or if the command returns a non-zero exit status.
- false
-
Returns false if the block is true, or if the command returns a 0 exit status.
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 |
# File 'lib/chef/mixin/command.rb', line 73 def not_if(command, args = {}) if command.kind_of?(Proc) chdir_or_tmpdir(args[:cwd]) do res = command.call if res return false end end else status = run_command({:command => command, :ignore_failure => true}.merge(args)) if status.exitstatus == 0 return false end end true end |
.only_if(command, args = {}) ⇒ Object
If command is a block, returns true if the block returns true, false if it returns false. (“Only run this resource if the block is true”)
If the command is not a block, executes the command. If it returns any status other than 0, it returns false (clearly, a 0 status code is true)
Parameters
- command<Block>, <String>
-
A block to check, or a string to execute
Returns
- true
-
Returns true if the block is true, or if the command returns 0
- false
-
Returns false if the block is false, or if the command returns a non-zero exit code.
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
# File 'lib/chef/mixin/command.rb', line 42 def only_if(command, args = {}) if command.kind_of?(Proc) chdir_or_tmpdir(args[:cwd]) do res = command.call unless res return false end end else status = run_command({:command => command, :ignore_failure => true}.merge(args)) if status.exitstatus != 0 return false end end true end |
.output_of_command(command, args) ⇒ Object
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 |
# File 'lib/chef/mixin/command.rb', line 131 def output_of_command(command, args) Chef::Log.debug("Executing #{command}") stderr_string, stdout_string, status = "", "", nil exec_processing_block = lambda do |pid, stdin, stdout, stderr| stdout_string, stderr_string = stdout.string.chomp, stderr.string.chomp end args[:cwd] ||= Dir.tmpdir unless File.directory?(args[:cwd]) raise Chef::Exceptions::Exec, "#{args[:cwd]} does not exist or is not a directory" end Dir.chdir(args[:cwd]) do if args[:timeout] begin Timeout.timeout(args[:timeout]) do status = popen4(command, args, &exec_processing_block) end rescue Timeout::Error => e Chef::Log.error("#{command} exceeded timeout #{args[:timeout]}") raise(e) end else status = popen4(command, args, &exec_processing_block) end Chef::Log.debug("---- Begin output of #{command} ----") Chef::Log.debug("STDOUT: #{stdout_string}") Chef::Log.debug("STDERR: #{stderr_string}") Chef::Log.debug("---- End output of #{command} ----") Chef::Log.debug("Ran #{command} returned #{status.exitstatus}") end return status, stdout_string, stderr_string end |
.popen4(cmd, args = {}, &b) ⇒ Object
This is taken directly from Ara T Howard’s Open4 library, and then modified to suit the needs of Chef. Any bugs here are most likely my own, and not Ara’s.
The original appears in external/open4.rb in its unmodified form.
Thanks Ara!
210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 |
# File 'lib/chef/mixin/command.rb', line 210 def popen4(cmd, args={}, &b) # Waitlast - this is magic. # # Do we wait for the child process to die before we yield # to the block, or after? That is the magic of waitlast. # # By default, we are waiting before we yield the block. args[:waitlast] ||= false args[:user] ||= nil unless args[:user].kind_of?(Integer) args[:user] = Etc.getpwnam(args[:user]).uid if args[:user] end args[:group] ||= nil unless args[:group].kind_of?(Integer) args[:group] = Etc.getgrnam(args[:group]).gid if args[:group] end args[:environment] ||= {} # Default on C locale so parsing commands output can be done # independently of the node's default locale. # "LC_ALL" could be set to nil, in which case we also must ignore it. unless args[:environment].has_key?("LC_ALL") args[:environment]["LC_ALL"] = "C" end pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe verbose = $VERBOSE begin $VERBOSE = nil ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC) cid = fork { pw.last.close STDIN.reopen pw.first pw.first.close pr.first.close STDOUT.reopen pr.last pr.last.close pe.first.close STDERR.reopen pe.last pe.last.close STDOUT.sync = STDERR.sync = true if args[:group] Process.egid = args[:group] Process.gid = args[:group] end if args[:user] Process.euid = args[:user] Process.uid = args[:user] end args[:environment].each do |key,value| ENV[key] = value end if args[:umask] umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777) File.umask(umask) end begin if cmd.kind_of?(Array) exec(*cmd) else exec(cmd) end raise 'forty-two' rescue Exception => e Marshal.dump(e, ps.last) ps.last.flush end ps.last.close unless (ps.last.closed?) exit! } ensure $VERBOSE = verbose end [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close} begin e = Marshal.load ps.first raise(Exception === e ? e : "unknown failure!") rescue EOFError # If we get an EOF error, then the exec was successful 42 ensure ps.first.close end pw.last.sync = true pi = [pw.last, pr.first, pe.first] if b begin if args[:waitlast] b[cid, *pi] # send EOF so that if the child process is reading from STDIN # it will actually finish up and exit pi[0].close_write Process.waitpid2(cid).last else # This took some doing. # The trick here is to close STDIN # Then set our end of the childs pipes to be O_NONBLOCK # Then wait for the child to die, which means any IO it # wants to do must be done - it's dead. If it isn't, # it's because something totally skanky is happening, # and we don't care. o = StringIO.new e = StringIO.new pi[0].close stdout = pi[1] stderr = pi[2] stdout.sync = true stderr.sync = true stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK) stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK) stdout_finished = false stderr_finished = false results = nil while !stdout_finished || !stderr_finished begin channels_to_watch = [] channels_to_watch << stdout if !stdout_finished channels_to_watch << stderr if !stderr_finished ready = IO.select(channels_to_watch, nil, nil, 1.0) rescue Errno::EAGAIN ensure results = Process.waitpid2(cid, Process::WNOHANG) if results stdout_finished = true stderr_finished = true end end if ready && ready.first.include?(stdout) line = results ? stdout.gets(nil) : stdout.gets if line o.write(line) else stdout_finished = true end end if ready && ready.first.include?(stderr) line = results ? stderr.gets(nil) : stderr.gets if line e.write(line) else stderr_finished = true end end end results = Process.waitpid2(cid) unless results o.rewind e.rewind b[cid, pi[0], o, e] results.last end ensure pi.each{|fd| fd.close unless fd.closed?} end else [cid, pw.last, pr.first, pe.first] end end |
.run_command(args = {}) ⇒ Object
Parameters
args<Hash>: A number of required and optional arguments
command<String>, <Array>: A complete command with options to execute or a command and options as an Array
creates<String>: The absolute path to a file that prevents the command from running if it exists
cwd<String>: Working directory to execute command in, defaults to Dir.tmpdir
timeout<String>: How many seconds to wait for the command to execute before timing out
returns<String>: The single exit value command is expected to return, otherwise causes an exception
ignore_failure<Boolean>: Whether to raise an exception on failure, or just return the status
output_on_failure<Boolean>: Return output in raised exception regardless of Log.level
user<String>: The UID or user name of the user to execute the command as
group<String>: The GID or group name of the group to execute the command as
environment<Hash>: Pairs of environment variable names and their values to set before execution
Returns
Returns the exit status of args
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 |
# File 'lib/chef/mixin/command.rb', line 108 def run_command(args={}) command_output = "" args[:ignore_failure] ||= false args[:output_on_failure] ||= false if args.has_key?(:creates) if File.exists?(args[:creates]) Chef::Log.debug("Skipping #{args[:command]} - creates #{args[:creates]} exists.") return false end end status, stdout, stderr = output_of_command(args[:command], args) command_output << "STDOUT: #{stdout}" command_output << "STDERR: #{stderr}" handle_command_failures(status, command_output, args) status end |
.run_command_with_systems_locale(args = {}) ⇒ Object
Call #run_command but set LC_ALL to the system’s current environment so it doesn’t get changed to C.
Parameters
args<Hash>: A number of required and optional arguments that will be handed out to #run_command
Returns
Returns the result of #run_command
195 196 197 198 199 |
# File 'lib/chef/mixin/command.rb', line 195 def run_command_with_systems_locale(args={}) args[:environment] ||= {} args[:environment]["LC_ALL"] = ENV["LC_ALL"] run_command args end |