GNU/Linux - 4. deo – Shell skripte i automatizacija procesa

Uvod

Posle upoznavanja sa osnovnim i napredni(ji)m konzolnim komandama (što je procedura koja svakako podrazumeva i samostalno isprobavanje primera, pravilno 'taloženje informacija' i povremeno utvrđivanje gradiva), na red dolazi upoznavanje sa različitim metodama za automatizaciju procesa ....

Glavna tema članka biće kreiranje i pokretanje shell skripti u okruženju Bash, ali, prvo ćemo se upoznati sa privilegijama za pristup datotekama i direktorijumima, budući da bez dodele odgovarajućih privilegija - doslovno nije moguće pokretati skripte. :)

Na kraju (nakon detaljnog upoznavanja sa prethodno navedenim temama), upoznaćemo se ukratko i sa programima watch i cron koji takođe predstavljaju mehanizme za automatizaciju procesa u UNIX-olikim operativnim sistemima (i mogu 'sarađivati' sa shell skriptama).

Kratak osvrt na kompatibilnost skripti

Striktno govoreći, shell skripte u UNIX-olikim operativnim sistemima nisu univerzalne i svako shell okruženje u kome se skripte izvršavaju (Bash, Zsh, Fish, Dash i sl) - donosi sa sobom pojedinosti o kojima se mora voditi računa.

Međutim, u praksi - pogotovo na početku - gotovo je sigurno da ćete kao shell program koristiti upravo Bash, ** a ako ne koristite Bash, gotovo je sigurno da koristite Zsh ili Fish.

Za Fish smo još u uvodnom članku naveli da koristi sopstvenu shell sintaksu koja nije kompatibilna sa sintaksom okruženja Bash, * a što se tiče Zsh-a, skripte pisane za Bash su kompatibilne sa okruženjem Zsh (gotovo uvek), pri čemu najčešće važi i obrnuto (autor ovog teksta koristi upravo Zsh kao (glavni) shell program, ali, sve skripte koje ćete videti u članku, uspešno su isprobane u oba okruženja).

Najjednostavnije: može se reći da sintaksa okruženja Bash predstavlja de facto standard za pisanje shell skripti pod Linux-om (duži niz godina unazad), i zato će i primeri koje ćemo prikazivati biti usklađeni sa navedenim okolnostima.

Privilegije korisnika za pristup datotekama i direktorijumima

Kao što smo naveli još u uvodnom članku, UNIX-oliki operativni sistemi odlikuju se preciznim i nedvosmislenim sistemom privilegija za pristup datotekama i direktorijumima.

Za svaku datoteku ili direktorijum, jasno su definisane privilegije:

• vlasnika datoteke (vlasnik = korisnik koji je kreirao datoteku)
• grupe korisnika kojoj vlasnik pripada
• (svih) ostalih korisnika (koji ne pripadaju jednoj od prethodne dve kategorije)

Da bismo se upoznali sa sistemom privilegija u praksi, dovoljno je pokrenuti komandu ls -l (pri čemu ćemo dobiti, kao što znamo od ranije, detaljan tabelarni listing datoteka i direktorijuma).

		
$ ls -l
drwxr-xr-x  2 korisnik_1 admin 4096 Aug 17  2022 data
-rw-r--r--  1 korisnik_1 admin  743 Aug 25  2022 .config
		
	

Može se primetiti da je vlasnik direktorijuma data i datoteke .config, korisnik korisnik_1 (koji pripada grupi admin), * a mogu se primetiti i podaci koji se tiču privilegija vlasnika i ostalih kategorija korisnika (podaci se nalaze sa leve strane, u prvoj koloni koja sadrži 10 znakova).

Prvi znak prikazuje da li je u pitanju direktorijum (d), ili je u pitanju obična datoteka (-), a sledeće tri troslovne niske definišu (kao što smo prethodno naveli): privilegije vlasnika datoteke, privilegije grupe kojoj vlasnik pripada, i (na kraju), privilegije svih ostalih korisnika.

U konkretnom primeru koji smo prikazali, ako se usmerimo na direktorijum data, mogu se zapaziti sledeće informacije:

• d - u pitanju je direktorijum (uz obične datoteke, na prvom mestu stoji odrednica -)
• rwx - vlasnik ima sve privilegije za pristup direktorijumu *
• r-x - korisnici iz grupe kojoj vlasnik pripada, imaju privilegije pristupa (r) i izvršavanja (x)
• r-x - svi ostali korisnici takođe imaju privilegije pristupa i izvršavanja

U zavisnosti od toga da li je u pitanju datoteka ili direktorijum, svaka od tri troslovne niske prikazuje (redom) sledeće privilegije:

• r - korisnik ili grupa korisnika ima privilegiju čitanja (datoteka se može čitati (tj. otvarati), odnosno, može se pristupiti direktorijumu)
• w - korisnik ili grupa korisnika ima pravo upisa (u datoteku ili direktorijum)
• x - korisnik ili grupa korisnika ima pravo da pokrene izvršnu datoteku
• - - pojava znaka - na bilo kom od tri mesta, označava da je privilegija uskraćena

Pravi smisao privilegija za pristup, najlakše je razumeti preko dodatnih primera.

Najočigledniji primer je sledeći: "nekako deluje" da određeni korisnik "ipak" može pristupiti direktorijumu čiji je 'vlasnik' - bez obzira na to "šta piše u tim čudnim rwx niskama" - međutim - privilegije su sasvim nedvosmislene.

Zamislićemo da su u početnoj situaciji definisane sledeće privilegije za direktorijum /home/korisnik_1 ....

		
drwxr-xr-x 21 korisnik_1 korisnik_1 4.0K Mar 15 10:31 korisnik_1
		
	

.... nakon čega nastaje (nova) situacija, u kojoj su privilegije promenjene (primetite da drugi znak, odnosno, prvi znak u prvoj troslovnoj niski, nije više 'r'):

		
d-wxr-xr-x 18 korisnik_1 korisnik_1 4.0K Mar 15 10:31 korisnik_1
		
	

U novonastaloj situaciji, korisnik korisnik_1 doslovno neće više biti u stanju da pristupa sopstvenom home direktorijumu!

U sledećem primeru, korisnik korisnik_2 je vlasnik datoteke skripta_1.sh i definisao je privilegije na sledeći način:

		
-rwxrwxr-x 21 korisnik_2 admin 1.0K Jun 04 10:31 skripta_1.sh
		
	

U navedenoj situaciji, različiti korisnici imaju sledeće privilegije:

• korisnik korisnik_2 ima sve privilegije
• korisnici iz grupe admin (kojoj pripada korisnik korisnik_2), takođe imaju sve privilegije
• ostali korisnici, imaju privilegiju čitanja (mogu otvarati skriptu u editorima i sl), imaju privilegiju pokretanja skripte, ali, nemaju privilegije za modifikaciju sadržaja skripte

U prethodno navedenim okolnostima, svi korisnici (tj. administratori) iz grupe "admin", mogu menjati sadržaj skripte skripta_1.sh, čiji je vlasnik korisnik korisnik_2 (pri čemu ostali korisnici mogu otvarati skriptu), međutim, u drugim okolnostima, mogu se podesiti drugačije privilegije:

		
-rwxr-x--x 21 korisnik_2 admin 1.0K Jun 04 10:31 skripta_1.sh
		
	

