Home > commandline tools, linux tips, programming, shell scripting > Sourcing a shell script in bash

Sourcing a shell script in bash

When a script is called using “.” or “source” command, then a script is said to be sourced. There are different ways of sourcing a script which are given below:

source script-name

or

. script-name

The difference between executing a script normally and sourcing a script is that, when a script is normally executed, a new shell is created and commands inside the script are executed in the new shell. The environment variables of the parent process are made available to the child process, but the local variables are not.

But when a script is sourced, the commands of the sourced script are executed in the same shell as the script from which it is called. And therefore all the local variables of the parent script is available to the sourced script. It is typically executed as if the contents of the sourced script are the contents of the parent script.

Generally scripts are sourced, when the variables of a script is required to be used inside another script, so that each of the variables which are required do not have to exported to be made available inside the sourced script.

Lets verify this with simple proof of concept.

Write a script as given below, which will be used to invoke the other script in different ways.

#!/bin/bash
echo “In caller script”
echo “$0″

BLOG=’Blulin’
PLATFORM=’Wordpress’

export BLOG=”$BLOG”

echo “BLOG=$BLOG”
echo “PLATFORM=$PLATFORM”

ps -o pid,ppid,cmd | grep -v “ps”

echo “————————————”
echo “Inside directly called script”
./called.sh

echo “————————————”
echo “Inside sourced script”
. ./called.sh

echo “————————————”
echo “Back in the caller script”
exit 0

Here is the caller script, we have defined two variables, BLOG and PLATFORM. variable BLOG is also exported using the “export” command, then the contents of variables are displayed and then there is ps command executed to display the processes currently running in the terminal from which it is called. Output of ps command is formatted such that it displays process id, parent process id and the name of the process. Then we have a child script “called.sh” which is normally called and then the same script is called again, but this time it is sourced.

Now lets define the contents of the called script.

#!/bin/bash
echo $0
echo “BLOG=$BLOG”
echo “PLATFORM=$PLATFORM”

ps -o pid,ppid,cmd | grep -v “ps”
exit 0

Inside called script we display the value of variables BLOG and PLATFORM, which is not defined in this script. and then we have a ps command, which is the same one as used in the caller script. By default ps command also prints the process details of itself, so to reduce the clutter of output we ignore the information about ps command itself, by piping it to grep. Then we have an exit command at the end of script.

Now as we have contents of both caller script and called script in place, let’s execute the script and look at the output. When the caller script is executed from the terminal, this is the output we get:

In caller script
./caller.sh
BLOG=Blulin
PLATFORM=Wordpress
PID  PPID CMD
4291  2884 bash
16158  4291 /bin/bash ./caller.sh
————————————
Inside directly called script
./called.sh
BLOG=Blulin
PLATFORM=
PID  PPID CMD
4291  2884 bash
16158  4291 /bin/bash ./caller.sh
16161 16158 /bin/bash ./called.sh
————————————
Inside sourced script
./caller.sh
BLOG=Blulin
PLATFORM=Wordpress
PID  PPID CMD
4291  2884 bash
16158  4291 /bin/bash ./caller.sh

Now let’s analyze the output of the scripts.

caller.sh output:

  • First the display statements in the caller scripts are executed and it is as expected.
  • Then the ps command output has two lines, which shows the process currently executing in the terminal from which the script was called, first line is the bash shell with process id “4291”, which is executed when a terminal is opened. Next line shows the process id of the caller script “16158” and the command name of the process.

output of called.sh when directly executed:

  • Next the display statements of called.sh script output which is called normally shows variable BLOG has a value, because BLOG is exported in the caller.sh script and as this called.sh is the child process of caller.sh script, it is made available here, but PLATFORM variable is not, because this called.sh runs as an independent child process.
  • ps command output of the directly called script shows that the caller.sh is indeed the parent process of called.sh script.

output of called.sh when sourced:

  • Next the display statements of called script which is sourced shows that, command name of script is same as that caller.sh script(output of “echo $0”). Then the variables both has a value, even as the PLATFORM variable is not exported. As a new bash shell is not created this time and these variables become local to called.sh
  • finally ps command output proves that there is no new process created this time, when called.sh is sourced.
  • Also, it is important to note that the display statements “Back in the caller script” is not printed as “exit 0” is given in called.sh. When that statement is executed in called.sh the script caller.sh is exited as well, because both caller.sh and called.sh runs under same process and this does not happen when it is called normally.

Hope this example is useful in understanding the concept of sourcing shell scripts.

Advertisements
  1. No comments yet.
  1. No trackbacks yet.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: