Gyakorlat: shell scriptek

Megjegyzés

Parancsok: echo, változókezelés, read, ``, expr, .

1. Készíts egy tetszőleges tartalmú szövegfájlt az mcedit segítségével! A fájl neve legyen proba.txt!

feri@aries:~$ mcedit proba.txt

2. Készíts shell scripet, mely kiírja a következő szöveget: Hello world!

#!/bin/bash
echo "Hello world!"

3. Készíts programot, mely az A váltózónak értéket ad, majd kiírja azt!

#!/bin/bash
A=12
echo "A=$A"

4. Készíts programot, mely a billentyűzetről bekéri a felhasználó nevét, és személyesen köszönti őt!

#!/bin/bash
echo -n "Add meg a neved: "
read NEV
echo "Üdvözöllek, kedves $NEV"

5. Készíts programot, mely kiírja a mai nap nevének angol rövidítését! Az akuális nap neve a date parancs megfelelő paraméterezésével nyerhető ki.

#!/bin/bash
DATUM=`date '+%a'`
echo "A mai nap neve: $DATUM"

6. Készíts programot, mely az VER változóba beolvassa a /etc/debian_version fájl tartalmát, majd kiírja azt! Ebben a fájlban a Debian/GNU Linux verziószáma található.

#!/bin/bash
VER_FILE="/etc/debian_version"
VER=`cat $VER_FILE`
echo "Az operációs rendszer verziószáma: $VER"

7. Készíts programot, mely a billentyűzetről bekéri egy négyzet oldalának hosszát, majd kiírja annak kerületét és területét! A program neve legyen negyzet

#!/bin/bash
echo "Négyzet kerületének és területének kiszámítása"
# Bekérjük az oldal hosszát
echo -n "Oldal hossza: "
read OLDAL
# Kiszámítjuk a kerületet és a területet
KER=`expr $OLDAL \* 4`
TER=`expr $OLDAL \* $OLDAL`
# Kiírjuk az eredményt
echo "A $OLDAL oldalú négyzet kerülete $KER, területe $TER."

8. Példa a bemenet átirányítására: készítse el az oldal.txt fájlt, mely egy pozitív egész számot tartalmazzon. Használja fel az előző feladatban készített negyzet nevű programot úgy, hogy a szövegfájlban levő adatra végezze el a terület és kerület kiszámítását!

./negyzet < oldalak.txt

9. Készíts programot, mely megadja, hogy a rendszergazda ebben a hónapban hányszor jelentkezett be! Írja ki ennek a számnak a kétszeresét is!

#!/bin/bash
FINDTHIS="root"
N=`last | grep ^$FINDTHIS | wc -l`
D=`expr $N \* 2`
echo "Belépések száma: $N, kétszerese: $D"

10. Készíts shell scripet, mely egy hosszabb szöveget ír ki a képernyőre a Here In Document elv alkalmazásával!

#!/bin/bash
cat <<END
Hol nördség van,
ott nördség van
nemcsak a gép zúgó zajában,
a tárt wikipédiában,

a száz nyitott ablakban,
villámgyors alt-tab-ban,
ott nördség van
a falban utazó LAN-ban,

ahogy az egér füle kattan,
ahogy az ikonod
mappába vonszolod,
dreggeled, droppolod...
END

11. Készíts programot, mely paramétereit egy konfigurációs fájlból veszi! A NEV és a KOR nevű változókat olvassa be a params.conf fájlból, majd írja ki azok értékét!

A params.conf fájl tartalma:
NEV="Kiss Lajos"
KOR=60

12. Készíts programot, mely bekéri egy felhasználó login nevét, és a /etc/passwd file-ból kikeresi annak teljes nevét! A program neve legyen usersearch! 

#!/bin/bash
echo -n "Login név: "
read NEV
FULLNAME=`cat /etc/passwd | grep ^$NEV: | cut -d: -f5`
echo "Teljes név: $FULLNAME"

Elágazások

Megjegyzés

Parancsok: if, case, &&, ||

1. Készíts programot, mely egy futásidőben bekért számról eldönti, hogy nagyobb-e, mint 5!

#!/bin/bash
echo -n "Add meg a vizsgálandó számot!"
read SZAM
if [ "$SZAM" -gt 5 ] ; then
    echo "A $SZAM nagyobb, mint 5"
else
    echo "A $SZAM kisebb, mint 5"