U novim okolnostima:

• korisnici iz grupe "admin" mogu samo čitati i pokretati skriptu (na primer, 'pao je dogovor' da svaki administrator ubuduće uređuje samo svoje skripte)
• ostali korisnici (poslednja troslovna niska), mogu samo pokretati skriptu

Predstavljanje privilegija preko brojčanih kodova

U opštem smislu, "rwx niske" su (naravno/očigledno) - niske, ali, takve niske se lako mogu zamisliti i kao trocifreni binarni brojevi (sa uključenim ili isključenim bitovima na određenim pozicijama), to jest, praktičnije, "rwx niske" se mogu zamisliti kao oktalne cifre (koje odgovaraju kombinacijama uključenih "bitova").

Pogledajmo nekoliko primera:

• rwx => 111₍₂₎ => 7₍₈₎
• rw- => 110₍₂₎ => 6₍₈₎
• r-x => 101₍₂₎ => 5₍₈₎
• r-- => 100₍₂₎ => 4₍₈₎

Poznavanje 'oktalnih kodova' za "rwx" statuse, biće od pomoći pri korišćenju komande chmod.

chmod - promena privilegija datoteke/direktorijuma

Preko komande chmod ("Change Mode"), moguće je definisati (nove) privilegije za pristup određenoj datoteci, ili određenom direktorijumu.

Komanda chmod može se pozivati na razne načine, a za početak ćemo razmotriti najjednostavniji primer:

		
$ chmod u+x skripta_1.sh
		
	

.... pri čemu argument u+x znači da vlasnik dobija privilegiju izvršavanja datoteke.

Ako je potrebno (praktično) poništiti dodelu privilegija iz prethodnog koraka, možemo pozvati sledeću komandu:

		
$ chmod u-x skripta_1.sh
		
	

U drugom slučaju, u pitaju je oduzimanje tj. uskraćivanje privilegija, preko argumenta -.

Ako je potrebno dopuniti privilegije, tako da korisnik (tj. vlasnik) dobije privilegije izvršavanja, a grupa kojoj korisnik pripada dobije privilegije upisa, komanda se može izvršiti na sledeći način:

		
$ chmod u+x,g+w skripta_1.sh
		
	

Vlasnik (u), dobija privilegije izvršavanja (+x), a grupa (g), kojoj korisnik pripada, dobija privilegije upisa (+w).

Ako je potrebno izvršiti (umesto prethodne komande), komandu preko koje ....

• vlasnik dobija privilegiju izvršavanja
• grupa kojoj vlasnik pripada dobija privilegiju upisa
• svi ostali korisnici gube privilegiju čitanja

.... komanda se može dopuniti na sledeći način:

		
$ chmod u+x,g+w,a-r skripta_1.sh
		
	

Komande koje smo koristili u nekoliko poslednjih primera, sasvim su adekvatne (same po sebi), ali, deluju previše "opširno", i stoga - za primere sa više izmena privilegija - u praksi se gotovo uvek koriste oktalni kodovi (sa kojima smo se prethodno upoznali).

Korišćenje oktalnih kodova podrazumeva malo drugačiji način razmišljanja: nećemo (u praktičnom smislu) više razmišljati o tome "kom korisniku ili grupi korisnika treba dodeliti ili ukinuti koju privilegiju", već, samo o tome kako na kraju treba da budu definisani (novi) nivoi privilegija za sve tri grupe korisnika.

Za primer ćemo uzeti krajnje tipičnu situaciju, koja je (ujedno) usko povezana sa tematikom članka.

Prvi korak u kreiranju nove skripte podrazumeva (skoro uvek) - kreiranje nove prazne datoteke preko komande touch:

		
$ mkdir ~/skripte
$ cd ~/skripte
$ touch skripta_1.sh
		
	

Datoteka koja je kreirana na prikazani način ima sledeće privilegije:

		
-rw-r--r-- 1 korisnik_1 admin 0 Apr 02 09:18 skripta_1.sh
		
	

.... i može se primetiti da privilegija izvršavanja (x), nije navedena ni na jednom mestu.

Postojeće (uključene) privilegije, mogu se svesti na oktalni kod 644, po sledećem postupku:

• rw- r-- r-- se može shvatiti kao 110 100 100
• 110 100 100 - posle prevođenja u oktalni oblik - postaje 644.

Pošto je potrebno svim korisnicima dodeliti privilegiju izvršavanja - preko oktalnog koda (to jest, da budemo precizni, potrebno je da se u sve tri grupe aktivira atribut x), može se razmišljati na sledeći način:

• rw- r-- r-- je početna niska, koja, posle uključivanja privilegija upisa (na sva tri mesta), postaje rwx r-x r-x
• rwx r-x r-x se može shvatiti kao 111 101 101
• 111 101 101 - posle prevođenja u oktalni oblik - postaje 755

Pošto smo sagledali "idejno poreklo" argumenta 755, privilegije za pokretanje skripte najlakše je dodeliti (odnosno izmeniti) preko sledeće naredbe:

		
$ chmod 755 skripta_1.sh
		
	

chown - promena vlasnika datoteke/direktorijuma

Promena vlasnika datoteke ili direktorijuma, obavlja se preko komande chown ("Change Owner").

Na primer, u sledećoj situaciji:

		
-rwxr-xr-x 1 korisnik_2 admin 0 Mar 17 09:18 skripta_1.sh
		
	

.... posle izvršavanja komande chown:

		
$ chown korisnik_1 skripta_1.sh
		
	

.... datoteka (čiji je dotadašnji vlasnik bio korisnik korisnik_2), dobija novog vlasnika (novi vlasnik je korisnik korisnik_1):

		
-rwxr-xr-x 1 korisnik_1 admin 0 Mar 17 09:18 skripta_1.sh
		
	

Ukoliko je prethodni vlasnik datoteke root korisnik:

		
-rwxr-xr-x 1 root root 0 Mar 17 09:18 skripta_x.sh
		
	

.... potrebno je komandu chown pozvati preko komande sudo:

		
$ sudo chown korisnik skripta_x.sh
		
	

.... posle čega (slično prethodnom primeru), nastaje sledeći rezultat:

		
-rwxr-xr-x 1 korisnik_1 admin 0 Mar 17 09:18 skripta_x.sh
		
	

Sada je vreme da se usmerimo na kreiranje skripti.

Prikazaćemo prvo tipičan postupak kreiranja i pokretanja skripte, a u nastavku ćemo se baviti tipovima podataka u shell skriptama i kontrolnim strukturama (naravno, uz odgovarajuće propratne primere).

Kreiranje i pokretanje skripti

Za početak, potrebno je pripremiti zaseban direktorijum sa prigodnim nazivom skripte (ubuduće ćemo u navedeni direktorijum smeštati sve skripte):

		
$ mkdir ~/skripte
$ cd ~/skripte
		
	

Na UNIX-olikim sistemima, tipična procedura za kreiranje i pokretanje (nove) skripte, podrazumeva:

• kreiranje prazne datoteke
• dodeljivanje privilegija za pokretanje novoj (praznoj) datoteci
• unos sadržaja (tj. komandi), u datoteku
• čuvanje datoteke i pokretanje skripte

