BASH on Ricky

TIL: timeout in Bash scripts

Thu, 12 Jun 2025 09:04:00 +0800

TIL: timeout in Bash scripts
timeout 1m ./until.sh
wrap

timeout 1m bash -c "until curl --silent --fail-with-body 10.0.0.1:8080/health; do
 sleep 1
done"

Advanced Shell Scripting Techniques: Automating Complex Tasks with Bash

Wed, 25 Sep 2024 09:23:00 +0800

Advanced Shell Scripting Techniques: Automating Complex Tasks with Bash

Use Built-in Commands

Built-in commands execute faster because they don’t require loading an external process.

Minimize Subshells

Subshells can be expensive in terms of performance.

# Inefficient
output=$(cat file.txt)

# Efficient
output=$(<file.txt)

Use Arrays for Bulk Data

When handling a large amount of data, arrays can be more efficient and easier to manage than multiple variables.

# Inefficient
item1="apple"
item2="banana"
item3="cherry"

# Efficient
items=("apple" "banana" "cherry")
for item in "${items[@]}"; do
 echo "$item"
done

Enable Noclobber

To prevent accidental overwriting of files.

set -o noclobber

Use Functions

Functions allow you to encapsulate and reuse code, making scripts cleaner and reducing redundancy.

Efficient File Operations

When performing file operations, use efficient techniques to minimize resource usage.

# Inefficient
while read -r line; do
 echo "$line"
done < file.txt

# Efficient
while IFS= read -r line; do
 echo "$line"
done < file.txt

Parallel Processing

Tools like xargs and GNU parallel can be incredibly useful.

Error Handling

Robust error handling is critical for creating reliable and maintainable scripts.

# Exit on Error: Using set -e ensures that your script exits immediately if any command fails, preventing cascading errors.
set -e

# Custom Error Messages: Implement custom error messages to provide more context when something goes wrong.
command1 || { echo "command1 failed"; exit 1; }

# Trap Signals: Use the `trap` command to catch and handle signals and errors gracefully.
trap 'echo "Error occurred"; cleanup; exit 1' ERR

function cleanup() {
 # Cleanup code
}

# Validate Inputs: Always validate user inputs and script arguments to prevent unexpected behavior.
if [[ -z "$1" ]]; then
 echo "Usage: $0 <argument>"
 exit 1
fi

# Logging: Implement logging to keep track of script execution and diagnose issues.
logfile="script.log"
exec > >(tee -i $logfile)
exec 2>&1

echo "Script started"

Automating Complex System Administration Tasks:

Automated Backups
System Monitoring
User Management
Automated Updates
Network Configuration

Makefiles for Web Projects: Manage Your Environment Workflow

Mon, 05 Aug 2024 17:21:24 +0800

Note: Makefile indentation must use tabs, otherwise you’ll get syntax errors.

The Core of a Makefile: Targets

up:
 cp .env.example .env
 docker compose up -d workspace

stop:
 docker compose stop

zsh:
 docker compose exec workspace zsh

This example has three targets: up, stop, and zsh. By default, Make treats the first target as the Goal (it cannot start with a dot), which is the project’s primary workflow. In this case, make and make up do the same thing.
But the copy step above is not a typical Make use case. Make shines at deciding whether each target needs to run. For example, we often store secrets in .env. If .env already exists, we shouldn’t overwrite it by copying .env.example again. In that case, we can make .env a target:

up: .env
 docker compose up -d workspace

.env:
 cp .env.example .env

By default, target names are treated as filenames. The name “make” implies building a target; it will only execute the target’s recipe when the conditions are met (like the file not existing).
- In this example, when you run the up target, if .env doesn’t exist it will run the .env target first to create it, then start the workspace container. If .env already exists, it skips the .env target and starts the container directly.
- Likewise, if there is a file named up in the directory, the up target won’t run. You can define Phony Targets to tell Make that certain targets aren’t filenames, but named workflows instead:

.PHONY: up stop zsh

Add Some Variables

Make supports variables (Variable). Following common Unix environment variable conventions, we usually write them in SCREAMING_SNAKE_CASE. When used, variables are wrapped in $().

