IT 244: Introduction to Linux/Unix

IT 244: Introduction to Linux/Unix
Class 24

Microphone

Questions

Are there any questions before I begin?

Homework 11

I have posted homework 11 here.

This will be the last homework assignment.

It is due this coming Sunday at 11:59 PM.

Graded Quiz 9

You can connect to Gradescope to take weekly graded quiz today during the last 15 minutes of the class.

Once you start the quiz you have 15 minutes to finish it.

You can only take this quiz today.

There is no makeup for the weekly quiz.

Tips and Examples

Only One `if ... elif ... else` Clause Will Run

A student once asked me what would happen if more than one test were true ...
inside an if ... elif ... else statement
Let's say we have an if ... elif ... else statement with 2 elif clauses
What would happen if the test conditions for both the 1st and 2nd clauses were true?
The best way to find out is to run a test

I created the following script

if [ -f xxxx ]
then
    echo Found xxxx
elif [ -f foo1.txt ]
then
    echo Found foo1.txt
elif [ -f foo2.txt ]
then
    echo Found foo2.txt
fi

If I run this script in a directory with many "foo" files
```
$ ls -1 foo?.txt
foo1.txt
foo2.txt
...
```
I get this result
```
$ ./elif_test.sh 
Found foo1.txt
```
So if the test for one elif condition were true ...
no further test conditions will be checked

Review

Using `test` in Scripts

Bash provides a synonym for test ...
to make scripts look more like a "real" programming language
A pair of square brackets, [ ] ...
are the same thing as test
To test whether the value of the variable n1 ...
is greater than the value of the variable n2
You could write either
```
test $n1 -gt $n2
```
or
```
[ $n1 -gt $n2 ]
```
There must be a space before and after each square bracket
test returns true or false through the exit status
If test returns an exit status of 0 ...
it means the condition was true
If the condition is false ...
test returns an exit status of 1

The `if ... then ... else ...` Construct

The second type of if statement is the if ... then ... else ... ...

which has the following format

if  COMMAND
then
   COMMAND_1
   COMMAND_2
   ...
else
   COMMAND_A
   COMMAND_B
   ...
fi

If COMMAND returns an exit status of 0
COMMAND_1, COMMAND_2 will be executed
Otherwise COMMAND_A, COMMAND_B, ...
will be run

The `if ... then ... elif ...` Construct

The third type of if statement is the if ... then ... elif ...

In this construct you can test for many different conditions

if COMMAND
then
   COMMAND_1
   COMMAND_2
   ...
elif ANOTHER_COMMAND
then
   COMMAND_A
   COMMAND_B
   ...
...
[else
   COMMAND_N1
   COMMAND_N2
   ...]
fi

elif stands for "else if"
Notice that elif must be followed by then
The then must either be on the next line ...
or the same line separated by a semicolon, ;
The else statement must be terminated by a fi
elif only requires a single fi at the end
You can have as many elif clauses as you wish
The else clause is optional

Checking the Arguments to a Script

If a script must have a certain number of arguments ...
it should check for them
If it doesn't get the right number of arguments ...
it should print a usage message and exit
A usage message has a standard form
```
Usage:   PROGRAM_NAME  ARG1  ARG2  ...
```
There should be one string for each argument ...
after the program name
Each string should indicate what sort of value is needed
For example DIR_NAME when a directory name is required
Use the positional parameter 0 along with basename ...
to get the program name

Like this

