ક્લાસિકે લખ્યું છે કે ખુશ કલાકો જોતા નથી. તે જંગલી સમયમાં ન તો પ્રોગ્રામરો હતા અને ન તો યુનિક્સ, પરંતુ આજે પ્રોગ્રામરો ખાતરીપૂર્વક જાણે છે: ક્રોન તેમના બદલે સમયનો ટ્રેક રાખશે.

આદેશ વાક્ય ઉપયોગિતાઓ મારા માટે નબળાઈ અને કામકાજ બંને છે. sed, awk, wc, cut અને અન્ય જૂના પ્રોગ્રામ્સ દરરોજ અમારા સર્વર પર સ્ક્રિપ્ટ દ્વારા ચલાવવામાં આવે છે. તેમાંના ઘણા ક્રોન માટેના કાર્યો તરીકે ડિઝાઇન કરવામાં આવ્યા છે, જે મૂળ 70 ના દાયકાના શેડ્યૂલર છે.

લાંબા સમય સુધી, મેં વિગતોમાં ગયા વિના, ક્રોનનો સુપરફિસિયલ ઉપયોગ કર્યો, પરંતુ એક દિવસ, જ્યારે મને સ્ક્રિપ્ટ ચલાવતી વખતે ભૂલ આવી, ત્યારે મેં તેને સંપૂર્ણ રીતે તપાસવાનું નક્કી કર્યું. આ રીતે આ લેખ દેખાયો, તે લખતી વખતે હું POSIX ક્રોન્ટાબ, લોકપ્રિય Linux વિતરણોમાં મુખ્ય ક્રોન વિકલ્પો અને તેમાંના કેટલાકની રચનાથી પરિચિત થયો.

શું તમે Linux નો ઉપયોગ કરો છો અને ક્રોન કાર્યો ચલાવી રહ્યા છો? શું તમને યુનિક્સમાં સિસ્ટમ એપ્લિકેશન આર્કિટેક્ચરમાં રસ છે? પછી અમે અમારા માર્ગ પર છીએ!

અનુક્રમણિકા

• જાતિઓની ઉત્પત્તિ
• પોસિક્સ ક્રોન્ટાબ
• બેસ્ટ સેલર - Vixie cron 3.0pl1
• ડેબિયન અને ઉબુન્ટુ પર ક્રોન
• Red Hat, Fedora અને CentOS પર cronie
• SLES અને openSUSE માં ક્રોની
• વિક્સી ક્રોન ઉપકરણ
• ઉચ્ચારણ

જાતિઓની ઉત્પત્તિ

વપરાશકર્તા અથવા સિસ્ટમ પ્રોગ્રામ્સનું સામયિક અમલ એ તમામ ઓપરેટિંગ સિસ્ટમ્સમાં સ્પષ્ટ આવશ્યકતા છે. તેથી, પ્રોગ્રામરોને એવી સેવાઓની જરૂરિયાતનો અહેસાસ થયો કે જે તેમને કેન્દ્રિય રીતે યોજના ઘડી શકે અને લાંબા સમય પહેલા કાર્યોનો અમલ કરી શકે.

યુનિક્સ જેવી ઓપરેટિંગ સિસ્ટમો તેમની ઉત્પત્તિને વર્ઝન 7 યુનિક્સ પર શોધી કાઢે છે, જે છેલ્લી સદીના 70 ના દાયકામાં બેલ લેબ્સમાં વિકસિત કરવામાં આવી હતી, જેમાં પ્રખ્યાત કેન થોમ્પસનનો પણ સમાવેશ થાય છે. વર્ઝન 7 યુનિક્સમાં ક્રોનનો પણ સમાવેશ થાય છે, જે સુપરયુઝર કાર્યોને નિયમિત રીતે ચલાવવા માટેની સેવા છે.

સામાન્ય આધુનિક ક્રોન એ એક સરળ પ્રોગ્રામ છે, પરંતુ મૂળ સંસ્કરણનું ઓપરેટિંગ અલ્ગોરિધમ વધુ સરળ હતું: સેવા એક મિનિટમાં એકવાર જાગી જાય છે, એક જ ફાઇલ (/etc/lib/crontab)માંથી કાર્યો સાથેનું ટેબલ વાંચે છે અને તેના માટે પરફોર્મ કરે છે. સુપરયુઝર તે કાર્યો કે જે વર્તમાન ક્ષણે કરવા જોઈએ.

ત્યારબાદ, યુનિક્સ જેવી ઓપરેટિંગ સિસ્ટમ સાથે સરળ અને ઉપયોગી સેવાના સુધારેલા સંસ્કરણો પૂરા પાડવામાં આવ્યા.

ક્રોન્ટાબ ફોર્મેટનું સામાન્ય વર્ણન અને યુટિલિટીની કામગીરીના મૂળભૂત સિદ્ધાંતોનો સમાવેશ યુનિક્સ જેવી ઓપરેટિંગ સિસ્ટમના મુખ્ય ધોરણ - POSIX -માં 1992માં કરવામાં આવ્યો હતો, અને આ રીતે ક્રોન ડિ ફેક્ટો સ્ટાન્ડર્ડમાંથી જ્યુર સ્ટાન્ડર્ડ બની ગયું હતું.

