Linux Script Executing

Introduction

This lab focuses on understanding and using the source command in Linux, which is a powerful tool for executing scripts in the current shell. Unlike regular script execution that runs in a separate subprocess, the source command executes commands from a file in the current shell environment. This allows variables and functions defined in the script to persist in your current session.

Throughout this lab, you will learn:

• How to create and execute scripts using the source command
• How to pass parameters to scripts when using source
• How the source command differs from regular script execution
• How to use the source command to set up environment variables

By the end of this lab, you will be comfortable using the source command for efficient Linux shell scripting and environment management.

Skills Graph

Creating and Sourcing a Basic Script

In this step, we will create a simple script file and use the source command to execute it in our current shell environment. This will help us understand how source differs from regular script execution.

When you run a script normally (using ./script.sh), the shell creates a new subprocess to execute the script. Any variables or functions defined in that script only exist within that subprocess and disappear when the script finishes. However, when you use the source command (or its shorthand .), the commands in the script execute in your current shell environment, allowing variables and functions to persist after the script completes.

Let's create a basic script to demonstrate this concept:

1. Navigate to the project directory

First, make sure you're in the correct directory:

cd ~/project

2. Create a simple script file

Create a new file named variables.sh using the nano editor:

nano variables.sh

Add the following content to the file:

#!/bin/bash
## This script sets an environment variable
export WEATHER="Sunny"
echo "The weather is now set to: $WEATHER"

Press Ctrl+O to save the file, then Enter to confirm the filename, and finally Ctrl+X to exit nano.

3. Make the script executable

Before we can run the script, we need to make it executable:

chmod +x variables.sh

4. Run the script normally

First, let's run the script in the traditional way:

./variables.sh

You should see output similar to:

The weather is now set to: Sunny

Now, check if the WEATHER variable exists in your current shell:

echo $WEATHER

You'll likely see nothing output, or an empty line. This is because the variable was only set in the subprocess that ran the script, not in your current shell.

5. Source the script

Now, let's use the source command to run the script:

source variables.sh

You'll see the same output:

The weather is now set to: Sunny

Check the WEATHER variable again:

echo $WEATHER

This time, you should see:

Sunny

The WEATHER variable now exists in your current shell because you used the source command to execute the script.

6. Using the shorthand notation

You can also use the dot (.) shorthand notation for the source command:

. variables.sh

This will produce the same result as using source variables.sh.

Using Source with Parameters

In this step, we'll learn how to pass parameters to a script when using the source command. This is useful when you need to make your scripts more flexible and reusable.

Just like regular script execution, you can pass arguments to a script when using the source command. Inside the script, these arguments are accessible through the standard positional parameters ($1, $2, etc.), just as they would be when running the script directly.

1. Creating a script that accepts parameters

Create a new file called greeting.sh in the ~/project directory:

cd ~/project
nano greeting.sh

Add the following content to the file:

#!/bin/bash
## This script accepts a name parameter and sets a greeting variable

## Check if a parameter was provided
if [ -z "$1" ]; then
  NAME="Guest"
else
  NAME="$1"
fi

## Set the greeting environment variable
export GREETING="Hello, $NAME!"
echo "$GREETING"

Save and exit nano by pressing Ctrl+O, Enter, and then Ctrl+X.

2. Make the script executable

chmod +x greeting.sh

3. Source the script with a parameter

Let's source the script and pass a name parameter:

source greeting.sh "Alice"

You should see the output:

Hello, Alice!

Now check if the GREETING variable is set in your current shell:

echo $GREETING

You should see:

Hello, Alice!

4. Source with a different parameter

Try sourcing the script again with a different name:

source greeting.sh "Bob"

Output:

Hello, Bob!

Check the GREETING variable again:

echo $GREETING

Output:

Hello, Bob!

Notice how the GREETING variable has been updated with the new value.

5. Source without parameters

You can also source the script without any parameters:

source greeting.sh

Output:

Hello, Guest!

The script uses a default value ("Guest") when no parameter is provided.

Check the GREETING variable one more time:

echo $GREETING

Output:

Hello, Guest!

This demonstrates how you can make your scripts adaptable by processing different input parameters.

Creating a Development Environment Script

In this step, we'll create a more practical example: a script that sets up a development environment with multiple variables. This is a common use case for the source command in real-world scenarios.

1. Creating the development environment script

Create a new file called dev_env.sh in the ~/project directory:

cd ~/project
nano dev_env.sh

Add the following content to the file:

#!/bin/bash
## Development environment setup script

## Database connection settings
export DB_HOST="localhost"
export DB_PORT="5432"
export DB_USER="dev_user"
export DB_PASSWORD="dev_password"
export DB_NAME="dev_database"

## API settings
export API_URL="http://localhost:3000/api"
export API_KEY="dev_api_key_123"

## Application paths
export APP_ROOT="/home/labex/project/app"
export LOG_DIR="/home/labex/project/logs"

## Create directories if they don't exist
mkdir -p $APP_ROOT
mkdir -p $LOG_DIR

## Display confirmation message
echo "Development environment configured with the following settings:"
echo "-----------------------------------------------------------"
echo "Database: $DB_USER@$DB_HOST:$DB_PORT/$DB_NAME"
echo "API URL: $API_URL"
echo "App Root: $APP_ROOT"
echo "Log Directory: $LOG_DIR"
echo "-----------------------------------------------------------"
echo "Environment is ready for development!"

Save and exit nano by pressing Ctrl+O, Enter, and then Ctrl+X.

2. Make the script executable

chmod +x dev_env.sh

3. Source the development environment script

Now, let's source the script to set up our development environment:

source dev_env.sh

You should see output similar to:

Development environment configured with the following settings:
-----------------------------------------------------------
Database: dev_user@localhost:5432/dev_database
API URL: http://localhost:3000/api
App Root: /home/labex/project/app
Log Directory: /home/labex/project/logs
-----------------------------------------------------------
Environment is ready for development!

4. Verify that the environment variables are set

Let's check some of the environment variables that were set by the script:

echo "Database connection string: $DB_USER:$DB_PASSWORD@$DB_HOST:$DB_PORT/$DB_NAME"

Output:

Database connection string: dev_user:dev_password@localhost:5432/dev_database

Check the API settings:

echo "API settings: $API_URL with key $API_KEY"

Output:

API settings: http://localhost:3000/api with key dev_api_key_123

5. Verify that the directories were created

Check if the directories specified in the script were created:

ls -la ~/project/app ~/project/logs

You should see output showing that both directories exist.

This example demonstrates how you can use the source command to set up a complete development environment with multiple environment variables and configurations. This approach is commonly used in development workflows to switch between different environments (development, testing, production, etc.).

Summary

In this lab, you have learned how to use the source command in Linux to execute scripts in the current shell environment. Here's a recap of what you've accomplished:

1. Creating and Sourcing Basic Scripts: You learned how using source differs from regular script execution, as it allows variables and functions defined in the script to persist in your current shell session.

2. Passing Parameters to Sourced Scripts: You explored how to make scripts more flexible by passing parameters to them when using the source command, and how to process those parameters within the script.

3. Setting Up Development Environments: You created a practical script that sets up a development environment with multiple environment variables and configurations, which is a common real-world use case for the source command.

The source command is a powerful tool in Linux scripting that allows you to:

• Set environment variables that persist across your shell session
• Define functions that can be used later in your session
• Create modular configurations that can be reused
• Set up complex environments quickly and consistently

These skills are fundamental for anyone working with Linux systems, particularly for developers, system administrators, and DevOps engineers. By mastering the source command, you can create more efficient and organized scripts for managing your Linux environment.