fi

2. Készítsünk olyan programot, amely bekér két számot, és kiírja a nagyobbikat a képernyőre. Ha a két szám egyenlő, azt is kijelzi.

#!/bin/bash
# Készítette: Magyar Péter
echo -n "Add meg az első számot!"
read SZAM1
echo -n "Add meg a második számot!"
read SZAM2
if [ "$SZAM1" -gt "$SZAM2" ] ; then
  echo "A(z) $SZAM1 nagyobb, mint a(z) $SZAM2."
else
  if [ "$SZAM2" -gt "$SZAM1" ] ; then
    echo "A(z) $SZAM2 nagyobb, mint a(z) $SZAM1."
  else
    echo "A két szám egyenlő."
  fi
fi

3. Egészítsük ki az előző feladatot azzal, hogy a futás során történt eseményekről részletes naplóbejegyzést készítünk a "~/naplo.log" file-ba oly módon, hogy minden futás önálló tartalmat generáljon, felülírva a korábbi naplózási eredményeket.

#!/bin/bash
# Készítette: Magyar Péter
echo "Naplózás indul!" > ~/naplo.log
echo -n "Kérem az első számot!"
read A
echo "Az első szám = $A" >> ~/naplo.log
echo -n "Kérem a második számot!"
read B
echo "A második szám = $B" >> ~/naplo.log
if [ "$A" -gt "$B" ] ; then
    echo "A(z) $A nagyobb, mint a(z) $B."
    echo "A(z) $A nagyobb, mint a(z) $B." >> ~/naplo.log
else
    if [ "$B" -gt "$A" ] ; then
        echo "A(z) $B nagyobb, mint a(z) $A."
        echo "A(z) $B nagyobb, mint a(z) $A." >> ~/naplo.log
    else
        echo "A két szám egyenlő."
        echo "A két szám egyenlő." >> ~/naplo.log
    fi
fi
echo "Naplózás vége." >> ~/naplo.log

4. Módosítsuk a naplózási stratégiát, hogy ugyanabba a file-ba növekményesen naplózódjanak az eredmények. Ekkor a futás elején írjuk bele a napófileba az aktuális dátumot és időt, majd a futási log bejegyzéseket.

#!/bin/bash
# Készítette: Magyar Péter
date >> ~/naplo.log
echo "Naplózás indul!" >> ~/naplo.log
echo -n "Kérem az első számot!"
read A
echo "Az első szám = $A" >> ~/naplo.log
echo -n "Kérem a második számot!"
read B
echo "A második szám = $B" >> ~/naplo.log
if [ "$A" -gt "$B" ] ; then
    echo "A(z) $A nagyobb, mint a(z) $B."
    echo "A(z) $A nagyobb, mint a(z) $B." >> ~/naplo.log
else
    if [ "$B" -gt "$A" ] ; then
        echo "A(z) $B nagyobb, mint a(z) $A."
        echo "A(z) $B nagyobb, mint a(z) $A." >> ~/naplo.log
    else
        echo "A két szám egyenlő."
        echo "A két szám egyenlő." >> ~/naplo.log
    fi
fi
echo "Naplózás vége." >> ~/naplo.log
echo "-----------------------------------------" >> ~/naplo.log

5. Oldjuk meg, hogy a script induláskor ellenőrizze le, hogy a napló fájl hossza meghaladja-e a 1 megabyte-ot. Amennyiben igen, úgy a napló fájlról készítsen másolatot naplo.old néven, majd hozzon létre egy üres napló fájlt, és folytassa a futást.

#!/bin/bash
# Készítette: Magyar Péter & Kis Balázs
MERET=`ls -l ~/naplo.log | cut -d" " -f5`
if [ "$MERET" -gt 1024 ] ; then
mv ~/naplo.log ~/naplo.old
fi
date >> ~/naplo.log
echo "Naplózás indul!" >> ~/naplo.log
echo -n "Kérem az első számot!"
read A
echo "Az első szám = $A" >> ~/naplo.log
echo -n "Kérem a második számot!"
read B
echo "A második szám = $B" >> ~/naplo.log
if [ "$A" -gt "$B" ] ; then
echo "A(z) $A nagyobb, mint a(z) $B."
echo "A(z) $A nagyobb, mint a(z) $B." >> ~/naplo.log
else
if [ "$B" -gt "$A" ] ; then
    echo "A(z) $B nagyobb, mint a(z) $A."
    echo "A(z) $B nagyobb, mint a(z) $A." >> ~/naplo.log