1987 માં, પોલ વિક્સીએ, યુનિક્સ વપરાશકર્તાઓને ક્રોન માટેની તેમની ઇચ્છાઓ વિશે સર્વેક્ષણ કર્યા પછી, ડિમનનું બીજું સંસ્કરણ બહાર પાડ્યું જેણે પરંપરાગત ક્રોનની કેટલીક સમસ્યાઓ સુધારી અને ટેબલ ફાઇલોના વાક્યરચનાનો વિસ્તાર કર્યો.

વિક્સી ક્રોનના ત્રીજા સંસ્કરણ દ્વારા POSIX આવશ્યકતાઓને પૂર્ણ કરવાનું શરૂ થયું, વધુમાં, પ્રોગ્રામ પાસે ઉદાર લાયસન્સ હતું, અથવા તેના બદલે, README માંની ઇચ્છાઓ સિવાય કોઈ લાયસન્સ નહોતું: લેખક ગેરંટી આપતા નથી, લેખકનું નામ કાઢી શકાતું નથી, અને પ્રોગ્રામ ફક્ત સોર્સ કોડ સાથે વેચી શકાય છે. આ આવશ્યકતાઓ ફ્રી સોફ્ટવેરના સિદ્ધાંતો સાથે સુસંગત હોવાનું બહાર આવ્યું જે તે વર્ષોમાં લોકપ્રિયતા મેળવી રહ્યું હતું, તેથી 90 ના દાયકાની શરૂઆતમાં દેખાતા કેટલાક મુખ્ય Linux વિતરણોએ વિક્સી ક્રોનને તેમની સિસ્ટમ એક તરીકે લીધી અને આજે પણ તેનો વિકાસ કરી રહી છે.

ખાસ કરીને, Red Hat અને SUSE વિક્સી ક્રોન - ક્રોનીનો ફોર્ક વિકસાવે છે અને ડેબિયન અને ઉબુન્ટુ ઘણા પેચ સાથે વિક્સી ક્રોનની મૂળ આવૃત્તિનો ઉપયોગ કરે છે.

ચાલો પહેલા POSIX માં વર્ણવેલ યુઝર યુટિલિટી ક્રોન્ટાબથી પરિચિત થઈએ, તે પછી આપણે વિક્સી ક્રોનમાં પૂરા પાડવામાં આવેલ સિન્ટેક્સ એક્સ્ટેંશન અને લોકપ્રિય લિનક્સ ડિસ્ટ્રિબ્યુશનમાં વિક્સી ક્રોનની વિવિધતાઓનો ઉપયોગ જોઈશું. અને છેલ્લે, કેક પરની ચેરી એ ક્રોન ડિમન ઉપકરણનું વિશ્લેષણ છે.

પોસિક્સ ક્રોન્ટાબ

જો મૂળ ક્રોન હંમેશા સુપરયુઝર માટે કામ કરે છે, તો આધુનિક શેડ્યુલર્સ ઘણીવાર સામાન્ય વપરાશકર્તાઓના કાર્યો સાથે વ્યવહાર કરે છે, જે વધુ સુરક્ષિત અને અનુકૂળ છે.

ક્રોન્સ બે પ્રોગ્રામ્સના સમૂહ તરીકે પૂરા પાડવામાં આવે છે: સતત ચાલતું ક્રોન ડિમન અને વપરાશકર્તાઓ માટે ઉપલબ્ધ ક્રોન્ટાબ ઉપયોગિતા. બાદમાં તમને સિસ્ટમમાં દરેક વપરાશકર્તા માટે વિશિષ્ટ કાર્ય કોષ્ટકોને સંપાદિત કરવાની મંજૂરી આપે છે, જ્યારે ડિમન વપરાશકર્તા અને સિસ્ટમ કોષ્ટકોમાંથી કાર્યો શરૂ કરે છે.

В POSIX ધોરણ ડિમનની વર્તણૂક કોઈપણ રીતે વર્ણવવામાં આવતી નથી અને માત્ર વપરાશકર્તા પ્રોગ્રામ ઔપચારિક છે crontab માં. વપરાશકર્તા કાર્યો શરૂ કરવા માટેની પદ્ધતિઓનું અસ્તિત્વ, અલબત્ત, ગર્ભિત છે, પરંતુ તેનું વિગતવાર વર્ણન નથી.

ક્રોન્ટાબ યુટિલિટીને કૉલ કરીને, તમે ચાર વસ્તુઓ કરી શકો છો: એડિટરમાં વપરાશકર્તાના કાર્ય કોષ્ટકને સંપાદિત કરો, ફાઇલમાંથી કોષ્ટક લોડ કરો, વર્તમાન કાર્ય કોષ્ટક બતાવો અને કાર્ય કોષ્ટક સાફ કરો. ક્રોન્ટાબ ઉપયોગિતા કેવી રીતે કાર્ય કરે છે તેના ઉદાહરણો:

crontab -e # редактировать таблицу задач
crontab -l # показать таблицу задач
crontab -r # удалить таблицу задач
crontab path/to/file.crontab # загрузить таблицу задач из файла

જ્યારે બોલાવવામાં આવે છે crontab -e પ્રમાણભૂત પર્યાવરણ ચલમાં ઉલ્લેખિત સંપાદકનો ઉપયોગ કરવામાં આવશે EDITOR.

કાર્યો પોતે નીચેના ફોર્મેટમાં વર્ણવેલ છે:

