Theory
Commands ને એક program માં બાંધવા
અત્યાર સુધી તમે એક પછી એક command ટાઇપ કરતા આવ્યા છો. પણ backup નું કામ, એટલે કે folder બનાવવું, files ની નકલ કરવી, એમના પર સમયનું ટપકું મારવું, એ અનેક commands છે અને એ તમારે વારંવાર ચલાવવા પડશે. દર વખતે એ બધું ટાઇપ કરવું કંટાળાજનક છે અને એમાં ભૂલ થવાની શક્યતા પણ ઘણી છે.
એનો ઉકેલ છે shell script: એ commands ધરાવતી લખાણની file, જેને તમે એક જ program તરીકે ચલાવો છો. અહીંથી જ Linux commands ના સમૂહમાંથી બદલાઈને એક programming નું વાતાવરણ બની જાય છે. આ પાઠ શીખવે છે કે script કઈ રીતે બનાવવો, ઉપર કઈ એક લીટી મૂકવી, અને શરૂઆત કરનારા સૌથી વધુ કયું પગથિયું ભૂલી જાય છે, એટલે કે એને ચલાવવાલાયક બનાવવાનું.
Theory
Script લખવો: editor અને shebang
તમે script terminal માંના કોઈ text editor માં બનાવો છો. શરૂઆત કરનારા માટે nano મૈત્રીપૂર્ણ પસંદગી છે (પડદા પર જ સૂચનાઓ દેખાય, સાચવવું અને બહાર નીકળવું સહેલું); vi (કે vim) વધુ શક્તિશાળી છે અને દરેક system પર મળે છે, પણ એ modal છે અને શીખવામાં અઘરો છે.
Script ની પહેલી લીટી ખાસ હોય છે: એ shebang, જે #!/bin/bash તરીકે લખાય છે. એ system ને જણાવે છે કે આ file ને કયો interpreter ચલાવે, અહીં Bash. એ પછી તમે સામાન્ય commands લખો છો, દરેક લીટીએ એક, બરાબર જેમ તમે ટાઇપ કરતા હો એ જ રીતે. પ્રથા પ્રમાણે file ને .sh વાળા નામથી સાચવો, અને તમારો script તૈયાર.
Practical
પહેલો script, અને એને ચલાવવો (ચકાસાયેલું)
# In nano, create backup.sh containing:
#!/bin/bash
echo "Backing up..."
# Back at the shell, a new file is NOT executable yet:
$ ls -l backup.sh
-rw-r--r-- 1 riya riya ... backup.sh # no x bits!
$ chmod +x backup.sh # add execute permission
$ ls -l backup.sh
-rwxr-xr-x 1 riya riya ... backup.sh # now executable
$ ./backup.sh # run it (note the ./)
Backing up...Watch out
જાણીતી જાળ: chmod +x, અને પેલું ./
તદ્દન નવો script execute ની permission વગર જ બને છે (rw-r--r--). એને ચલાવવા જાઓ તો 'Permission denied' મળે છે. એનો ઉપાય છે `chmod +x script.sh`, જે execute નો bit ઉમેરે છે (અને એ સીધું permissions ના પાઠ સાથે જોડાય છે).
એ પણ ધ્યાનમાં રાખો કે તમે એને `./script.sh` તરીકે ચલાવો છો, આગળ ./ મૂકીને. એનો અર્થ છે 'બરાબર આ જ directory માં પડેલો script'. એના વગર shell ફક્ત પોતાના PATH પર જ જુએ છે અને તમારો script એને મળતો નથી. આ બે નાનાં પગથિયાં, એટલે chmod +x અને પછી ./, લગભગ દરેક શરૂઆત કરનારને એક વાર તો ગૂંચવે જ છે.
Quiz
તમે હમણાં જ nano માં backup.sh બનાવ્યો અને ./backup.sh ટાઇપ કર્યું, પણ 'Permission denied' મળ્યું. ઉપાય શું?
- File નું નામ બદલીને backup.exe કરી દેવું
- chmod +x backup.sh ચલાવીને execute ની permission ઉમેરવી, અને પછી ફરી ./backup.sh ચલાવવું
- Server ને ફરી શરૂ કરવો
- Script માં વધુ commands ઉમેરવા
Show the answer
chmod +x backup.sh ચલાવીને execute ની permission ઉમેરવી, અને પછી ફરી ./backup.sh ચલાવવું
નવો script execute ના bit વગર જ બને છે (permissions rw-r--r--), એટલે એને ચલાવવા જતાં 'Permission denied' મળે છે. ઉપાય છે chmod +x backup.sh, જે execute ની permission ઉમેરે છે (અને એને rwxr-xr-x બનાવે છે), ત્યાર પછી ./backup.sh ચાલે છે. વિકલ્પ A ખોટો છે: Linux .exe જેવાં પૂંછડિયાં નામ વાપરતું નથી; ચલાવી શકાય કે નહીં એ નામ નહીં પણ execute ની permission નક્કી કરે છે. વિકલ્પ C અર્થહીન છે: server ફરી શરૂ કરવાથી file ની permissions બદલાતી નથી. વિકલ્પ D મુદ્દો ચૂકી જાય છે: permission ની આ ભૂલ સાથે script ની અંદર શું લખ્યું છે એને કશો સંબંધ નથી; એ ફક્ત હજી ચલાવવાલાયક તરીકે નોંધાયો નથી. નવા script માટે બે પગથિયાંની આ વિધિ યાદ રાખો: એક વાર chmod +x, અને પછી ./ થી ચલાવવું.
Think first
ફક્ત script.sh ને બદલે ./script.sh કેમ ટાઇપ કરવું પડે છે?
ls જેવા commands તો આગળ કોઈ ./ વગર જ ચાલે છે. તો પછી તમારા પોતાના script ને ./ કેમ જોઈએ છે? વિચારીને પછી tap કરો.
Show the answer
કારણ કે shell commands ને શોધે છે એ રીતને લીધે, એટલે કે PATH નામની directories ની યાદી વાપરીને, અને તમારી અત્યારની directory સામાન્ય રીતે એ યાદીમાં હોતી નથી. તમે ls ટાઇપ કરો ત્યારે shell PATH માંની directories (જેમ કે /bin અને /usr/bin) માં શોધે છે, ત્યાં ls મળે છે, અને એને ચલાવે છે. તમારો નવો script તમારી અત્યારની directory માં પડ્યો છે, જેને સલામતીના કારણોસર જાણીજોઈને PATH માંથી બહાર રાખવામાં આવી છે; જો અત્યારની directory આપોઆપ શોધાતી હોત, તો કોઈ હુમલાખોર સામાન્ય command જેવા નામની ખરાબ file કોઈ folder માં મૂકી દે અને તમે અજાણતાં એ ચલાવી બેસો. એટલે અત્યારની directory માંનો script ચલાવવા તમારે shell ને સ્પષ્ટ કહેવું પડે કે એ ક્યાં છે, અને ./ નો અર્થ છે 'બરાબર આ જ directory માં' (યાદ કરો કે . એટલે અત્યારની directory). તેથી ./backup.sh કહે છે કે 'અહીં પડેલો backup.sh ચલાવ', અને એ PATH ની શોધને બાજુએ મૂકી દે છે. જો તમારે ./ વગર ચલાવવો હોય, તો કાં તો એને PATH વાળી કોઈ directory માં (જેમ કે /usr/local/bin) ખસેડવો પડે, અથવા એની directory ને PATH માં ઉમેરવી પડે. આ ./ એ નડતર નહીં પણ સલામતીની નાની સગવડ છે: તમે કોઈ folder માં ઊભા છો એટલા માટે જ shell ત્યાંની files ચૂપચાપ ચલાવી ન દે, એ એ સાચવે છે.
Summary
Key takeaways
- Shell script એટલે commands ધરાવતી લખાણની file જે એક જ program તરીકે ચાલે છે, અને backups જેવાં વારંવારનાં કામ માટે આદર્શ છે.
- Scripts editor માં લખો: nano (શરૂઆત કરનારા માટે સહેલો) કે vi/vim (શક્તિશાળી, દરેક system પર હાજર).
- પહેલી લીટી shebang છે, એટલે કે #!/bin/bash, જે file ને ચલાવનારા interpreter નું નામ આપે છે.
- નવો script execute ની permission વગર બને છે, એટલે પહેલાં chmod +x script.sh ચલાવવો પડે છે.
- અત્યારની directory માંનો script ./script.sh તરીકે ચલાવો; આગળનું ./ કહે છે કે 'બરાબર અહીં'.
- ./ એટલા માટે જોઈએ છે કે અત્યારની directory PATH પર હોતી નથી (એ સલામતીની પસંદગી છે), નહીં તો shell ને script મળે જ નહીં.
- યાદ રાખવાની કડી: ઉપર shebang, એક વાર chmod +x, અને ./ થી ચલાવવું.