Kurs dobrego skryptowania w bash - #1 Wstęp, praktyki i przydatne narzędzia

 1#!/bin/bash
 2
 3### Ten skrypt służy za prezentację złych praktyk, nie odpalaj go, bo możesz stracić 
 4### swoje pliki!
 5
 6### Tutaj dodatkowa linia dla nieostrożnych, co jednak metody Kopiego&Pasty sobie 
 7### nie pożałują
 8echo "Only for presentation purposes, do not run this - can remove your files!"
 9exit 255
10
11### ZŁA PRAKTYKA: nawet nie wiemy, czy $1 jest tutaj ustawione
12WORKING_DIR=$1
13
14# Checking if lock script exists
15### ZŁA PRAKTYKA: zahardcodowany plik - duża podatność na błędy - gdzie indziej może być
16### zahardcodowany z literówką
17if [ -e "/tmp/bad-script-lck-file" ]; then
18	echo "File lock found, another instance is running?"
19	exit 1
20fi
21
22# Create lock file to prevent another script do something while this one is working
23### ZŁE PRAKTYKI
24###  - zahardcodowany plik blokady
25###  - co jeśli komenda touch będzie z błędem (uprawnienia, brak miejsca na dysku?)
26touch /tmp/bad-script-lck-file
27
28# Checking if WORKING_DIR exist
29### ZŁE PRAKTYKI:
30### 1) To jedynie sprawdza istnienie samego katalogu, a nie np. praw wejścia do niego (sprawdź to na /root np)
31### 2) Na tę chwilę mamy utworzony plik blokady, jeśli tu zakończymy, plik blokady pozostanie
32if [ ! -d "$WORKING_DIR" ]; then
33	echo "$WORKING_DIR does not exist, leaving."
34	exit 2
35fi
36
37# Go to WORKING_DIR
38### ZŁE PRAKTYKI: co jeśli nie możemy wejść do katalogu mimo, że on istnieje?
39cd $WORKNG_DIR
40
41# Working with config file
42### ZŁE PRAKTYKI:
43### 1) Plik config hardcoded (znowu coś hardcoded) - narażenie na błędy
44### 2) Komenda mv nie jest w ciapkach (cudzysłowiach) - może dojść do jakiegoś rozsplitowania jej
45### 3) `` nie jest zalecane przy "wrapowaniu" komendy, używa się konstrukcji $()
46### 4) W ogóle co jeśli komenda mv wykona się z błędem z jakiegoś powodu?
47### 5) Co jeśli skierowanie strumienia do pliku config też będzie z błędem? (np. pełny dysk)
48### 6) Tak w ogóle w tym miejscu to my nawet nie wiemy, czy jesteśmy we właściwym katalogu
49###    więc możemy bawić się plikami "config", które do tej zabawy nie przewidziano...
50if [ -e "config" ]; then
51	mv config old.config.`date +%s`
52else
53	`date +%s` > config
54fi
55
56# Removing old timestamp file - keeping only last three
57### !!! NIEBEZPIECZNE !!!
58### ZŁE PRAKTYKI:
59### 1) Bardzo groźny moment - nie wiemy nawet czy ta komenda będzie wykonana we właściwym katalogu :-)
60### 2) Nie sprawdzamy tutaj żadnego kodu błędu
61### 3) Nie używamy np. globów, aby "zawęzić" listę plików i nie ryzykować usunięciem postronnych
62rm -f `ls -t | tail -n +4`
63
64# Finally remove lock file to allow another instances of this script to work
65### BAD PRACTISES:
66### ZŁE PRAKTYKI:
67### 1) Niektóre corner case poprzednio "olano", a tu jest koniec skryptu
68### 2) Co jeśli komenda rm zwróci błąd?
69rm -f /tmp/bad-script-lck-file

 1$ shellcheck bad-script 
 2
 3In bad-script line 38:
 4cd $WORKNG_DIR
 5^-- SC2164: Use 'cd ... || exit' or 'cd ... || return' in case cd fails.
 6   ^-- SC2153: Possible misspelling: WORKNG_DIR may not be assigned, but WORKING_DIR is.
 7   ^-- SC2086: Double quote to prevent globbing and word splitting.
 8
 9
