Running and Debugging Scripts
1. Running a Shell Script
A shell script is just a text file with commands. To run a shell script, you need to follow a few steps:
Making a Script Executable
Before running a script, you need to ensure it has executable permissions. This is done using the chmod command.
Example:
Suppose you have a script called myscript.sh. To make it executable, run the following command:
chmod +x myscript.sh
The chmod command changes file permissions. The +x flag adds executable permissions, allowing the script to be run.
Running a Script:
Once a script is executable, you can run it by specifying the path to the script.
Example:
To run the script in the current directory:
./myscript.sh
The ./ tells the shell that the script is located in the current directory. Without it, the shell will search for the script in directories listed in the PATH environment variable.
Running Scripts with Bash Explicitly:
If you want to run a script without making it executable, you can call the script directly with bash or sh.
Example:
bash myscript.sh
This command tells Bash to execute the script without needing to change its permissions.
2. Understanding Errors and Debugging
When you run a script, you may encounter errors that prevent it from functioning as expected. There are two main types of errors: syntax errors and runtime errors.
Syntax Errors:
Syntax errors occur when the script contains incorrect syntax, such as a missing fi or incorrect use of commands. These errors will prevent the script from executing.
A missing fi in an if statement
#!/bin/bash
if [ $1 -gt 10 ]
then
echo "Number is greater than 10"
# Missing fi here!
Fix: The correct script should include the fi statement to close the if block:
#!/bin/bash
if [ $1 -gt 10 ]
then
echo "Number is greater than 10"
fi
Runtime Errors:
Runtime errors occur when the script runs but encounters issues during execution, such as trying to access a non-existent file or directory, or encountering invalid input.
A script that attempts to copy a file that doesn't exist:
#!/bin/bash
cp non_existent_file.txt /tmp/
Error Message: The script will fail with an error like below.
cp: cannot stat 'non_existent_file.txt': No such file or directory
Fix: You should check whether the file exists before attempting the cp command.
#!/bin/bash
if [ -f non_existent_file.txt ]
then
cp non_existent_file.txt /tmp/
else
echo "File does not exist!"
fi
3. Debugging a Shell Script
Sometimes, you may need to debug your script to identify where it's going wrong. There are several ways to approach this:
Using echo for Debugging:
The simplest way to debug a script is by inserting echo statements to print the values of variables and check the flow of execution.
Example: Debugging a script with echo:
#!/bin/bash
var1="Hello"
var2="World"
echo "var1: $var1"
echo "var2: $var2"
This will print the values of var1 and var2 so you can verify that the variables are set correctly.
Using set -x for Tracing:
The set -x command enables debug mode, where the shell prints every command before executing it. This is useful to trace the script's execution and understand where things go wrong.
Example: Add set -x at the beginning of your script:
#!/bin/bash
set -x # Enable tracing
echo "This is a test"
ls /non_existent_directory
When running the script, every command and its output will be printed, helping you pinpoint the error:
+ echo 'This is a test'
This is a test
+ ls /non_existent_directory
ls: cannot access '/non_existent_directory': No such file or directory
Using set -e for Stopping on Errors:
The set -e command causes the script to stop as soon as any command returns a non-zero exit status (an error). This is helpful for preventing scripts from running through multiple errors that might otherwise go unnoticed.
Example: Using set -e in a script:
#!/bin/bash
set -e
echo "This is a test"
ls /non_existent_directory
echo "This will not run"
The script will stop after the ls command fails, and the second echo statement will not be executed.
Using trap for Error Handling:
You can use the trap command to catch errors and define a custom error handler. For example, you can log an error message if something goes wrong.
Example: Trap errors and print a custom message:
#!/bin/bash
trap 'echo "An error occurred. Exiting..."; exit 1' ERR
echo "Starting script"
ls /non_existent_directory
echo "This will not run"
If the ls command fails, the script will display the custom error message and exit.
4. Common Debugging Practices
Here are some general tips to help debug shell scripts more efficiently:
- Check for Typos: Simple typos in variable names or commands can cause errors.
- Use Comments: Comment out sections of your script and run them incrementally to isolate the problem.
- Test in Parts: Break the script into smaller sections and test them individually to make sure each part works as expected.
- Use Logical Operators: Ensure your conditions and loops are structured correctly with proper logic (e.g.,
if,else,&&,||). - Check Command Exit Status: Use
$?to check the exit status of a command:
command
if [ $? -ne 0 ]; then
echo "Command failed!"
fi
5. Exiting Scripts with Exit Status
Shell scripts can exit with an exit status, where 0 indicates success and any non-zero number indicates failure.
Example: A script that exits with a status of 1 if a file is missing.
#!/bin/bash
if [ ! -f "file.txt" ]; then
echo "File not found!"
exit 1
fi
The script checks if file.txt exists. If it doesn't, it prints an error message and exits with a status of 1.
Key Takeaways
- Running Shell Scripts: Learn how to make scripts executable and run them using
bashor./script.sh. - Debugging Techniques: Use
echofor tracing variable values,set -xfor command tracing, andset -eto stop execution on errors. - Error Handling with trap: Implement the
trapcommand to handle errors gracefully. - Common Debugging Practices: Focus on checking for typos, logical errors, and proper use of commands.
- Exit Status Handling: Use exit codes (0 for success, non-zero for failure) to control the flow of your scripts and handle errors effectively.