Prazna datoteka može se kreirati preko komande touch (koja je poznata od ranije) ....

		
$ touch skripta_01.sh
		
	

.... i potom se datoteka može otvoriti u bilo kom tekstualnom editoru (shell skripte su, u tehničkom smislu, tekstualne datoteke).

Privilegije za pokretanje datoteke (tj. 'buduće skripte'), podesićemo preko komande chmod:

		
$ chmod 755 skripta_01.sh
		
	

.... ili, jednostavnije:

		
$ chmod +x skripta_01.sh
		
	

U skriptu ćemo uneti sledeći sadržaj:

		
#!/bin/bash

# promenljive:
direktorijum=/home/korisnik_1/
datoteka=/home/korisnik_1/.skripte/listing_home

# izvršne komande:
ls -lha $direktorijum > $datoteka
		
	

.... i (na kraju), skripta se može pokrenuti na sledeći način:

		
[korisnik_1@codeblog ~/.skripte] $ ./skripta_01.sh
		
	

U praktičnom smislu, primećujemo da skripta smešta (tabelarni) listing direktorijuma /home/korisnik_1 - u datoteku /home/korisnik_1/.skripte/listing_home.

Što se tiče 'tehnikalija', osvrnimo se na sledećih nekoliko detalja:

• komentari u shell skriptama počinju znakom # (što znamo od ranije), ali ....
• direktiva #!/bin/bash nije komentar, već, nalog operativnom sistemu da skriptu izvrši preko konkretnog shell programa (u primeru koji smo prikazali, u pitanju je Bash)

Primećujemo i to da smo u skripti koristili promenljive, što možemo smatrati dobrim uvodom u tematiku upotrebe promenljivih u shell skriptama (a upoznaćemo se uskoro i sa kontrolnim strukturama) ....

Promenljive u shell skriptama

Promenljive u shell skriptama, definišu se (kao što smo već videli), na vrlo neposredan način (slično kao u Python-u) ....

		
#!/bin/bash

a=10
b=15
		

	

.... i pozivaju se uz prefiks $ (slično kao u PHP-u) * ....

		
#!/bin/bash

echo "a = $a, b = $b"
# ispis: a = 10, b = 15
		

	

Deklaracija i inicijalizacija promenljivih u shell skriptama jeste veoma nalik deklaraciji i inicijalizaciji promenljivih u 'uobičajenijim' programskim jezicima * (najveća je sličnost sa Python-om), ali, aritmetičke i logičke operacije obavljaju se na nešto drugačiji način.

U svakom slučaju, na ovom mestu ćemo pretpostaviti da čitaoci (koji su zainteresovani za upoznavanje sa shell skriptama), imaju prethodnog iskustva u programiranju i solidno poznaju bar jedan programski jezik, ** i stoga nećemo "taksativno nabrajati" operacije, već ćemo izneti zapažanja koja se tiču razlika u odnosu na pristup koji je poznat od ranije.

Aritmetičke operacije sa promenljivama

Kada je u pitanju obavljanje aritmetičkih i logičkih operacija, potrebno je prvo razumeti da se sintaksa shell skripti idejno razlikuje od sintakse (velike većine) programskih jezika.

Skripte se (doslovno) pokreću u okruženju koje je namenjeno interpretiranju konzolnih naredbi - pre nego interpretiranju naredbi kao što su c = a + b; ili if (a > 5) printf("Pozdrav!");, i stoga ne čudi što u svemu važe "druga pravila".

Pojava ("jednostrukih") zagrada, praktično pokreće novo shell okruženje u kome se mogu izvršavati programi, a rezultat izvršavanja se (nadalje) može dodeliti promenljivoj ....

		
datum_i_vreme=$(date)
		
	

.... međutim, na ovom mestu, od većeg značaja je mogućnost uvođenja shell interpretatora u režim tumačenja algebarskih izraza - navođenjem "dupliranih" zagrada na početku i na kraju izraza:

		
c=$((a + b))
		
	

Kada se shell interpretator uvede u kontekst tumačenja algebarskih izraza (tzv. "aritmetički kontekst"), nije više potrebno navoditi prefiks $ pri obraćanju promenljivama, a dozvoljeno je koristiti i razmake u izrazima (zarad preglednosti).

Shodno navedenom, prethodni izraz može se zapisati i na sledeći način:

		
((c = a + b))
		
	

Pored opcija koje su prikazane, takođe postoji mogućnost da se vrednost izraza računa preko komande expr: *

		
a=10
b=15
c=$(expr $a + $b)
		
	

.... što znači (u širem kontekstu), da sličan 'obrazac razmišljanja' možete koristiti ukoliko je potrebno da u shell skriptama obrađujete podatke preko programa koje ste sami pisali. *

Operatori poređenja i logičke operacije

Za početak, pogledajmo standardno if grananje u C-u ....

		
if (a > o) {
	printf("Vrednost je pozitivna.");
}
		
	

.... koje ćemo uporediti sa odgovarajućom shell sintaksom za proveru uslova (koja praktično obavlja isti zadatak):

		
if [ $a -gt 0 ]; then
	echo "Vrednost je pozitivna."
fi
		
	

Prva 'pomisao' je (najverovatnije): grananja u shell programima se zapisuju slično kao u C-u, "i samo se koriste drugačije zagrade".

Međutim (iako grananja u shell skriptama jesu 'vizuelno slična' grananjima u C-u), iza svega stoji ponešto drugačiji pristup.

Za proveru uslova u shell skriptama, zapravo se koristi ugrađena komanda test .... *

		
test uslov; then komanda
		
	

.... koja se izvršava po sledećem principu: ako je uslov (koji je kao argument predat komandi test) - tačan, pokreće se "komanda" (koja je takođe predata kao argument).

Negde u toku razvoja programa Bash, usvojena je (to jest, implementirana) - uprošćena sintaksa za komandu test ....

		
[ uslov ]; komanda
		
	

.... i takva sintaksa (uz ponešto dorade), postala je i deo sintakse za if grananja (kao što smo već videli).

Unutar komande test u shell skriptama (ili, praktičnije - unutar uslova u if grananjima), koriste se i posebni operatori poređenja (u jednom od prethodnih primera koristili smo operator -gt, sa značenjem "veće od", a ostale operatore prikazujemo na slici ispod):

		
# bash/test   C-ovski ekvivalent
-eq           ==   # EQual (jednako)
-gt           >    # Greater Than (veće od)
-ge           >=   # Greater than or Equal (veće ili jednako)    
-lt           <    # Less Than (manje od)
-le           <=   # Less than or Equal (manje ili jednako)
		
	

Sa navedenim operatorima dodatno ćemo se upoznati u nešto kasnijim poglavljima, preko primera (videćemo i kako se definišu složeni uslovi), ali, prvo ćemo se ukratko osvrnuti na različite načine za dodelu vrednosti promenljivama.

Sa jedne strane, eksplicitno zadavanje vrednosti je svakako zanimljivo i korisno samo po sebi (i pre svega neophodno, u brojnim situacijama), ali, postoji i mogućnost da se promenljivoj dodeli rezultat izvršavanja određenog programa, a takođe postoji mogućnost učitavanja (sadržaja) datoteka u promenljive ....