# строки-комментарии игнорируются
#
# задача, выполняемая ежеминутно
* * * * * /path/to/exec -a -b -c
# задача, выполняемая на 10-й минуте каждого часа
10 * * * * /path/to/exec -a -b -c
# задача, выполняемая на 10-й минуте второго часа каждого дня и использующая перенаправление стандартного потока вывода
10 2 * * * /path/to/exec -a -b -c > /tmp/cron-job-output.log

રેકોર્ડના પ્રથમ પાંચ ક્ષેત્રો: મિનિટ [1..60], કલાકો [0..23], મહિનાના દિવસો [1..31], મહિનાઓ [1..12], અઠવાડિયાના દિવસો [0. .6], જ્યાં 0 રવિવાર છે. છેલ્લું, છઠ્ઠું, ક્ષેત્ર એ એક રેખા છે જે પ્રમાણભૂત આદેશ દુભાષિયા દ્વારા ચલાવવામાં આવશે.

પ્રથમ પાંચ ક્ષેત્રોમાં, મૂલ્યોને અલ્પવિરામ દ્વારા અલગ કરીને સૂચિબદ્ધ કરી શકાય છે:

# задача, выполняемая в первую и десятую минуты каждого часа
1,10 * * * * /path/to/exec -a -b -c

અથવા હાઇફન સાથે:

# задача, выполняемая в каждую из первых десяти минут каждого часа
0-9 * * * * /path/to/exec -a -b -c

કાર્ય સુનિશ્ચિત કરવા માટે વપરાશકર્તાની ઍક્સેસને POSIX માં cron.allow અને cron.deny ફાઇલો દ્વારા નિયંત્રિત કરવામાં આવે છે, જે અનુક્રમે ક્રૉન્ટાબની ​​ઍક્સેસ ધરાવતા વપરાશકર્તાઓ અને પ્રોગ્રામની ઍક્સેસ વિનાના વપરાશકર્તાઓને સૂચિબદ્ધ કરે છે. માનક આ ફાઇલોના સ્થાનને કોઈપણ રીતે નિયંત્રિત કરતું નથી.

સ્ટાન્ડર્ડ મુજબ, લોંચ થયેલા પ્રોગ્રામ્સ માટે ઓછામાં ઓછા ચાર એન્વાયર્નમેન્ટ વેરિયેબલ પાસ કરવા આવશ્યક છે:

1. હોમ - વપરાશકર્તાની હોમ ડિરેક્ટરી.
2. LOGNAME — વપરાશકર્તા લૉગિન.
3. PATH એ પાથ છે જ્યાં તમે પ્રમાણભૂત સિસ્ટમ ઉપયોગિતાઓ શોધી શકો છો.
4. શેલ - વપરાયેલ આદેશ દુભાષિયાનો માર્ગ.

નોંધનીય રીતે, આ ચલો માટેના મૂલ્યો ક્યાંથી આવે છે તે વિશે POSIX કંઈ કહેતું નથી.

બેસ્ટ સેલર - Vixie cron 3.0pl1

લોકપ્રિય ક્રોન વેરિઅન્ટ્સનો સામાન્ય પૂર્વજ Vixie cron 3.0pl1 છે, જે 1992માં comp.sources.unix મેઇલિંગ લિસ્ટમાં રજૂ કરવામાં આવ્યો હતો. અમે આ સંસ્કરણની મુખ્ય લાક્ષણિકતાઓને વધુ વિગતવાર ધ્યાનમાં લઈશું.

વિક્સી ક્રોન બે પ્રોગ્રામ્સમાં આવે છે (ક્રોન અને ક્રોન્ટાબ). હંમેશની જેમ, ડિમન સિસ્ટમ ટાસ્ક ટેબલ અને વ્યક્તિગત વપરાશકર્તા કાર્ય કોષ્ટકોમાંથી કાર્યો વાંચવા અને ચલાવવા માટે જવાબદાર છે, અને ક્રોન્ટાબ ઉપયોગિતા વપરાશકર્તા કોષ્ટકોને સંપાદિત કરવા માટે જવાબદાર છે.

કાર્ય કોષ્ટક અને ગોઠવણી ફાઇલો

સુપરયુઝર ટાસ્ક ટેબલ /etc/crontab માં સ્થિત છે. સિસ્ટમ કોષ્ટકનું વાક્યરચના વિક્સી ક્રોનના વાક્યરચનાને અનુરૂપ છે, અપવાદ સાથે કે તેમાંની છઠ્ઠી કૉલમ તે વપરાશકર્તાનું નામ સૂચવે છે કે જેના વતી કાર્ય શરૂ કરવામાં આવ્યું છે:

# Запускается ежеминутно от пользователя vlad
* * * * * vlad /path/to/exec

નિયમિત વપરાશકર્તા કાર્ય કોષ્ટકો /var/cron/tabs/username માં સ્થિત છે અને તે જ વાક્યરચનાનો ઉપયોગ કરે છે. જ્યારે તમે વપરાશકર્તા તરીકે ક્રોન્ટાબ ઉપયોગિતા ચલાવો છો, ત્યારે આ તે ફાઇલો છે જે સંપાદિત થાય છે.

