Tag: linux

A Basic Improvement in My rsync Script

rsync is used for efficient file synchronization and backup. It copies only the differences between source and destination, saving time and bandwidth.

And it is preinstalled on Ubuntu.

I use rsync to back up some of my folders to external storage like this:

As you can see, I use && and \.

• && is used to combine two bash commands and run the second command only if the first command succeeds (exits with status 0).
• \ is used for line continuation – it tells the shell that the command continues on the next line, making long commands more readable.

We could use ; instead of &&, but ; would run the second command regardless of whether the first command succeeded or failed. && is safer for backup operations because if the first backup fails, the second won’t run, preventing incomplete or corrupted backups.

---

The Improved Script with a Loop

The problem with my original approach is that I had to manually write a line for each external drive. If I added a new drive, I had to update the script. Also, if a drive wasn’t connected, rsync would still try to run and throw an error.

Here’s my improved script that automatically handles multiple drives and checks if they’re connected:

Array definition. Creates an array variable named DRIVES containing four paths (one per drive). The parentheses () define an array, and each quoted string is an element. Using an array allows us to loop through all drives without repeating code.

The Very Important Symbol: [@]

The critically important symbol is [@] (at-sign with brackets).

---

Why [@] is So Important

What it does:

${DRIVES[@]} expands to all elements of the array DRIVES, with each element treated as a separate word.

The Danger of NOT using [@]

If you wrote this incorrectly as:

for DRIVE in ${DRIVES[@]}; do   # Missing quotes - WRONG!

Or worse:

for DRIVE in $DRIVES; do        # Just wrong - treats array as single string

Here’s what happens with a drive path containing spaces, like "/media/fakhri/SAMSUNG SSD":

Correct Way	Incorrect Way
"${DRIVES[@]}"	${DRIVES[@]} (no quotes)
SAMSUNG SSD stays as ONE item	SAMSUNG and SSD become TWO separate items
The script sees: /media/fakhri/SAMSUNG SSD	The script sees: 1. /media/fakhri/SAMSUNG 2. SSD (which is not a valid path)

---

The Three Array Expansion Options Compared

Symbol	Behavior	When to Use
$DRIVES	Only first element (treats array as scalar)	Never for arrays
${DRIVES[*]}	All elements as single string	When you want one combined string
${DRIVES[@]}	All elements as separate words	Most common – use in loops
"${DRIVES[@]}"	All elements as separate words, preserving spaces	ALWAYS USE THIS for paths with spaces

---

The Golden Rule

Always use "${ARRAY[@]}" with quotes when iterating over arrays containing file paths.

The quotes + [@] combination ensures:

1. Each array element stays intact (spaces preserved)
2. Empty elements are preserved
3. Special characters (like * or ?) are not expanded

Without this, your backup script will fail silently and try to write to completely wrong locations!

Every Important Symbol Explained

Here’s the breakdown of every critical symbol in these lines:

if [ -d "$DRIVE" ]; then
    # ... backup commands ...
else
    echo "Skipping $DRIVE (Drive not connected)"
fi
done

---

if [ -d "$DRIVE" ]; then

