Ruby development for system administrators

Most Linux and UNIX system administrators use a diverse mix of shell scripts and tools like grep, awk, cut and so on. The classical approach has proven its merits, but these scripts are generally not easy to read or to maintain. One solution is to use a real programming language for system administration tasks. In a complex environment, system administration can become much easier with a real programming language instead of shell scripts. Traditionally, Perl has been very popular among sysadmins, but some people maintain that this is not much better than shell.

In this article, we choose Ruby, a feature-rich but simple object-oriented programming language known from the popular web application framework Ruby on Rails. The Ruby programming language has many built-in and external libraries that can come in handy for typical system administration tasks such as file manipulation and text processing, log file analysis, logging into other servers, and so on. The gentle learning curve of this programming language, coupled to the easy-to-read and maintainable form of the scripts, makes this a valid choice for sysadmins.

Simple but effective
Let’s start with some basic features of the language, to show you why Ruby is in many cases a better choice than Perl or a shell script. First of all, everything in Ruby is an object, even primitive types such as numbers and strings. For instance, an array of numbers is just an object, which has methods and properties. This has a very simple syntax. For example, this is how you get the length of an array:

[1, 2, 3, 4, 5].length

And this is how you get the last element of an array:

[1, 2, 3, 4, 5].last

A second powerful feature are code blocks, which allow for shorter and easier-to-grasp code. A code block is a function without a name, that can be passed to another function as a parameter. For example, if you have an array of numbers, you could double each one in one line:

numbers = [1, 2, 3, 4, 5]
doubles = numbers.collect { |n| 2*n }

#!/usr/bin/env ruby
require ‘mysql’
db = Mysql.new(“localhost”, “root”, “password”)
db.select_db(“myusers”)
result = db.query(“select name,email from users”)
result.each { |row| puts “User #{name} has email address #{email}” }

resolve = `host #{address}`
puts “Host #{address} does not exist” if resolve =~ /does not exist/

#!/usr/bin/env ruby
require ‘csv’
ip = ARGV[0]
CSV::Reader.parse(File.open(‘bandwidth.csv’)) do |row|
if row[0].to_s == “download” and row[1].to_s == “day” and row[3].to_s == ip
   puts “From #{Time.at(row[4].to_i)} to #{Time.at(row[5].to_i)}: #{row[6].to_i/1048576} Mbytes”
   end
end

#!/usr/bin/env ruby
require ‘csv’
require ‘rexml/document’
ip = ARGV[0]
xml = REXML::Document.new
root = xml.add_element(“statistics”)
CSV::Reader.parse(File.open(‘bandwidth.csv’)) do |row|
   if row[0].to_s == “download” and row[1].to_s == “day” and row[3].to_s != ‘COMBINED’
   ip = row[3].to_s
   host = root.elements[“host[@ip=’#{ip}’]”]
   if host == nil
   host = root.add_element(“host”, {“ip” => ip})
   end
   day = host.add_element(“day”)
   day.attributes[“begin”] = Time.at(row[4].to_i)
   day.attributes[“end”] = Time.at(row[5].to_i)
   day.add_element(“bandwidth”, {“bytes” => row[6].to_i})
   end
end
puts xml

In our previous scripts, we already used the method File.open to read a file. We can also create a new file and write text to it:

file = File.new(“temp.txt”, “w”)
file.puts(“foobar”)
file.close

We can also do a lot with file metadata:

puts File.open(“temp.txt”).atime
File.open(“temp.txt”).chmod(0600)
File.open(“temp.txt”).chown(1000, 1000)

But most of the interesting methods are class methods, which take the filename as an argument…

File.dirname(“/home/koan/temp.txt”)
File.basename(“/home/koan/temp.txt”)
File.size(“/home/koan/temp.txt”)
File.delete(“/home/koan/temp.txt”)
File.exists?(“/home/koan/temp.txt”)
File.directory?(“/home/koan/temp.txt”)
File.executable?(“/home/koan/temp.txt”)

There’s also a Dir class for directories, a module FileUtils for copying, moving, removing files and so on, and a module Find to make it easier to recursively search for files under a directory. We’ll illustrate this in a script that searches for backup files (*~) in a directory (recursively) and zips them for archival. The original files can then be deleted safely, but we leave this as an exercise to the reader.

#!/usr/bin/env ruby
require ‘rubygems’
gem ‘rubyzip’
require ‘find’
require ‘zip/zip’

directory = ARGV[0]
pattern = “*~”
Zip::ZipFile.open(“backup.zip”, Zip::ZipFile::CREATE) do |zipfile|
   Find.find(directory) do |path|
      filename = File.basename(path)
      if File.directory?(path)
         if filename == ‘.’ or filename == ‘..’
            Find.prune
         end
      else
         if File.fnmatch(pattern, filename)
            puts path
            zipfile.add(path.sub(directory, “”), path)
         end
      end
   end
end

Here we see another way to install a non-standard Ruby library: using Ruby gems, the programming language’s own package manager. The directory that we want to search in is the first argument to the script, and the search pattern is ‘*~’. Then we create a zip file and start searching in the directory with the Find.find method.

This will iterate through each file recursively. If the file is ‘.’ (the current directory) or ‘..’ (the parent directory), we don’t look any further into this directory. If it’s another directory we don’t do anything with the directory itself, which means that next it’s the turn of the files in this directory. In the other case (the current file is a regular file), the filename is matched to the pattern – if it matches, the file is added to the zip file, with its relative path to the directory we searched in as the zip index.

Advanced usage
Of course, Ruby is not the holy grail for sysadmins. There are a lot of cases where Perl or even shell scripts are better. For example, the number of Ruby libraries can’t beat the breadth of Perl modules in CPAN. So if your task requires such functionality, it’s probably better to use Perl. However, Ruby catches on quickly, and recently some powerful system administration tools have been written in Ruby, such as the configuration management tool Puppet, which we’ll talk about in another article.

The examples we have shown are of course rather basic, but you get the picture. If you want to do some serious sysadmin tasks in Ruby scripts, you have to take care of error handling and a robust command-line interface instead of just using ARGV[0]. The GetoptLong module can parse the command’s arguments and options in a structured way.
When your Ruby sysadmin scripts begin to grow in complexity, it’s also a good idea to restructure them as Rake tasks. Rake originated as a simple Ruby build program with capabilities similar to the UNIX make command, but it’s also very usable to do deployment tasks or migrate database schemas.