ક્રોન્ટાબની ​​ઍક્સેસ ધરાવતા વપરાશકર્તાઓની યાદીઓ /var/cron/allow અને /var/cron/deny ફાઇલોમાં મેનેજ કરવામાં આવે છે, જ્યાં તમારે માત્ર એક અલગ લાઇનમાં વપરાશકર્તા નામ દાખલ કરવાની જરૂર છે.

વિસ્તૃત વાક્યરચના

POSIX ક્રોન્ટાબની ​​તુલનામાં, પોલ વિક્સીના સોલ્યુશનમાં ઉપયોગિતાના કાર્ય કોષ્ટકોના વાક્યરચનામાં ઘણા ઉપયોગી ફેરફારો છે.

એક નવું ટેબલ સિન્ટેક્સ ઉપલબ્ધ બન્યું છે: ઉદાહરણ તરીકે, તમે નામ દ્વારા અઠવાડિયાના દિવસો અથવા મહિનાનો ઉલ્લેખ કરી શકો છો (સોમ, મંગળ અને તેથી વધુ):

# Запускается ежеминутно по понедельникам и вторникам в январе
* * * Jan Mon,Tue /path/to/exec

તમે પગલાંનો ઉલ્લેખ કરી શકો છો કે જેના દ્વારા કાર્યો શરૂ કરવામાં આવે છે:

# Запускается с шагом в две минуты
*/2 * * * Mon,Tue /path/to/exec

પગલાં અને અંતરાલો મિશ્રિત કરી શકાય છે:

# Запускается с шагом в две минуты в первых десять минут каждого часа
0-10/2 * * * * /path/to/exec

સામાન્ય વાક્યરચના માટે સાહજિક વિકલ્પો સમર્થિત છે (રીબૂટ, વાર્ષિક, વાર્ષિક, માસિક, સાપ્તાહિક, દૈનિક, મધ્યરાત્રિ, કલાકદીઠ):

# Запускается после перезагрузки системы
@reboot /exec/on/reboot
# Запускается раз в день
@daily /exec/daily
# Запускается раз в час
@hourly /exec/daily

કાર્ય અમલીકરણ વાતાવરણ

વિક્સી ક્રોન તમને ચાલી રહેલ એપ્લિકેશન્સનું વાતાવરણ બદલવાની મંજૂરી આપે છે.

પર્યાવરણ ચલો USER, LOGNAME અને HOME ફક્ત ડિમન દ્વારા પ્રદાન કરવામાં આવતાં નથી, પરંતુ ફાઇલમાંથી લેવામાં આવ્યા છે. પાસવડ. PATH ચલ "/usr/bin:/bin" પર સેટ છે અને SHELL ચલ "/bin/sh" પર સેટ છે. LOGNAME સિવાયના તમામ ચલોની કિંમતો વપરાશકર્તા કોષ્ટકોમાં બદલી શકાય છે.

કેટલાક પર્યાવરણ ચલો (સૌથી ખાસ કરીને SHELL અને HOME)નો ઉપયોગ ક્રોન દ્વારા કાર્ય ચલાવવા માટે થાય છે. કસ્ટમ કાર્યો ચલાવવા માટે માનક sh ને બદલે bash નો ઉપયોગ આવો દેખાય છે તે અહીં છે:

SHELL=/bin/bash
HOME=/tmp/
# exec будет запущен bash-ем в /tmp/
* * * * * /path/to/exec

આખરે, કોષ્ટકમાં વ્યાખ્યાયિત તમામ પર્યાવરણ ચલો (ક્રોન દ્વારા ઉપયોગમાં લેવાય છે અથવા પ્રક્રિયા દ્વારા જરૂરી છે) ચાલી રહેલ કાર્યમાં પસાર કરવામાં આવશે.

ફાઇલોને સંપાદિત કરવા માટે, ક્રૉન્ટાબ VISUAL અથવા EDITOR પર્યાવરણ વેરીએબલમાં ઉલ્લેખિત એડિટરનો ઉપયોગ કરે છે. જો પર્યાવરણ જ્યાં ક્રોન્ટાબ ચલાવવામાં આવ્યું હતું ત્યાં આ ચલોને વ્યાખ્યાયિત કર્યા નથી, તો પછી "/usr/ucb/vi" નો ઉપયોગ થાય છે (યુસીબી કદાચ યુનિવર્સિટી ઓફ કેલિફોર્નિયા, બર્કલે છે).

ડેબિયન અને ઉબુન્ટુ પર ક્રોન

ડેબિયન અને ડેરિવેટિવ ડિસ્ટ્રિબ્યુશનના વિકાસકર્તાઓએ રિલીઝ કર્યું છે અત્યંત સંશોધિત સંસ્કરણ વિક્સી ક્રોન સંસ્કરણ 3.0pl1. કોષ્ટક ફાઇલોના સિન્ટેક્સમાં કોઈ તફાવત નથી; વપરાશકર્તાઓ માટે તે સમાન વિક્સી ક્રોન છે. સૌથી મોટી નવી સુવિધા: સપોર્ટ syslog, SELinux и PAM.

ઓછા ધ્યાનપાત્ર, પરંતુ મૂર્ત ફેરફારોમાં રૂપરેખાંકન ફાઇલો અને કાર્ય કોષ્ટકોનું સ્થાન શામેલ છે.

