Creating an Easy Lookup Table in a UNIX or Linux Shell Script

As a Configuration Manager, I'm always looking for ways to improve the automation of the builds and deployments of my company's applications. We use scripts to compile the apps, replace certain token strings with environment-specific values, and copy the new executable code out to the production servers. Ideally, we should not have to use separate scripts when deploying to different run-time environments (development, integration test, production, etc.). We want instead to pass the target environment into these scripts, and use logic to determine environment-specific values. So I set out to create a Lookup Table to set the values according to the target environment.

I wanted to keep it simple so maintenance would be easy. I wanted it to run in a basic command shell (I use 'bash', but most other shells would work as well). UNIX and linux utilities like 'sed', 'awk,' and various xml parsers would have done the job, but they added complexity so I stayed away from them (although I did use 'grep'). The listing below is a simplified version of what I came up with. It takes one parameter representing the target environment, and sets 3 variables: the target server, the target database, and a process user ID. It then prints the new values to the screen for verification (an optional step). In reality, the unsimplified version of this script also defines target directories, service names, and website urls among other things, but this is enough to give you the idea:

Listing 1#!/bin/bash
# Sets environment variables based on lookup string
# Environments: DEV = Development, QA = Quality Assurance,
# UAT = User Acceptance Test, PROD = Production
ENVIRONMENT=$1

# Set server addresses, database names, and user IDs.
line=`grep ^$ENVIRONMENT --- ------------------------ --------- ----------
DEV dev.myapp.mybusiness.com myappdev devappuser
QA qa.myapp.mybusiness.com myappqa qaappuser
UAT uat.myapp.mybusiness.com myappuat uatappuser
PROD prod.myapp.mybusiness.com myappprod prodappuser
EOF`

set -- $line
export AppServer=$2
export DataBase=$3
export UserID=$4
#
# Show environment settings:
echo "AppServer = $AppServer"
echo "DataBase = $DataBase"
echo "UserID = $UserID"

Sample run:
$ ./Lookup.sh DEV
AppServer = dev.myapp.mybusiness.com
DataBase = myappdev
UserID = devappuser
$

Using the Technique

Knowing how this script works is not essential to using the technique, as long as you realize that you can expand it by adding more values to the ends of the input lines, and creating enough values with the 'export' statements to accomodate the new values. If you have more than 4 target environments, you simply create more input lines, using the first word in each line to match the additional environment identifiers. If you want to understand what's happening, so that you can expand upon and evolve the technique, read on.

The first key to understanding this script is knowing how redirection works. In shell scripts as in DOS, '>'s redirect standard output, usually to a file. '>>' also redirects output to a file, but appends to the end of the file instead of over-writing it. 'The second key to understanding this script is knowing that the back-ticks '`' tell the shell to execute everything between them and return the result as a string. In our case, the back-ticks enclose the grep command and the input we're feeding to grep, so the shell will execute this and assign the resultant string to our variable 'line.' So, in our example run, we passed in the word 'DEV' as the parameter, and assign it to the variable $ENVIRONMENT. We then send all the text between the EOF strings in the script to grep, which only returns the one line beginning with 'DEV.' It assigns this line to the variable $line.

The third and final key to this script is the 'set' line. You may know that parameters you pass into a script on the command line are automatically assigned to the general variables $1, $2, $3, and so on. That's how we got the $ENVIRONMENT variable assigned. 'set' has a number of functions, but this script is only using one, which is to re-assign those general variables to the values of the given variable, $line. set -- $line does this. So, in the example run, $line contains the input line matching 'DEV'. $1 is assigned the first word ('DEV'), $2 is assigned 'dev.myapp.mybusiness.com', $3 gets 'myappdev', and $4 gets 'devappuser.' Then it's just a matter of giving those values meaningful variable names, and dumping them to the screen with the 'echo' commands.

There you have it. A simple Lookup Table, implemented in a shell script, which can be used to assign a group of values to a set of variables based on an input parameter. You can then use these variables to deploy your applications to a number of different environments without a lot of complex if-then-else logic to determine environment-specific settings.