Bash source Command with Examples

The Bash source command is an essential utility in Linux and UNIX systems, designed to read and execute commands from a file within the current shell environment. This built-in tool is especially useful for loading functions, variables, and configurations into your shell scripts.

Key Uses of the Bash Source Command

Modify Current Shell: Unlike running a script in a subshell, the source command allows modifications to the current shell environment. This is useful for setting variables or defining functions.
Configuration Loading: The source command can load settings from a separate file, making your scripts more modular and easier to manage.
Code Reusability: By placing commonly used functions or variables in a separate file, the source command allows you to include them in multiple scripts, adhering to the DRY (Don’t Repeat Yourself) principle.
Dynamic Code Execution: The source command can execute dynamically generated code, offering flexibility in advanced scripting scenarios.

While powerful, the source command should be used with caution. Always review the contents of a file before sourcing it, and be mindful that it executes commands in the current shell, which can have unintended consequences.

The upcoming sections will comprehensively examine the Bash source command, including its syntax and practical examples. This guide aims to enhance your understanding and utilization of this indispensable tool in Bash scripting.

Basics of the Bash Source Command

Syntax of the Source Command

The source command follows a simple syntax:

source FILENAME [ARGUMENTS]
. FILENAME [ARGUMENTS]

Here, source and . (a period) are interchangeable, both representing the same command. The FILENAME should be the full path to the file you want to source. If a full path is not provided, the command will search for the file in the directories specified in the $PATH environmental variable. If the file is not found in the $PATH, the command will look in the current directory.

Any ARGUMENTS given will become positional parameters to the FILENAME. If the FILENAME exists, the source command exit code is 0, indicating success. If the file is not found, it will return 1, indicating an error.

Basic Examples of the Source Command

Let’s look at some basic examples of how to use the source command.

Sourcing Functions

Suppose you have shell scripts that use the same functions. You can extract these functions into a separate file and then source that file in your scripts. For instance, let’s create a file that includes a bash function that checks whether the user running the script is the root. If not, it shows a message and exits the script.

Create a file named functions.sh:

check_root () {
  if [[ $EUID -ne 0 ]]; then
    echo "This script must be run as root" 
    exit 1
  fi
}

Now, in each script that needs to be run only by the root user, simply source the functions.sh file and call the function:

#!/usr/bin/env bash

source functions.sh
check_root

echo "I am root"

If you run the script above as a non-root user, it will print “This script must be run as root” and exit. This approach makes your scripts smaller, more readable, and allows you to reuse the same function file whenever needed. If you need to modify a function, you only need to edit one file.

Loading Configuration Files

With the source command, you can also read variables from a file. The variables must be set using the Bash syntax, VARIABLE=VALUE. Let’s create a test configuration file named config.sh:

VAR1=foo
VAR2=bar

In your bash script, use the source command to read the configuration file:

#!/usr/bin/env bash

source config.sh

echo "VAR1 is $VAR1"
echo "VAR2 is $VAR2"

If you run the script, the output will look like this:

VAR1 is foo
VAR2 is bar

So, if you want to store the “SHELL” environment variable in a new variable named “MYSHELL”, you would write:

export MYSHELL=$(echo $SHELL)

Bash Source Command: Basic Examples

Executing Functions on Terminal

If you have a bash script, you can use source to execute it instead of using a period. The syntax for that is shown below.

source script.sh

The advantage of using source over a period is that with source, you can use the current and the parent variables, even those defined, without using the export keyword.

Importing Functions from Another Script

You can also execute functions in another bash script to build a library of functions. Let’s have a script named demo1.sh with one function that prints the uptime.

uptime_func() {
  uptime
}

Let’s create another script, verify.sh. If we needed to access the function from another bash script, we could achieve that using the source command. You first source the name of the file.

#!/bin/bash

source demo1.sh

uptime_func

Once that is done, you can proceed to use functions from the other script on the current script. You can execute the script on the terminal to confirm that it works.

Importing Functions on Terminal

You can also import a function into the current shell. To do that, you first source the file.

source demo1.sh

Once you have the file imported, use its functions on the terminal.

uptime_func

Updating Variable Values

Suppose you needed to update the values of variables in a given script regardless of its location. In that case, you could source the script, then update the variable without using the export command. In this example, we are updating a script named linuxcapable.sh.

Let’s start by sourcing the file, and we can do that by adding its full path.

source /path/to/linuxcapable.sh

Once we’ve sourced it, go ahead and update the variable.

VAR1=new_value

Execute the script using the source command to verify the updates.

source linuxcapable.sh

Passing Environmental Variables

When using source, you can also import environmental variables when writing a script. You could choose to read and set various environmental variables, or collect any variable from the imported file, and use it in your script.

In such a case, all you need to do is to source the path to the environmental variable; from there, you can use any of its functions.

For instance, let’s create a script that sources the ~/.bashrc and gets a value from the imported environmental variable.

#!/bin/bash

source ~/.bashrc

echo $PATH

Executing the script gives a value from the imported environmental variable file.

Bash Source Command: Advanced Scenarios

Using Source with Conditional Statements

The source command can be used in conjunction with conditional statements to perform more complex operations. For instance, you might want to source a file only if it exists and is readable. Here’s how you can do that:

#!/bin/bash

FILE=/path/to/your/file

if [[ -r $FILE ]]; then
    source $FILE
else
    echo "File does not exist or is not readable"
fi

In this script, the -r test checks if the file is readable. If it is, the script sources the file. If not, it prints a message.

Sourcing Files in a Loop

