Today’s post will go into some detail on getting started with Rerun. Rerun is a tool that’s kind of meant to bridge the gap between having a bunch of sysadmin scripts and a full-blown configuration management tool. The truth is that a lot of times, groups have a bunch of bash scripts that can perform differently on different machines or exist in several different versions. This makes it hard to ensure that you’re always using the right one, the right flags are being passed, etc., etc. Rerun sets out to help wrangle your shell scripts and present them as something super easy to use.
- Installing Rerun is really just a ‘git clone’ and then adding a bunch of
variables to your .bash_profile. I rolled it all into a script so it can just be
run (at your own risk). Just issue
chmod +x whatever_you_name.sh, followed by
- Exit the terminal and restart, then issue
rerunto see if it’s working. This should give you a list of the modules installed:
##Create a Module & Command## Now let’s run through the Rerun tutorial. A lot of this part of the post will be a rehashing of that page, with some differences here and there to keep myself from just copying/pasting and not actually committing this to memory. We will be creating a waitfor module that simply waits for a variety of different conditions like ping to be available at a given address, a file to exist, etc..
- Rerun uses a module:command type syntax, where module is kind of the general idea of what you’re trying to do, while command is the specifics. So, let’s use the stubbs module’s add-module command to create the bones for our waitfor module:
- Okay, now let’s add a ping command to our waitfor module with
Note that this command creates both a script and a test.sh file. script is what will actually get run, the test file is for us to write a test plan.
- For ping, we’ll want to add a host and an interval option. Host will be required, while we will set the interval option with a default and make overriding that optional.
- Set the required host option:
- Set the optional interval option:
- Let’s make sure our params look right by checking the output with
rerun waitfor. Rerun gives a pretty easy to read/understand output when you try to figure out what a module is capable of.
##Implement the Command## So now we’ve got our command created, but it doesn’t actually do anything. Rerun can’t read our mind, so it just lays down some basics and it’s up to us to implement the particulars.
- Open the file
~/rerun/modules/waitfor/commands/ping/scriptfor editing. Scroll down to the bottom, where you will see:
- Replace the ‘Put the command implementation here’ with your code. I had to throw in a -t flag in the ping command to timeout quicker on Mac. For our ping check, the code will look like:
- Test it out with a call to localhost. This should always return a positive ping.
rerun waitfor:ping --host localhost --interval 1
##Write Tests## Okay, let’s write the tests for our new command. This will help us ensure it’s working the right way.
~/rerun/modules/waitfor/tests/ping-1-test.shfor editing. Remove the whole ‘it_fails_without_a_real_test’ block.
We’ll create two new functions. One will check that the required host is present. The other will check that localhost responds as expected. These tests are straight from the wiki tutorial with extra comments to explain what’s actually happening.
- Finally, let’s check that the output of the stubbs:test command to make sure
our tests pass. Issue
rerun stubbs:test --module waitfor --plan ping
##Extend, Extend, Extend##
Now that we have learned all of the functionality from the official tutorial, it’s time to extend our module to do other things. Consider what the ‘waitfor’ module is for. It is there to wait on things in general, not just ping responses. So let’s extend our module to support another wait use case, waiting for a file to exist.
- First let’s add the new command to our module. This is as simple as it was earlier, just pass the proper options as needed:
- Add options for the filepath we want to check, as well as the interval we want to wait to check:
- Time to implement the actual logic behind our file checker. You’ll notice that since this command is similar in function to our ping command, a lot of the same logic that we used previously still applies. Here’s the relevant bash from ‘waitfor/commands/file/script’:
- We can now see this in action by issuing our command, waiting for a few cycles to occur, then touching the file that we want to exist in another terminal. For me, the touch command was simply touch /tmp/test.txt.
- Finally, we would want to write some tests around this command to ensure it functions as expected when variables are missing, etc.. This post is getting pretty lengthy, so I will leave that task up to you.
And that’s it! I hope you enjoyed this intro to Rerun. It’s a really fun tool to use once you pick up the basics, and it really makes it dead simple to allow other team mates (even those who may not be very adept with bash) to execute scripts in a known, repeatable manner.