Ruby run linux command

Executing commands in ruby

Ruby allows many different ways to execute a command or a sub-process. In this article we are going to see some of them.

1. Returns standard output

backtick returns the standard output of the operation.

Result of above code is

2. Exception is passed on to the master program

Backtick operation forks the master process and the operation is executed in a new process. If there is an exception in the sub-process then that exception is given to the main process and the main process might terminate if exception is not handled.

In the following case I am executing xxxxx which is not a valid executable name.

Result of above code is given below. Notice that puts was never executed because the backtick operation raised exception.

3. Blocking operation

Backtick is a blocking operation. The main application waits until the result of backtick operation completes.

4. Checking the status of the operation

To check the status of the backtick operation you can execute $?.success?

Notice that the last line of the result contains true because the backtick operation was a success.

backtick returns STDOUT . backtick does not capture STDERR . If you want to learn about STDERR then checkout this excellent article .

You can redirect STDERR to STDOUT if you want to capture STDERR using backtick.

5. String interpolation is allowed within the ticks

6. Different delimiter and string interpolation

%x does the same thing as backtick. It allows you to have different delimiter.

backtick runs the command via shell. So shell features like string interpolation and wild card can be used. Here is an example.

system behaves a bit like backtick operation. However there are some differences.

First let’s look at similarities.

1. Blocking operation

Just like backtick , system is a blocking operation.

2. Eats up all exceptions

system eats up all the exceptions. So the main operation never needs to worry about capturing an exception raised from the child process.

Result of the above operation is given below. Notice that even when exception is raised the main program completes and the output is printed. The value of output is nil because the child process raised an exception.

3. Checking the status of the operation

system returns true if the command was successfully performed ( exit status zero ) . It returns false for non zero exit status. It returns nil if command execution fails.

exec replaces the current process by running the external command. Let’s see an example.

Here I am in irb and I am going to execute exec(‘ls’) .

I see the result but since the irb process was replaced by the exec process I am no longer in irb .

Behind the scene both system and backtick operations use fork to fork the current process and then they execute the given operation using exec .

Since exec replaces the current process it does not return anything if the operation is a success. If the operation fails then `SystemCallError is raised.

sh actually calls system under the hood. However it is worth a mention here. This method is added by FileUtils in rake . It allows an easy way to check the exit status of the command.

If you are going to capture stdout and stderr then you should use popen3 since this method allows you to interact with stdin , stdout and stderr .

I want to execute git push heroku master programmatically and I want to capture the output. Here is my code.

And here is the output. It has been truncated since rest of output is not relevant to this discussion.

The important thing to note here is that when I execute the program ruby lab.rb I do not see any output on my terminal for first 10 seconds. Then I see the whole output as one single dump.

The other thing to note is that heroku is writing all this output to stderr and not to stdout .

Above solution works but it has one major drawback. The push to heroku might take 10 to 20 seconds and for this period we do not get any feedback on the terminal. In reality when we execute git push heroku master we start seeing result on our terminal one by one as heroku is processing things.

So we should capture the output from heroku as it is being streamed rather than dumping the whole output as one single chunk of string at the end of processing.

Here is the modified code.

Now when I execute above command using ruby lab.rb I get the output on my terminal incrementally as if I had typed git push heroku master .

Here is another example of capturing streaming output.

In the above case you will get the output of ping on your terminal as if you had typed ping www.google.com on your terminal .

Now let’s see how to check if command succeeded or not.

popen2e is similar to popen3 but merges the standard output and standard error .

In all other areas this method works similar to popen3 .

Kernel.spawn executes the given command in a subshell. It returns immediately with the process id.

You might also like

If you liked this blog post, check out similar ones from BigBinary

Источник

How to Run System Commands From Ruby

If you want to run an external command from Ruby…

…like wkhtmltopdf to convert an HTML file into a PDF.

There are a few Ruby methods you can use.

Depending on the method you use you’ll get different results.

Let’s explore these methods together!

The Ruby System Method

The Ruby system method is the simplest way to run an external command.

It looks like this:

Notice that system will print the command output as it happens.

Also system will make your Ruby program wait until the command is done.

There are ways to run commands in the background as we’ll see later.

System can return 3 possible values:

• true if the command worked
• false if the command returns an error code
• nil if command execution fails (command not found)

You can get the exit status code of the last external command that you ran with the $? global variable. This status code can give you more information about why the command failed.

What is Shell Expansion?

When you run an external command with system you’ll get the “shell expansion” effect.

Shell expansion is when the shell (sh/bash/zsh) takes some special characters ( * , ? , and [ ) from your command & expands them into a file list.

This will print every file & folder in the current directory.

The * is replaced with the list of files before the command runs.

If you want to use these special characters as they are pass the arguments as the 2nd argument of system .

Now the output will be * .

How to Use Environment Variables

If you want to pass a specific environment variable to an external command you can use a hash as the first argument.

Here’s an example:

This will not change the current environment of your Ruby application.

%x / Kernel#`

If you want to get the output from the command you’re running, instead of displaying it then you can use %x or the Kernel#` method.

They do the same thing.

Here’s an example:

These two examples will return a string with the output of the ls command.

Notice that you still have to wait for the command to finish unless you run it inside a thread.

How to Use Fork + Exec To Run External Commands On a Separate Process

Forking makes a copy of your current process (your Ruby app) then you can replace that copy with another process using exec.

Note: The fork method is not available on Windows.

This is a popular pattern in the Unix world.

Here’s how it works:

This will run ls on another process & display its output.

Because this command is running in another process it will not block your Ruby app from running like the system method or %x .

