Bash จัดการไฟล์และพาธอย่างปลอดภัย



สคริปต์ที่จัดการไฟล์ผิดพลาดทำข้อมูลหายถาวรได้ บทนี้รวมเทคนิคที่ทำให้การจัดการไฟล์ทนทาน — ชื่อมีช่องว่าง, ไฟล์เขียนพร้อมกัน, เขียนไม่สมบูรณ์, ลบผิดที่

ไฟล์ชั่วคราว — mktemp เสมอ

# ผิด — เดาได้, ชนได้, race condition
tmp=/tmp/myscript.$$
tmp=/tmp/myscript.tmp

# ถูก
tmp=$(mktemp)                            # /tmp/tmp.aB3xY9zK1p
tmpdir=$(mktemp -d)                      # โฟลเดอร์ชั่วคราว
tmp=$(mktemp /tmp/backup.XXXXXX)         # กำหนด prefix (ต้องมี XXXXXX อย่างน้อย)
tmp=$(mktemp -t myapp.XXXXXX)            # ใช้ $TMPDIR ถ้าตั้งไว้

mktemp สร้างไฟล์จริงทันที (atomic) ด้วยชื่อสุ่ม สิทธิ์ 600 — ไม่มี race condition

คู่กับ trap EXIT เสมอ (บทที่ 29)

tmpdir=$(mktemp -d)
trap 'rm -rf "$tmpdir"' EXIT

# ใช้ $tmpdir อย่างอิสระ — จะถูกลบตอนสคริปต์จบไม่ว่าออกทางไหน

atomic write — เขียนไฟล์แบบครบหรือไม่เขียนเลย

ปัญหา: command > important.conf — ถ้า command พังกลางคัน important.conf เหลือครึ่ง ๆ กลาง ๆ และไฟล์เดิมหายแล้ว

# ผิด
generate_config > /etc/myapp.conf        # เสี่ยงไฟล์พังถ้า generate_config ล้มเหลว

# ถูก — เขียน temp ก่อน แล้ว mv (rename เป็น atomic ในไฟล์ระบบเดียวกัน)
tmp=$(mktemp)
if generate_config > "$tmp"; then
    mv "$tmp" /etc/myapp.conf            # ทันที ครบถ้วน หรือไม่เกิดเลย
else
    rm -f "$tmp"
    die "สร้าง config ล้มเหลว — ไฟล์เดิมไม่ถูกแตะ"
fi

mv ในไฟล์ระบบเดียวกัน = rename = atomic operation — ผู้อ่านไฟล์ไม่มีวันเห็นสถานะครึ่ง ๆ

สำคัญ: temp ต้องอยู่ ไฟล์ระบบเดียวกัน กับปลายทาง (ไม่งั้น mv = copy + delete ไม่ atomic) — สร้าง temp ในโฟลเดอร์ปลายทาง

dst=/etc/myapp.conf
tmp=$(mktemp "$(dirname "$dst")/.tmp.XXXXXX")
trap 'rm -f "$tmp"' EXIT
generate_config > "$tmp"
chmod 644 "$tmp"
mv "$tmp" "$dst"
trap - EXIT                              # mv สำเร็จแล้ว ไม่ต้อง cleanup

sponge (จาก moreutils) ทำ atomic write ให้ในบรรทัดเดียว: generate_config | sponge /etc/myapp.conf

path — realpath, basename, dirname

abs=$(realpath "$input")                 # absolute path, resolve .. และ symlink
abs=$(realpath -m "$input")              # ไม่ต้องมีไฟล์จริง (-m = missing ok)
canonical=$(readlink -f "$input")        # คล้ายกัน (GNU)