Bash Bitwise Operators

Mon, 04 Jul 2022 15:20:39 +0800

Bash Bitwise Operators

Bash’s Tools for Base Conversion

Bash’s arithmetic expansion allows us to write numbers in any base by prefixing the numeric digits of the base followed by the hash symbol.

$ echo $((2#1001))
9

bc allows us to convert effortlessly between bases, using the parameters ibase (for the input base) and obase (for the output base). So, let’s convert the decimal number 9 to base 2

$ echo "ibase=10;obase=2;9" | bc
1001

Parse Command Line Arguments in Bash

Tue, 07 Jun 2022 14:48:47 +0800

Parse Command Line Arguments in Bash

getopts

getopts optstring opt [arg ...]

#!/bin/bash

while getopts 'abc:h' opt; do
 case "$opt" in
 a)
 echo "Processing option 'a'"
 ;;

 b)
 echo "Processing option 'b'"
 ;;

 c)
 arg="$OPTARG"
 echo "Processing option 'c' with '${OPTARG}' argument"
 ;;

 ?|h)
 echo "Usage: $(basename $0) [-a] [-b] [-c arg]"
 exit 1
 ;;
 esac
done
shift "$(($OPTIND -1))"

optstring represents the supported options. The option expects an argument if there is a colon (:) after it. For instance, if option c expects an argument, then it would be represented as c: in the optstring
When an option has an associated argument, then getopts stores the argument as a string in the OPTARG shell variable. For instance, the argument passed to option c would be stored in the OPTARG variable.
opt contains the parsed option.

#!/bin/bash

while getopts ':abc:h' opt; do
 case "$opt" in
 a)
 echo "Processing option 'a'"
 ;;

 b)
 echo "Processing option 'b'"
 ;;

 c)
 arg="$OPTARG"
 echo "Processing option 'c' with '${OPTARG}' argument"
 ;;

 h)
 echo "Usage: $(basename $0) [-a] [-b] [-c arg]"
 exit 0
 ;;

 :)
 echo -e "option requires an argument.\nUsage: $(basename $0) [-a] [-b] [-c arg]"
 exit 1
 ;;

 ?)
 echo -e "Invalid command option.\nUsage: $(basename $0) [-a] [-b] [-c arg]"
 exit 1
 ;;
 esac
done
shift "$(($OPTIND -1))"

Note that we’ve updated optstring as well. Now it starts with the colon(:) character, which suppresses the default error message.
The getopts function disables error reporting when the OPTERR variable is set to zero.

Parsing Long Command-Line Options With getopt

#!/bin/bash

VALID_ARGS=$(getopt -o abg:d: --long alpha,beta,gamma:,delta: -- "$@")
if [[ $? -ne 0 ]]; then
 exit 1;
fi

eval set -- "$VALID_ARGS"
while [ : ]; do
 case "$1" in
 -a | --alpha)
 echo "Processing 'alpha' option"
 shift
 ;;
 -b | --beta)
 echo "Processing 'beta' option"
 shift
 ;;
 -g | --gamma)
 echo "Processing 'gamma' option. Input argument is '$2'"
 shift 2
 ;;
 -d | --delta)
 echo "Processing 'delta' option. Input argument is '$2'"
 shift 2
 ;;
 --) shift;
 break
 ;;
 esac
done

-o option represents the short command-line options
--long option represents the long command-line options

Best Practices for Writing Bash Scripts

Mon, 06 Dec 2021 11:11:54 +0800

#!/usr/bin/env bash
# Bash3 Boilerplate. Copyright (c) 2014, kvz.io
set -o errexit
set -o pipefail
set -o nounset
# set -o xtrace

# Set magic variables for current file & dir
__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
__file="${__dir}/$(basename "${BASH_SOURCE[0]}")"
__base="$(basename ${__file} .sh)"
__root="$(cd "$(dirname "${__dir}")" && pwd)" # <-- change this as it depends on your app

arg1="${1:-}"

Use shift to read function arguments

This makes it easier to reorder arguments, if you change your mind later.