If you use exec without fork you’re going to replace your current process.

This means your Ruby program will end.

How to Use the Popen Method For Two Way Communication With An External Program

• More control over the process
• Two-way communication

Then the IO.popen method is what you are looking for.

In the following example I use the popen method to launch an irb process, then send some input to it & read the output.

Here the example:

This r variable is an IO object, this means that you can write & read from it like a regular file.

Using popen also means that your external command will run on its own process, so you don’t have to run it on a thread.

There is also a popen3 method in the standard library.

The difference with the regular popen is that it will split regular output & error messages into separate IO objects.

Conclusion

You have learned about the different ways that you can interact with external commands in Ruby.

Be careful with these!

Don’t pass any kind of user input into these commands unless you want a security issue in your Ruby app.

If you learned something new please share this article so more people can see it.

Источник

Using the Command Line to Run Ruby Scripts

Running and Executing rb Files

Imgorthand / Getty Images

Before really starting to use Ruby, you need to have a basic understanding of the command line. Since most Ruby scripts won’t have graphical user interfaces, you’ll be running them from the command line. Thus, you’ll need to know, at the very least, how to navigate the directory structure and how to use pipe characters (such as |, ) to redirect input and output. The commands in this tutorial are the same on Windows, Linux, and OS X.

Opening the Command Prompt

• To start a command prompt on Windows, go to Start -> Run. In the dialog that appears, enter cmd into the input box and press OK.
• To start a command prompt on Ubuntu Linux, go to Applications -> Accessories -> Terminal.
• To start a command prompt on OS X, go to Applications -> Utilities -> Terminal.

Once you’re at the command line, you’ll be presented with a prompt. It’s often a single character such as $ or #. The prompt may also contain more information, such as your username or your current directory. To enter a command all you need to do is type in the command and hit the enter key.

The first command to learn is the cd command, which will be used to get to the directory where you keep your Ruby files. The command below will change directory to the \scripts directory. Note that on Windows systems, the backslash character is used to delimit directories but on Linux and OS X, the forward slash character is used.

Running Ruby Scripts

Now that you know how to navigate to your Ruby scripts (or your rb files), it’s time to run them. Open your text editor and save the following program as test.rb.

Open a command line window and navigate to your Ruby scripts directory using the cd command. Once there, you can list files, using the dir command on Windows or the ls command on Linux or OS X. Your Ruby files will all have the .rb file extension. To run the test.rb Ruby script, run the command ruby test.rb. The script should ask you for your name and greet you.

Alternatively, you can configure your script to run without using the Ruby command. On Windows, the one-click installer already set up a file association with the .rb file extension. Simply running the command test.rb will run the script. In Linux and OS X, for scripts to run automatically, two things must be in place: a «shebang» line and the file being marked as executable.

The shebang line is already done for you; it’s the first line in the script starting with #!. This tells the shell what type of file this is. In this case, it’s a Ruby file to be executed with the Ruby interpreter. To mark the file as executable, run the command chmod +x test.rb. This will set a file permission bit indicating that the file is a program and that it can be run. Now, to run the program, simply enter the command ./test.rb.

Whether you invoke the Ruby interpreter manually with the Ruby command or run the Ruby script directly is up to you. Functionally, they are the same thing. Use whichever method you feel most comfortable with.

Using Pipe Characters

Using the pipe characters is an important skill to master, as these characters will alter the input or output of a Ruby script. In this example, the > character is used to redirect the output of test.rb to a text file called test.txt instead of printing to the screen.

If you open new test.txt file after you run the script, you’ll see the output of the test.rb Ruby script. Knowing how to save output to a .txt file can be very useful. It allows you to save program output for careful examination or to be used as input to another script at a later time.

Similarly, by using the character you can redirect any input a Ruby script may read from the keyboard to read from a .txt file. It’s helpful to think of these two characters as funnels; you’re funneling output to files and input from files.

Then there’s the pipe character, |. This character will funnel the output from one script to the input of another script. It’s the equivalent of funneling the output of a script to a file, then funneling the input of a second script from that file. It just shortens the process.

The | character is useful in creating «filter» type programs, where one script generates unformatted output and another script formats the output to the desired format. Then the second script could be changed or replaced entirely without having to modify the first script at all.

C:\scripts>ruby example1.rb | ruby example2.rb

Starting the Interactive Ruby Prompt

One of the great things about Ruby is that it’s test-driven. The interactive Ruby prompt provides an interface to the Ruby language for instant experimentation. This comes in handy while learning Ruby and experimenting with things like regular expressions. Ruby statements can be run and the output and return values can be examined immediately. If you make a mistake, you can go back and edit your previous Ruby statements to correct those mistakes.

To start the IRB prompt, open your command-line and run the irb command. You’ll be presented with the following prompt:

Type the «hello world» statement we’ve been using into the prompt and hit Enter. You’ll see any output the statement generated as well as the return value of the statement before being returned to the prompt. In this case, the statement output «Hello world!» and it returned nil.

To run this command again, simply press the up key on your keyboard to get to the statement you previously ran and press the Enter key. If you want to edit the statement before running it again, press the left and right arrow keys to move the cursor to the correct place in the statement. Make your edits and press Enter to run the new command. Pressing up or down additional times will allow you to examine more of statements you’ve run.

The interactive Ruby tool should be used throughout learning Ruby. When you learn about a new feature or just want to try something, start up the interactive Ruby prompt and try it. See what the statement returns, pass different parameters to it and just do some general experimenting. Trying something yourself and seeing what it does can be a lot more valuable than just reading about it!

Источник