ruby system command check exit code

Question

From the documentation:

system returns true if the command gives zero exit status, false for non zero exit status. Returns nil if command execution fails.

system("unknown command")     #=> nil
system("echo foo")            #=> true
system("echo foo | grep bar") #=> false

Furthermore

An error status is available in $?.

system("VBoxManage createvm --invalid-option")

$?             #=> #<Process::Status: pid 9926 exit 2>
$?.exitstatus  #=> 2

For me, I preferred use `` to call the shell commands and check $? to get process status. The $? is a process status object, you can get the command's process information from this object, including: status code, execution status, pid, etc.

Some useful methods of the $? object:

   $?.exitstatus => return error code    
   $?.success? => return true if error code is 0, otherwise false
   $?.pid => created process pid

system returns false if the command has an non-zero exit code, or nil if there is no command.

Therefore

system( "foo" ) or exit

or

system( "foo" ) or raise "Something went wrong with foo"

should work, and are reasonably concise.

You're not capturing the result of your system call, which is where the result code is returned:

exit_code = system("ruby test.rb")

Remember each system call or equivalent, which includes the backtick-method, spawns a new shell, so it's not possible to capture the result of a previous shell's environment. In this case exit_code is true if everything worked out, nil otherwise.

The popen3 command provides more low-level detail.

One way to do this is to chain them using and or &&:

system("VBoxManage createvm --name test1") and system("ruby test.rb")

The second call won't be run if the first fails.

You can wrap those in an if () to give you some flow-control:

if (
  system("VBoxManage createvm --name test1") && 
  system("ruby test.rb")
) 
  # do something
else
  # do something with $?
end

I want something like

system("VBoxManage createvm --name test1", 0) <-- where the second parameter checks the exit code and confirms that that system call was successful, and if not, it'll raise an error or do something of that sort.

You can add exception: true to your system call to have an error raised on non 0 exit codes.

For example, consider this small wrapper around system which prints the command (similar to bash -x, fails if there's a non 0 exit code (like bash -e) and returns the actual exit code:

def sys(cmd, *args, **kwargs)
  puts("\e[1m\e[33m#{cmd} #{args}\e[0m\e[22m")
  system(cmd, *args, exception: true, **kwargs)
  return $?.exitstatus
end

To be called like: sys("hg", "update") If you want to call a program that uses a different convention for exit codes, you can suppress raising the exception:

sys("robocopy", src, dst, "/COPYALL", "/E", "/R:0", "/DCOPY:T", exception: false)

You can also suppress stdout and stderr for noisy programs:

sys("hg", "update", "default", :out => File::NULL, :err => File::NULL)