Učitavanje datoteka i prosleđivanje rezultata izvršavanja komandi u promenljive

Za početak, razmotrićemo jednostavan primer.

Komanda cat - za koju smo više puta pomenuli da se uglavnom koristi za ispis sadržaja tekstualnih datoteka u konzoli, ovoga puta biće upotrebljena shodno osnovnoj nameni (spajanje sadržaja datoteka), ali - izlaz komande biće učitan u promenljivu:

		
#!/bin/bash

# Ukoliko su datoteke na istoj putanji
# kao skripta, putanje do datoteka mogu se
# navesti na sledeći način:

datoteka1=./proba1
datoteka2=./proba2
datoteka3=./proba3

spojene_datoteke=$(cat $datoteka1 $datoteka2 $datoteka3)

echo $spojene_datoteke
		

	

U svojstvu primera koji je za nijansu kompleksniji, prikazaćemo pajpovanje komande date u komandu awk, * zarad izdvajanja trenutnog vremena (pri čemu se rezultat takođe čuva preko promenljive):

		
#!/bin/bash

vreme=$(date | awk ' { printf("%s\n", $4) } ')
echo $vreme
		
	

Osvrnimo se i na nekoliko praktičnih primera (koje smo ranije najavili), koji dodatno prikazuju korišćenje UNIX komandi u shell skriptama:

		
#!/bin/bash

korisnik=$(whoami)
operativni_sistem=$(uname)
aktivni_direktorijum=$(pwd)

echo "Korisnički nalog: $korisnik"
echo "Operativni sistem: $operativni_sistem"
echo "Aktivni direktorijum: $aktivni_direktorijum"
		
	

Upis u datoteke i čitanje iz datoteka

Po potrebi, sadržaj određene promenljive može se proslediti u datoteku, na način koji je čitaocima (verujemo) dobro poznat od ranije.

		
#!/bin/bash

echo $spojene_datoteke > /putanja/nova_datoteka.txt
		

	

Naravno, u pitanju je 'redirekcija' (korisna tehnika sa kojom smo se susreli još u uvodnom članku).

Učitavanje datoteka se takođe može obaviti na idejno sličan način, ali, uz korišćenje nešto drugačije sintakse (koja je, srećom, vrlo jednostavna za razumevanje):

		
#!/bin/bash

a=$(</home/korisnik_1/datoteka.txt)
		

	

Gornji primer (budući da smo ionako u odeljku koji se tiče promenljivih u shell skriptama) - može se uopštiti:

		
#!/bin/bash

datoteka=/home/korisnik_1/datoteka.txt

a=$(<$datoteka)
		

	

Nizovi (liste)

Nizovi u shell skriptama najčešće se definišu metodom implicitne deklaracije (pogotovo u situacijama kada korisnici sami kreiraju nizove) ....

		
#!/bin/bash

niz[0]=10
niz[1]=12
niz[2]=15
		

	

.... ali (sasvim očekivano), postoje i drugi načini, kao što je eksplicitna deklaracija ....

		
#!/bin/bash

declare -a niz
		
	

.... ili, metoda složene dodele, koja podrazumeva istovremenu deklaraciju i inicijalizaciju celog niza:

		
#!/bin/bash

niz=(1 2 3 4 5)
		
	

Pristup pojedinačnom elementu obavlja se na prepoznatljiv način (ali, uz korišćenje 'vitičastih' zagrada u određenim okolnostima):

		
#!/bin/bash

niz[0]=15
echo ${niz[0]}
		
	

Očitavanje dužine niza obavlja se na sledeći način:

		
#!/bin/bash

d=${#niz[*]}
		
	

Uklanjanje pojedinačnog elementa, ili celog niza, obavlja se preko komande unset:

		
#!/bin/bash

unset niz[4] # uklanjanje petog elementa
unset niz    # uklanjanje celog niza
		
	

Obilazak strukture niza tipično se obavlja preko for petlje (što ćemo sagledati na primerima u nastavku, u odeljku koji je posvećen for petljama).

Shell promenljive (environment variables)

Pored promenljivih koje korisnici mogu sami definisati u okviru skripte, postoje i promenljive koje se ('globalno') prepoznaju u okviru određenog shell okruženja, a mogu se koristiti i u korisničkim skriptama (koje se pokreću u datom shell okruženju).

Budući da su shell promenljive idejno slične globalnim promenljivama u C-u (i drugim srodnim jezicima) - identifikatori shell promenljivih tipično se pišu uz upotrebu tzv. "allcaps" notacije (svako slovo u identifikatoru je veliko slovo):

		
#!/bin/bash

echo "Shell: $SHELL"
echo "Terminal: $TERM"
# --------------------------------------
echo "Sistemske putanje: $PATH"
# pažnja: promenljiva PATH može
# sadržati veliki broj putanja
# --------------------------------------
echo "Home direktorijum: $HOME"
echo "Aktivni direktorijum: $PWD"
echo "Prethodni aktivni direktorijum: $OLDPWD"
echo "Verzija programa Bash: $BASH_VERSION"
echo "Naziv računara u mreži: $HOSTNAME"
		
	

Gornja skripta je "samoobjašnjujuća" (uz svaku 'globalnu' promenljivu iz shell okruženja stoji odgovarajući opis), a što se tiče konkretnih vrednosti koje se odnose na vašu instalaciju Linux-a (ili nekog drugog "nix" sistema) - napišite skriptu i pokrenite je. :)

Kontrola toka

U shell skriptama (slično kao u C-olikim i mnogim drugim programskim jezicima), pojavljuju se sledeći tokovi izvršavanja instrukcija:

• linearno (tj. uzastopno) izvršavanje naredbi
• grananja
• petlje

Prvo ćemo se upoznati sa linearnim izvršavanjem naredbi.

Linearno izvršavanje naredbi

Uzmimo za primer da određeni program (koji koristimo), ostavlja konfiguracione datoteke u home direktorijumu, * zbog čega postoji potreba za povremenim uklanjanjem datoteka ("koje nismo tražili"), pri čemu, naravno, želimo da uklanjanje datoteka izvedemo na što jednostavniji način.

U situaciji koju smo opisali, shell skripte tipično predstavljaju pravo rešenje. **

Ukoliko su preduzete sve mere predostrožnosti, možemo napisati sledeću jednostavnu skriptu:

		
#!/bin/bash

# Uklanjanje datoteka koje ostaju posle
# pokretanja komande xyz
	
echo "----------------------------------"
echo "Uklanjanje suvišnih datoteka:"
echo "----------------------------------"

rm ~/.xyzconf
rm ~/.xyzerrorlog
rm ~/.xyzhistory

echo "Sledeće datoteke:"
echo "    ~/.xyzconf"
echo "    ~/.xyzerrolog"
echo "    ~/.xyzhistory"
echo ".... uspešno su uklonjene."
echo "----------------------------------"
		
	

Kao što vidimo:

• u skriptama se mogu pokretati komande (u gornjem primeru, komanda je rm)
• preko komande echo, obavlja se ispis u konzoli

(Nastavljamo dalje ....)

Grananja (if, case)