ડેબિયનમાં વપરાશકર્તા કોષ્ટકો /var/spool/cron/crontabs ડિરેક્ટરીમાં સ્થિત છે, સિસ્ટમ કોષ્ટક હજી પણ છે - /etc/crontab માં. ડેબિયન પેકેજ-વિશિષ્ટ કાર્ય કોષ્ટકો /etc/cron.d માં મૂકવામાં આવે છે, જ્યાંથી ક્રોન ડિમન તેમને આપમેળે વાંચે છે. વપરાશકર્તા ઍક્સેસ નિયંત્રણ /etc/cron.allow અને /etc/cron.deny ફાઇલો દ્વારા નિયંત્રિત થાય છે.

ડિફૉલ્ટ શેલ હજુ પણ /bin/sh છે, જે ડેબિયનમાં એક નાનો POSIX- સુસંગત શેલ છે આડંબર, કોઈપણ રૂપરેખાંકન (બિન-ઇન્ટરેક્ટિવ મોડમાં) વાંચ્યા વિના લોન્ચ કર્યું.

ડેબિયનના નવીનતમ સંસ્કરણોમાં ક્રોન પોતે systemd દ્વારા લોન્ચ કરવામાં આવે છે, અને લોન્ચ રૂપરેખાંકન /lib/systemd/system/cron.service માં જોઈ શકાય છે. સેવા રૂપરેખાંકનમાં વિશેષ કંઈ નથી; કોઈપણ વધુ સૂક્ષ્મ કાર્ય વ્યવસ્થાપન દરેક વપરાશકર્તાના ક્રોન્ટાબમાં સીધા જાહેર કરાયેલ પર્યાવરણ ચલ દ્વારા કરી શકાય છે.

RedHat, Fedora અને CentOS પર cronie

ક્રોની — વિક્સી ક્રોન સંસ્કરણ 4.1 નો ફોર્ક. ડેબિયનની જેમ, વાક્યરચના બદલાઈ નથી, પરંતુ PAM અને SELinux માટે સપોર્ટ, ક્લસ્ટરમાં કામ કરવું, inotify નો ઉપયોગ કરીને ફાઈલો ટ્રેકિંગ અને અન્ય સુવિધાઓ ઉમેરવામાં આવી છે.

મૂળભૂત રૂપરેખાંકન સામાન્ય સ્થળોએ છે: સિસ્ટમ કોષ્ટક /etc/crontab માં છે, પેકેજો તેમના કોષ્ટકોને /etc/cron.d માં મૂકે છે, વપરાશકર્તા કોષ્ટકો /var/spool/cron/crontabs માં જાય છે.

ડિમન systemd નિયંત્રણ હેઠળ ચાલે છે, સેવા રૂપરેખાંકન /lib/systemd/system/crond.service છે.

Red Hat-જેવા વિતરણો પર, /bin/sh એ સ્ટાર્ટઅપ પર મૂળભૂત રીતે વપરાય છે, જે પ્રમાણભૂત બેશ છે. એ નોંધવું જોઈએ કે જ્યારે /bin/sh દ્વારા ક્રોન જોબ્સ ચલાવી રહ્યા હોય, ત્યારે બેશ શેલ POSIX- સુસંગત મોડમાં શરૂ થાય છે અને બિન-ઈન્ટરેક્ટિવ મોડમાં ચાલતા કોઈપણ વધારાના રૂપરેખાંકનને વાંચતું નથી.

SLES અને openSUSE માં ક્રોની

જર્મન ડિસ્ટ્રિબ્યુશન SLES અને તેના ડેરિવેટિવ openSUSE સમાન ક્રોનીનો ઉપયોગ કરે છે. અહીં ડિમન પણ systemd હેઠળ લોન્ચ થયેલ છે, સેવા રૂપરેખાંકન /usr/lib/systemd/system/cron.service માં સ્થિત છે. રૂપરેખાંકન: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh એ જ બેશ છે જે POSIX- સુસંગત બિન-ઇન્ટરેક્ટિવ મોડમાં ચાલે છે.

વિક્સી ક્રોન ઉપકરણ

વિક્સી ક્રોનની સરખામણીમાં ક્રોનના આધુનિક વંશજો ધરમૂળથી બદલાયા નથી, પરંતુ તેમ છતાં નવી સુવિધાઓ પ્રાપ્ત કરી છે જે પ્રોગ્રામના સિદ્ધાંતોને સમજવા માટે જરૂરી નથી. આમાંના ઘણા એક્સ્ટેંશન ખરાબ રીતે ડિઝાઇન કરેલા છે અને કોડને ગૂંચવણમાં મૂકે છે. પોલ વિક્સીનો મૂળ ક્રોન સોર્સ કોડ વાંચીને આનંદ થયો.

તેથી, મેં વિકાસની બંને શાખાઓમાં સામાન્ય ક્રોન પ્રોગ્રામના ઉદાહરણનો ઉપયોગ કરીને ક્રોન ઉપકરણનું વિશ્લેષણ કરવાનું નક્કી કર્યું - Vixie cron 3.0pl1. વાંચનને જટિલ બનાવતા ifdefs ને દૂર કરીને અને નાની વિગતોને અવગણીને હું ઉદાહરણોને સરળ બનાવીશ.

રાક્ષસના કાર્યને ઘણા તબક્કામાં વહેંચી શકાય છે:

