CSE 374, Lecture 5: Shell Scripts

Exit codes

We use the command "exit" to quit an ssh session ("logging off") or to quit a shell script (end the program). "exit" also has an optional "error code" that you can provide to it to indicate whether or not the program ran successfully. An exit code of "0" indicates no errors (and is the default).

    # Both of the following exit statements do the same thing - indicates no error
    exit
    exit 0

On the other hand, "1" indicates a general error of some kind. So if we add a value of 1 in the case of something going wrong (like not enough arguments), we will indicate that things failed.

    exit 1

There are other codes that are conventionally used for certain kinds of errors - investigate on your own to see what those are and what they mean.

Comparison with Java

• Bash is really good at file access and processing, executing other programs, and connecting program output together via pipes. It's interactive and fast. However it has a lot of gotchas, weird shortcuts and metacharacters, and bizarre quoting rules.

• Java has none of the previous gotchas and weird rules due to static typechecking, compilation, modularity, local variables, array-checking, and real data structures. However, it's more complicated for writing simple programs and takes longer.

• Treatment of strings

                      Java        bash
   Use a variable     foo         $foo
   The string foo     "foo"       foo
   Assign variable    foo = "hi"  foo=hi
   Concatenation      foo + "oo"  ${foo}oo
   Convert to number  library     silent
  

• In Java, variable use is generally easier than string constant use, while in bash it is the opposite.

Scripting: general rules of thumb

• No shell scripts longer than 200 lines.
  • HW3 will push the limits here (scripting isn't really a great language due to all the gotchas we've discussed)
• Never do something manually if automating via a script would be faster.
• Never write a script if you need a large or robust piece of software.
• Use SPACES NOT TABS to make things more readable

Script: Safe Delete

Today, we'll review what we've learned about scripting to write a program "sdel" that safely deletes a file. This is similar to how the "Trash" works on a normal GUI operating system - when you delete a file, the file is not actually deleted but is instead moved to a folder called "TRASH". After a certain period of time in the TRASH (let's say 2 days), the files are then permanently deleted. In addition, we will compress the files using a utility called "tar" before putting them in the trash to save space.

First, we need to see whether the TRASH folder actually exists. Let's put the TRASH in the user's home directory.

    #!/bin/bash
    trash=~/TRASH
    if [ ! -e $trash ]; then
      mkdir $trash
    elif [ ! -d $trash ]; then
      echo "usage: trash is not a directory"; exit 1
      exit 1
    fi

Here we're using a few new ideas:

• File tests. In the first if statement, we test for whether the trash exists with the "-e" ("exists") check, and in the else-if case, we check whether the trash is in fact a directory and not a regular file with the "-d" check ("directory").
• Semicolon (;). Notice that we're using semicolons here. What do semicolons do? They allow us to combine multiple commands on a single line, and they will be executed one after the other. This is definitely not necessary - we can split all of the commands in the previous example onto their own lines - but it is a demonstration fo what you can do.
• Exit codes.

Now we want to go through the files given to the sdel command, tar them up, move the tar to the TRASH directory, and delete the original file.

    while [ $# -gt 0 ]; do
      if [ ! -e $1 ]; then
          echo "tried to delete file that does not exist:" $1; shift; continue
      fi
      tarname="$1.tar"
      tar -cf "$tarname" "$1"
      mv "$tarname" $trash
      rm -rf "$1"
      shift
    done

Note a few things we're using in this piece:

• Another file test - make sure the file exists with the "-e" test.
• A "continue" statement. When used in a loop, "continue" means that we should continue on to the next iteration of the loop, abandoning anything else for this iteration of the loop.
• Using the "tar" command to create a compressed directory.
• Using quotes around the variable names. Why would we use quotes, and not just the raw $1? Hint: what if we pass * as a parameter to this script?
• Shift to move to the next argument.

The final piece is to delete any files older than 2 days from the TRASH directory.

    now=`date +%s`
    cd $trash
    for f in `ls`; do
      fileage=$(stat -c '%Y' "$f")
      if [ $((now - fileage)) -gt $((60*60*24*2)) ]; then
        rm -rf "$f"
      fi
    done

What to note in this bit of code:

• Backticks (``). In the first line, we set a variable "now" equal to the result of the "date" command. We can do this by putting the date command in backticks (`date +%s`) which tells the shell to execute as a command whatever is stored in the backtick and use that value. We can also do this in the for loop - use the result of ls (which is all files in the trash directory) and iterate through those files with a for loop.
• We can also set variables like fileage to the result of a command with the $() syntax. This works too!
• Math. We're doing math to test whether the difference between now and the time the file was last touched is older than 2 days.

Last note

All of this work that we've been doin with scripts is NOT the same as the "script" command! The script command is misnamed; you've been using it to record your shell session in a file, but you can't actually run the resulting file. The "script" command is very different from the runnable scripts that we have been writing.