Pošto smo se ranije upoznali sa time "odakle 'ćoškaste zagrade' u if-ovima u shell okruženju", upoznaćemo se detaljnije sa sintaksom za zapisivanje grananja u shell skriptama, uz "povlačenje paralela" u odnosu na C i Python.

if-else-elif-fi grananje

Za početak, pogledajmo primer 'običnog' if grananja (ispituje se da li je vrednost a veća od 10):

		
#!/bin/bash

a=10

if [ $a -gt 10 ]; then
	poruka="Vrednost a je veća od 10."
else
	poruka="Vrednost a nije veća od 10."
fi

echo "${poruka}"
		
	

Ukoliko else blok postoji, 'true grana' počinje rezervisanom reči then i završava se pojavom rezervisane reči else, dok se u suprotnom 'true grana' završava rezervisanom reči fi (koja u svakom slučaju stoji na kraju if bloka).

Višestruka grananja (slično kao u Python-u), tipično se izvode preko rezervisane reči elif (ponovo ćemo se poslužiti jednostavnim primerom koji predstavlja 'ispis dana u nedelji, shodno rednom broju'):

		
#!/bin/bash

dan=5
uslov=true

# Višestruko grananje preko konstrukcije elif:

if [ $dan = 1 ]; then
	poruka="Ponedeljak"
elif [ $dan = 2 ]; then
	poruka="Utorak"
elif [ $dan = 3 ]; then
	poruka="Sreda"
elif [ $dan = 4 ]; then
	poruka="Četvrtak"
elif [ $dan = 5 ]; then
	poruka="Petak"
elif [ $dan = 6 ]; then
	poruka="Subota"
elif [ $dan = 7 ]; then
	poruka="Nedelja"
else
	poruka="Dan nije definisan"
	uslov=false
fi

# Uobičajeno grananje (if-else):

if [ $uslov = true ]; then
	echo "Dan u nedelji: ${poruka}."
else
	echo "${poruka}"
fi
		
	

U pitanju je kod koji je sam po sebi krajnje adekvatan, međutim, budući da u shell skriptama (za razliku od Python-a), postoji i konstrukcija nalik na switch grananja u C-olikim jezicima (doduše, pod drugačijim - ali dobro poznatim nazivom), 'mnogostruka grananja' se često mogu zapisati na elegantniji način (što ćemo razmotriti na primeru istog algoritma) ....

case-esac grananje

Slično kao i switch u C-olikim jezicima, case grananje u shell skriptama omogućava pregledniju organizaciju višestrukih uslova - onda kada jeste moguće navesti višestruke uslove preko konstrukcije case.

Uzmimo (ponovo) primer sa ispisom dana u nedelji (shodno unetom rednom broju):

		
#!/bin/bash

dan=5
uslov=true

# Switch koji se koristi
# umesto višestrukog grananja
# iz prošlog primera:

case $dan in
	1) poruka="Ponedeljak" ;;
	2) poruka="Utorak"     ;;
	3) poruka="Sreda"      ;;
	4) poruka="Četvrtak"   ;;
	5) poruka="Petak"      ;;
	6) poruka="Subota"     ;;
	7) poruka="Nedelja"    ;;
	*) poruka="Dan nije definisan."
	   uslov=false
	;;
esac

# Primer uobičajenog grananja (if-else):

if [ $uslov = true ]; then
	echo "Dan u nedelji: ${poruka}."
else
	echo "${poruka}"
fi
		
	

Na prethodnoj slici smo prikazali kod koji se može realizovati preko case grananja, ali (kao što smo nagovestili), postoje i situacije u kojima se case grananje ne može izvesti.

Nije moguće (recimo), koristiti višestruke uslove ....

		
case $a in
	$a -ge 1 -a $a -le 5) promenljiva=$vrednost_1 ;;
	$a -ge 6 -a $a -le 7) promenljiva=$vrednost_2 ;;
	$a -ge 8 -a $a -le 10) promenljiva=$vrednost_3 ;;
	*) promenljiva=$vrednost_4 ;;
esac
		
	

.... i stoga - u situacijama kakve prikazuje primer sa gornje slike - potrebno je koristiti konstrukciju if-else-elif-fi.

Praktičan primer skripte koja koristi grananje

Sa grananjem u shell skriptama još bolje ćemo se upoznati kroz konkretan primer (iz svakodnevne prakse), koji može dobro poslužiti korisnicima laptop računara (a verujemo da tematika može biti zanimljiva i ostalim čitaocima).

Linux čuva podatke o statusu i kapacitetu baterije * preko sledeće dve datoteke:

• /sys/class/power_supply/BAT0/status - status baterije (navešćemo u nastavku šta predstavljaju različiti statusi)
• /sys/class/power_supply/BAT0/capacity - kapacitet baterije u procentima (s tim da znak % nije zapisan u datoteci)

Podaci jesu dostupni, ali - ako je potrebno da sve bude formatirano i prikazano na pregledan i dopadljiv način - moramo se dodatno potruditi.

Da objasnimo prvo šta označavaju različiti statusi baterije (koji se mogu pročitati iz datoteke status):

• "Not charging" - ispravljač nije priključen i baterija se prazni
• "Charging" - ispravljač je priključen i baterija se puni
• "Full" - ispravljač je priključen i baterija je u potpunosti napunjena
• "Not Charging" - ispravljač je priključen, ali, baterija se ne puni (česta situacija do koje dolazi kada se ispravljač priključi onda kada je baterija, koja se do tada praznila, napunjena na preko 90% kapaciteta)

Pojam kapaciteta (u trenutnom kontekstu), lakši je za razumevanje: u datoteci capacity uvek je zapisana određena vrednost, bez obzira na to da li je ispravljač priključen ili nije (tj. bez obzira na to da li se baterija prazni ili puni i sl).

Pošto smo upoznati sa tehnikalijama, možemo napisati skriptu u celosti:

		
# ---------------------------------------------------------
#!/bin/bash
# ---------------------------------------------------------
# Čitanje podataka:

bat_stat=$(</sys/class/power_supply/BAT0/status)
bat_cap=$(</sys/class/power_supply/BAT0/capacity)
# ---------------------------------------------------------
# Razmatranje svih mogućih statusa:

if [ "$bat_stat" = "Charging" ]; then
	status="Ispravljač je uključen."
	poruka="Trenutni kapacitet baterije: ${bat_cap}%."
elif [ "$bat_stat" = "Full" ]; then
	status="Ispravljač je uključen."
	poruka="Baterija je potpuno napunjena."
elif [ "$bat_stat" = "Not charging" ]; then
	status="Ispravljač je uključen - ali se baterija ne puni."
	poruka="Trenutni kapacitet baterije: ${bat_cap}%."
else
	# status="Discharging" - ako se nije
	# aktivirao nijedan od prethodnih if-ova
	status="Ispravljač je isključen."
	poruka="Trenutni kapacitet baterije: ${bat_cap}%."
fi
# ---------------------------------------------------------
# Ispis poruke (koji se obavlja u svim okolnostima)

echo "$status $poruka"
# ---------------------------------------------------------
# Dodatni ispis (ukoliko je ispravljač isključen,
# a kapacitet baterije je nizak):