If you have multiple files to source, you can use a loop. This is particularly useful if the files are in a specific directory or follow a naming pattern. Here’s an example:

#!/bin/bash

for FILE in /path/to/files/*.sh; do
    if [[ -r $FILE ]]; then
        source $FILE
    else
        echo "Unable to source $FILE"
    fi
done

In this script, the for loop iterates over all .sh files in the specified directory. If a file is readable, the script sources it. If not, it prints a message.

Sourcing a File Based on User Input

You can source a file based on user input. This can be useful in scripts that need to load different configuration files based on the user’s choice. Here’s an example:

#!/bin/bash

echo "Enter the configuration file to load:"
read FILE

if [[ -r $FILE ]]; then
    source $FILE
else
    echo "File does not exist or is not readable"
fi

In this script, the read command gets input from the user. The script then tries to source the file that the user specified.

Sourcing a File from a URL

In some cases, you might want to source a file from a URL. You can do this with the curl or wget command and process substitution. Here’s an example:

#!/bin/bash

URL=https://example.com/myfile.sh

if curl --output /dev/null --silent --head --fail "$URL"; then
    source <(curl -s "$URL")
else
    echo "URL does not exist or is not accessible"
fi

In this script, the curl command checks if the URL is accessible. If it is, the script sources the file from the URL.

Sourcing Files Recursively

If you need to source all files in a directory and its subdirectories, you can use a recursive function. Here’s an example:

#!/bin/bash

function source_files() {
    for FILE in "$1"/*; do
        if [[ -d $FILE ]]; then
            source_files "$FILE"
        elif [[ -r $FILE && $FILE == *.sh ]]; then
            source "$FILE"
        fi
    done
}

source_files /path/to/directory

In this script, the source_files function sources all .sh files in the specified directory and its subdirectories.

Sourcing Files with Error Handling

When sourcing a file, you might want to handle errors that occur. You can do this with a trap command. Here’s an example:

#!/bin/bash

trap 'echo "Error sourcing file"' ERR

source /path/to/file.sh

In this script, the trap command specifies a command to run if an error occurs. If there’s an error sourcing the file, the script prints a message.

Sourcing Files with a Timeout

If you’re sourcing a file that might take a long time to run, you can use a timeout. Here’s an example:

#!/bin/bash

if timeout 5s source /path/to/file.sh; then
    echo "File sourced successfully"
else
    echo "Timeout when sourcing file"
fi

In this script, the timeout command tries to source the file. If the source command takes more than 5 seconds, the timeout command returns an error, and the script prints a message.

Adopting Best Practices with the Bash Source Command

Ensuring File Existence Prior to Sourcing

Before invoking the source command, it’s prudent to verify the existence and readability of the file. This preemptive check can help avoid potential errors in your script. You can accomplish this by using an if statement in conjunction with the -r test. This practice not only enhances the robustness of your script but also improves its fault tolerance.

Emphasizing the Use of Full Paths

When you’re specifying the file to source, it’s advisable to use the full path to the file. This practice ensures that the correct file is sourced, irrespective of the current directory or the contents of the $PATH variable. Using full paths provides a clear and unambiguous reference to the file, thereby reducing the likelihood of sourcing the wrong file.

Exercising Caution with Untrusted Files

Remember, sourcing a file executes its contents in the current shell. This means that any commands in the file, including potentially harmful ones, will be executed. Therefore, it’s crucial to exercise caution and only source files that you trust. This practice is particularly important to maintain the security and integrity of your scripts and systems.

Incorporating Comments for Clarity

When sourcing files, it’s beneficial to include comments that explain why the file is being sourced. These comments can serve as valuable documentation, making your script easier to understand for others, and for your future self. Well-documented code is easier to maintain, debug, and extend, making this a worthwhile practice.

Limit the Use of Global Variables

When sourcing a file, any variables defined in that file will become global variables in the current shell. This can potentially lead to variable name clashes and unexpected behavior. Therefore, it’s a good practice to limit the use of global variables in the files you source. If you need to use variables, consider using local variables or uniquely named global variables.

Use Error Handling Mechanisms

When sourcing a file, any errors in the file will cause your script to exit unless you’ve set up error handling. You can use the trap command to specify a command to run if an error occurs. This can help you catch and handle errors, making your script more robust.

Keep Sourced Files Small and Focused

The files you source should be small and focused, each one dealing with a specific aspect of your script. This makes your scripts easier to understand and maintain. It also makes it easier to reuse these files in other scripts.

Test Sourced Files Independently

Before sourcing a file in your script, test it independently to make sure it works as expected. This can help you catch and fix any errors before they affect your script.

Use Version Control

If you’re working on a large project with many sourced files, it’s a good idea to use a version control system like Git. This allows you to track changes to the files, making it easier to find and fix bugs. It also allows you to experiment with changes in a safe way, without risking the stability of your project.

Wrapping Up: Bash Source Command Insights

In this comprehensive guide, we’ve delved into the intricacies of the Bash source command, a powerful built-in tool that reads and executes commands from a specified file within the current shell environment. We’ve explored its syntax, basic usage, and how it can be employed to load functions, variables, and configuration files into shell scripts. We’ve also examined a range of examples, from basic to advanced, demonstrating the versatility and utility of the source command.

As a final recommendation, remember to use the source command judiciously. Always check the contents of a file before sourcing it, and use full paths to ensure the correct file is sourced. The source command is a potent tool in your Bash scripting arsenal, but it should be used with care and understanding. By following these guidelines, you’ll be able to harness the full power of the source command while maintaining the safety and integrity of your scripts.