1. કાર્યક્રમની શરૂઆત કરી રહ્યા છીએ.
2. ચલાવવા માટેના કાર્યોની સૂચિ એકત્રિત અને અપડેટ કરવી.
3. મુખ્ય ક્રોન લૂપ ચાલી રહ્યું છે.
4. એક કાર્ય શરૂ કરો.

ચાલો તેમને ક્રમમાં જોઈએ.

આરંભ

જ્યારે શરૂ થાય, ત્યારે પ્રક્રિયાની દલીલો તપાસ્યા પછી, ક્રોન SIGCHLD અને SIGHUP સિગ્નલ હેન્ડલર્સ ઇન્સ્ટોલ કરે છે. પ્રથમ બાળક પ્રક્રિયાના સમાપ્તિ વિશે લોગ એન્ટ્રી કરે છે, બીજો લોગ ફાઇલના ફાઇલ વર્ણનકર્તાને બંધ કરે છે:

signal(SIGCHLD, sigchld_handler);
signal(SIGHUP, sighup_handler);

ક્રોન ડિમન હંમેશા સિસ્ટમ પર એકલા ચાલે છે, માત્ર સુપરયુઝર તરીકે અને મુખ્ય ક્રોન ડિરેક્ટરીમાંથી. નીચેના કૉલ્સ ડિમન પ્રક્રિયાની PID સાથે લૉક ફાઇલ બનાવે છે, ખાતરી કરો કે વપરાશકર્તા સાચો છે અને વર્તમાન ડિરેક્ટરીને મુખ્યમાં બદલો:

acquire_daemonlock(0);
set_cron_uid();
set_cron_cwd();

ડિફૉલ્ટ પાથ સેટ કરેલ છે, જેનો ઉપયોગ પ્રક્રિયાઓ શરૂ કરતી વખતે કરવામાં આવશે:

setenv("PATH", _PATH_DEFPATH, 1);

પછી પ્રક્રિયા "ડિમોનાઇઝ્ડ" છે: તે ફોર્કને કૉલ કરીને પ્રક્રિયાની ચાઇલ્ડ કૉપિ બનાવે છે અને ચાઇલ્ડ પ્રક્રિયામાં નવું સત્ર (સેટસિડને કૉલ કરીને) બનાવે છે. પિતૃ પ્રક્રિયાની હવે જરૂર નથી, અને તે બહાર નીકળી જાય છે:

switch (fork()) {
case -1:
    /* критическая ошибка и завершение работы */
    exit(0);
break;
case 0:
    /* дочерний процесс */
    (void) setsid();
break;
default:
    /* родительский процесс завершает работу */
    _exit(0);
}

પિતૃ પ્રક્રિયાને સમાપ્ત કરવાથી લૉક ફાઇલ પર લૉક રિલીઝ થાય છે. આ ઉપરાંત, બાળકને ફાઇલમાં PID અપડેટ કરવું જરૂરી છે. આ પછી, કાર્ય ડેટાબેઝ ભરવામાં આવે છે:

/* повторный захват лока */
acquire_daemonlock(0);

/* Заполнение БД  */
database.head = NULL;
database.tail = NULL;
database.mtime = (time_t) 0;
load_database(&database);

પછી ક્રોન મુખ્ય કાર્ય ચક્ર પર આગળ વધે છે. પરંતુ તે પહેલાં, કાર્ય સૂચિ લોડ કરવા પર એક નજર નાખવી યોગ્ય છે.

કાર્ય સૂચિ એકત્રિત અને અપડેટ કરવી

load_database કાર્ય કાર્યોની યાદી લોડ કરવા માટે જવાબદાર છે. તે મુખ્ય સિસ્ટમ ક્રોન્ટાબ અને વપરાશકર્તા ફાઇલો સાથે ડિરેક્ટરીને તપાસે છે. જો ફાઇલો અને ડિરેક્ટરી બદલાઈ નથી, તો કાર્ય સૂચિ ફરીથી વાંચવામાં આવશે નહીં. નહિંતર, કાર્યોની નવી સૂચિ રચવાનું શરૂ થાય છે.

વિશિષ્ટ ફાઇલ અને કોષ્ટક નામો સાથે સિસ્ટમ ફાઇલ લોડ કરી રહ્યું છે:

/* если файл системной таблицы изменился, перечитываем */
if (syscron_stat.st_mtime) {
    process_crontab("root", "*system*",
    SYSCRONTAB, &syscron_stat,
    &new_db, old_db);
}

લૂપમાં વપરાશકર્તા કોષ્ટકો લોડ કરી રહ્યાં છે:

while (NULL != (dp = readdir(dir))) {
    char    fname[MAXNAMLEN+1],
            tabname[MAXNAMLEN+1];
    /* читать файлы с точкой не надо*/
    if (dp->d_name[0] == '.')
            continue;
    (void) strcpy(fname, dp->d_name);
    sprintf(tabname, CRON_TAB(fname));
    process_crontab(fname, fname, tabname,
                    &statbuf, &new_db, old_db);
}

જે પછી જૂના ડેટાબેઝને નવા સાથે બદલવામાં આવે છે.

ઉપરના ઉદાહરણોમાં, process_crontab ફંક્શન કૉલ ચકાસે છે કે ટેબલ ફાઇલના નામ સાથે મેળ ખાતો વપરાશકર્તા અસ્તિત્વમાં છે (સિવાય કે તે સુપરયુઝર હોય) અને પછી load_user ને કૉલ કરે છે. બાદમાં પહેલેથી જ ફાઇલને વાક્ય દ્વારા વાંચે છે:

while ((status = load_env(envstr, file)) >= OK) {
    switch (status) {
    case ERR:
        free_user(u);
        u = NULL;
        goto done;
    case FALSE:
        e = load_entry(file, NULL, pw, envp);
        if (e) {
            e->next = u->crontab;
            u->crontab = e;
        }
        break;
    case TRUE:
        envp = env_set(envp, envstr);
        break;
    }
}

અહીં, load_env / env_set ફંક્શનનો ઉપયોગ કરીને પર્યાવરણ વેરીએબલ સેટ કરવામાં આવે છે (ફોર્મ VAR=વેલ્યુની રેખાઓ), અથવા load_entry ફંક્શનનો ઉપયોગ કરીને કાર્ય વર્ણન વાંચવામાં આવે છે (* * * * * /path/to/exec).

લોડ_એન્ટ્રી પરત કરે છે તે એન્ટ્રી એન્ટિટી અમારું કાર્ય છે, જે કાર્યોની સામાન્ય સૂચિમાં મૂકવામાં આવે છે. ફંક્શન પોતે જ ટાઈમ ફોર્મેટનું વર્બોઝ પાર્સિંગ કરે છે, પરંતુ અમને એન્વાયર્નમેન્ટ વેરિયેબલ્સ અને ટાસ્ક લોન્ચ પેરામીટર્સની રચનામાં વધુ રસ છે:

/* пользователь и группа для запуска задачи берутся из passwd*/
e->uid = pw->pw_uid;
e->gid = pw->pw_gid;

/* шелл по умолчанию (/bin/sh), если пользователь не указал другое */
e->envp = env_copy(envp);
if (!env_get("SHELL", e->envp)) {
    sprintf(envstr, "SHELL=%s", _PATH_BSHELL);
    e->envp = env_set(e->envp, envstr);
}
/* домашняя директория */
if (!env_get("HOME", e->envp)) {
    sprintf(envstr, "HOME=%s", pw->pw_dir);
    e->envp = env_set(e->envp, envstr);
}
/* путь для поиска программ */
if (!env_get("PATH", e->envp)) {
    sprintf(envstr, "PATH=%s", _PATH_DEFPATH);
    e->envp = env_set(e->envp, envstr);
}
/* имя пользовтеля всегда из passwd */
sprintf(envstr, "%s=%s", "LOGNAME", pw->pw_name);
e->envp = env_set(e->envp, envstr);

મુખ્ય લૂપ કાર્યોની વર્તમાન સૂચિ સાથે કામ કરે છે.

મુખ્ય લૂપ

વર્ઝન 7 યુનિક્સનું મૂળ ક્રોન એકદમ સરળ રીતે કામ કરે છે: તેણે લૂપમાં ગોઠવણીને ફરીથી વાંચી, સુપરયુઝર તરીકે વર્તમાન મિનિટના કાર્યોને શરૂ કર્યા, અને આગલી મિનિટની શરૂઆત સુધી સૂઈ ગયા. જૂના મશીનો પર આ સરળ અભિગમ માટે ઘણા બધા સંસાધનોની જરૂર હતી.

SysV માં વૈકલ્પિક સંસ્કરણની દરખાસ્ત કરવામાં આવી હતી, જેમાં ડિમન ક્યાં તો નજીકની મિનિટ કે જેના માટે કાર્ય વ્યાખ્યાયિત કરવામાં આવ્યું હતું ત્યાં સુધી અથવા 30 મિનિટ માટે સૂઈ જાય છે. આ મોડમાં રૂપરેખાંકનને ફરીથી વાંચવા અને કાર્યોને તપાસવા માટે ઓછા સંસાધનોનો ઉપયોગ કરવામાં આવ્યો હતો, પરંતુ કાર્યોની સૂચિને ઝડપથી અપડેટ કરવી અસુવિધાજનક બની હતી.

વિક્સી ક્રોન એક મિનિટમાં એકવાર કાર્ય સૂચિઓ તપાસવા પર પાછો ફર્યો, સદભાગ્યે 80 ના દાયકાના અંત સુધીમાં પ્રમાણભૂત યુનિક્સ મશીનો પર નોંધપાત્ર રીતે વધુ સંસાધનો હતા:

/* первичная загрузка задач */
load_database(&database);
/* запустить задачи, поставленные к выполнению после перезагрузки системы */
run_reboot_jobs(&database);
/* сделать TargetTime началом ближайшей минуты */
cron_sync();
while (TRUE) {
    /* выполнить задачи, после чего спать до TargetTime с поправкой на время, потраченное на задачи */
    cron_sleep();

    /* перечитать конфигурацию */
    load_database(&database);

    /* собрать задачи для данной минуты */
    cron_tick(&database);

    /* перевести TargetTime на начало следующей минуты */
    TargetTime += 60;
}

ક્રોન_સ્લીપ ફંક્શન સીધા જ કાર્યોને ચલાવવામાં સામેલ છે, જોબ_રનક્યૂ (કાર્યોની ગણતરી કરો અને ચલાવો) અને do_command (દરેક વ્યક્તિગત કાર્ય ચલાવો) કાર્યોને કૉલ કરો. છેલ્લું કાર્ય વધુ વિગતવાર તપાસવા યોગ્ય છે.