else
    echo "A két szám egyenlő."
    echo "A két szám egyenlő." >> ~/naplo.log
fi
fi
echo "Naplózás vége." >> ~/naplo.log
echo "-----------------------------------------" >> ~/naplo.log

6. Készíts programot, mely megjeleníti a ~/testfile fájl tartalmát. Ha a fájl nem létezik, akkor létrehozza azt, és beleírja a programot futtató felhasználó nevét (ezt a shell a $USER változóban teszi elérhetővé).

#!/bin/bash
TESTFILE=~/testfile.txt
if [ -f $TESTFILE ]; then
echo "A $TESTFILE már létezik, a tartalma a következő:"
cat $TESTFILE
else
echo "$TESTFILE létrehozása."
echo $USER >$TESTFILE
fi

7. Készíts programot, mely bekéri egy hét napjának sorszámát, és kiírja az ahhoz tartozó nap nevét!

#!/bin/bash
echo -n "Nap sorszáma: "
read N
case $N in
    1) echo "Hétfo" ;;
    2) echo "Kedd" ;;
    3) echo "Szerda" ;;
    4) echo "Csütörtök" ;;
    5) echo "Péntek" ;;
    6) echo "Szombat" ;;
    7) echo "Vasárnap" ;;
    *) echo "Nincs ilyen nap." ;;
esac

8. Készíts programot, mely bekéri egy téglalap oldalainak nagyságát, és kiírja annak területét. A programnak ellenőriznie kell, hogy a megadott oldal hosszak nagyobbak-e 0-nál.

#!/bin/bash
echo -n "A oldal: "
read A
echo -n "B oldal: "
read B
# Ha A és B is pozitív egész
if [ "$A" -gt 0 -a "$B" -gt 0 ]
then
    echo "Terület: " ` expr $A \* $B ` "."
else
    echo "Érvénytelen adatok"
fi

9. Készíts programot, mely ellenőrzi, hogy azt a root felhasználó futtatja-e, ha nem, akkor adjon hibaüzenetet!

#!/bin/bash
if [ $USER != "root" ] ; then
    echo "Ön nem rendszergazda."
    exit
fi
echo "Ön rendszergazda."

10. Készíts programot, mely bekéri egy felhasználó login nevét, és a /etc/passwd file-ból kikeresi annak teljes nevét! A program ellenőrizze, hogy a felhasználó valóban adott-e keresendő nevet, és adjon értelmes választ akkor is, ha a keresett felhasználó nincs a rendszerben!

#!/bin/bash
echo -n "Login név: "
read NAME
if [ -z "$NAME" ] ; then
    echo "Meg kell adnia a nevet."
    exit
fi
FULLNAME=`cat /etc/passwd | grep ^$NAME: | cut -d: -f5`
if [ ! -z "$FULLNAME" ] ; then
    echo "Teljes név: $FULLNAME"
else
    echo "Nincs $NAME felhasználó a rendszerben."
fi

Hibakezelés

Megjegyzés

Parancsok: $?

1. Készíts programot, mely létrehozza a /tmp/testDir nevű könyvtárat! Az esetleges hibaüzenetek ne jelenjenek meg, de ha a könyvtár létrehozása sikertelen, akkor írjunk ki saját hibaüzenetet!

#!/bin/bash
# A hibákat átirányítjuk a /dev/null-ba
mkdir /etc/alma 2>/dev/null
# Az ERR változóba kerül a parancs által adott visszatérési érték
ERR=$?
if [ $ERR -ne 0 ] ; then
    echo "Hiba a könyvtár létrehozásakor: $ERR"
fi

Ciklusok

Megjegyzés

Parancsok: for, seq, while, (expr, mail)

1. Készíts shell scriptet, mely a billentyűzetről bekért szöveget 10-szer írja ki! A program sorszámozza az egyes sorokat!

#!/bin/bash
echo -n "Add meg a szöveget: "
read SZOVEG
# Kiírjuk 10-szer
I=1
    while [ $I -le 10 ] ; do
    echo "$I: $SZOVEG"
    I=`expr $I + 1`
done

2. Készíts shell scriptet, mely a NEVEK változó tartalmát (mely szóközzel elválasztott keresztneveket tartalmaz) egymás utáni sorokban írja ki!

