🚨 धडा 08 — Errors आणि safety: आगीची तालीम

📍 तुम्ही इथे आहात: 12 पैकी धडा 08 · पुढे: lesson-09-processes-jobs

📦 या ब्रँचमध्ये काय आहे

धडे 01–08. Strict mode, traps, temp files, dry runs आणि linter — कोणी लक्ष देत नसतानाही script चालवणे सुरक्षित करणाऱ्या पाच सवयी.

bin/school.sh — set -euo pipefail, mktemp + trap … EXIT, आधी लिहा-मग-mv
bin/backup.sh — dry runs साठी run(), trap ने सोडले जाणारे lock, न वाचता येणाऱ्या archive वर die

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

एखादे दार उघडत नसतानाही काम चालू ठेवणारा केअरटेकर शेवटी चुकीचा मजला पुसत बसतो. Strict mode त्याला सांगतो: fail होणाऱ्या पहिल्याच गोष्टीवर थांब (-e), अस्तित्वात नसलेला name tag वापरायला नकार दे (-u), आणि pipe च्या मधेच झालेले अपयश लक्षात घे (-o pipefail). trap म्हणजे आगीच्या तालमीचे कार्ड: काहीही होवो — यश, error, Ctrl-C — temp files आवरून ठेव आणि lock सोड. dry run म्हणजे रंगीत तालीम: काय करशील ते सांग, कशालाही हात लावू नकोस.

🗺️ आकृती

flowchart LR
  S["set -euo pipefail"] --> T["tmp=$(mktemp)<br/>trap 'rm -f \"$tmp\"' EXIT"] --> W["write to $tmp"] --> M["mv $tmp target (atomic)"]
  X["any failure / Ctrl-C"] -.-> T

❓ काय

set -e fail होणाऱ्या command वर exit — पण if, while, &&/|| साखळ्या, किंवा condition मध्ये बोलावलेल्या function च्या आत नाही. set -u unset variable म्हणजे error. set -o pipefail कोणताही टप्पा fail झाला तर pipe fail.
trap 'cleanup' EXIT प्रत्येक exit वर चालतो; ERR, INT, TERM सुद्धा.
कच्च्या कामासाठी mktemp / mktemp -d; तिथे लिहा, मग mv — वाचणाऱ्यांना कधीच अर्धवट लिहिलेली file दिसत नाही.
अपयश चालणार असेल तेव्हा || true; कोणत्याही rm -rf "$VAR/" आधी ${VAR:?}.
DRY_RUN=1: चालवण्याऐवजी log करणारा run() wrapper.
shellcheck script.sh: quoting चा प्रत्येक सापळा ओळखणारा linter.

🤔 का

देखरेखीशिवाय चालणाऱ्या scripts पहाटे 2 वाजता, कोणी पाहत नसताना fail होतात. Strict mode गुपचूप अर्धवट राहिलेल्या कामाला मोठ्याने थांबण्यात बदलतो; traps पसारा साठू देत नाहीत; dry runs मुळे production मधल्या विध्वंसक बदलाचा सुरक्षितपणे सराव करता येतो.

🔧 कसे (या repo मध्ये)

school.sh ओळ 15: strict mode. cmd_grade: tmp=$(mktemp); trap 'rm -f "$tmp"' EXIT; awk … > "$tmp" && mv "$tmp" "$REGISTER". backup.sh: run() { [[ "${DRY_RUN:-0}" == 1 ]] && log "would: $*" || "$@"; }, mkdir "$LOCK" || die, trap 'rmdir "$LOCK"' EXIT, tar -tzf "$out" || die.

🧪 करून पाहा

DRY_RUN=1 bin/backup.sh --dest /tmp/bk               # the rehearsal: "would: tar …", nothing written
ls /tmp/bk 2>/dev/null | wc -l                        # 0
bash -c 'set -u; echo "$REGISTR"'; echo "exit $?"     # the typo is caught
bash -c 'set -o pipefail; false | true'; echo "exit $?"    # 1 — the pipe knows
bash -c 'set -e; if false; then :; fi; echo "still here (set -e is off inside if)"'
bash -c 't=$(mktemp); trap "echo cleanup; rm -f $t" EXIT; echo working; exit 2'; echo "exit $?"
command -v shellcheck && shellcheck bin/school.sh || echo "install shellcheck: brew install shellcheck / apt install shellcheck"

✅ तपासा — तुम्हाला काय दिसायला हवे

dry run would: tar … log करतो आणि काहीही बनवत नाही; unbound variable exit 1; pipefail exit 1; set -e ची ओळ तरीही छापली जाते; working, cleanup, मग exit 2 — trap चालला आणि exit code टिकला.

🏁 तुम्ही आत्ताच काय सिद्ध केले

तुम्ही script ला अपयशावर थांबवू शकता, प्रत्येक exit वर साफसफाई करायला लावू शकता, कोणताही परिणाम न होता सराव करू शकता — आणि set -e तुम्हाला कुठे वाचवणार नाही ती एक जागा तुम्हाला माहीत आहे.