# basename/dirname — สองทาง
name=$(basename "$path")                 # เรียก process
name=${path##*/}                         # ในตัว (บทที่ 18) — เร็วกว่าใน loop

dir=$(dirname "$path")                   # จัดการ edge case ครบ (path ไม่มี / → ".")
dir=${path%/*}                           # ในตัว — แต่ผิดถ้า path ไม่มี /

สำหรับ input จากผู้ใช้ที่ไม่รู้รูปแบบ — ใช้ basename/dirname (จัดการ /, //, ., trailing slash ให้ครบ) สำหรับ path ที่สร้างเองในสคริปต์ — parameter expansion เร็วกว่า

วนไฟล์ที่ชื่อมีช่องว่าง / newline

# ผิด — พังกับชื่อมีช่องว่าง
for f in $(find . -name '*.log'); do rm "$f"; done

# ผิด — พังกับชื่อมี newline (พบน้อยแต่มี)
find . -name '*.log' | while read -r f; do rm "$f"; done

# ถูก — null delimiter
find . -name '*.log' -print0 | while IFS= read -r -d '' f; do
    echo "ลบ $f"
    rm "$f"
done

# หรือให้ find ทำเอง (ดีสุดถ้าทำได้)
find . -name '*.log' -delete
find . -name '*.log' -exec rm {} +
find . -name '*.tmp' -exec gzip {} \;

# หรือ glob + nullglob (ชั้นเดียว) / globstar (ลึก)
shopt -s nullglob globstar
for f in ./**/*.log; do rm "$f"; done

null byte (\0) เป็นอักขระเดียวที่ห้ามมีในชื่อไฟล์ — จึงเป็นตัวคั่นที่ปลอดภัย 100% -print0 / read -d '' จับคู่กัน

เปรียบเทียบเวลาไฟล์

[[ "$src" -nt "$dst" ]] && echo "$src ใหม่กว่า — ต้อง rebuild"
[[ "$dst" -ot "$src" ]] && rebuild

# build เฉพาะไฟล์ที่เปลี่ยน
for src in src/*.c; do
    obj="build/$(basename "$src" .c).o"
    if [[ "$src" -nt "$obj" ]]; then
        gcc -c "$src" -o "$obj"
    fi
done

lockfile — กันสคริปต์รันซ้อน

flock (แนะนำ)

#!/usr/bin/env bash
set -euo pipefail

exec 9>/var/lock/myjob.lock              # เปิด fd 9 ชี้ lock file
if ! flock -n 9; then                    # -n = ไม่รอ ล้มเหลวทันทีถ้าล็อกไม่ได้
    echo "อีก instance กำลังทำงานอยู่ — ออก" >&2
    exit 1
fi

# ตั้งแต่นี้เรามีล็อก — flock ปล่อยอัตโนมัติเมื่อ fd 9 ปิด (สคริปต์จบ)
echo "เริ่มงาน (PID $$)"
long_running_job

flock ผูกล็อกกับ fd — พอ process ตาย (แม้ถูกฆ่า) ล็อกหลุดเอง ไม่มี stale lock

หรือแบบสั้น — ห่อทั้งสคริปต์

#!/usr/bin/env bash
exec flock -n "/var/lock/$(basename "$0").lock" -c "$0.impl $*" || {
    echo "กำลังทำงานอยู่" >&2; exit 1
}

mkdir (พกพากว่า — ไม่มี flock ทุกที่)

LOCKDIR=/tmp/myjob.lock
if mkdir "$LOCKDIR" 2>/dev/null; then     # mkdir เป็น atomic — สำเร็จแค่คนเดียว
    trap 'rmdir "$LOCKDIR"' EXIT
else
    echo "ล็อกอยู่ — อีก instance ทำงาน" >&2
    exit 1
fi

ข้อเสีย: ถ้าสคริปต์ถูก kill -9 โฟลเดอร์ล็อกค้าง (stale) — ต้องเช็ก PID ข้างในเพิ่ม

กันลบผิด — guard ตัวแปรว่าง

# หายนะ — ถ้า $BUILD_DIR ว่าง (พิมพ์ผิด/unset) กลายเป็น rm -rf /*
rm -rf "$BUILD_DIR"/*
rm -rf "$BUILD_DIR/"

# ปลอดภัย
rm -rf "${BUILD_DIR:?BUILD_DIR ไม่ได้ตั้งค่า}"/*        # ${var:?} จบสคริปต์ถ้าว่าง
[[ -n "${BUILD_DIR:-}" && -d "$BUILD_DIR" ]] || die "BUILD_DIR ไม่ถูกต้อง"
rm -rf "${BUILD_DIR:?}"/*

# ปลอดภัยยิ่งขึ้น — cd เข้าไปก่อนแล้วลบ relative
( cd "$BUILD_DIR" && rm -rf ./* ) || die "ลบไม่สำเร็จ"

${var:?message} (บทที่ 17) เป็นเกราะสำคัญ — set -u ช่วยกรณี unset แต่ไม่ช่วยกรณีตั้งเป็นว่าง

ทำงานกับไฟล์อย่างระวัง

# เช็กก่อนเขียนทับ
if [[ -e "$dst" ]]; then
    confirm "$dst มีอยู่แล้ว เขียนทับ?" || exit 0
fi

# สร้างโฟลเดอร์ปลายทางถ้ายังไม่มี
mkdir -p "$(dirname "$dst")"

# copy รักษา metadata
cp -a "$src" "$dst"                       # -a = -dR --preserve=all

# ตรวจ disk space ก่อนเขียนไฟล์ใหญ่
avail=$(df --output=avail -B1 "$(dirname "$dst")" | tail -1)
(( avail > needed )) || die "พื้นที่ไม่พอ"

เรื่องที่คนมักพลาด

  • /tmp/$$ หรือชื่อ temp คงที่ — race condition, ชนกัน ใช้ mktemp
  • cmd > file แล้ว cmd พัง — ไฟล์เหลือครึ่ง เดิมหาย ใช้ atomic write (> tmp && mv)
  • temp กับปลายทางคนละ filesystem — mv ไม่ atomic สร้าง temp ในโฟลเดอร์ปลายทาง
  • for f in $(find ...) — พังกับช่องว่าง ใช้ -print0 | while read -d '' หรือ -exec
  • rm -rf "$DIR/" เมื่อ $DIR ว่าง — ลบ / ใช้ ${DIR:?}
  • mkdir lock แต่ kill -9 แล้วค้าง — ใช้ flock (หลุดเองเมื่อ process ตาย)
  • ลืม trap ลบ tmpdir — ขยะสะสมใน /tmp ตั้ง trap 'rm -rf "$tmp"' EXIT ทันที

สรุป

  • mktemp / mktemp -d เสมอ — ไม่เดาชื่อ + trap 'rm -rf "$tmp"' EXIT ทันที
  • atomic write: เขียน temp (ในโฟลเดอร์ปลายทาง) แล้ว mv ทับ — ครบหรือไม่เกิดเลย
  • path: realpath/readlink -f (absolute+resolve), basename/dirname สำหรับ input ไม่รู้รูปแบบ
  • วนไฟล์ปลอดภัย: find -print0 | while IFS= read -r -d '' หรือ find -exec ... + หรือ globstar
  • lockfile: flock -n 9 (หลุดเองเมื่อ process ตาย) หรือ mkdir (พกพากว่า แต่ stale ได้)
  • กันลบผิด: rm -rf "${DIR:?}"/* — ${var:?} จบสคริปต์ถ้าตัวแปรว่าง
  • [[ src -nt dst ]] เช็กว่าไฟล์ต้นทางใหม่กว่า (rebuild เฉพาะที่เปลี่ยน)

บทถัดไปว่าด้วยวันเวลาและการคำนวณ — date, epoch, arithmetic, ทศนิยมด้วย bc/awk