if [ $bat_cap -le 25 ] && [ "$bat_stat" = "Discharging" ]; then
	echo "PAŽNJA: Nizak kapacitet baterije!\n"
	echo "Potrebno je uključiti ispravljač."
fi
# ---------------------------------------------------------
		
	

Primer koji smo prikazali je dovoljno zanimljiv sam po sebi (verujemo da je tako), međutim, svakako se može staviti u kontekst u kome postaje - još zanimljiviji.

U uvodnom članku o GNU/Linux distribucijama pomenuli smo da različita desktop okruženja i (pogotovo) menadžeri prozora, mogu - zarad prikaza sistemskih parametara - koristiti skripte i programe koje korisnici kreiraju samostalno.

Osnovna ideja je da se parametri očitavaju periodično (recimo, na svakih 1s) i, u takvim okolnostima, jedan od parametara za prikaz može biti - formatirani ispis u vezi sa stanjem baterije.

Međutim, s obzirom na to da je ispis koji smo spremili u prethodnom primeru prilično opsežan (prosto rečeno - mnogo teksta za statusnu liniju :)), ispis se može stilizovati upotrebom specijalnih znakova koji - umesto tekstualne poruke - prikazuju simbol za bateriju (kada je ispravljač isključen), ili simbol za utikač (kada je ispravljač uključen), a mogu se koristiti i različite boje za označavanje elemenata i sl:

Ali - "to nije sve" - može se osmisliti i mehanizam za čuvanje prethodnog stanja, što omogućava da se trenutno stanje poredi sa prethodnim (pri svakom očitavanju), što nadalje omogućava da se registruju trenuci kada korisnik uključi ili isključi ispravljač (na šta se može odreagovati ispisivanjem odgovarajuće poruke preko posebnih programa za ispis tekstualnih poruka u prozorima). *

Petlje (while, for)

Petlje u shell skriptama su idejno slične petljama u 'uobičajenijim' programskim jezicima, sintaksa podseća na if grananja u shell skriptama, a 'dodatak' je specifična konstrukcija do-done, koja predstavlja graničnik tela petlje.

while petlja

Osnovni princip funkcionisanja while petlji u shell skriptama možemo sagledati preko sledećeg primera (ispis brojeva od 1 do 10):

		
#!/bin/bash

a=1

while [ $a -le 10 ]
do
	echo "a=${a}"
	a=$((a+1))
done
		
	

Kao što smo ranije nagovestili, kontrolne strukture se takođe mogu i ugnežđavati, pa tako (recimo) while petlja u narednom primeru prolazi kroz vrednosti od 1 do 10 i ispituje (i ispisuje), za svaku vrednost, da li je broj paran ili neparan:

		
#!/bin/bash

a=1

while [ $a -le 10 ]
do
	o=$(($a%2)) # ostatak

	if [ $o = 0 ]; then
		echo "a=${a}; broj je paran"
	else
		echo "a=${a}; broj je neparan"
	fi

	a=$(($a+1))
done
		
	

Osvrnućemo se takođe na to da se u while petljama (koje se koriste u shell skriptama), prilično često javlja "motiv" beskonačnih petlji.

U pitanju je praktičan (iako ne baš previše elegantan), način da se realizuje "program koji se ne isključuje", tipično uz upotrebu sledeća dva mehanizma:

• funkcija sleep zaustavlja izvršavanje skripte na određeno vreme, u svakom koraku petlje (čime se praktično definiše interval u kome se petlja ponavlja)
• if grananje, uz funkciju break, zaustavlja petlju (to jest, celu skriptu), ukoliko se pojave okolnosti u kojima treba zaustaviti izvršavanje skripte

Praktičan primer skripte koja koristi petlju

U novom primeru, prepoznaje se trenutak kada kapacitet baterije (laptop računara), 'padne' ispod 25%:

		
#!/bin/bash

uslov=true

while [ $uslov = true ]
do
    # spisak naredbi koje se mogu izvršavati
    # ako je kapacitet baterije veći od 25%
    # naredba 1
    # naredba 2
    # ....
    # naredba n
    
	bat_cap=$(</sys/class/power_supply/BAT0/capacity)
    
    if [ $bat_cap -le 25 ]; then
        uslov=false
        echo "-------------------------------------"
        echo "Prekida se izvršavanje programa"
        echo "zbog nedovoljnog kapaciteta baterije."
    else
        echo "Kapacitet baterije je ($bat_cap%) >= 25%"
    fi

    sleep 1
done
		
	

Skripta se pokreće na svakih 1s, i zaustavlja se ukoliko promenljiva uslov dobije vrednost true (do čega dolazi ako se ustanovi da ispravljač nije priključen i pri tom je kapacitet baterije manji od 25%).

Za isprobavanje skripte: napravite datoteku kapacitet (u istom direktorijumu u kom je skripta), u prvu liniju unesite brojčanu vrednost, prepravite (privremeno) glavnu skriptu na sledeći način ....

		
# .... prethodne naredbe	
	
# bat_cap=$(</sys/class/power_supply/BAT0/capacity)
bat_cap=$(<./kapacitet)
	
# ostatak skripte ....
		
	

.... potom pokrenite skriptu - i menjajte usput vrednosti u datoteci kapacitet (u nekom trenutku, unesite vrednost <= 25).

Ako skriptu pokrećete preko menadžera prozora ....

.... moći ćete da sagledate ceo proces na jednoj radnoj površini. *

Opsežniji i zanimljiviji primer while petlje koja se "vrti ukrug" (beskonačna petlja), videli smo još u uvodnom članku (link vodi direktno do primera while petlje za ispis sistemskih parametara na naslovnoj traci menadžera prozora). **

for petlja

For petlje u shell skriptama koriste princip "iteracije kroz listu" (slično kao for petlje u Python-u) ....

		
#!/bin/bash

niz=(10 20 30 40 50)

for element in ${niz[@]}
do
	echo "e = ${element}"
done
		
	

.... ali, vidimo da je potrebno vrlo precizno navesti sintaksu za obraćanje nizu (za razliku od JS-a i Python-a koji omogućavaju vrlo jednostavan način obraćanja nizovima).

Za 'najuobičajenije' for petlje, koje se izvršavaju u rasponu "od-do", postoji i skraćeni način definisanja 'liste koju for petlja treba da obiđe':

		
#!/bin/bash

for element in {1..10}
do
	echo "e = ${element}"
done
		
	

Ukratko o funkcijama u shell skriptama

Kao što smo već nagovestili, shell programi takođe omogućavaju pokretanje funkcija, sa sintaksom koja je (ovoga puta) relativno slična sintaksi iz C-olikih jezika (uz jedan zanimljiv izuzetak, na koji ćemo se uskoro osvrnuti).

Opšta šema je sledeća:

		
naziv_funkcije () {
	komande
}
		
	

Kao početni primer može poslužiti veoma jednostavna "hello world" funkcija, koja se zapisuje (i poziva) na sledeći način ....

		
#/bin/bash

pozdrav() {
	echo "Dobar dan! :)"
}

pozdrav
		
	

.... pri čemu se u terminalu (očekivano) dobija ispis ....

		
Dobar dan! :)
		
	

Što se tiče (prethodno najavljene) 'zanimljivosti' u sintaksi shell funkcija - u pitanju je predavanje argumenata.