⚠️ नेहमीच्या चुका

if च्या आत किंवा || नंतर set -e वर विश्वास ठेवणे. अपयशाचा मार्ग test करा.
double quotes असलेला trap variables खूप लवकर expand करतो. मुद्दाम तसे करायचे नसेल तर trap string single-quote करा.
DIR रिकामा असू शकतो तिथे rm -rf "$DIR/"*. "${DIR:?}".

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: fail झालेल्या cd नंतरही चालू राहून चुकीचे release delete करणारा deploy; रिकाम्या archive सह "यशस्वी" झालेला backup — दोन्ही या धड्याच्या दहा ओळींनी टाळता आले असते.

⏭️ पुढे

धडा 09 — processes आणि jobs: इमारतीत कोण आहे, आणि त्यांना बाहेर जायला कसे सांगायचे.

🚨 Lesson 08 — Errors & safety: the fire drill

📍 You are here: Lesson 08 of 12 · Next: lesson-09-processes-jobs

📦 What's in this branch

Lessons 01–08. Strict mode, traps, temp files, dry runs and the linter — the five habits that make a script safe to run unattended.

bin/school.sh — set -euo pipefail, mktemp + trap … EXIT, write-then-mv
bin/backup.sh — run() for dry runs, a lock released by trap, die on an unreadable archive

🧒 Explain like I'm 5

A caretaker who keeps working after a door will not open ends up mopping the wrong floor. Strict mode tells them: stop at the first thing that fails (-e), refuse to use a name tag that does not exist (-u), and notice a failure in the middle of a pipe (-o pipefail). A trap is the fire drill card: whatever happens — success, error, Ctrl-C — put the temp files away and release the lock. A dry run is the rehearsal: say what you would do, touch nothing.

🗺️ Diagram

flowchart LR
  S["set -euo pipefail"] --> T["tmp=$(mktemp)<br/>trap 'rm -f \"$tmp\"' EXIT"] --> W["write to $tmp"] --> M["mv $tmp target (atomic)"]
  X["any failure / Ctrl-C"] -.-> T

❓ What

set -e exit on a failing command — not inside if, while, &&/|| chains, or a function called in a condition. set -u unset variable is an error. set -o pipefail a pipe fails if any stage fails.
trap 'cleanup' EXIT runs on every exit; also ERR, INT, TERM.
mktemp / mktemp -d for scratch; write there, then mv — readers never see a half-written file.
|| true when a failure is fine; ${VAR:?} before any rm -rf "$VAR/".
DRY_RUN=1: a run() wrapper that logs instead of executing.
shellcheck script.sh: the linter that knows every quoting trap.

🤔 Why

Unattended scripts fail at 2 a.m. with nobody watching. Strict mode turns a silent half-done job into a loud stop; traps keep the mess from piling up; dry runs let you rehearse a destructive change in production safely.

🔧 How (in this repo)

school.sh line 15: strict mode. cmd_grade: tmp=$(mktemp); trap 'rm -f "$tmp"' EXIT; awk … > "$tmp" && mv "$tmp" "$REGISTER". backup.sh: run() { [[ "${DRY_RUN:-0}" == 1 ]] && log "would: $*" || "$@"; }, mkdir "$LOCK" || die, trap 'rmdir "$LOCK"' EXIT, tar -tzf "$out" || die.

🧪 Try it

DRY_RUN=1 bin/backup.sh --dest /tmp/bk               # the rehearsal: "would: tar …", nothing written
ls /tmp/bk 2>/dev/null | wc -l                        # 0
bash -c 'set -u; echo "$REGISTR"'; echo "exit $?"     # the typo is caught
bash -c 'set -o pipefail; false | true'; echo "exit $?"    # 1 — the pipe knows
bash -c 'set -e; if false; then :; fi; echo "still here (set -e is off inside if)"'
bash -c 't=$(mktemp); trap "echo cleanup; rm -f $t" EXIT; echo working; exit 2'; echo "exit $?"
command -v shellcheck && shellcheck bin/school.sh || echo "install shellcheck: brew install shellcheck / apt install shellcheck"

✅ Verify — what you should see

The dry run logs would: tar … and creates nothing; unbound variable exit 1; pipefail exit 1; the set -e line still prints; working, cleanup, then exit 2 — the trap ran and the exit code survived.

🏁 What you just proved

You can make a script stop on failure, clean up on every exit, rehearse without side effects — and you know the one place set -e will not save you.

⚠️ Common mistakes

Trusting set -e inside if or after ||. Test the failure path.
trap with double quotes expanding variables too early. Single-quote the trap string unless you mean it.
rm -rf "$DIR/"* where DIR might be empty. "${DIR:?}".

🏭 Why this matters in production: the deploy that continued after a failed cd and deleted the wrong release; the backup that "succeeded" with an empty archive — both prevented by this lesson's ten lines.

⏭️ Next

Lesson 09 — processes & jobs: who is in the building, and how to ask them to leave.

← Previousfunctions arguments Next →processes jobs

This page is the lesson's README from the lesson-08-errors-safety branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.