કાર્ય ચલાવવું

do_command ફંક્શન સારી યુનિક્સ શૈલીમાં ચલાવવામાં આવે છે, એટલે કે, તે અસુમેળ રીતે કાર્ય કરવા માટે ફોર્ક કરે છે. પિતૃ પ્રક્રિયા કાર્યો શરૂ કરવાનું ચાલુ રાખે છે, બાળક પ્રક્રિયા કાર્ય પ્રક્રિયા તૈયાર કરે છે:

switch (fork()) {
case -1:
    /*не смогли выполнить fork */
    break;
case 0:
    /* дочерний процесс: на всякий случай еще раз пробуем захватить главный лок */
    acquire_daemonlock(1);
    /* переходим к формированию процесса задачи */
    child_process(e, u);
    /* по завершению дочерний процесс заканчивает работу */
    _exit(OK_EXIT);
    break;
default:
    /* родительский процесс продолжает работу */
    break;
}

ચાઇલ્ડ_પ્રોસેસમાં ઘણો તર્ક છે: તે સ્ટાન્ડર્ડ આઉટપુટ અને એરર સ્ટ્રીમ્સ પોતાના પર લે છે, પછી તેને મેઇલ પર મોકલવા માટે (જો MAILTO એન્વાયર્નમેન્ટ વેરીએબલ ટાસ્ક ટેબલમાં ઉલ્લેખિત છે), અને છેવટે, મુખ્યની રાહ જુએ છે. કાર્ય પૂર્ણ કરવાની પ્રક્રિયા.

કાર્ય પ્રક્રિયા અન્ય ફોર્ક દ્વારા રચાય છે:

switch (vfork()) {
case -1:
    /* при ошибки сразу завершается работа */
    exit(ERROR_EXIT);
case 0:
    /* процесс-внук формирует новую сессию, терминал и т.д.
     */
    (void) setsid();

    /*
     * дальше многословная настройка вывода процесса, опустим для краткости
     */

    /* смена директории, пользователя и группы пользователя,
     * то есть процесс больше не суперпользовательский
     */
    setgid(e->gid);
    setuid(e->uid);
    chdir(env_get("HOME", e->envp));

    /* запуск самой команды
     */
    {
        /* переменная окружения SHELL указывает на интерпретатор для запуска */
        char    *shell = env_get("SHELL", e->envp);

        /* процесс запускается без передачи окружения родительского процесса,
         * то есть именно так, как описано в таблице задач пользователя  */
        execle(shell, shell, "-c", e->cmd, (char *)0, e->envp);

        /* ошибка — и процесс на запустился? завершение работы */
        perror("execl");
        _exit(ERROR_EXIT);
    }
    break;
default:
    /* сам процесс продолжает работу: ждет завершения работы и вывода */
    break;
}

તે મૂળભૂત રીતે તમામ ક્રોન છે. મેં કેટલીક રસપ્રદ વિગતો છોડી દીધી છે, ઉદાહરણ તરીકે, દૂરસ્થ વપરાશકર્તાઓ માટે એકાઉન્ટિંગ, પરંતુ મેં મુખ્ય વસ્તુની રૂપરેખા આપી છે.

ઉચ્ચારણ

ક્રોન એ આશ્ચર્યજનક રીતે સરળ અને ઉપયોગી પ્રોગ્રામ છે, જે યુનિક્સ વિશ્વની શ્રેષ્ઠ પરંપરાઓમાં બનાવવામાં આવે છે. તેણી કંઈપણ વધારાનું કામ કરતી નથી, પરંતુ તે છેલ્લા કેટલાક દાયકાઓથી તેનું કામ અદ્ભુત રીતે કરી રહી છે. ઉબુન્ટુ સાથે આવતા સંસ્કરણ માટે કોડ મેળવવામાં એક કલાકથી વધુ સમય લાગ્યો નહીં, અને મને ખૂબ મજા આવી! મને આશા છે કે હું તેને તમારી સાથે શેર કરવામાં સક્ષમ હતો.

હું તમારા વિશે જાણતો નથી, પરંતુ મને એ જાણીને થોડો દુ:ખ થાય છે કે આધુનિક પ્રોગ્રામિંગ, તેના અતિ-જટિલ અને વધુ પડતા અમૂર્તની વૃત્તિ સાથે, લાંબા સમયથી આવી સરળતા માટે અનુકૂળ નથી.

ક્રોન માટે ઘણા આધુનિક વિકલ્પો છે: systemd-ટાઈમર તમને અવલંબન સાથે જટિલ સિસ્ટમો ગોઠવવા માટે પરવાનગી આપે છે, fcron તમને કાર્યો દ્વારા સંસાધન વપરાશને વધુ લવચીક રીતે નિયંત્રિત કરવાની મંજૂરી આપે છે. પરંતુ વ્યક્તિગત રીતે, સૌથી સરળ ક્રોન્ટાબ હંમેશા મારા માટે પૂરતું હતું.

ટૂંકમાં, યુનિક્સને પ્રેમ કરો, સરળ પ્રોગ્રામ્સનો ઉપયોગ કરો અને તમારા પ્લેટફોર્મ માટે મન વાંચવાનું ભૂલશો નહીં!

સોર્સ: www.habr.com