if [ $# -gt 0 ]
then
    dir=$1
else
    echo Usage: $(basename $0) DIR_NAME
    exit 1
fi

Debugging Scripts

If you are trying to find a bug in a script you can run Bash with the -x option

The shell will print each line of the script just before it executes that line

$ cat match_three.sh 
#! /bin/bash
#
# takes three stings as input and compares them

if [ $# -lt 3 ]
then
   echo Usage: $(basename $0) string1 string2 string3
   exit 1
fi

if [ "$1" = "$2" -a "$2" = "$3" ]
then
   echo "All arguments match"
elif [ "$1" = "$2" ]
then
   echo "Arguments 1 and 2 match"
elif [ "$1" = "$3" ]
then
   echo  "Arguments 1 and 3 match"
elif [ "$2" = "$3" ]
then
   echo  "Arguments 2 and 3 match"
else
   echo "No arguments match"
fi

$ bash -x match_three.sh foo bar foo
+ '[' 3 -lt 3 ']'
+ '[' foo = bar -a bar = foo ']'
+ '[' foo = bar ']'
+ '[' foo = foo ']'
+ echo 'Arguments 1 and 3 match'
Arguments 1 and 3 match

Before printing a line from the script ...
the shell prints a plus sign, +
This is to let you know that the line is not output from the script

Attendance

New Material

`for ... in ...` Loops

The most common programming construct after the if statement is the loop
Bash provides many kinds of loops but we'll start with the for ... in loop

It has the following format

for LOOP_VARIABLE  in  LIST_OF_VALUES
do
   COMMAND_1
   COMMAND_2
   ...
done

The do must be on a different line from for ...
unless you place a semicolon, ;, before the do ...
just like then in an if statement
The commands between do and done are repeated each time through the loop
In a for ... in loop, Bash
- Assigns the first value in the LIST_OF_VALUES to the variable specified by LOOP_VARIABLE
- Executes the commands between do and done
- Assigns the next value in the LIST_OF_VALUES to the LOOP_VARIABLE
- Executes the commands between do and the done again
- And so on until each value in LIST_OF_VALUES has been used

Here is an example

$ cat fruit.sh
#! /bin/bash
#
# demonstrates the for in loop

for fruit in apples oranges pears bananas
do
   echo $fruit
done
echo Task complete.

$ ./fruit.sh 
apples
oranges
pears
bananas
Task complete.

fruit does not have a dollar sign, $, in front of it at the top of the loop
That's because here we are dealing with the variable ...
not its value
We are telling Bash which variable to use inside the loop

`for` Loops

The for loop is simpler than the for ... in ... loop

It has the following format

for LOOP_VARIABLE
do
   COMMAND_1
   COMMAND_2
   ...
done

The difference between the two for loops is where they get the values
The for ... in ... loop gets values from the list that follows in
These values are "hard coded" into the script
They never change
In practice, the list of values is often created using meta-characters
So the actual values change ...
depending on where the for loop is run
The plain for loop, in contrast ...
gets its values from the command line
This means that this kind of loop can never be used at the command line
It can only be used inside a script
The plain for loop can have different values each time it is run

Here is an example

$ cat for_test.sh 
#! /bin/bash
#
# demonstrates the simple for loop

for arg
do
   echo $arg
done

$ ./for_test.sh foo bar bletch
foo
bar
bletch

$ ./for_test.sh bing bang boom
bing
bang
boom

The Numeric `for` Loop

The for loops above are very different ...
from the for loops in most programming languages
In these languages, the for loop
- Initializes a loop variable to an integer
- Tests the value of the loop variable to decide whether to run the loop one more time
- Changes the loop variable at the end of the loop code
These for loops ...
create the values used in the loop ...
and the values must be integers
But the bash for loops we saw above ...
must be given the values used in the loop
Either from a list following in ...
or from the command line
And the values are strings
But there is a third form of for loop in Bash
This form creates the integer values for the loop variable ...
like most programming languages

It has the following form

for (( CMD_1; CMD_2; CMD_3 ))
do
   COMMAND_1
   COMMAND_2
   ...
done

Notice that the three commands are inside double parentheses
That means that anything inside will be treated as numbers
Not text
The first command gives the loop variable its first value
The second is a logical test
As long as it is true the loop will continue
The third command changes the value of the loop variable
This is done after each pass through of the loop

Let's look at an example

$ cat count_to_five.sh 
#! /bin/bash
#
# this script demonstrates the three statement for loop

for (( count=1; count<=5; count++ ))
do
   echo $count
done

$ ./count_to_five.sh 
1
2
3
4
5

The command count++ increases the value of count by one
Without this, third statement the loop would never end ...
and we would have an infinite loop

`while` Loops

The first two for loops keep running ...
until all values have been used
A while loop continues running ...
as long as the command following while ...
returns a status code of 0

while loops have the form

while  COMMAND
do
   COMMAND_1
   COMMAND_2
   ...
done

As long as the COMMAND returns a status code of 0 ...
the commands between do and done will be run

Let's look at an example

$ cat count_to_nine.sh 
#! /bin/bash
#
# counts to 9, then stops

number=0
while [ $number -lt 10 ] 
do
   echo -n $number
   (( number += 1))
done
echo

$ ./count_to_nine.sh 
0123456789

Double parentheses tells Bash to treat what's inside as a number ...
not a string
The += operator adds the number that follows ...
to the current value of number
The echo command in the while loop uses the -n option ...
so it will not print a newline
This allows the script to print the numbers one right after the other ...
on the same line
To end the output and get a new line ...
we need the final echo command
The condition that the while loop tests must change ...

or the while loop will run forever

$ cat forever.sh 
#! /bin/bash
#
# this loop runs forever

number=0
while [ $number -lt 10 ]
do
   echo  $number
done

$ ./forever.sh 
0
0
0
0
^C

The value of number never changes
So the expression given to test never becomes false ...
and the script loops forever
This is why bother.sh runs for a long time ...

unless you kill it

#!/bin/bash
#
# prints something to the terminal 1000 times

count=0
while [ $count -lt 1000 ]
do
    sleep 5
    echo Excuse me
    (( count++ ))
done

`until` Loops

The until loop is similar the while loop
But the until loop ends ...
when the test condition becomes true
Whereas the while loop stops ...
when the test condition becomes false

The until loop has the form

until COMMAND 
do
   COMMAND_1
   COMMAND_2
   ...
done

Here is an example

$ cat count_until.sh
#! /bin/bash
#
# counts from 1 to its argument, then stops 

if [ $# -eq 0 ]
then
   echo Usage:  $(basename $0)  NUMBER
   exit 1
fi

number=1
until [ $number -gt $1 ]
do
   echo  $number
   (( number += 1))
done

$ ./count_until.sh 10
1
2
3
4
5
6
7
8
9
10

$

while loops are used much more often than until loops

`continue`

Normally, a loop will run through all the commands between do and done
Sometimes, however, you want to skip all or part of the loop commands
Let's say you are calculating interest for a group of savings accounts
In doing this you perform a series of operations on all savings accounts
But if you get to an account that has been closed ...
you don't want to perform these operations
In other words, you want to stop working on a specific account ...
but continue looping through the other accounts
It is for situations like this that continue was created
The shell stops running the loop code ...
when comes to continue inside a loop
So it then jumps to the top of the loop ...
to begin another pass through the loop

Here is an example

$ cat continue.sh
#! /bin/bash
#
# demonstrates how continue works

total=0    
for number in 1 2 3 4 5 
do
   if [ $number -eq 2 -o $number -eq 4  ]
   then  
      continue
   fi
   echo Adding $number to $total
   (( total += $number ))
done
echo 
echo total: $total

$ ./continue.sh
Adding 1 to 0
Adding 3 to 1
Adding 5 to 4

total: 9

When number is not 2 or 4 the loop executes normally
But when in is 2 or 4 it does not advance through the loop code
Instead it jumps back to the top of the loop
continue does not cause the script to break out of the loop
It merely stops running through the rest of the loop code ...
and goes back to the top of the list

`break`

Every time you start a loop ...
you must specify what will cause the loop to end
The first two for loops end when every list value is used
The while and until loops end when a logical condition is met
This is also true for the three statement for loop
In each case the condition that causes the loop to stop ...
is specified at the top of the loop
But what if you encountered some unusual condition inside the loop?
And you wanted to jump completely out of the loop?
To do this, you would have to use break

Let's look at an example

$ cat break.sh
#! /bin/bash
#
# demonstrates how break works

for filename in *
do
   if  [ -x $filename ]
   then
      echo First executable file: $filename
      break
   fi
done

$ ./break.sh
First executable file: bother.sh

This script looks at each file in the current directory
When it finds a file that is executable
It prints that filename and stops
The loop will end either
- When it finds an executable file
- Or when it has examined every file and found no executable file
continue jumps out of the loop for one iteration
But the loop will continue with the next loop value
break will exit the loop completely

Real World `for` Loop Examples

I use a for loop often when doing administrative work for my classes
For example I need to find the Unix username for each student ...
at the start of the semester

I can run finger on a username to get the name behind each username

$ finger it244gh
Login: it244gh        			Name: Glenn Hoffman Dummy
Directory: /home/it244gh            	Shell: /bin/bash
Last login Sun Dec  8 19:29 (EST) on pts/34 from 209.6.202.123
Mail forwarded to glennhoffman@mac.com
No mail.
Plan:
This account is a test account for Glenn Hoffman teaching it244

I only need the top line, so I can pipe this output through head -1

$ finger it244gh | head -1
Login: it244gh        			Name: Glenn Hoffman Dummy

If I go to the class directory ...

the following script will show the name behind each account

$ for username in *
> do
> finger $username | head -1
> done
Login: aburch96       			Name: Austin Burch
Login: ancox          			Name: Andrew Cox
Login: antony11       			Name: Antony Karanja
...

Here is another example
All my important files are backed up in a remote repository using Subversion
Subversion is Unix versioning software
Programmers use versioning software to backup their code
Versioning software numbers each backup ...
and allows you to attach a comment to each
This makes it easy to return to a previous version of your code
To get the latest version of all files in a directory I use
```
svn update
```
I have many different projects, each in their own directory
And each project directory is backed up to this repository
The local copies of each of these project directories ...
are all stored in a single directory
The name of this directory is stored in the variable wksp
I can update each project directory by going to the directory that holds each project directory ...
and runing the svn update command

Here is a script that does this for me

pushd $wksp &> /dev/null
for entry in *
do
    if [ -d $entry ]
    then
    	echo $entry
    	cd $entry
        pwd
        svn update
        cd ..    	
    fi
done
popd &> /dev/null