Symbol	Name	What it does
if	Keyword	Starts a conditional statement. If the following command returns true (exit code 0), execute the code between then and else/fi
[	Test command (left bracket)	A built-in command that evaluates conditional expressions. Must have spaces around it! [ -d "$DRIVE" ] not [-d "$DRIVE"]
(space)	Space separator	Required between [ and -d – bash needs spaces to distinguish commands from arguments
-d	Flag (directory test)	Tests if the following path exists and is a directory. Returns true (0) if yes, false (1) if not
(space)	Space separator	Required between -d and the path
"$DRIVE"	Double-quoted variable	Expands to the value of DRIVE variable while preserving spaces in the path. Without quotes, a path like /media/fakhri/SAMSUNG SSD would break into two words
(space)	Space separator	Required between the path and the closing bracket
]	Closing bracket	Ends the test command. Must have a space before it!
;	Command separator	Allows multiple commands on one line. Here it separates the test command from then
then	Keyword	Marks the beginning of the code block to execute if the if condition is true

---

else

Symbol	Name	What it does
else	Keyword	Marks the alternative code block. Executes if the if condition was false (the drive was NOT a directory)

---

echo "Skipping $DRIVE (Drive not connected)"

Symbol	Name	What it does
echo	Command	Prints text to the terminal
" "	Double quotes	Everything inside becomes a single argument to echo, even if it contains spaces or variables. Variables inside ($DRIVE) still expand
$DRIVE	Variable expansion	Replaces $DRIVE with its actual value (e.g., /media/fakhri/32Go)
()	Parentheses	Regular text characters here – just part of the message. Not a command substitution because there’s no $ before them

---

fi

Symbol	Name	What it does
fi	Keyword	Closes the if block. It’s “if” spelled backwards. Every if must have a matching fi

---

done

Symbol	Name	What it does
done	Keyword	Closes the for loop. Marks the end of the loop body. Every for must have a matching done

---

The Most Critical Symbol: [ ] (Test Command)

The brackets [ ] are NOT syntax – they are a command!

Mental model:

if [ -d "$DRIVE" ]; then

Is equivalent to:

if test -d "$DRIVE"; then

The [ command is just an alias for test that requires a closing ].

Common Mistakes with [ ]:

❌ Wrong	✅ Correct	Why
[-d "$DRIVE"]	[ -d "$DRIVE" ]	Missing spaces – bash can’t find the [ command
[$DRIVE]	[ -n "$DRIVE" ]	No flag – what are you testing?
[ -d $DRIVE ]	[ -d "$DRIVE" ]	No quotes – path with spaces breaks

---

Symbol Hierarchy in Context

if [ -d "$DRIVE" ]; then
│  │ │ │        │  │
│  │ │ │        │  └── ends the "then" block start
│  │ │ │        └── separates test from "then"
│  │ │ └── variable expands to actual path
│  │ └── tests if path is a directory
│  └── starts test command
└── begins conditional

then
│
└── marks true block

else
│
└── marks false block

echo "Skipping $DRIVE (Drive not connected)"
│    │                    │
│    │                    └── variable inside quotes expands
│    └── quotes keep everything as one argument
└── prints to terminal

fi
│
└── closes if

done
│
└── closes for loop

---

Quick Reference Card

Symbol	Meaning	Remember by
if	Begin conditional	“if this is true…”
[	Start test	Left bracket opens the test
-d	Directory check	“-d” for “directory”
$	Variable value	Dollar = value
" "	Preserve spaces	Quotes = togetherness
]	End test	Right bracket closes the test
;	Command separator	Semicolon = stop then go
then	True branch	“then do this…”
else	False branch	“otherwise do this…”
fi	End if	“if” backwards
done	End loop	“for…done”

The most important takeaway: [ ] needs spaces inside and outside, and always quote your variables inside tests!

Final Note: Use [[ ]] Instead of [ ]

For Bash scripts, the double-bracket [[ ]] is superior to the single-bracket [ ] used in this article. Unlike [ ] (a command that requires spaces and quoted variables), [[ ]] is a Bash keyword that prevents word splitting and pathname expansion. This means you can write [[ -d $DRIVE ]] without quotes, even if the path contains spaces. [[ ]] also supports pattern matching (== *.txt), regex matching (=~), and natural logical operators (&&, ||). Stick with [ ] only if you need portability to other shells like sh; otherwise, always prefer [[ ]] for cleaner, safer, and more readable conditional tests.

To see why exit 1 and exit 0 are so important, we have to look at what happens when a script lies to the computer.

If you omit them, Bash simply reports the exit status of the very last command that ran. This can lead to a “False Success.”

1. The “Broken” Script (No Exit Codes)

Save this as broken_backup.sh. Notice there is no exit 1.

Bash

2. The “Good” Script (With Exit Codes)

Save this as good_backup.sh.

Bash

3. How to Test Them (The “Truth” Test)

Run these commands in your terminal one after the other. We will use the && operator, which only runs the second command if the first one reports Success (0).

Testing the Broken Script:

Bash

Result: Even though the script printed “ERROR,” the computer saw the final echo succeeded, so it ran the “SUCCEEDED” message. This is dangerous because a backup could fail and you wouldn’t know!

Testing the Good Script:

Bash

Result: The script stops at exit 1. The computer sees the 1, skips the && part, and triggers the || (failure) part.

Here are the results as copied from my terminal:

Why this matters in the real world

Imagine you have a script that:

1. Deletes your old files.
2. Copies your new files (The Backup).
3. Cleans up the temporary folder.

If Step 2 (The Backup) fails because the disk is full, but you didn’t write exit 1, the script will continue to Step 3 and delete your only remaining copies, thinking everything is fine!

Summary: * With exit 1: The script “screams” when there is a problem.

• Without it: The script “whispers” an error but smiles at the computer, pretending everything is perfect.

---

Note: about the use of “bash” at the start of the command below:

1. Manual Interpreter: Typing bash before your filename manually tells the system to use the Bash program to translate and run your script’s code.

2. Bypasses Permissions: It allows you to execute a script immediately without needing to set “executable” permissions via chmod +x.

3. Ensures Compatibility: It guarantees the script runs in the full Bash environment rather than a limited shell (like sh) that might misunderstand your syntax.

4. Testing Logic: It is the most reliable way to test if your exit 0 and exit 1 codes are working correctly before finalizing the script for automation.