10In bad-script line 49:
11	mv config old.config.`date +%s`
12                             ^-- SC2046: Quote this to prevent word splitting.
13                             ^-- SC2006: Use $(..) instead of legacy `..`.
14
15
16In bad-script line 51:
17	`date +%s` > config
18        ^-- SC2092: Remove backticks to avoid executing output.
19        ^-- SC2006: Use $(..) instead of legacy `..`.
20
21
22In bad-script line 60:
23rm -f `ls -t | tail -n +4`
24      ^-- SC2046: Quote this to prevent word splitting.
25      ^-- SC2006: Use $(..) instead of legacy `..`.
26       ^-- SC2012: Use find instead of ls to better handle non-alphanumeric filenames.

 1#!/bin/bash
 2
 3## Na wypadek "nieobsłużonego" błędu - kończ natychmiast
 4set -e 
 5
 6## Nie wykonuj jeśli znajdziesz niezaincjowaną zmienną
 7set -u
 8
 9## Definiujemy ważne zmienne, nawet te, które będą komendami
10working_dir=$1
11## Nasz plik blokady - ponieważ używamy tym razy zmiennej, mniejsza szansa na błąd w jednym z kilku miejsc
12lock_file="/tmp/good-script-lock-file"
13## Komendy, których będziemy używać, możemy na nie wpłynąć już tutaj
14cmd_rm="rm -f"
15cmd_mv="mv"
16cmd_find=(find . -maxdepth 1 -type f -iname "*config*" -printf "%p\n")
17prefix="old"
18config_file_name="config"
19how_many_newest_files_keep=3
20
21## Definiujemy funkcje, która będzie "sprzątać" pliki blokady, funkcję
22## bo nie raz i nie dwa tej funkcjonalności będziemy potrzebować
23function remove_lock_file() 
24{
25	if [ -e "${lock_file}" ]; then
26        ## Przy okazji sprawdzamy, czy możemy usunąć plik blokady, bo tu też może wystąpić
27        ## jakiś problem, który pokrzyżuje nam plany
28		${cmd_rm} "${lock_file}" || { 
29			echo "Cannot remove lock file: ${lock_file}" >&2;
30			exit 4
31		}
32	fi
33}
34
35## Przechwytujemy Ctrl+C i "sprzątamy", co by po takiej akcji plik blokady nie pozostał
36trap remove_lock_file SIGINT
37
38## Sprawdzamy czy plik blokady istnieje
39if [ -e "${lock_file}" ]; then
40	echo "File lock found, another instance is running?" >&2;
41	exit 1
42fi
43
44## Tworzymy plik blokady i dodajemy obsługę sytuacji, w której z jakiegoś powodu wystąpił błąd przy tym tworzeniu
45touch "${lock_file}" || {
46    echo "Cannot create lock file - exiting" >&2;
47	exit 2
48}
49
50## Wchodzimy do $working_dir lub "obslugujemy" błąd, jeśli nie możemy wejść do $working_dir
51cd "${working_dir}" || { 
52	echo "Cannot enter to working dir." >&2;
53    remove_lock_file
54    exit 3
55}
56
57## tworzymy zmienne config_file_path i pobieramy unixtime do dalszego użycia
58config_file_path="${working_dir}/${config_file_name}"
59time_now=$(date +%s)
60
61if [ -e "${config_file_path}" ]; then
62    ## Komenda mv też może zwrócić jakiś błąd więc też nie zapominamy o jego ew. obsłudze
63	${cmd_mv} "${config_file_path}" "${prefix}.${config_file_name}.${time_now}" || {
64	    echo "Cannot rename ${config_file_path} as ${prefix}.${config_file_name}.${time_now}"  >&2;
65		remove_lock_file
66		exit 5
67	}
68fi
69
70## W poniższej sytuacji również obsługujemy ew. błąd, który może wystąpić
71echo "${time_now}" > "${config_file_path}" || {
72	echo "Cannot save unixtime ${time_now} to ${config_file_path}" >&2;
73	remove_lock_file
74	exit 6
75}
76
77## Usuwamy stare i zostawiamy X ostatnich określonych w zmiennej how_many_newest_files_keep
78how_many=$((how_many_newest_files_keep + 1))
79
80## shellcheck zasugerował tutaj użyć komendy find zamiast ls z powodu lepszej 
81## obsługi niektórych nazw plików
82for file in $( "${cmd_find[@]}" | sort -rz | tail -n +${how_many}); do
83    ## Komenda rm może zwrócić błąd, który tutaj obsłużymy
84	${cmd_rm} "${file}" || {
85		echo "Cannot remove old file: ${file}" >&2;
86		remove_lock_file
87		exit 7
88	}
89done
90
91## Koniec pracy - sprzątamy
92remove_lock_file

  1#!/usr/bin/env bash
  2
  3## Na wypadek "nieobsłużonego" błędu - kończ natychmiast
  4set -e 
  5
  6## Nie wykonuj jeśli znajdziesz niezaincjowaną zmienną
  7set -u
  8
  9## Definiujemy ważne zmienne, nawet te, które będą komendami
 10working_dir=$1
 11lock_file_or_dir="/var/lock/good-script-lock-dir"
 12cmd_locking="mkdir ${lock_file_or_dir}"
 13cmd_check_lock="test -d ${lock_file_or_dir}"
 14cmd_unlocking="rm -rf ${lock_file_or_dir}"
 15cmd_rm="rm -f"
 16cmd_mv="mv"
 17cmd_find="find"
 18cmd_find=(${cmd_find} . -maxdepth 1 -type f -iname "*config*" -printf "%p\n")
 19prefix="old"
 20config_file_name="config"
 21how_many_newest_files_keep=3
 22
 23## Sprawdza czy blokada jest aktywna
 24## 1 dla wartości prawda (true) - blokada jest aktywna
 25## 0 dla wartości fałsz (false) - blokady albo nie ma, albo jest jakiś błąd (w przypadku dziwnego błędu zawsze lepiej nie startować skryptu)
 26function is_already_running()
 27{
 28	local cmd_check_lock=${1}
 29
 30	${cmd_check_lock} || { 
 31		return 1
 32	}
 33
 34	return 0
 35}
 36
 37## Tworzymy blokadę
 38function create_lock()
 39{
 40	local cmd_locking=${1}
 41
 42	${cmd_locking} || {
 43		printf "Cannot create lock\n"
 44		exit 2
 45	}
 46}
 47
 48## Usuwamy blokadę
 49function remove_lock() 
 50{
 51	local cmd_unlocking="${1}"
 52	${cmd_unlocking} || {
 53		printf "Cannot unlock\n"
 54		exit 3
 55	}
 56}
 57
 58## Łapiemy m.in. Ctrl+C i sprzątamy blokadę
 59trap 'remove_lock "${cmd_unlocking}"' SIGINT SIGTERM
 60
 61## Używając naszych funkcji tutaj sprawdzamy, czy nie ma jakiejś blokady, czyli, że 
 62## nie ma drugiej instancji skryptu już działającej
 63if is_already_running "${cmd_check_lock}" ; then
 64	printf "Cannot acquire lock (another instance is running?) - exiting.\n"
 65	exit 1
 66fi
 67
 68## Tworzymy blokadę
 69create_lock "${cmd_locking}"
 70
 71## Wchodzimy do $working_dir lub "obslugujemy" błąd, jeśli nie możemy wejść do $working_dir
 72cd "${working_dir}" || { 
 73	remove_lock "${cmd_unlocking}"
 74	printf "Cannot enter to working dir.\n" >&2 ;
 75	exit 4
 76}
 77
 78## Tworzymy zmienne config_file_path i pobieramy unixtime do dalszego użycia
 79config_file_path="${working_dir}/${config_file_name}"
 80time_now=$(date +%s)
 81
 82if [ -e "${config_file_path}" ]; then
 83	## Komenda mv też może zwrócić jakiś błąd więc też nie zapominamy o jego ew. obsłudze
 84	${cmd_mv} "${config_file_path}" "${prefix}.${config_file_name}.${time_now}" || {
 85	    printf "Cannot rename %s as %s.%s.%s\n" "${config_file_path}" "${prefix}" "${config_file_name}" "${time_now}" >&2 ;
 86		remove_lock "${cmd_unlocking}"
 87		exit 5
 88	}
 89fi
 90
 91## W poniższej sytuacji również obsługujemy ew. błąd, który może wystąpić
 92printf "%s" "${time_now}" > "${config_file_path}" || {
 93	printf "Cannot save unixtime %s to %s\n" "${time_now}" "${config_file_path}" >&2 ;
 94	remove_lock "${cmd_unlocking}"
 95	exit 6
 96}
 97
 98## Usuwamy stare i zostawiamy X ostatnich określonych w zmiennej how_many_newest_files_keep
 99how_many=$((how_many_newest_files_keep + 1))
100
101## shellcheck zasugerował tutaj użyć komendy find zamiast ls z powodu lepszej 
102## obsługi niektórych nazw plików
103for file in $( "${cmd_find[@]}" | sort -rz | tail -n +${how_many}); do
104	## Komenda rm może zwrócić błąd, który tutaj obsłużymy
105	${cmd_rm} "${file}" || {
106		printf "Cannot remove old file: %s\n" "${file}" >&2 ;
107		remove_lock "${cmd_unlocking}"
108		exit 7
109	}
110done
111
112## Celowe opóźnienie do testów blokady, żadnego innego zastosowania ta linia nie posiada
113sleep 5
114
115## Koniec pracy - sprzątamy
116remove_lock "${cmd_unlocking}"