Naime, u shell funkcijama ne postoji "C-oliki" način definisanja parametara "u zagradi" (iako se same zagrade navode uz identifikator funkcije).

Umesto uobičajenog pristupa, parametri se označavaju rednim brojevima - tako da 'redni broj parametra' odgovara redosledu predavanja argumenata pri pozivu funkcije: pozicioni parametar $1 odgovara prvom predatom argumentu, parametar $2 odgovara drugom argumentu .... parametar $9 odgovara devetom predatom argumentu.

Ukoliko (za primer) definišemo funkciju koja pronalazi i ispisuje veću od dve unete vrednosti ....

		
veci_od_dva() {
	if [ $1 -ge $2 ]; then
        echo "Broj $1 je veći od broja $2 (ili jednak)."
    else
        echo "Broj $2 je veći od broja $1."
    fi
}
		
	

.... funkcija se poziva na sledeći način ....

		
#/bin/bash
	
# definicija funkcije veci_od_dva (sa slike #66),
# izostavljena je zarad preglednosti.

# poziv funkcije:
veci_od_dva 12 15
		
	

.... nakon čega se dobija sledeći ispis:

		
Broj 15 je veći od broja 12 (ili jednak).
		
	

U sledećem poglavlju, upoznaćemo se još i sa time kako shell skripte mogu obrađivati argumente komande linije (a u narednim člancima, biće i 'konkretnijih'/zanimljivijih primera shell funkcija) ....

Uvodno izlaganje o shell skriptama završićemo * uz osvrt na još nekoliko zanimljivih tehnikalija ("koje dobro dođu").

Obrada korisničkog unosa

Ukoliko je potrebno da korisnik ("ručno") unese tekst u skriptu, tekst se može uneti preko terminala (pogledajmo primer):

		
#!/bin/bash

echo "---------------------------------------------------"
echo "Kreiranje novog direktorijuma na trenutnoj putanji:"
echo "---------------------------------------------------"

read -p "Unesite naziv direktorijuma: " novi_dir

pwd=$(pwd) # rezultat izvršavanja
           # komande pwd

putanja="$pwd/$novi_dir"

if [ -d "$putanja" ]; then
	echo "Direktorijum već postoji!"
else
	mkdir $putanja
	echo "Novi direktorijum: $novi_dir"
	echo "Apsolutna putanja: $putanja"
	echo "Direktorijum je kreiran."
fi
		
	

Kroz primer, upoznali smo se sa komandom read, koja omogućava unos podataka u okviru shell okruženja.

Koristili smo argument -p (prompt), a inače se po potrebi može navesti i argument -s ("silent"), * što je korisno pri učitavanju lozinki.

		
read -ps "Unesite lozinku: " lozinka
		
	

U prvom primeru pojavljuje se i komanda za očitavanje trenutnog direktorijuma (pwd), koju smo iskoristili za formiranje apsolutne putanje novog direktorijuma (putanja se pojavila u svojstvu argumenta komande mkdir).

Predavanje argumenata preko terminala

Ukoliko je potrebno da skripta učita argumente komande linije, obrada se obavlja na sledeći način:

- Pri pozivu skripte, argumenti se predaju isto onako kako se argumenti predaju npr. programima koji su pisani u C++-u i sl:

		
$ ./skripta.sh 10 12
		
	

- Argumenti komande linije prihvataju se preko 10 specijalnih promenljivih, to jest, tzv. pozicionih parametara * u rasponu od $0 do $9:

		
#/bin/bash

# pozvaćemo funkciju veci_od_dva
# koju smo definisali u prethodnom poglavlju:

veci_od_dva $1 $2
		
	

Pokretanje skripte skripta.sh, proizvodi sledeći ispis:

		
Broj 12 je veći od broja 10 (ili jednak).
		
	

Formatiranje izlaza preko komande printf

Ukoliko je potrebno formatirati tekst na precizan način, moguće je (u shell okruženjima Bash i Zsh), koristiti dobro poznatu komandu printf (doduše, uz ponešto izmenjenu sintaksu): *

		
#!/bin/bash

a=10
b=15

printf "%d + %d = %d" $a $b `expr $a + $b`

# izlaz: 10 + 15 = 25
		
	

Automatsko pokretanje procesa preko komande watch

Na UNIX-olikim operativnim sistemima, jednostavno periodično pokretanje ("drugih") procesa u konzoli obavlja se preko programa watch, prema sledećem opštem obrascu:

		
watch -n interval komanda (argumenti)
		
	

• interval - interval za pokretanje ("unutrašnje") komande
• komanda - komanda koja se pokreće periodično
• argumenti - argumenti koji se mogu predavati unutrašnjoj komandi (nije obavezno predavati argumente i nije obavezno da određena interna komanda prepoznaje dodatne argumente)

Razmotrićemo (krajnje tipičan) primer upotrebe komande watch:

		
watch -n 1 free -h
		
	

Komanda free (poznata iz 2. nastavka), * pokreće se u intervalu od jedne sekunde (-n 1) ** i svaki put kada se proces pokrene - automatski se osvežava prikaz.

Ukoliko se komanda watch navede uz predavanje argumenta -d ("differences"):

		
watch -n 1 -d free -h
		
	

.... u prikazu će biti označene razlike (tj. promene), između dva 'očitavanja':

Periodično/redovno pokretanje procesa (cron, crontab)

Pored komande watch, na UNIX-olikim operativnim sistemima postoji i pozadinski proces cron, čija je namena - pokretanje procesa (tj. programa, skripti i drugih pozadinskih procesa), u pravilnim intervalima koje korisnici mogu sami definisati preko posebnih tabela.

Cron tabele se najčešće koriste za ozbiljnije zadatke kao što je redovno pokretanje skripti za administraciju sistema (ažuriranje, bekap i sl), pri čemu se pristup tabelama obavlja preko sledeće komande: *

		
crontab -e
		
	

Svaki red u cron tabeli - koji predstavlja periodično pokretanje pojedinačnog procesa (eng. "cron job") - definisan je po sledećem obrascu:

		
┌ ╶ ╶ ╶ ╶ ╶ minut         (0-59)
| ┌ ╶ ╶ ╶ ╶ sat           (0-23)
| | ┌ ╶ ╶ ╶ dan u mesecu  (1-31)
| | | ┌ ╶ ╶ mesec         (1-12)
| | | | ┌ ╶ dan u nedelji (0-6) *
| | | | |
* * * * * korisnik komanda
		
	

Osvrnimo se na konkretan primer ....

		
0 * * * * korisnik_1 /home/korisnik_1/.skripte/glavni_bekap.sh
		
	

Prema navedenim podešavanjima: operativni sistem (preko korisničkog naloga korisnik_1), na svaki pun sat pokreće skriptu glavni_bekap.sh (koja se nalazi na navedenoj putanji), ali - pretpostavićemo da (možda) "ne deluje da tako piše u gornjoj tabeli" - i stoga ćemo pojasniti (na jednostavan način, preko dodatnih primera), kako se zadaju vremenski intervali za pokretanje cron zadataka.

Sledeći kod (gotovo istovetan) ....

		
* * * * * korisnik_1 /home/korisnik_1/.skripte/skripta.sh
		
	