#!/bin/bash
NEVEK="Péter Ilona Béla Pál János"
for NEV in $NEVEK ; do
    echo $NEV
done

3. A cimek.txt fájl e-mail címeket tartalmaz. Készíts shell scriptet, mely az ebben szereplő címekre egy teszt levelet küld! A cimek.txt fájl tartalma:

test1@freemail.hu
test2@gmail.com
user3@vipmail.hu

#!/bin/bash
DATAFILE="cimek.txt"
CIMEK=`cat $DATAFILE`
for CIM in $CIMEK ; do
    echo "Levél küldése $CIM címre"
    echo "Ez teszt levél, kérem törölje." | mail -s "teszt levél" $CIM
done

4. Alakítsd át a múlt órán írt négyzet területét és kerületét kiszámító programot úgy, hogy ne csak egy négyzet adatait dolgozza fel: egy négyzet feldolgozása után kérje be a következő oldalának hosszát. Az adatsor végét a már ismert CTRL-z jelezze. A program neve legyen negyzet2!

#!/bin/bash
while read OLDAL ; do
    KER=`expr $OLDAL \* 4`
    TER=`expr $OLDAL \* $OLDAL`
    echo "A $OLDAL oldalú négyzet kerülete $KER, területe $TER."
done

5. Példa a bemenet átirányítására: készítse el az oldal2.txt fájlt, mely soronként egy pozitív egész számot tartalmazzon. Használja fel az előző feladatban készített negyzet2 nevű programot úgy, hogy a szövegfájlban levő összes adatra végezze el a terület és kerület kiszámítását! Példa az oldalak.txt fájl tartalmára:

3
12
43
23

./negyzet2 < oldalak.txt

6. Készíts shell scriptet, mely 3-tól 20-ig kettes lépésközzel ír ki számokat!

#!/bin/bash
LISTA=`seq 3 2 20`
for I in $LISTA ; do
    echo $I
done

7. Készíts shell scriptet, mely a nap minden órájára kiírja az akkor helyes köszönés formát! (pl reggel 8-kor "jó reggelt kívánok").

#!/bin/bash
for ORA in `seq 0 1 23`; do
N="ejszakat"
if [ $ORA -ge 5 -a $ORA -le 8 ] ; then
    N="reggelt"
fi
if [ $ORA -ge 9 -a $ORA -le 18 ] ; then
    N="napot"
fi
if [ $ORA -ge 18 -a $ORA -le 22 ] ; then
    N="estet"
fi
echo "[$ORA órakor]: Jó $N kívánok."
done

8. Készíts shell scriptet, mely sorban feldolgozza az /etc könyvtár .conf kiterjesztésű fájljait! (A feldolgozás jelentse azt, hogy a program kiírja: "Feldolgozás: "!)

