How do I call shell commands from inside of a Ruby program? How do I then get output from these commands back into Ruby?
This explanation is based on a commented Ruby script from a friend of mine. If you want to improve the script, feel free to update it at the link.
First, note that when Ruby calls out to a shell, it typically calls /bin/sh, not Bash. Some Bash syntax is not supported by /bin/sh on all systems.
Here are ways to execute a shell script:
cmd = "echo 'hi'" # Sample string that can be used
Kernel#` , commonly called backticks – `cmd`
This is like many other languages, including Bash, PHP, and Perl.
Returns the result (i.e. standard output) of the shell command.
Docs: http://ruby-doc.org/core/Kernel.html#method-i-60
value = `echo 'hi'`
value = `#{cmd}`
Built-in syntax, %x( cmd )
Following the x character is a delimiter, which can be any character.
If the delimiter is one of the characters (, [, {, or <,
the literal consists of the characters up to the matching closing delimiter,
taking account of nested delimiter pairs. For all other delimiters, the
literal comprises the characters up to the next occurrence of the
delimiter character. String interpolation #{ ... } is allowed.
Returns the result (i.e. standard output) of the shell command, just like the backticks.
Docs: https://docs.ruby-lang.org/en/master/syntax/literals_rdoc.html#label-Percent+Strings
value = %x( echo 'hi' )
value = %x[ #{cmd} ]
Kernel#system
Executes the given command in a subshell.
Returns true if the command was found and run successfully, false otherwise.
Docs: http://ruby-doc.org/core/Kernel.html#method-i-system
wasGood = system( "echo 'hi'" )
wasGood = system( cmd )
Kernel#exec
Replaces the current process by running the given external command.
Returns none, the current process is replaced and never continues.
Docs: http://ruby-doc.org/core/Kernel.html#method-i-exec
exec( "echo 'hi'" )
exec( cmd ) # Note: this will never be reached because of the line above
Here's some extra advice:
$?, which is the same as $CHILD_STATUS, accesses the status of the last system executed command if you use the backticks, system() or %x{}.
You can then access the exitstatus and pid properties:
$?.exitstatus
For more reading see:
http://www.elctech.com/blog/i-m-in-ur-commandline-executin-ma-commands
http://blog.jayfields.com/2006/06/ruby-kernel-system-exec-and-x.html
http://tech.natemurray.com/2007/03/ruby-shell-commands.html
Here's a flowchart based on "When to use each method of launching a subprocess in Ruby". See also, "Trick an application into thinking its stdout is a terminal, not a pipe".
The way I like to do this is using the %x literal, which makes it easy (and readable!) to use quotes in a command, like so:
directorylist = %x[find . -name '*test.rb' | sort]
Which, in this case, will populate file list with all test files under the current directory, which you can process as expected:
directorylist.each do |filename|
filename.chomp!
# work with file
end
Here's the best article in my opinion about running shell scripts in Ruby: "6 Ways to Run Shell Commands in Ruby".
If you only need to get the output use backticks.
I needed more advanced stuff like STDOUT and STDERR so I used the Open4 gem. You have all the methods explained there.
My favourite is Open3
require "open3"
Open3.popen3('nroff -man') { |stdin, stdout, stderr| ... }
Some things to think about when choosing between these mechanisms are:
Do you just want stdout or do you
need stderr as well? Or even
separated out?
How big is your output? Do you want
to hold the entire result in memory?
Do you want to read some of your
output while the subprocess is still
running?
Do you need result codes?
Do you need a Ruby object that
represents the process and lets you
kill it on demand?
You may need anything from simple backticks (``), system(), and IO.popen to full-blown Kernel.fork/Kernel.exec with IO.pipe and IO.select.
You may also want to throw timeouts into the mix if a sub-process takes too long to execute.
Unfortunately, it very much depends.
I'm definitely not a Ruby expert, but I'll give it a shot:
$ irb
system "echo Hi"
Hi
=> true
You should also be able to do things like:
cmd = 'ls'
system(cmd)
One more option:
When you:
need stderr as well as stdout
can't/won't use Open3/Open4 (they throw exceptions in NetBeans on my Mac, no idea why)
You can use shell redirection:
puts %x[cat bogus.txt].inspect
=> ""
puts %x[cat bogus.txt 2>&1].inspect
=> "cat: bogus.txt: No such file or directory\n"
The 2>&1 syntax works across Linux, Mac and Windows since the early days of MS-DOS.
The answers above are already quite great, but I really want to share the following summary article: "6 Ways to Run Shell Commands in Ruby"
Basically, it tells us:
Kernel#exec:
exec 'echo "hello $HOSTNAME"'
system and $?:
system 'false'
puts $?
Backticks (`):
today = `date`
IO#popen:
IO.popen("date") { |f| puts f.gets }
Open3#popen3 -- stdlib:
require "open3"
stdin, stdout, stderr = Open3.popen3('dc')
Open4#popen4 -- a gem:
require "open4"
pid, stdin, stdout, stderr = Open4::popen4 "false" # => [26327, #<IO:0x6dff24>, #<IO:0x6dfee8>, #<IO:0x6dfe84>]
If you really need Bash, per the note in the "best" answer.
First, note that when Ruby calls out to a shell, it typically calls /bin/sh, not Bash. Some Bash syntax is not supported by /bin/sh on all systems.
If you need to use Bash, insert bash -c "your Bash-only command" inside of your desired calling method:
quick_output = system("ls -la")
quick_bash = system("bash -c 'ls -la'")
To test:
system("echo $SHELL")
system('bash -c "echo $SHELL"')
Or if you are running an existing script file like
script_output = system("./my_script.sh")
Ruby should honor the shebang, but you could always use
system("bash ./my_script.sh")
to make sure, though there may be a slight overhead from /bin/sh running /bin/bash, you probably won't notice.
You can also use the backtick operators (`), similar to Perl:
directoryListing = `ls /`
puts directoryListing # prints the contents of the root directory
Handy if you need something simple.
Which method you want to use depends on exactly what you're trying to accomplish; check the docs for more details about the different methods.
Using the answers here and linked in Mihai's answer, I put together a function that meets these requirements:
Neatly captures STDOUT and STDERR so they don't "leak" when my script is run from the console.
Allows arguments to be passed to the shell as an array, so there's no need to worry about escaping.
Captures the exit status of the command so it is clear when an error has occurred.
As a bonus, this one will also return STDOUT in cases where the shell command exits successfully (0) and puts anything on STDOUT. In this manner, it differs from system, which simply returns true in such cases.
Code follows. The specific function is system_quietly:
require 'open3'
class ShellError < StandardError; end
#actual function:
def system_quietly(*cmd)
exit_status=nil
err=nil
out=nil
Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thread|
err = stderr.gets(nil)
out = stdout.gets(nil)
[stdin, stdout, stderr].each{|stream| stream.send('close')}
exit_status = wait_thread.value
end
if exit_status.to_i > 0
err = err.chomp if err
raise ShellError, err
elsif out
return out.chomp
else
return true
end
end
#calling it:
begin
puts system_quietly('which', 'ruby')
rescue ShellError
abort "Looks like you don't have the `ruby` command. Odd."
end
#output: => "/Users/me/.rvm/rubies/ruby-1.9.2-p136/bin/ruby"
We can achieve it in multiple ways.
Using Kernel#exec, nothing after this command is executed:
exec('ls ~')
Using backticks or %x
`ls ~`
=> "Applications\nDesktop\nDocuments"
%x(ls ~)
=> "Applications\nDesktop\nDocuments"
Using Kernel#system command, returns true if successful, false if unsuccessful and returns nil if command execution fails:
system('ls ~')
=> true
Don't forget the spawn command to create a background process to execute the specified command. You can even wait for its completion using the Process class and the returned pid:
pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2")
Process.wait pid
pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'")
Process.wait pid
The doc says: This method is similar to #system but it doesn't wait for the command to finish.
The easiest way is, for example:
reboot = `init 6`
puts reboot
The backticks (`) method is the easiest one to call shell commands from Ruby. It returns the result of the shell command:
url_request = 'http://google.com'
result_of_shell_command = `curl #{url_request}`
Given a command like attrib:
require 'open3'
a="attrib"
Open3.popen3(a) do |stdin, stdout, stderr|
puts stdout.read
end
I've found that while this method isn't as memorable as
system("thecommand")
or
`thecommand`
in backticks, a good thing about this method compared to other methods is
backticks don't seem to let me puts the command I run/store the command I want to run in a variable, and system("thecommand") doesn't seem to let me get the output whereas this method lets me do both of those things, and it lets me access stdin, stdout and stderr independently.
See "Executing commands in ruby" and Ruby's Open3 documentation.
If you have a more complex case than the common case that can not be handled with ``, then check out Kernel.spawn(). This seems to be the most generic/full-featured provided by stock Ruby to execute external commands.
You can use it to:
create process groups (Windows).
redirect in, out, error to files/each-other.
set env vars, umask.
change the directory before executing a command.
set resource limits for CPU/data/etc.
Do everything that can be done with other options in other answers, but with more code.
The Ruby documentation has good enough examples:
env: hash
name => val : set the environment variable
name => nil : unset the environment variable
command...:
commandline : command line string which is passed to the standard shell
cmdname, arg1, ... : command name and one or more arguments (no shell)
[cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
options: hash
clearing environment variables:
:unsetenv_others => true : clear environment variables except specified by env
:unsetenv_others => false : dont clear (default)
process group:
:pgroup => true or 0 : make a new process group
:pgroup => pgid : join to specified process group
:pgroup => nil : dont change the process group (default)
create new process group: Windows only
:new_pgroup => true : the new process is the root process of a new process group
:new_pgroup => false : dont create a new process group (default)
resource limit: resourcename is core, cpu, data, etc. See Process.setrlimit.
:rlimit_resourcename => limit
:rlimit_resourcename => [cur_limit, max_limit]
current directory:
:chdir => str
umask:
:umask => int
redirection:
key:
FD : single file descriptor in child process
[FD, FD, ...] : multiple file descriptor in child process
value:
FD : redirect to the file descriptor in parent process
string : redirect to file with open(string, "r" or "w")
[string] : redirect to file with open(string, File::RDONLY)
[string, open_mode] : redirect to file with open(string, open_mode, 0644)
[string, open_mode, perm] : redirect to file with open(string, open_mode, perm)
[:child, FD] : redirect to the redirected file descriptor
:close : close the file descriptor in child process
FD is one of follows
:in : the file descriptor 0 which is the standard input
:out : the file descriptor 1 which is the standard output
:err : the file descriptor 2 which is the standard error
integer : the file descriptor of specified the integer
io : the file descriptor specified as io.fileno
file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not
:close_others => false : inherit fds (default for system and exec)
:close_others => true : dont inherit (default for spawn and IO.popen)
This is not really an answer but maybe someone will find it useful:
When using TK GUI on Windows, and you need to call shell commands from rubyw, you will always have an annoying CMD window popping up for less then a second.
To avoid this you can use:
WIN32OLE.new('Shell.Application').ShellExecute('ipconfig > log.txt','','','open',0)
or
WIN32OLE.new('WScript.Shell').Run('ipconfig > log.txt',0,0)
Both will store the ipconfig output inside log.txt, but no windows will come up.
You will need to require 'win32ole' inside your script.
system(), exec() and spawn() will all pop up that annoying window when using TK and rubyw.
Not sure about shell commands. I used following for capturing system command's output into a variable val:
val = capture(:stdout) do
system("pwd")
end
puts val
shortened version:
val = capture(:stdout) { system("pwd") }
capture method is provided by active_support/core_ext/kernel/reporting.rb
Simlarly we can also capture standard errors too with :stderr
Here's a cool one that I use in a ruby script on OS X (so that I can start a script and get an update even after toggling away from the window):
cmd = %Q|osascript -e 'display notification "Server was reset" with title "Posted Update"'|
system ( cmd )
You can use format method as below to print some information:
puts format('%s', `ps`)
puts format('%d MB', (`ps -o rss= -p #{Process.pid}`.to_i / 1024))
Related
This command works fine when using backticks to make a system call:
aspell -a < /path/textfile
However, if I try this it does not work:
result = IO.popen(["aspell", "-a", "<", "/path/textfile"]).read
It seems to be an issue with the angle bracket, because this works fine:
result = IO.popen([ "aspell", "--help"]).read
What am I doing wrong here?
That's a shell operation, and as popen is interfacing directly with your command, you can't do it. Instead you assume the responsibility for doing this, which is why the Open3 library exists and things like the popen2 method in particular:
Adapting your code:
require 'open3'
Open3.popen2('aspell', '-a') do |stdin, stdout, wait_thr|
# Feed the contents of /path/textfile into the STDIN of this
# subprocess.
stdin.write(File.read('/path/textfile'))
stdin.close
# Read the results back
result = stdout.read
end
This might be advantageous since you no longer need to write to a temporary file to do operations like this, you can just feed in data directly through the stdin pipe.
I'm currently grep-ing the system and returning the results into ruby to manipulate.
def grep_system(search_str, dir, filename)
cmd_str ="grep -R '#{search_str}' #{dir} > #{filename}"
system(cmd_str)
lines_array = File.open(filename, "r").read.split("\n)
end
As you can see, I'm just writing the results from the grep into a temp file, and then re-opening that file with "File.open".
Is there a better way to do this?
Never ever do anything like this:
cmd_str ="grep -R '#{search_str}' #{dir}"
Don't even think about it. Sooner or later search_str or dir will contain something that the shell will interpret in unexpected ways. There's no need to invoke a shell at all, you can use Open3.capture3 thusly:
lines = Open3.capture3('grep', '-R', search_str, dir).first
lines, _ = Open3.capture3('grep', '-R', search_str, dir)
That will leave you with a newline delimited list in lines and from there it should be easy.
That will invoke grep directly without using a shell at all. capture3 also nicely lets you ignore (or capture) the command's stderr rather than leaving it be printed wherever your stderr goes by default.
If you use this form of capture3, you don't have to worry about shell metacharacters or quoting or unsanitary inputs.
Similarly for system, if you want to use system with arguments you'd use the multi-argument version:
system('ls', some_var)
instead of the potentially dangerous:
system("ls #{some_var}")
You shouldn't need to pass an argument for the temporal filename. After all, writing and reading to/from a temporal file is something you should avoid if possible.
require "open3"
def grep_system(search_str, dir)
Open3.capture2("grep -R '#{search_str}' #{dir}").first.each_line.to_a
end
Instead of using system(cmd_str), you could use:
results = `#{cmd_str}`
Yes, there are a few better ways. The easiest is just to assign the result of invoking the command with backticks to a variable:
def grep_system(search_str, dir, filename)
cmd_str ="grep -R '#{search_str}' #{dir}"
results = `#{cmd_str}`
lines_array =results.split("\n)
end
value = %x( #{"svn lock #{#path}/#{#file}"} )
=>
svn: warning: W160035: Path '/README.txt' is already locked by user 'tester' in filesystem 'some_path'
""
Returns empty string rather then the svn:warning message. I want to record the svn warning message. What am I doing wrong.
Thanks for your help in advance.
This is likely because the output is being sent to STDERR, not STDOUT (which is all %x captures). Because you’re not capturing it, it does what it would normally and prints to the console.
You can either redirect STDERR to STDOUT in your command:
%x(svn lock #{#path}/#{#file} 2>&1)
Or use Open3 to capture both STDOUT & STDERR:
require 'open3'
Open3.popen3("svn lock #{#path}/#{#file}") do |stdin, stdout, stderr, wait_thr|
puts "stdout is:" + stdout.read
puts "stderr is:" + stderr.read
end
The first option offloads the work to the shell executing the command and depending on the environment it may not support it. As such using Open3 is a much more portable solution.
Some additional notes: note I’ve removed the unnecessary interpolation in your %x statement. Also, consider using ShellWords to properly escape interpolated string in shell commands. This is particularly important if these are user-inputted strings.
Your problem is that backticks (or %x) returns the output of STDOUT, whereas in this case you want STDERR. Use e.g. Open3::capture2e instead:
http://www.ruby-doc.org/stdlib-2.0.0/libdoc/open3/rdoc/Open3.html#method-c-capture2e
This is something I have been curious about for a while. When a bash command is executed in Ruby (e.g. w/ ` usage), does it return a true boolean value upon completion and false if it fails? Any assistance is greatly appreciated!
If you use system() to perform the command, you will get false or nil on failure (dependant on what failed), and true on success.
If you use Backticks however, the result will be whatever the shelled-out program wrote to STDOUT.
http://rubyquicktips.com/post/5862861056/execute-shell-commands
In general there are four approaches to execute a command in Ruby and treat STDIN, STDOUT, and STDERR differently.
# Kernel#system
# returns true (zero exit status), false (non zero exit status) or nil (command execution fails)
# Kernel#` (backticks)
# returns the STDOUT
# outputs the STDERR, but not capture it
# The built-in syntax %x{...} uses this method
# IO#popen
# the STDIN and STDOUT will be connected to the returned IO object
# Open3#popen3
# STDIN, STDOUT and STDERR are all captured to IO objects
And you can still handle STDERR separately in the original command, like:
system("[command_which_fails]") #=> STDERR & false
system("[command_which_fails] > /dev/null 2>&1") #=> false
Backquotes ` ` will not return true or false but that does not mean you can not check for the successful execution of command. You can always use $? it returns you the error code. If the last command ran successfully it should be 0.
You can use system(' '). It returns true or false depending on the result of your command.
You can use many ways to execute commands in ruby. Most of them are explained in following article.
5 ways to run shell commands in Ruby
It should return nil when fails and true upon success.
I am not sure if this makes sense but I am thinking if there is a way to suppress the output shown for a command when run using the system method in ruby? I mean it should just output true or false to STDOUT and not the output of the command. What I think is it can just only be done if the command can run silently and not from the system method. Can someone provide a bit more insight?
If you want to take advantage of the variadic form of Kernel.system, which side-steps the many quoting issues with shells, you can use the same options which Kernel.spawn accepts.
TL;DR - Use :out => File::NULL to silence output from Kernel.system
Arguments with special characters (spaces, etc.) can cause problems with the shell:
irb(main):001:0> filename_with_spaces = "foo bar.txt"
=> "foo bar.txt"
irb(main):002:0> system "ls -l #{filename_with_spaces}"
ls: bar.txt: No such file or directory
ls: foo: No such file or directory
=> false
So if you are interpolating variables into a system call, it is safer to provide the arguments separately:
irb(main):003:0> system "ls", "-l", filename_with_spaces
-rw-r--r-- 1 nobody nobody 9 Feb 1 16:53 foo bar.txt
=> true
But now we have a problem if we want to hide the output.
irb(main):004:0> system "ls", "-l", filename_with_spaces, "> /dev/null"
ls: > /dev/null: No such file or directory
-rw-r--r-- 1 nobody nobody 9 Feb 1 16:53 foo bar.txt
=> false
We could close STDOUT using the :out => :close option:
irb(main):005:0> system "ls", "-l", filename_with_spaces, :out => :close
=> true
However, this might cause issues with certain commands which may try to attach to STDOUT.
irb(main):006:0> system "echo", "hi there", :out => :close
echo: write: Bad file descriptor
=> false
To fix this, we can go back to redirecting our output, using File::NULL to remain portable:
irb(main):007:0> system "echo", "hi there", :out => File::NULL
=> true
After a call to system the exit code is in the special variable $? so if useradd returns different values to indicate if the user was successfully added (e.g. 0 for success) then you can do the following:
system('useradd xx > /dev/null')
if $? == 0
puts 'added'
else
puts 'failed'
end
where the redirect to /dev/null will suppress the output.
Alternatively if the program being called does not use its exit code to indicate success or failure you can use backticks and search for a particular substring in the output e.g.
if `useradd xx`.include? 'success'
puts 'it worked'
else
puts 'failed to add user'
end
As an addendum, I've been surprised a few times when I've used backticks and saw output "slipping past" my variables when running scripts from the command line.
Invariably, the issue is that the text I'm seeing is actually coming from stderr rather than stdout. So, to wrangle that text into stdout as well, remember to append 2>&1 to the command you're trying to run.
I hope that's helpful to someone. I just wasted twenty minutes re-learning this lesson :)
I was faced with this question as well...
Keep in mind that with ruby system calls, the UNIX command you are trying to use might offer a "silent" option--nullifying the need to suppress terminal output altogether!
For instance:
system 'curl -s "your_params_here"'
Will suppress the output that typically accompanies a curl call.
IO.popen
This is another good option:
IO.popen(['echo', 'a']) do |f|
f.read == "a\n" or raise
end
$?.exitstatus == 0 or raise
Nothing will get output to your stdout.
http://www.ruby-doc.org/core-2.1.4/IO.html#method-c-popen
define null_device, it's operating systems dependent: windows 7 and newer use nul, while *nix systems uses /dev/null
run the command
redirect it's standard and error output to null_device
then use the exit code, or the backtick method as mentioned by #mikej to determine the output
as follows:
null_device = Gem.win_platform? ? "/nul" : "/dev/null"
do method
system "run command 1>#{null_device} 2>#{null_device} "
p ($? == 0)
end
You can also use backticks or %x
This should work
system ls, STDOUT:'/dev/null'