Different ways to run Shell Commands in Ruby

anjana — Tue, 22 Nov 2016 16:39:41 +0000

Exec

System

Backticks ()

IO#popen

open3#popen3

open4#popen4

Exec Kernel#exec (or simply exec) replaces the current process by running the given command, which can take one of the following forms: exec(commandline) command line string which is passed to the standard shell exec(cmdname, arg1, ...) command name and one or more arguments (no shell) exec([cmdname, argv0], arg1, ...) command name, argv and zero or more arguments (no shell) In the first form, the string is taken as a command line that is subject to shell expansion before being executed. In the second form (exec(“command1”, “arg1”, …)), the first is taken as a command name and the rest are passed as parameters to command with no shell expansion. In the third form (exec([“command”, “argv0”], “arg1”, …)), starting a two-element array at the beginning of the command, the first element is the command to be executed, and the second argument is used as the argv[0] value, which may show up in process listings. The major drawback is that you have no knowledge of the success or failure of the command from your Ruby script. Eg:

exec "echo", "*" # echoes an asterisk

System The system command operates similarly but the system command runs in a subshell instead of replacing the current process. The system gives us a little more information than exec in that it returns true if the command ran successfully and false otherwise. The system returns true if the command gives zero exit status, false for non-zero exit status. Returns nil if command execution fails. An error status is available in $?. System eats up all the exceptions. So the main operation never needs to worry about capturing an exception raised from the child process. Eg:

system("ls") #=> true
puts $? #=> pid 14822 exit 0

Backticks () Backticks (also called “backquotes”) runs the command in a subshell and returns the standard output from that command. Backtick operation forks the master process and the operation is executed in a new process. Backtick is a blocking operation. The main application waits until the result of backtick operation completes. Backtick runs the command via shell. So shell features like string interpolation and a wild card can be used. Eg:

date  #=> "Mon Nov 14 13:32:54 IST 2016\n"

IO#popen IO#popen is another way to run a command in a subprocess. popen gives you a bit more control where the subprocess standard input and standard output are both connected to the IO object.It returns an object of ‘IO’ class. You can loop through the output or use map to access individual elements. Eg:

IO.popen("date") { |f| f.gets() } #=> "Mon Nov 14 13:36:13 IST 2016\n"

Open3#popen3 The Ruby standard library includes the class Open3. It’s easy to use and returns stdin, stdout and stderr. Eg:

require 'open3'
cmd = 'git push heroku master'
Open3.popen3(cmd) do |stdin, stdout, stderr, wait_thr|
  puts "stdout is:" + stdout.read
  puts "stderr is:" + stderr.read
end

Output: stdout is: stderr is: —–> Heroku receiving push —–> Ruby/Rails app detected —–> Installing dependencies using Bundler version 1.2.1 Open4#popen4 Open4#popen4 is a Ruby Gem put together by Ara Howard. It operates similarly to open3 except that we can get the exit status from the program. popen4 returns a process id for the subshell and we can get the exit status from that waiting on that process. Eg:

$ irb
>> require "open4"
=> true
>> pid, stdin, stdout, stderr = Open4::popen4 "false"
=> [26327, #, #, #]
>> $?
=> nil
>> pid
=> 26327
>> ignored, status = Process::waitpid2 pid
=> [26327, #]
>> status.to_i
=> 256

References http://ruby-doc.org/core/Kernel.html#method-i-exec http://ruby-doc.org/core/Kernel.html#method-i-system Hope this article comes to your use.]]>

Enable log rotation within the rails application

coderhs — Wed, 27 Jul 2016 05:00:19 +0000

heroku, as heroku won’t let you store files for more than 15 minutes in their server. You also do not need it if you are using some third party services like loggly or papertrail to manage your logs . In the unix world, you can use log rotate service, which would be installed by default in all linux servers. But we at Red Panthers feel that everything that touches or involves our rails application should be placed along with our rails application as much as possible. If you feel the same way, it can be achieved by placing the code below in the production.rb file.

config.logger = Logger.new( Rails.root.join("log", Rails.env + ".log" ), 5 , 100 * 1024 * 1024 )

The Logger.new accepts three parameters:

The file name, which would be production.log
The number of files you want to keep
The size of each file in bytes. (100 * 1024*1024 means 100 MB)

So, when the time comes to add the 6th 100 MB log file, it will delete the oldest. Unix Way For those who still want to use the unix log rotate, they should create a new config file at /etc/logrotate.d/myrailsapp-config as shown below

$ cat /etc/logrotate.d/myrailsapp-config
/var/www/myrailsapp/current/log/*.log {
  compress
  copytruncate
  daily
  dateext
  delaycompress
  missingok
  rotate 90
}

In case you were wondering, here are what these options mean:

compress – Compress logs using gzip
copytruncate – Copy the log out of the way, and then truncate the existing logs
daily – Rotate daily
dateext – Add the date the logs were rotated as the extension instead of a number
delaycompress – Skip compressing the log until the following day
missingok – Do not raise an error when there is a missing log file
rotate 90 – Keep up to 90 days worth of logs

]]>

unix – redpanthers.co

Different ways to run Shell Commands in Ruby

Enable log rotation within the rails application