Avdeling for informatikk og e-læring, Høgskolen i Sør-Trøndelag Tor Halsan 01.09.2010 Lærestoffet er utviklet for faget LN199D Scripting av Servere Resymé: Vi fortsetter å se på variabler, denne gangen på spesielle variabler. Så vil vi gå gjennom løkker med flere eksempler på anvendelse av disse. Vi vil så se på enkel filbehandling. Til slutt har vi kommet så langt at vi gir noen tips, selv om ikke alle disse er like nyttige... Innhold 2 1 2.1 Variabler, del II.................................... 2 2.1.1 Spesialvariabler................................ 2 2.1.2 Miljøvariabler................................. 3 2.2 Løkker......................................... 5 2.2.1 For løkker................................... 5 2.2.2 While løkker................................. 7 2.3 Filbehandling..................................... 8 2.3.1 Skriving til fil................................. 8 2.3.2 Lesing fra fil................................. 9 2.4 Noen tips....................................... 10 2.4.1 Bryt opp lange linjer............................. 10 2.4.2 Alternativ til løkker.............................. 11 2.4.3 Fancy utdata................................. 11 2.5 Oppsummering.................................... 12
side 2 av 12 2 2.1 Variabler, del II Vi vil her fortsette å se på variabler. Vi introduserte variabler som generelt konsept i forrige leksjon, og dette skulle være greit for alle med litt programmeringserfaring. Vi skal nå gå en del mer spesielle variabler etter i sømmene. 2.1.1 Spesialvariabler Vi har allerede sett på noen få spesialvariabler, nemlig $0, $1 osv. Vi har en del flere vi skal presentere her. Listen er ikke 100% komplett, men ikke alle slike spesialparametre er like egnet for scripting. $0 $1 $2 osv... Dette gjennomgikk vi i forrige leksjon. $0 er selve scriptnavnet, og så vi $1, $2 osv. representere de ulike parameter gitt inn til scriptet separert med mellomrom. I de tilfeller hvor en trenger med enn 9 parameter må en huske å bruker klammer, slik: parameter 10 vil bli: ${10} for å unngå forveksling med $1 $# Dette gir oss antallet parameter sendt inn til scriptet. Ved å kjøre et script, eksempelvis slik:./ny_bruker -a bimbo vil spesialvariabelen $# få verdien 2 siden vi oppgir 2 parameter $? Dette er en statusvariabel som gir oss status på siste utførte komman. Husker du exitkodene brukt i forrige leksjon? Dette er eksempler på statuskoder etter avslutning av en komman. $$ Dette er en variabel som holder prosessid til den kjørende prosessen vi er inne i. $! Lik den over, men denne gir oss prosessid til den siste startede bakgrunnsprossesen vi har startet med scriptet. $* Gir oss en liste over alle parameter på ubeskyttet form (mer om dette lenger ned). $@ Gir oss en liste over alle parameter på beskyttet form. $- Gir oss de opsjoner som det nåværende skallet ble startet med I listen over bruker jeg begreper som beskyttet og ubeskyttet om parameter. Hva menes med dette? Enkelt sagt vil dette si å sende inn flere ord eller tegn inn som et parameter. Dette vil for eksempel være aktuelt når en skal sende inn fullt navn til et script. Siden parameter blir separert med mellomrom må vi knytte sammen for og etternavn til et parameter. Dette gjøres ved å bruke anførselstegn. Her er vi inne på noe meget sentralt vi må jobbe en del med for å klarhet i. Bruk av anførselstegn kan være forvirrende, og er ikke helt lett. Vi skal belyse dette med et grundig eksempel som forhåpentligvis gir mer klarhet i dette. For å vise hvordan dette virker lager vi først et lite miniscript som kun har til hensikt å gi oss opplysninger om parameter det mottar. Til dette bruker vi spesialvariabelene $# og $* for å skrive disse til konsollet. Etterpå lager vi et litt større script som sender inn parametre vha. både $*, «$*», $@ og «$@» for å se på forskjellen. Vi skriver inn dette scriptet:
Variabler, del II side 3 av 12 # Enkelt script som kun returnerer opplysninger om parameter echo "Jeg fikk inn $# parameter, de er: $*" exit 0 Vi lagrer dette scriptet som test_sub.sh og gjør det kjørbart. For å teste dette kjører vi det to ganger:./test_sub.sh tre ulike parameter Jeg fikk inn 3 parameter, de er: tre ulike parameter og./test_sub.sh "tre ulike" parameter Jeg fikk inn 2 parameter, de er: tre ulike parameter Forskjellen kommer vel frem her, men legg merke til at ingen anførselstegn blir med videre. Nå skal vi lage et nytt script som tar inn parameter, og sender disse til miniscriptet for utskrift. # Script som tar inn parameter og sender disse # til miniscriptet for utskrift til konsoll echo "Med \$*:"./test_sub.sh $* echo "Med \$* i anførselstegn:"./test_sub.sh "$*" echo "Med \$@:"./test_sub.sh $@ echo "Med \$@ i anførselstegn:"./test_sub.sh "$@" En kjøring av dette scriptet gir:./test.sh "tre ulike" parameter Med $*: Jeg fikk inn 3 parameter, de er: tre ulike parameter Med $* i anførselstegn: Jeg fikk inn 1 parameter, de er: tre ulike parameter Med $@: Jeg fikk inn 3 parameter, de er: tre ulike parameter Med $@ i anførselstegn: Jeg fikk inn 2 parameter, de er: tre ulike parameter Som vi ser har bruken av anførselstegn mye å si. Dette er ikke lett å få til med den gang, men med en del øvelse og prøving og feiling vil det etterhvert komme. 2.1.2 Miljøvariabler Begrepet miljøvariabler kan benyttes om to typer variabler: 1. Miljøvariabler satt i skallet, tilgjengelig for oss som kjente variabelnavn. Eksempler på dette er $PATH, $USERNAME, $PWD osv.
side 4 av 12 2. Miljøvariabler vi setter for et spesifikt script. Vi skal se litt på begge deler. De førstnevnte miljøvariabler er gitt av den brukeren som kjører scriptet sine miljøvariabler. Du finner lett dine egne miljøvariabler ved å bruke kommanen env. Men hvis man baserer seg på disse kan det være skummelt, da den brukeren som kjører scriptet kan ha ulike miljøvariabler fra en selv. Et klassisk eksempel på dette er når en kjører et script som en cronjob. Hvis vi lager et svært banalt script som returnerer verdien av miljøvariabelen $PATH vil vi belyse dette: echo $PATH > /tmp/path Kjører vi dette scriptet vil filen /tmp/path typisk se slik ut: /usr/local/bin:/usr/bin:/bin:/usr/games Men legger jeg inn dette i crontaben min (kommanen crontab -e) vil fila se slik ut: usr/local/bin:/usr/bin:/bin Lite trolig at jeg vil bruke et spill i et script, men det belyser uansett poenget. Er en ikke forsiktig vil et script som fungerer perfekt når en testkjører det, feile når det kjøres som en cronjob. Den andre type miljøvariabler vil være svært nyttig når en vil ha et sett variabler for flere script. Har en en fil med variablene, trenger en kun å endre disse en plass for flere script. I scriptet henviser en da kun til denne filen med et punktum etterfulgt av et mellomrom og filnavnet hvori variablene er satt. Vi tyr igjen til et eksempel: Vi tenker oss at vi tar en enkel backup av noen filer, databaser etc regelmessig. Alle disse sikkerhetskopiene skal på samme sted, men dette kan endre seg. Vi legger i dette tilfellet variablene i en fil, /etc/backup/environ: # Miljøvariabler for backup # Sist endret: 2009-01-20, torhal WORK_DIR=/backup BIN_DIR=$WORK_DIR/bin BACKUP_DIR=$WORK_DIR/files CONF_DIR=$WORK_DIR/conf Her er 4 variabler satt. Nå skal vi hente dem inn i selve backupscriptet: #!/bin/sh # # Script som tar backup av ulike kataloger og databaser, og legger # disse på et dertil egnet sted. # # 2009-01-20, torhal # # Sette miljøvariabler ENVIRON=/etc/backup/environ. $ENVIRON [...] Nå har vi variablene satt i filen /etc/backup/environ (listet litt lengre opp) til full disposisjon i resten av vårt script.
Løkker side 5 av 12 2.2 Løkker Nå har vi sett mye på tørt stoff om variabler. Da er det på tide å utvide horisonten med å se på en annen sentral del av både scripting og programmering generelt, løkker. Vi har to typer løkker i shellscripting: 1. For løkker 2. While løkker Vi skal nå se på de begge 2.2.1 For løkker Vi kan skille for-løkkene i to ulike former, vi ser selvsagt på begge. Den første kan sammenlignes med «for each» kjent fra andre programmeringsspråk, og kan skjematisk fremstilles slik: for <variabel> in <liste> <Alt i denne blokken mellom blir utført en gang for hvert element i listen> Variabelen er slik vi er kjent med den fra forrige leksjon, listen er en liste med strenger separert av skilletegn (mellomrom, linjeskift, tab etc.) Vi starter med et enkelt eksempel for å belyse dette: # # Enkelt script som viser løkke, eksempel 1 for i in 1 2 3 4 5 6 echo "Dette er linje $i" Her ser vi at vi bruker variabelen i som teller, og denne teller seg gjennom listen med tall vi har satt opp. En kjøring av dette scriptet vil gi følgende ut: Dette er linje 1 Dette er linje 2 Dette er linje 3 Dette er linje 4 Dette er linje 5 Dette er linje 6 Dette er jo enkelt å se, og kanskje ikke ekstremt nyttig. La oss se på et annet eksempel som bedre viser styrken til denne type for løkker. Vi kan la listen bli generert av en komman. Vi skal nå se på et større eksempel som illustrerer dette. Ikke la dere skremme av at dette scriptet innfører mer nytt enn bare løkker, jeg synes det er greit å vise et praktisk nytteeksempel. Dette er en sensurert utgave av et script jeg bruker for å ta sikkerhetskopi av MySQL databaser:
side 6 av 12 # Script som spinner gjennom alle databasene i MySQL # og dumper disse i angitt katalog. # torhal, 2007-09 # Variabler BRUKER="root" PASSORD="detfårikkederevite" TJENER="localhost" PLASSERING="/backup/mysql" IDAG= date +"%Y-%m-%d" TID1= date +"%s" ANTALL=0 MAXALDER=7 MAILTO="labben-driftsmeldinger@aitel.hist.no" MAILSUBJECT="MySQL-dump: " /bin/hostname LOGGFIL=$PLASSERING"/"$IDAG".log" # Passer på at målkatalogen for sikkerhetskopien finnes # og har korrekte rettigheter [! -d $PLASSERING ] && mkdir -p $PLASSERING : chown root:root -R $PLASSERING chmod 0700 $PLASSERING # Finner alle databasene i MySQL, # og legger dem inn i variabelen DATABASER DATABASER= mysql -u $BRUKER -h $TJENER -p$passord -Bse show databases # Sletter de gamle kopiene, (de finnes i sentral backup) echo "Sletter filer eldre enn $MAXALDER dager." > $LOGGFIL find $PLASSERING -type f -mtime +$MAXALDER -exec rm {} \; for db in $DATABASER FIL=$PLASSERING/$db-$IDAG.sql echo "Sikkerhetskopierer $db..." > > $LOGGFIL mysqldump -u $BRUKER -h $TJENER -p$passord --create-options $db > $FIL chmod 600 $FIL ANTALL= expr "$ANTALL" "+" "1" TID2= date +"%s" TID= expr "$TID2" "-" "$TID1" STATUSMSG="MySQL: $ANTALL databaser kopiert, forbrukt tid: $TID sekunder." echo $STATUSMSG > > $LOGGFIL echo $STATUSMSG mail -s "$MAILSUBJECT" $MAILTO Det som er mest interessant for oss nå er merket med rød skrift. Dette er to plasser i scriptet, den første er stedet hvor vi tar utdata fra en komman som viser alle databaser og legger inn i en variabel. Den andre interessante plassen er selve løkken, hvor vi foretar en dump for hver av disse databasene i en løkke. På denne måten kan nye databaser komme til, scriptet vil selv finne korrekt løkke hver
Løkker side 7 av 12 gang. Bruk litt tid på å studere dette scriptet selv, og prøv det gjerne om dere har MySQL installert. Vi har som nevnt en annen måte å skrive for løkker på, den kan skjematisk fremstilles slik: for ((uttrykk1; uttrykk2; uttrykk3 )) <Alt i denne blokken mellom blir utført om igjen til uttrykk2 evalueres til sann (true)> Dette er svært likt løkker vi kjenner fra for eksempel Java og C. Vi starter med et tilsvarende enkelt eksempel for å belyse dette: # # Enkelt script som viser løkke, eksempel 2 for (( i = 1 ; i <= 6; i++ )) echo "Dette er linje $i" En kjøring av dette scriptet vil gi følgende ut (i likhet med eksempelscript 1): Dette er linje 1 Dette er linje 2 Dette er linje 3 Dette er linje 4 Dette er linje 5 Dette er linje 6 Vi ser at ved store løkker hvor det skal telles opp er dette mer hensiktsmessig enn å selv skrive inn rekken med tall. Forøvrig regner jeg med at dere kjenner bruken av slik løkke fra tidligere fag innen programmering. For løkker kan selvsagt nøstes med flere utenpå hverandre. 2.2.2 While løkker Dette er en enkel løkke hvor løkken kjøres så lenge en betingelse er sann. Skjematisk kan den fremstilles slik: while [ <betingelse> ] komman 1 komman 2...osv Pass på at en av kommanene som blir kjørt inne i løkken oppdaterer løkkebetingelse, slik at vi unngår en uendelig løkke. Vi vi viser også her et tilsvarende enkelt eksempel:
side 8 av 12 # # Enkelt script som viser løkke, eksempel 3 i=1 while [ $i -le 6 ] echo "Dette er linje $i" i= expr $i + 1 Ikke overraskende får vi følgende ut: Dette er linje 1 Dette er linje 2 Dette er linje 3 Dette er linje 4 Dette er linje 5 Dette er linje 6 Legg merke til linjen som øker variabelen i med en for gjennomløp av løkken, slik at vi unngår faren med evig løkke. 2.3 Filbehandling 2.3.1 Skriving til fil I eksemplet over hvor vi tok sikkerhetskopier av databaser introduserte vi filbehandling. Her dere at scriptet skriver til en loggfil. De fleste kjenner sikkert til skriving til fil fra tidligere befatning med Linux, men vi tar det kort her: echo "Dette er en linje i en tekstfil" > tekstfil I dette eksemplet skrives linjen «Dette er en linje i en tekstfil» inn i en tekstfil. Her betyr tegnet «>» at vi redirigerer utdata til en fil. Her benyttet vi en «>». Merk følgende: Hvis filen finnes fra før, vil den bli overskrevet med nytt innhold. Hvis filen ikke finnes fra før, vil den bli opprettet. Vi kan også benytte «> >», som vist i dette eksemplet: echo "Dette er en ny linje i en tekstfil" > > tekstfil Merk her følgende, og se forskjellen fra forrige eksempel: Hvis filen finnes fra før, vil det nye innholdet bli skrevet sist i filen, etter eksisterende innhold. Hvis filen ikke finnes fra før, vil den også her bli opprettet. Se eksemplet med sikkerhetskopiering av MySQL igjen, og legg merke til den lille loggen som blir skrevet. En kodelinje oppretter en ny loggfil, og lenger ned blir det skrevet til flere linjer til denne eksisterende loggfilen
Filbehandling side 9 av 12 2.3.2 Lesing fra fil Vi skal nå lese inn fra en fil. Dette er ikke like enkelt å få oversikt over som skriving. Vi skal benytte noen eksempel for å illustrere noen poeng. Vi tar utgangspunkt i en fil vi kaller testfil, som har følgende innhold: (opprett denne selv) nald passord01 lly passord02 mikke passord03 minni passord04 Vi kan lese innholdet inn i en variabel med de metoder vi allerde har sett på. La oss teste dette: # Enkelt script for lesing av fil # Virker dette etter hensikten? FIL= cat testfil echo "Først skriver vi ut innholdet i variabelen:" echo $FIL echo "Så ord for ord:" for ord in $FIL; echo $ord Hvis vi prøver dette, får vi bare en lang rekke med ord, våre linjeskift har gått tapt. Som en skjønner av vår eksempelfil, testfil, er det et poeng å lese inn linje for linje. Dette er jo brukernavn med tilhørende passord som kan brukes til å legge inn brukere. For å oppnå lesing av en fil linje for linje kan vi benytte følgende generelle metode: while read tekstlinje; echo $tekstlinje < tekstfil Som vi ser benyttes her dirigering av innhold med «<». Legg merke til forskjellen fra skriving til fil. Vi konkretiserer dette i et nytt eksempelscript: # Enkelt script for lesing av fil # Virker dette bedre? while read tekstlinje; echo $tekstlinje < testfil Nå inneholder variabelen tekstlinje enkeltlinjer fra testfilen vår, og vi kan enkelt manipulere disse videre. Dette kan kombineres med det vi lærte om innlegging av nye brukere, vi nøyer oss med å konstatere at dette virker:
side 10 av 12 # Enkelt script for lesing av fil # Dette virker etter hensikten! while read tekstlinje; BRUKERNAVN= echo $tekstlinje cut -f1 -d" " echo "Brukernavn: $BRUKERNAVN" PASSORD= echo $tekstlinje cut -f2 -d" " echo "Passord: $PASSORD" < testfil 2.4 Noen tips Hvis det som har blitt gjennomgått i denne leksjonen så lang har festet seg, har vi kommet et godt stykke på vei. Vi venter til neste leksjon med funksjoner, og bruker heller litt plass på noen tips. 2.4.1 Bryt opp lange linjer Noen ganger kan kommanlinjene bli lange, spesielt når vi sender utdata fra en komman inn til neste i flere omganger. For å lettere lese og vedlikeholde script kan det da være hensiktsmessig å dele opp en komman i flere linjer. Husk at vi i et vanlig terminalvindu kun har 80 tegn pr linje. Vi deler en komman i ny linje med tegnet «\». Det er også vanlig å benytte innrykk på neste linje under. Vi tyr selvsagt til et eksempel for å belyse dette: Jeg vil søke gjennom loggfilen /var/log/auth.log for å se om noen har prøvd su og feilet i går. Forsøk 1 uten deling blir slik: # YESTERDAY= date --date "1 day ago" "+%b %e" sed s/\.//g grep "$YESTERDAY" /var/log/auth.log grep -i "failed su" cut -d " " -f 1,2,3,11 sed s Så sammenligner vi med en versjon med linjeskift: YESTERDAY= date --date "1 day ago" "+%b %e" sed s/\.//g grep "$YESTERDAY" /var/log/auth.log \ grep -i "failed su" \ cut -d " " -f 1,2,3,11 \ sed s/$/: su feilet!/ \ sort Dette gjør koden mer lettlest og enklere å redigere. Hver nye komman som mottar data fra den forrige (via «pipe,») er på ny linje.
Noen tips side 11 av 12 2.4.2 Alternativ til løkker Ikke alltid vil løkker være den beste løsningen. Jeg retter oppmerksomheten tilbake til scriptet som sikkerhetskopierer databaser. Her er det en komman som leter opp gamle filer og sletter dem: find $PLASSERING -type f -mtime +$MAXALDER -exec rm {} \; Som løkke ville vi kanskje gjort det slik: FILER= find $PLASSERING -type f -mtime +$MAXALDER for fil in $FILER rm $fil Dette er både mer tungvint å skrive, og tar lengre tid å kjøre. 2.4.3 Fancy utdata Vi runder av med noe veldig unyttig, men forhåpentligvis litt morsomt. Dette vil ikke bli pensum til eksamen, så den som er lei kan hoppe over dette avsnittet. Hvis vi vil sprite opp utdata fra scriptet, enten for moro skyld, eller av andre årsaker er dette fullt mulig. Dere har kanskje lagt merke til at jeg flere plasser har brukt argumentet «-e» når jeg bruker kommanen echo. Dette skyldes en vane jeg har lagt meg til, for med dette argumentet vil vi få tilgang til en del formatering av teksten. Dette gjelder for eksempel farge og spesialtegn («ascii art»). Tenk tilbake til scriptet i forrige leksjon hvor vi sjekket om en bruker er root. Hvis vi legger til noen koder på linjen får vi en litt annen vri på dette: echo -e "\033[31mDu må være root for å kjøre dette scriptet\033[0m" Prøv denne linjen selv. Den første koden (\033[31m) slår på rød skrift, den andre (\033[0m) setter skriften tilbake til normal igjen. Hadde ikke vi hatt med denne siste hadde all utskrift blitt rød til vi ba om noe annet. Noen eksempler, prøv dem selv for å se resultatet. Du trenger ikke skrive dem inn i et script, det holder med å prøve dem rett i terminalvinduet. echo -e "\033[1mHei, jeg er uthevet\033[0m" echo -e "\033[5mHei, jeg blinker\033[0m" echo -e "\033[31mHei, jeg er rød\033[0m" echo -e "\033[32mHei, jeg er grønn\033[0m" echo -e "\033[34mHei, jeg er blå\033[0m" echo -e "\033[47mHei, jeg har lys bakgrunn\033[0m" echo -e "\033[40mHei, jeg har mørk bakgrunn\033[0m" Det finnes mange flere koden enn de nevnt ovenfor, men de kan dere finne på Internett om dere ønsker å bruke dem.
side 12 av 12 2.5 Oppsummering Vi har i denne leksjonen sett mer på variabler, denne gangen på spesialvariabler og miljøvariabler. Vi har sett på løkker, både for og while løkker. Vi har brukt disse i enkle eksempel, og fått med oss advarselen om at vi skal passe oss for å havne i en evig løkke når vi bruker while. Vi så også nærmere på skriving til og lesing fra fil. Til slutt så vi på noen tips, og lekte oss litt med fancy utdata til konsollet/terminalvinduet.