.... definiše da se skripta pokreće na svaki pun minut (programe ili skripte moguće je pokretati samo kada je broj sekundi na sistemskom časovniku "00"), ili, preciznije - skripta se pokreće:

• svakog meseca
• svakog dana u mesecu
• svakog dana u nedelji
• svakog sata
• na svaki pun minut

Ali - sa druge strane ....

Bilo koja vrednost koja nije * predstavlja (praktično) faktor ograničenja, i stoga (na primer) sledeći "cron job": 0 * * * * korisnik_1 /home/korisnik_1/.skripte/glavni_bekap.sh - definiše da se navedena skripta pokreće samo onda kada minut (na sistemskom časovniku) ima vrednost 0, što praktično znači - navedena skripta se pokreće na svaki pun sat (upravo onako kako smo videli u prvom primeru).

U nastavku, upoznaćemo se sa time kako se može udesiti da se određena skripta pokrene u određeno vreme (svakog dana, ili samo određenim danima).

Ako je potrebno da se određena skripta pokrene svakog dana u određeno vreme, dovoljno je navesti (samo) vreme izvršavanja (za primer ćemo uzeti skriptu koja odjavljuje prijavljene korisnike, nakon isteka radnog vremena).

		
31 16 * * * root /.skripte/logout.sh
		
	

Drugi primer biće cron job koji pokreće bekap podataka na nedeljnom nivou (jednom nedeljno, na primer, petkom):

		
35 16 * * 5 root /.skripte/bekap_nedeljni.sh
		
	

Međutim, ako je potrebno da se bekap obavlja svakog radnog dana, cron job koji je podešen po uzoru na cron job sa slike #82 neće biti od pomoći (budući da je u pitanju pokretanje procesa svakog dana - ne samo radnim danima), a u drugim situacijama, može postojati i potreba za preciznijim definisanjem intervala (recimo, nije potrebno da se određena skripta izvršava svakog minuta, ali, potrebno je da se izvršava "češće od svakog sata" i sl), i stoga je uputno da se upoznamo sa sintaksom koja omogućava (upravo) - dodatno preciziranje.

Definisanje raspona

Ukoliko se umesto jedne vrednosti navede raspon, u obliku početak-kraj (sa crticom između), cron job će se pokretati za svaku celobrojnu vrednost iz raspona.

Na primer, sledeći cron job ....

		
31 16 * * 1-5 root /.skripte/bekap_dnevni.sh
		
	

.... izvršava se u 16:31, svakog dana koji odgovara rasponu od 1 (ponedeljak), do 5 (petak).

Nabrajanje

Ukoliko se umesto jedne vrednosti, nabroje dve ili više vrednosti, u obliku v1, v2, v3 .... vn (broj vrednosti praktično je proizvoljan), cron job će biti pokrenut za svaku od nabrojanih vrednosti (umesto samo jedanput).

		
0 12 1,12,21,27 * * root /.skripte/bekap_dnevni.sh
		
	

U gornjem primeru, skripta se pokreće tačno u podne, prvog dana u mesecu, 12. dana u mesecu, kao i 21. i 27. dana u mesecu (to jest - u opštem smislu - skripta se pokreće samo navedenim danima u mesecu).

Podela intervala na korake

Bilo koji od pet pojedinačnih argumenata (koji definišu intervale), može se podeliti na celobrojne 'korake', preko sintakse: */korak.

Na primer, sledeći cron job .....

		
0/10 * * * * root /.skripte/bekap_10_min.sh
		
	

.... pokreće se svakog dana (sa početkom u 00:00) - svakoga sata - na svakih 10 min (tj. pokreće se u sledećim trenucima: 00:00:00, 00:10:00, 00:20:00 .... 23:59:40, 23:59:50).

Kombinacije

Parametri koji se koriste za preciziranje intervala, mogu se takođe i kombinovati.

U prvom primeru ....

		
0/10 8-15 * * 1-5 root /.skripte/kombinacije.sh
		
	

• skripta se izvršava (samo) radnim danima
• prvo izvršavanje je u 08:00, a poslednje u 15:50
• u periodu od 08:00 do 15:50 (uključujući i 15:50), skripta se izvršava na svakih 10 minuta

Sledeći primer (poslednji u članku), nešto je složeniji:

		
0/15 8-15/7 * * * root /.skripte/pocetak_i_kraj.sh
		
	

Skripta koja je navedena kao izvršna komanda, izvršava se "na svakih sedam sati, počevši od 08:00, zaključno sa 15:45", međutim, šta navedene vrednosti zapravo znače?

Mogući "započeti" sati, određeni su preko II kolone: 8-15/7.

Za svaki započeti sat (pri čemu su jedine moguće vrednosti 8 i 15), skripta se može izvršavati na svakih 1 min - ukoliko nije drugačije definisano.

Međutim, budući da je u prvoj koloni navedeno ograničenje 0/15, skripta se neće izvršavati na svaki minut između 08:00 i 08:59 i između 15:00 i 15:59, već - na svakih 15 minuta.

U praktičnom smislu, navedena skripta se izvršava: u prvih i poslednjih 1h radnog vremena - na svakih 15 min.

Ograničenja (parametri koji se ne mogu zadati direktno)

Opcije koje smo do sada prikazali deluju (zaista) sveobuhvatno, ali, postoje i intervali (u toku dana), koji se ne mogu obuhvatiti preko prethodno opisane sintakse.

Recimo, moguće je definisati cron job koji se pokreće na svakih 15 min, od 8h do 16h (s tim da se za poslednji sat piše 15) ....

		
0/15 8-15 * * * root /.skripte/bekap.sh
		
	

.... ali, nije moguće (npr. korišćenjem decimalnih vrednosti ili na drugi način), definisati raspon koji ne počinje i ne završava se 'na pun sat' (recimo, raspon od 07:30 do 17:30):

		
0/15 7.5-17.5 * * * root /.skripte/bekap.sh
		
	

Ukoliko je potrebno da izvršavanje započne (i/ili da se završi), između dva puna sata, na scenu stupa 'snalaženje' (što najčešće podrazumeva navođenje jednog ili dva 'pomoćna cron job-a' (uz osnovni)):

		
30/15 7 * * * root /.skripte/bekap.sh
0/15 8-16 * * * root /.skripte/bekap.sh
0-30/15 17 * * * root /.skripte/bekap.sh
		
	

U gornjem primeru, "srednji" cron job je "glavni", dok su prvi cron job (koji važi samo od 07:30 do 08:00), i treći (koji važi samo od 17:00 do 17:30) - "pomoćni".

Za kraj ....

Na ovom mestu, završavamo uvodni serijal posvećen GNU/Linux distribucijama i slobodnom softveru, u kome smo 'pretresli' osnovne ideje i osnovne 'tehnikalije'.

U člancima koje pripremamo, bavićemo se temama koje smo na početku najavili (instalacija i podešavanje 'minimalističke' GNU/Linux distribucije, naprednije opcije shell skripti i sl), a bavićemo se i ostalim temama koje smo 'načinjali' usput, kao i mnogim drugim temama i sadržajima koji su vezani za više nego zanimljivu tematiku FOSS softvera ....