I just got back from a trip where our team had to install a bunch of machines. There were fifteen machines total, but with the Solaris zones, we had twenty-eight total operating systems to work on. And on each of these systems, we had a number of things we had to do as we prepared them for production use -- create user accounts, disable unneeded services, copy some configuration files in place, set up some cron jobs... multiply that by twenty-eight, and it wasn't long before I was very, very tired of typing the same login and password.

It seemed to me that these very repetitive tasks were something that should be automatable. Then I remembered a tool I used years ago that might very well be just the trick.

Expect is an automation tool that automates interactive applications. The concept is really simple -- you tell it to send some data, and it expects a response. Expect has been around for ages: 1990, back when the command line was king.

Setting up a basic Expect script is pretty simple, since you can just copy the sample scripts or code chunks from the man page. If you want to do something like, say, updating multiple systems by reading lists of IP addresses from a file, reading arguments from a command line, and prompting for passwords and what commands to run (all of which I did), you have to know a little of Expect’s underlying language, TCL (Actually, there are variants of Expect now for Python, Perl, Java, and Ruby).

TCL (Tool Control Language) is a very straight-forward language, although a little unusual for someone used to the syntax of Java. For example, here’s a one-liner that sets the value of the variable “a” to the second item in a list:

% set a [ lindex { abc def ghi } 2 ]
ghi

The key parts of the script that I wrote were to read the list of host names from a file and to then iterate over that list. Here’s how I read in the host names, after setting the variable hostInputFile from command line or user input.

# read in the lines of the file into a variable
set fileLines [split "[read [ open $hostInputFile r]]" \n]

# iterate over each line
for {set lineIndex 0} { $lineIndex < [llength $fileLines]} {incr lineIndex} {
	# select the next line and trim it
	set nextLine [string trim [lindex $fileLines $lineIndex]]

	# append if line doesn’t begin with ‘#’ and line isn’t empty
	if {[ string first # $nextLine ] != 0
		[ string length $nextLine ] > 0} {
		lappend hostList $nextLine
	}
}

Later, I iterate over the list of hosts in hostList…

for {set hostIndex 0} {$hostIndex < [llength $hostList]} {incr hostIndex} {
	# get the next host from the list
	set nextHost [lindex $hostList $hostIndex]

	# spawn ssh
	spawn ssh -l $loginUser $nextHost
	expect -timeout 30 -nocase "password: "
	send $password
	send "\n"
	expect "bash"
	expect -re " $"

	# do whatever it is you need to do on this system
	# …

	send "exit\n"
	expect -re "Connection.*closed\."

	close
	wait
}

Not too complicated, eh? Running scripts similar to this (which actually DID something once logged in) took perhaps a minute to run on dozens of systems. Compare that with the tedium of typing the same logins and passwords and commands over and over, and you can see the usefulness of Expect.

Expect – a good tool for multi-system updates!