# Shell funksiyalari, exit kodlari, set -euo pipefail va trap !!! info "Bu darsda" - **Funksiyalar**: argumentlar, `local`, `return` va `$(...)` - Exit kodlari: `PIPESTATUS`, 126/127/130 - `set -euo pipefail` va u qayerda **ishlamasligi** - `trap ... EXIT` + `mktemp` + `mv` — axlatsiz va xavfsiz natija Endi skriptlarni **ishonchli** qiladigan to'rtta vositani o'rganamiz. --- ## "OK" degan, lekin buzilgan zaxira Har kecha cron zaxira skriptini ishga tushiradi, jurnalda: `Zaxira tayyor: OK`. Bir oydan keyin disk buziladi, zaxirani ochasiz — arxiv **buzilgan**. Skriptda: ``` # zaxira.sh dan parcha tar -cf - /srv/ilova | gzip > /backup/ilova.tar.gz echo "Zaxira tayyor: OK" ``` Bir kuni `tar` xato bilan to'xtagan. Lekin quvurning chiqish kodi — **oxirgi** buyruqniki, ya'ni `gzip` niki, u esa olgan yarim ma'lumotni siqib, 0 qaytargan. Skript "OK" yozgan. Ustiga-ustak, `/tmp` da vaqtinchalik fayllar to'planib borgan. --- ## Funksiyalar — kodga nom berish Funksiya — nom berilgan buyruqlar to'plami: bir marta yozib, oddiy buyruq kabi chaqirasiz. ```bash salom() { echo "Salom, $1! Siz $# ta argument berdingiz." } salom Aziz salom "Dilnoza Karimova" ortiqcha ``` ``` Salom, Aziz! Siz 1 ta argument berdingiz. Salom, Dilnoza Karimova! Siz 2 ta argument berdingiz. ``` Qoidalar: - Funksiya **chaqirilishidan oldin** e'lon qilinishi kerak (skript yuqoridan pastga o'qiladi). - Ichida `$1`, `$2`, ..., `$#`, `"$@"` — skriptning emas, **funksiyaning** argumentlari. `$0` esa baribir skript nomi. - `function salom { ... }` yozuvi Bash, zsh va ksh'da ishlaydi, lekin POSIX `sh` (dash) da ishlamaydi; `salom() { ... }` hamma joyda ishlaydi. ### Analogiya: oshxonadagi retsept kartochkasi Kartochka (funksiya) bir marta yoziladi, mahsulotlar (argumentlar) har safar boshqacha, natija esa ikki xil: **tayyor taom** (stdout'dagi ma'lumot) va **"bo'ldi / kuydi"** (chiqish kodi). ### Ikki xil natija: `echo` va `return` | | Nima uchun | Qanday olinadi | |---|---|---| | `echo ...` (stdout) | **ma'lumot** qaytarish (son, nom, yo'l) | `natija=$(funksiya ...)` | | `return N` | **muvaffaqiyat/xato** holati, 0–255 | `$?`, `if funksiya ...; then` | ```bash kvadrat() { echo $(( $1 * $1 )) } juftmi() { [ $(( $1 % 2 )) -eq 0 ] # shartning o'zi 0 yoki 1 qaytaradi } k=$(kvadrat 12) echo "12 ning kvadrati: $k" for n in 3 8; do if juftmi "$n"; then echo "$n juft"; else echo "$n toq"; fi done ``` `return` siz funksiya **oxirgi buyruqning** kodini qaytaradi — `juftmi` shunga tayanadi. `return 300` jimgina 44 ga aylanadi (kod 0–255). Funksiya ichidagi `exit` **butun skriptni** (`source` qilingan bo'lsa — terminalni) yopadi. Funksiyadan chiqish — `return`. ### local — o'zgaruvchini funksiya ichida qoldirish Bash'da funksiya ichidagi o'zgaruvchi sukut bo'yicha **global**. Bu jim xatolarga olib keladi: ```bash fayl="hisobot.txt" yomon() { fayl="$1.bak"; echo "$fayl"; } # local yo'q yaxshi() { local fayl="$1.bak"; echo "$fayl"; } yaxshi config.yml; echo "Asosiy fayl: $fayl" # hisobot.txt yomon config.yml; echo "Asosiy fayl: $fayl" # config.yml.bak — buzildi! ``` Qoida: funksiya ichidagi **har bir** o'zgaruvchi `local` bo'lsin. ### Kutubxona fayli va `source` Umumiy funksiyalarni alohida faylga yig'ib, `source` bilan ulash mumkin. Kutubxona faqat **funksiyalarni e'lon qiladi**, o'zi hech narsa bajarmaydi: ```bash mkdir -p /tmp/demo cat > /tmp/demo/lib.sh <<'EOF' # umumiy funksiyalar — faqat e'lonlar xabar() { echo "[$(date +%H:%M:%S)] $*" >&2; } toxta() { xabar "XATO: $1"; exit "${2:-1}"; } EOF cat > /tmp/demo/ish.sh <<'EOF' #!/bin/bash source /tmp/demo/lib.sh xabar "boshlandi" [ -d /etc ] || toxta "/etc yo'q" 3 xabar "tugadi" EOF chmod +x /tmp/demo/ish.sh /tmp/demo/ish.sh ``` `xabar` jurnalni **stderr**'ga yozadi, stdout ma'lumot uchun toza qoladi; `$*` argumentlarni bitta satrga qo'shadi. `toxta` (ingliz tilida `die`) ataylab `exit` ishlatadi. Funksiyalar ro'yxati: `declare -F`. --- ## Exit kodlari — chuqurroq Oldingi darsdagi jadvalga Bash'ning o'z kodlarini qo'shamiz: | Kod | Ma'nosi | |---|---| | 126 | fayl topildi, lekin ishga tushirib bo'lmaydi (masalan, `chmod +x` yo'q) | | 127 | buyruq topilmadi (nomida xato yoki PATH'da yo'q) | | 128+N | N-signal bilan o'ldirildi: 130 = Ctrl+C (SIGINT, 2), 143 = SIGTERM (15) | ```bash yoq_buyruq_xyz; echo "kod=$?" # 127 printf 'echo hi\n' > /tmp/x.sh /tmp/x.sh; echo "kod=$?" # 126 — bajarish huquqi yo'q ``` ### Quvurning kodi va PIPESTATUS Quvur sukut bo'yicha **faqat oxirgi** buyruqning kodini qaytaradi. Har bir bo'g'in kodi `PIPESTATUS` massivida — uni quvurdan **darhol keyin** o'qing: ```bash grep ERROR /var/log/yoq_fayl.log | sort | head -3 echo "kodlar: ${PIPESTATUS[*]}" # kodlar: 2 0 0 ``` `grep` 2 qaytardi, lekin `$?` 0 bo'lardi — zaxira hikoyasi aynan shu. --- ## set -euo pipefail — "xato bo'lsa darhol to'xta" ### set -e — muvaffaqiyatsiz buyruqda chiqish ```bash cat > /tmp/e.sh <<'EOF' #!/bin/bash set -e echo "1-qadam" cp /yoq/fayl /tmp/ echo "2-qadam — bu chiqmaydi" EOF bash /tmp/e.sh; echo "skript kodi=$?" ``` `cp` xato qaytargan zahoti skript o'sha kod (1) bilan tugaydi. `set -e` siz "2-qadam" chiqib, skript 0 bilan tugardi. Lekin `set -e` **har joyda ishlamaydi**. U buyruq kodi "tekshirilayotgan" joylarda o'chiq turadi: - `if`, `while`, `until` shartida: `if grep -q x fayl; then ...` - `&&` / `||` zanjirining oxirgi bo'g'inidan boshqa joylarida: `[ -f x ] && echo bor` - `!` bilan inkor qilingan buyruqda Xato **ruxsat etilgan** buyruq uchun — `|| true`: ```bash bash -c ' set -e rm /tmp/balki_yoq.lock 2>/dev/null || true # fayl yo'\''q bo'\''lsa ham davom et echo "davom etdik" ' ``` (`bash -c` ichida: `set -e` ni interaktiv terminalda yoqsangiz, birinchi xatoda terminal yopiladi.) !!! warning "Ikki jim tuzoq" **`local x=$(buyruq)`** — `local` ning o'zi muvaffaqiyatli bo'lgani uchun, `buyruq` xato qaytarsa ham kod 0 bo'ladi va `set -e` ishlamaydi. E'lon va qiymat berishni ajrating: `local x; x=$(buyruq)`. **Funksiya tekshirilayotgan joyda chaqirilsa** — `if f; then`, `f || kod=$?`, `x=$(f) || ...` — funksiya **ichida** ham `set -e` o'chiq bo'ladi: ichidagi xato e'tiborsiz qoladi va oxirgi buyruqning kodi qaytadi. Shuning uchun funksiya xatoni o'zi `return N` bilan bildirsin (quyidagi `port_ol` aynan shunday). !!! warning "Teskari tuzoq: oxirgi qatordagi `&&`" Funksiyaning oxirgi qatori `[ -f "$1" ] && echo bor` bo'lsa, fayl yo'q paytda funksiya 1 qaytaradi. Funksiya oddiy chaqirilgan bo'lsa, `set -e` skriptni **xabarsiz** to'xtatadi: ```bash bash -c 'set -e; bormi() { [ -f "$1" ] && echo bor; }; bormi /yoq; echo "yetib keldik"'; echo "kod=$?" ``` `yetib keldik` chiqmaydi, `kod=1`. Davo: `if` yozing yoki oxiriga `return 0` qo'ying. ### set -u — e'lon qilinmagan o'zgaruvchi = xato Mashhur halokat: ```bash unset ISH_PAPKA echo "Bajarilardi: rm -rf ${ISH_PAPKA}/*" ``` ``` Bajarilardi: rm -rf /* ``` `ISH_PAPKA` nomida harf xatosi bo'lsa, `rm -rf "$ISH_PAPKA/"*` aynan `rm -rf /*` ga aylanadi. `set -u` bilan Bash bunday o'zgaruvchini uchratgan zahoti to'xtaydi: ```bash printf '#!/bin/bash\nset -u\necho "papka: $ISH_PAPKA"\n' > /tmp/u.sh bash /tmp/u.sh; echo "kod=$?" # ISH_PAPKA: unbound variable, kod=1 ``` Ixtiyoriy o'zgaruvchilarga standart qiymat bering: `"${MUHIT:-dev}"`, `"${1:-}"`. ### set -o pipefail — quvurdagi har bir xatoni ko'rish «Pipes va Filterlar» darsida `pipefail` bilan tanishgan edik, endi uni `set -e` bilan birga ishlatamiz. Eslatma: `pipefail` yoqilganda quvurning kodi — **noldan farqli oxirgi** kod (hammasi 0 bo'lsa — 0): ```bash bash -c 'false | true; echo "pipefail yo'\''q: $?"' # 0 bash -c 'set -o pipefail; false | true; echo "pipefail bor: $?"' # 1 ``` `set -e` bilan birga quvurning istalgan bo'g'ini yiqilsa skript to'xtaydi — `tar | gzip` endi "OK" deya olmaydi. Shuning uchun production skriptlari odatda `set -euo pipefail` bilan boshlanadi. Bu xatolarni **ko'rinadigan** qiladi, lekin o'ylashni almashtirmaydi. --- ## trap — qanday tugasa ham tozalash `set -e` skriptni o'rtasida to'xtatsa, yarim yozilgan vaqtinchalik fayllar nima bo'ladi? Javob — `trap`: ``` trap 'BUYRUQLAR' SIGNAL... ``` Eng ko'p ishlatiladigani — maxsus **`EXIT`** "signali": skript qanday tugamasin (oddiy oxir, `exit 3`, `set -e` sabab yiqilish, Ctrl+C, `kill` bilan SIGTERM), shu buyruqlar bajariladi. Yagona istisno — `kill -9` (SIGKILL): uni ushlab bo'lmaydi, jarayon darhol o'ladi va trap ishlamaydi. ```mermaid flowchart TD A[Skript boshlanadi
trap tozala EXIT] --> B[mktemp: vaqtinchalik fayl] B --> C{Ish muvaffaqiyatlimi?} C -- Ha --> D[mv: natijani joyiga qo'y] D --> E[Oddiy tugash, kod 0] C -- Yo'q --> F[set -e: yiqilish, kod 1+] E --> G[tozala ishga tushadi] F --> G G --> H[Vaqtinchalik fayl o'chirildi,
chiqish kodi saqlandi] ``` ### mktemp — xavfsiz vaqtinchalik fayl Qattiq nomli `/tmp/hisobot.tmp` ni skriptning ikki nusxasi bir-biri ustidan yozadi. `mktemp` esa **noyob** fayl yaratib, yo'lini chiqaradi: ```bash f=$(mktemp) # /tmp/tmp.Xk3pQ2aZ1v kabi d=$(mktemp -d) # vaqtinchalik papka echo "$f $d" rm -rf "$f" "$d" ``` `mktemp` papkani `TMPDIR` dan oladi (bo'lmasa `/tmp`). Shablon bilan esa istalgan papkada: `mktemp /srv/hisobot.txt.XXXXXX` — `X` lar tasodifiy belgilarga almashadi. ### To'liq naqsh: trap + mktemp + mv Vazifa: `/etc/passwd` dan login shell'i `bash` bo'lgan foydalanuvchilar ro'yxatini `/tmp/bash_users.txt` ga yozish. Talab: natija fayli **hech qachon yarim yozilgan holda qolmasin** — boshqa dastur uni istalgan paytda o'qishi mumkin. ```bash cat > /tmp/royxat.sh <<'EOF' #!/bin/bash set -euo pipefail NATIJA="${1:-/tmp/bash_users.txt}" vaqtincha="" tozala() { local kod=$? # birinchi qator: chiqish kodini saqlab qolamiz [ -n "$vaqtincha" ] && rm -f "$vaqtincha" exit "$kod" } trap tozala EXIT vaqtincha=$(mktemp "$NATIJA.XXXXXX") # natija bilan BITTA papkada grep ':/bin/bash$' /etc/passwd | cut -d: -f1 | sort > "$vaqtincha" chmod 644 "$vaqtincha" # mktemp fayli 0600 bo'ladi mv "$vaqtincha" "$NATIJA" # bir zumda almashtirish vaqtincha="" # endi o'chiradigan narsa yo'q echo "Tayyor: $(wc -l < "$NATIJA") ta foydalanuvchi" >&2 EOF chmod +x /tmp/royxat.sh /tmp/royxat.sh; echo "kod=$?"; cat /tmp/bash_users.txt ``` Nima uchun shunday: 1. **Avval vaqtinchalik faylga, keyin `mv`.** Bitta fayl tizimi ichida `mv` faqat nomni almashtiradi, bu bir zumda bo'ladi: o'quvchi yo eski, yo to'liq yangi faylni ko'radi. Ish yarmida yiqilsa, eski natija **tegilmay** qoladi. 2. **Vaqtinchalik fayl natija yonida** (`mktemp "$NATIJA.XXXXXX"`), `/tmp` da emas. `/tmp` ko'pincha tmpfs, `/backup` esa alohida disk bo'ladi. Fayl tizimlari orasida `mv` nusxalash + o'chirishga aylanadi va o'quvchi yarim nusxani ko'rishi mumkin. 3. **`chmod 644`** — `mktemp` faylni `0600` (faqat egasi o'qiydi) qilib yaratadi, `mv` esa bu huquqni saqlaydi. Usiz boshqa foydalanuvchilar natijani o'qiy olmay qoladi. Arxiv kabi maxfiy natija uchun esa `0600` aynan kerakli huquq. 4. **`local kod=$?` — tozalashning birinchi qatori.** Undan oldin boshqa buyruq bajarilsa, `$?` o'zgaradi va asl chiqish kodi yo'qoladi. 5. **`vaqtincha=""` `mv` dan keyin** — o'chiradigan narsa qolmadi. 6. **`trap` `mktemp` dan oldin** — oradagi yiqilishda ham fayl qolmaydi. Endi buzib ko'ring: ```bash sed 's#/etc/passwd#/etc/yoq_fayl#' /tmp/royxat.sh > /tmp/royxat_buzuq.sh ls /tmp/bash_users.txt.* 2>/dev/null | wc -l bash /tmp/royxat_buzuq.sh; echo "kod=$?" ls /tmp/bash_users.txt.* 2>/dev/null | wc -l ``` `grep` 2 qaytaradi, `pipefail` buni quvurning kodi qiladi, `set -e` skriptni to'xtatadi, `trap` vaqtinchalik faylni o'chiradi — `bash_users.txt.XXXXXX` qoldiqlari soni 0 bo'lib qoladi, `/tmp/bash_users.txt` dagi eski ro'yxat esa joyida. !!! question "Tekshirib ko'ring" `/tmp/royxat.sh` dan `set -o pipefail` ni olib tashlasangiz (`set -eu` qoldirib), buzuq versiya qanday tugaydi va `/tmp/bash_users.txt` ga nima bo'ladi? !!! note "Javob" Quvurning kodi `sort` niki (0) bo'ladi, skript yiqilmaydi: bo'sh vaqtinchalik fayl `mv` bilan natija o'rniga qo'yiladi va `Tayyor: 0 ta foydalanuvchi` chiqadi, kod 0. Eski ro'yxat yo'qoldi — xuddi darsning boshidagi "OK" zaxira kabi. ### ERR — xato qatorini ko'rsatish ```bash cat > /tmp/signal.sh <<'EOF' #!/bin/bash set -euo pipefail trap 'echo "Xato: $LINENO-qator, kod=$?" >&2' ERR ls /yoq_papka echo "bu qatorga yetilmaydi" EOF bash /tmp/signal.sh; echo "kod=$?" ``` `ERR` tuzatishda qulay; tozalash uchun esa doim `EXIT`. E'tibor bering: `ERR` trap sukut bo'yicha funksiyalar **ichiga o'tmaydi** — funksiya ichidagi xatoda ham ishlashi uchun `set -E` (`set -eE -o pipefail`) qo'shing. Trap'ni olib tashlash: `trap - EXIT`. --- ## Hammasi birga — servis holati hisoboti Skript `*.conf` fayllaridan `port=` qiymatlarini yig'ib, hisobot faylini xavfsiz almashtiradi: ```bash mkdir -p /tmp/hisobot_demo/conf printf 'nom=web\nport=8080\n' > /tmp/hisobot_demo/conf/web.conf printf 'nom=api\nport=9000\n' > /tmp/hisobot_demo/conf/api.conf cat > /tmp/hisobot_demo/portlar.sh <<'EOF' #!/bin/bash set -euo pipefail xabar() { echo "[portlar] $*" >&2; } port_ol() { # $1 = conf fayl; stdout = port local qator qator=$(grep -m1 '^port=' "$1") || return 4 echo "${qator#port=}" } if [ $# -ne 2 ]; then xabar "foydalanish: $0 CONF_PAPKA NATIJA" exit 2 fi papka=$1 natija=$2 vaqtincha="" trap '[ -n "$vaqtincha" ] && rm -f "$vaqtincha"' EXIT vaqtincha=$(mktemp "$natija.XXXXXX") for f in "$papka"/*.conf; do [ -f "$f" ] || continue p=$(port_ol "$f") || { xabar "$f: port= yo'q"; exit 4; } echo "$(basename "$f" .conf) $p" >> "$vaqtincha" done sort -o "$vaqtincha" "$vaqtincha" mv "$vaqtincha" "$natija" vaqtincha="" xabar "yozildi: $natija" EOF chmod +x /tmp/hisobot_demo/portlar.sh /tmp/hisobot_demo/portlar.sh /tmp/hisobot_demo/conf /tmp/hisobot_demo/portlar.txt; echo "kod=$?" cat /tmp/hisobot_demo/portlar.txt printf 'nom=db\n' > /tmp/hisobot_demo/conf/db.conf /tmp/hisobot_demo/portlar.sh /tmp/hisobot_demo/conf /tmp/hisobot_demo/portlar.txt; echo "kod=$?" cat /tmp/hisobot_demo/portlar.txt ``` Ikkinchi chaqiruvda `db.conf` da `port=` yo'q: skript `exit 4` bilan tugaydi, `trap` vaqtinchalik faylni o'chiradi, `portlar.txt` eski to'g'ri hisobotni saqlaydi. `port_ol` xatoni **o'zi** `return 4` bilan bildiradi, chaqiruvchi `||` bilan ushlaydi. Trap bu yerda qisqa satr — chiqish kodiga tegmaydigan tozalash uchun shu yetarli. !!! tip "Trap satri bitta tirnoqda" Bitta tirnoq (`'`) ichidagi `$vaqtincha` trap **ishga tushganda** ochiladi; qo'shtirnoq bilan esa `trap` qatoridagi (hali bo'sh) qiymat qotib qoladi. --- !!! warning "Tez-tez uchraydigan xatolar" 1. Ma'lumotni `return` bilan qaytarish (u faqat 0–255 holat). 2. `local` ni unutish yoki funksiyada `exit`. 3. `local x=$(buyruq)` — xato kodi yutiladi. 4. `pipefail` siz quvur — `tar | gzip` da `tar` xatosi ko'rinmaydi. 5. Natijaga to'g'ridan-to'g'ri yozish yoki vaqtinchalik faylni boshqa diskda (`/tmp`) yaratish. 6. `set -e` ga ko'r-ko'rona ishonish — `if`, `&&`/`||` ichida u ishlamaydi. --- ## Xulosa — eng muhimi 1. **Funksiya**: `nom() { ... }`, ichida `$1`, `$#`, `"$@"`, har bir o'zgaruvchi `local`. Ma'lumot — `echo` + `$(...)`, holat — `return N`. Funksiyadan chiqish — `return`, skriptdan — `exit`. 2. Umumiy funksiyalar kutubxonada, **`source`** bilan ulanadi; kutubxona o'zi hech narsa bajarmaydi. 3. Kodlar: **126**, **127**, **128+N**; quvur kodlari — **`PIPESTATUS`**. 4. **`set -euo pipefail`** xatolarni ko'rinadigan qiladi, lekin `if`, `&&`/`||`, `local x=$(...)` ichida ishlamaydi. 5. **`trap tozala EXIT`** + natija yonida **`mktemp`** + **`mv`** — axlat qolmaydi, natija hech qachon yarim yozilmaydi (`kill -9` dan tashqari).