I just migrated onto a newer, bigger server (read that as “more expensive”, of course, but because my traffic's justifying it, I'm good with the change). To make matters more interesting, I also just bought a new laptop (a MacBook Pro), and between the two migrations, I've been looking through a lot of old directories and bumping into all sorts of scripts I've written in the past few years.

The one I thought would be interesting to explore here is one I wrote for a pal who was involved in a charity and wanted a way to have a single URL bounce people 50/50 to one of two different Web pages—a sort of mini-load balancer, though his application wasn't quite the same.

The core piece of this is the $RANDOM shell variable that's actually kind of magical—each time you reference it, you'll find it's different, even though you aren't actually assigning a new value to it. For example:

$ echo $RANDOM
21960
$ echo $RANDOM
19045
$ echo $RANDOM
2368
$ echo $RANDOM
2425
$ echo $RANDOM
10629

This violates the core user design principles of the shell and even the very definition of variables (which are supposed to be predictable—if you assign the value 37 to it, it still should have that value 200 lines and 17 references later). Other variables change value based on what you're doing, without you actually assigning it a new value, like $PWD, but because that's the present working directory, if you move around in the filesystem, it's logical that its value would change too.

The RANDOM value, however, is in a category of its own and makes it super easy to add some pseudo-randomness to your scripts and user interaction (whether it's truly random is a far more complicated—mind-numbingly complex—issue. If you're interested, try Googling “determining the randomness of random numbers” to jump down that particular rabbit hole.

In the Bourne Again Shell (bash), RANDOM numbers are within the range of 0..MAXINT (32,767). To chop it down and make it useful, you can simply divide it by the max numeric value you seek.

In other words, if you want a random number between 1..10, for example, use the % “remainder” function with a call to expr:

$ expr $RANDOM % 10
7
$ expr $RANDOM % 10
5
$ expr $RANDOM % 10
9
$ expr $RANDOM % 10
6
$ expr $RANDOM % 10
8

Boiling this down further, how to choose between two options randomly now should be jumping out of the page at you, dear reader:

if [ "$(expr $RANDOM % 2 )" -eq "0" ] ; then
      conditional expression
fi

If you wanted to be a purist, you also could write this with the $(( )) math notation, of course, as you'll see a bit later in this column.

That's enough for us to write the shell script I mentioned earlier, the one that randomly switched between two possible pages when invoked:

#!/usr/local/bin/bash
url1="http://www.bing.com/"
url2="http://www.google.com/"
if [ "$(expr $RANDOM % 2 )" -eq "0" ] ; then
  echo "Location: $url1"; echo ""
else
  echo "Location: $url2"; echo ""
fi
exit 0

Can you see what this example script does? If you guessed “randomly redirects you to either Google or Bing”, you're right! If not, well, what the heck? Go back and read the code again!

Now, let's say my friend said “75% of the time, I really want to take people to URL1. Can you do it, Dave?”

Here's how that might look:

if [ "$(expr $RANDOM % 100 )" -lt "75" ] ; then

(Or, even more clearly as % 4 -lt 3, for that matter.)

If you have more than two choices, you can use a case statement that makes uneven allocation a bit tricky but otherwise is straightforward:

case $(( $RANDOM % 4 )) in
  0 ) echo $url1;               ;;
  1 ) echo $url2;               ;;
  2 ) echo $url3;               ;;
  3 ) echo $url4;               ;;
esac

With this in mind, we could write an n-way load-balancing script, so that when people come to the home page, they automatically would be bounced to one of the n possible servers.

The interesting step actually would be to round-robin them, based on the server load, of course, which could be done by stepping through the data using the ruptime command.

So, given the uptime output of:

$ ruptime host1
host1   16:51  up 3+53:17, 3 users, load 0.65 0.68 0.51

What we really want is to get a list of hostnames sorted by how busy those systems are, which can be generated by ruptime with the -rl flags, as shown here:

$ ruptime -r -l
host1   down   16+08:34
host4   up     10+13:26,   7 users,  load 0.07, 0.39, 1.04
host3   up     14+06:49,   3 users,  load 0.10, 0.38, 0.49
host2   up      1+17:40,   4 users,  load 0.18, 0.13, 0.09

As you can see, the first step is to screen out the hosts that aren't actually up at the present moment, then grab the first field (as it's sorted by how busy the system is at the current moment).

One approach to this could be to call ruptime every time a request comes in and just grab the first value. This can be done like so:

$ ruptime -rl | grep -v down | head -1 | cut -d\  -f1
host2

The trouble is that the systems report uptime information only approximately every minute, and calling ruptime dozens or hundreds of times per second can end up producing a problem—the least-busy system will be swamped. If you get a lot of traffic, that's not going to be a manageable solution.

Here's where we could have our friend $RANDOM step back into the picture. Instead of always simply picking the machine with the lowest load average, let's randomly choose one of the three least-busy systems. The core snippet would look like this:

getline="$(( ( $RANDOM % 3 ) + 1 ))"
targethost="$(ruptime -rl | grep -v down |

   sed -n ${getline}p | cut -d\  -f1)"

With a bit more code, you could bias it so that, say, 50% of the time it would pick the least-busy system, 33% of the time it would pick the second-least-busy system, and 17% of the time it would pick the third-least-busy system. As time passed and as the load moved around, these systems would keep changing, and you'd achieve a crude but effective load-balancing system.

Knowing how easily you can select one of a number of possible paths randomly in a shell script, what else can you imagine that would be helpful or just fun?