source

Understanding the source Command

The source command reads and executes commands from a specified file in the current shell session. This means any variables, functions, or aliases defined within the sourced file become immediately available in your current shell. Contrast this with simply running a script using ./script.sh, which creates a new subshell to execute the commands. Changes made within that subshell do not persist after it exits.

Using the . (dot) is functionally equivalent to using source. Both achieve the same result: executing the commands in the current shell environment.

source script.sh  # Execute commands from script.sh in the current shell
. script.sh       # Equivalent to the above command

Practical Applications of source

Here are some common scenarios where source proves invaluable:

1. Loading Environment Variables: Suppose you have a file named .env containing environment variables:

.env file:

export MY_VAR="Hello from .env"
export MY_PATH="/path/to/something"

You can load these variables into your current shell session using source:

source .env
echo $MY_VAR   # Outputs: Hello from .env
echo $MY_PATH  # Outputs: /path/to/something

2. Defining Functions and Aliases: Let’s create a file named myfunctions.sh that defines a custom function and an alias:

myfunctions.sh file:

my_function() {
  echo "This is a custom function!"
}

alias la='ls -la'

To make these available in your current shell:

source myfunctions.sh
my_function     # Outputs: This is a custom function!
la             # Executes ls -la

3. Modifying Shell Configuration Files: Your shell’s configuration files (e.g., .bashrc, .zshrc) are typically sourced when the shell starts. However, you can manually source them again to apply changes without restarting the shell:

source ~/.bashrc

This is useful after making edits to your shell configuration and wanting to see the changes immediately.

4. Dynamic Configuration: You might have a script that generates configuration settings based on some condition, and then you use source to load these dynamically generated settings. Imagine a script that sets database connection parameters based on the environment (development, staging, production).

Example: Dynamic configuration based on environment variable

Let’s assume you have a script generate_db_config.sh that generates a configuration file named db_config.sh based on the ENV environment variable.

generate_db_config.sh:

#!/bin/bash
ENV=${ENV:-development}

case "$ENV" in
  development)
    echo 'export DB_HOST="localhost"' > db_config.sh
    echo 'export DB_USER="devuser"' >> db_config.sh
    echo 'export DB_PASS="devpass"' >> db_config.sh
    ;;
  staging)
    echo 'export DB_HOST="staging.example.com"' > db_config.sh
    echo 'export DB_USER="staginguser"' >> db_config.sh
    echo 'export DB_PASS="stagingpass"' >> db_config.sh
    ;;
  production)
    echo 'export DB_HOST="production.example.com"' > db_config.sh
    echo 'export DB_USER="produser"' >> db_config.sh
    echo 'export DB_PASS="prodpass"' >> db_config.sh
    ;;
  *)
    echo "Invalid environment: $ENV" >&2
    exit 1
    ;;
esac

Now you can run this and then source the generated file:

export ENV=staging
./generate_db_config.sh
source db_config.sh
echo $DB_HOST  # Outputs: staging.example.com

These examples demonstrate the versatility of the source command in various shell scripting and system administration tasks. Proper usage of source contributes to cleaner, more efficient, and maintainable scripts and shell configurations.