#!/bin/bash
for FILE in /etc/*.conf ; do
    echo "Feldolgozás: $FILE"
done

9. Készíts olyan shell scriptet, mely másolatot készít a 10 bájtos, vagy annál nagyobb méretű .txt fájlokról, hozzáfűzve az aktuális dátumot a fájlnévhez ééééhhnn formában.

#!/bin/bash
# Magyar Péter
DATUM=`date +%Y%m%d`
for FILE in ~/*.txt; do
    HOSSZ=`ls -l $FILE | cut -d" " -f5`
    if [ $HOSSZ -ge 10 ] ; then
    F2="$FILE.$DATUM"
    cp $FILE $F2
    fi
done

10. Készíts shell scriptet, mely a billentyűzetről beolvasott sorokat nagybetűssé alakítja! A programot a "vege" szó begépelésével lehessen megállítani!

#!/bin/bash
while read SOR
do
    # A feltétel igazsága esetén lefut a break parancs
    [ $SOR = "vege" ] && break
    echo $SOR | tr '[a-z]' '[A-Z]'
done

11. Készíts shell scriptet, mely a NEVEK változó tartalmát (mely szóközzel elválasztott keresztneveket tartalmaz) egymás utáni sorokban írja ki!

#!/bin/bash
NEVEK="Péter Ilona Béla Pál János"
for NEV in $NEVEK ; do
    echo $NEV
done

12. A cimek.txt fájl e-mail címeket tartalmaz. Készíts shell scriptet, mely az ebben szereplő címekre egy teszt levelet küld!

#!/bin/bash
DATAFILE="cimek.txt"
CIMEK=`cat $DATAFILE`
for CIM in $CIMEK ; do
    echo "Levél küldése $CIM címre"
    echo "Ez teszt levél, kérem törölje." | mail -s "teszt levél" $CIM
done

13. Az adatok.txt fájl soronként két, szóközzel elválasztott számot tartalmaz. Készíts shell scriptet, mely az ebben levő számpárokat egy téglalap oldalaiként dolgozza fel, és kiírja azok kerületét és területét! Az adatok.txt fájl tartalma:

1 2
3 4
5 6
7 8
9 10

#!/bin/bash
DATAFILE="adatok.txt"
cat $DATAFILE | while read I ; do
    A=`echo $I | cut -d' ' -f1`
    B=`echo $I | cut -d' ' -f2`
    KER=`expr $A + $A + $B + $B`
    TER=`expr $A \* $B`
    echo "[$A, $B]: K=$KER, T=$TER"
done

14. A /tmp könyvtárban cnt kiterjesztésű fájlok vannak. Minden fájl neve egy e-mail cím, a tartalma pedig az aznap kiküldött e-mailek száma. Készíts programot, amely levélszám szerinti sorrendben sorrendben megjeleníti a levélküldők listáját!

#!/bin/bash
for I in /tmp/*.cnt ; do
    N=`cat $I`
    echo $N `basename $I`
done | sort -n

Paraméterek

Megjegyzés

Parancsok: for, seq, while, (expr, mail)

1. Készíts programot parmstest néven, mely kiírja saját nevét, paramétereinek számát, a paraméterek listáját, és a paramétereket egyenként! (Példa a kipróbálásra: ./parmstest alma körte dió)

#!/bin/bash
echo "Az elindított program neve: $0"
echo "Paraméterek száma: $#"
echo "Paraméterlista: $@"
echo "Paraméterek egyenként: "
for I in $@ ; do
    echo $I
done

2. Készíts programrészt, mely két paramétert vár. Amennyiben a programot nem két paraméterrel hívjuk meg, adjon hibaüzenetet!

#!/bin/bash
if [ $# -ne 2 ]
then
    echo "A program hasznalata: $0 param1 param2"
    exit
fi

3. Készíts programot, mely 10-nél több paramétert is képes sorban megjeleníteni! Tehát a sokParameter 1 2 3 4 5 6 7 8 9 10 11 12 13 14 eredménye mind a 14 paraméter megjelenítése legyen a válasz! (Ne feledd, a paraméterek csak $9-ig érhetők el!)

#!/bin/bash
for I in $@ ;do
echo $I
done

4. Oldd meg az előző feladatot úgy, hogy egy paraméter feldolgozása után a további paramétereket a shift paranccsal rotálva éri el!

#!/bin/bash
while [ "$1" != "" ] ; do
echo -n "$1 "
shift
done

5. Készíts programot parmtest néven, mely paraméterként két paramétert vár, egy kezdő- és egy végértéket, melyek közül bármelyik elhagyható. A program dologozza fel a két paramétert úgy, hogy azok tetszőleges sorrendben legyenek megadhatók a következő formában: parmtest -v vegertek -k kezdoertek (tehát a parmtest -k kezdoertek -v vegertek is helyes megadási forma). A feldogozás végén a script a kezdőértéket K-ba, a végértéket V-be tegye, és jelenítse meg e két adatot!

#!/bin/bash
# Kezdőérték és végérték default értékének beállítása
K="Nincs megadva"
V="Nincs megadva"
I=$1
while [ "$I" != "" ]
do
case $I in
-v | --veg )
    shift
    V=$1
    ;;
-k | --kezdet )
    shift
    K=$1
    ;;
*)  echo "Érvénytelen paraméter. A program használata: $0 [-v kezdet] [-k vég]"
    exit 1
    ;;
esac
shift
I=$1
done
echo "Kezdőérték=$K, végérték=$V"

Függvények

1. Készíts shell scriptet, mely tartalmaz egy szamol nevű függvényt, amely a paraméterként kapott szám alapján visszaadja az ilyen oldalhosszúságú nényzet területét!

#!/bin/bash

szamol() {
[ $# -eq 0 ] && return 0
return `expr $1 \* $1`
}

szamol 9
T=$?
echo $T

2. Készíts shell scriptet, mely egy szám faktoriálisát számítja ki! A program tartalmazzon egy fact nevű függvényt, mely az érdemi munkát végzi!

#!/bin/bash

fact() {
if [ "$1" -gt "1" ]; then
    i=`expr $1 - 1`
    j=`fact $i`
    k=`expr $1 \* $j`
    echo $k
else
    echo 1
fi
}

fact 5

3. Figyeld meg a változók hatókörét az alábbi program alapján!

#!/bin/bash

if [ $# -ne 1 ] ; then
echo "A program használata: $0 "
exit
fi

NEV="Kiss Lajos"

fv() {
echo "fv: \$1=$1 \$NEV=$NEV"
NEV="Szabo Jozsef"
echo "fv: \$1=$1 \$NEV=$NEV"
}

echo "Start: \$1=$1 \$NEV=$NEV"
fv $1
echo "End: \$1=$1 \$NEV=$NEV"

Szignál kezelés

Megjegyzés

Parancsok: $$, trap

1. Készíts shell scriptet, mely másodpercenként kiírja a saját processID-jét, s mindezt legfeljebb 1000-szer teszi meg! Az aktuális processz ID-je a $$ shell változóban van. (Bevezető gyakorlat.)

#!/bin/bash
for I in `seq 1 1 1000`; do
    echo "$I: $$"
    sleep 1
done

2. Készíts egy shell scriptet, mely abban az esetben, ha azt a kill paranccsal le akarják állítani, még törli az átmeneti fájljait! Ahhoz, hogy ki tudjuk próbálni a programot, az másodpercenként írja ki az ő process ID-jét! (Kill szignált küldeni a kill paranccsal kell, ehhez érdemes egy újabb putty-t indítva még egyszer bejelentkezni a szerverbe. Példa a futtatásra:

feri@aries:~$ ls /tmp/at*
/tmp/atmeneti-21042.tmp
feri@aries:~$ kill 21042
feri@aries:~$ ls /tmp/at*
ls: /tmp/at*: Nincs ilyen fájl vagy könyvtár

#!/bin/bash
TMPFILE="/tmp/atmeneti-$$.tmp"

trap exit_handler EXIT

exit_handler() {
echo "Atmeneti fajlok torlese"
rm $TMPFILE
}

touch $TMPFILE
for i in `seq 1 1 1000`; do
echo $$: $i
sleep 1
done

3. Készíts shell scriptet sigtest néven, mely az előző feladathoz hasonlóan folyamatosan fut, másodpercenként írja ki a processID-jét és a NEV változó tartalmát. A NEV változó értékét a scriptnek a programmal azonos könyvtárban levő parameters.conf fájlból olvassa be a futás megkezdésekor! A scriptnek HUP szignált küldve az olvassa újra a parameters.conf fájlban levő változó értékét, és a másodpercenkénti kiírásban onnantól kezdve használja azt anélkül, hogy a programot leállítanánk! A parameters.conf tartalma a következő legyen:

NEV="Kiss Pál"

Példa a szignál küldésére és a NEV változó "Lajos"-ra változtatására egy másik putty-ban (innentől a másik ablakban futó program a Szabó Lajos nevet fogja másodpercenként a kimenetre írni):

feri@aries:~/signalDemo$ echo "NEV=Lajos" >parameters.txt
feri@aries:~/signalDemo$ kill -HUP 21703

Példa a sigtest futására az egyik putty ablakban:

feri@aries:~/signalDemo$ echo "NEV=Lajos" >parameters.txt
feri@aries:~/signalDemo$ kill -HUP 21703

Példa a szignál küldésére és a NEV változó Szabó Lajosra cserélésekor egy másik putty-ban (innentől a másik ablakban futó program a Szabó Lajos nevet fogja másodpercenként a kimenetre írni):

feri@aries:~/signalDemo$ ./sigtest
21703: 1 Kiss Pál
21703: 2 Kiss Pál
21703: 3 Kiss Pál
21703: 4 Kiss Pál
21703: 5 Kiss Pál
21703: 6 Szabó Lajos
21703: 7 Szabó Lajos

#!/bin/bash
trap reload_handler SIGHUP

reload_handler () {
    . parameters.conf
}

. parameters.conf
for I in `seq 1 1 1000`; do
    echo $$: $I $NEV
    sleep 1
done