സന്തോഷകരമായ മണിക്കൂറുകൾ കാണില്ലെന്ന് ക്ലാസിക് എഴുതി. ആ വന്യമായ കാലത്ത് പ്രോഗ്രാമർമാരോ യുണിക്സോ ഉണ്ടായിരുന്നില്ല, എന്നാൽ ഇന്ന് പ്രോഗ്രാമർമാർക്ക് ഉറപ്പായും അറിയാം: ക്രോൺ അവർക്ക് പകരം സമയം ട്രാക്ക് ചെയ്യും.

കമാൻഡ് ലൈൻ യൂട്ടിലിറ്റികൾ എനിക്ക് ഒരു ബലഹീനതയും ജോലിയുമാണ്. sed, awk, wc, cut എന്നിവയും മറ്റ് പഴയ പ്രോഗ്രാമുകളും എല്ലാ ദിവസവും ഞങ്ങളുടെ സെർവറുകളിൽ സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നു. അവയിൽ പലതും ക്രോണിന് വേണ്ടി രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്, യഥാർത്ഥത്തിൽ 70-കളിൽ നിന്നുള്ള ഒരു ഷെഡ്യൂളർ.

വിശദാംശങ്ങളിലേക്ക് കടക്കാതെ വളരെക്കാലമായി ഞാൻ ക്രോൺ ഉപരിപ്ലവമായി ഉപയോഗിച്ചു, എന്നാൽ ഒരു ദിവസം, ഒരു സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഒരു പിശക് നേരിട്ടപ്പോൾ, അത് നന്നായി പരിശോധിക്കാൻ ഞാൻ തീരുമാനിച്ചു. ഈ ലേഖനം പ്രത്യക്ഷപ്പെട്ടത് ഇങ്ങനെയാണ്, ഇത് എഴുതുമ്പോൾ, ജനപ്രിയ ലിനക്സ് വിതരണങ്ങളിലെ പ്രധാന ക്രോൺ ഓപ്ഷനുകളായ പോസിക്സ് ക്രോണ്ടാബും അവയിൽ ചിലതിന്റെ ഘടനയും എനിക്ക് പരിചിതമായി.

നിങ്ങൾ Linux ഉപയോഗിക്കുകയും ക്രോൺ ടാസ്‌ക്കുകൾ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നുണ്ടോ? Unix-ലെ സിസ്റ്റം ആപ്ലിക്കേഷൻ ആർക്കിടെക്ചറിൽ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടോ? അപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ വഴിയിലാണ്!

ഉള്ളടക്കം

• ജീവിവർഗങ്ങളുടെ ഉത്ഭവം
• പോസിക്സ് ക്രോണ്ടാബ്
• ബെസ്റ്റ് സെല്ലർ - Vixie cron 3.0pl1
• ഡെബിയൻ, ഉബുണ്ടു എന്നിവയിൽ ക്രോൺ
• Red Hat, Fedora, CentOS എന്നിവയിൽ ക്രോണി
• SLES, openSUSE എന്നിവയിൽ ക്രോണി
• വിക്സി ക്രോൺ ഉപകരണം
• Afterword

ജീവിവർഗങ്ങളുടെ ഉത്ഭവം

എല്ലാ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും യൂസർ അല്ലെങ്കിൽ സിസ്റ്റം പ്രോഗ്രാമുകളുടെ ആനുകാലിക നിർവ്വഹണം ഒരു വ്യക്തമായ ആവശ്യകതയാണ്. അതിനാൽ, ടാസ്‌ക്കുകൾ കേന്ദ്രീകൃതമായി ആസൂത്രണം ചെയ്യാനും നടപ്പിലാക്കാനും അനുവദിക്കുന്ന സേവനങ്ങളുടെ ആവശ്യകത പ്രോഗ്രാമർമാർ വളരെക്കാലം മുമ്പ് തിരിച്ചറിഞ്ഞു.

യുണിക്‌സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ അവയുടെ ഉത്ഭവം വേർഷൻ 7 യുണിക്‌സിൽ നിന്ന് കണ്ടെത്തുന്നു, ഇത് കഴിഞ്ഞ നൂറ്റാണ്ടിന്റെ 70 കളിൽ ബെൽ ലാബിൽ വികസിപ്പിച്ചെടുത്തതാണ്, പ്രശസ്ത കെൻ തോംസൺ ഉൾപ്പെടെ. പതിപ്പ് 7 യുണിക്സിൽ ക്രോൺ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, പതിവായി സൂപ്പർ യൂസർ ടാസ്ക്കുകൾ പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു സേവനം.

ഒരു സാധാരണ മോഡേൺ ക്രോൺ ഒരു ലളിതമായ പ്രോഗ്രാമാണ്, എന്നാൽ യഥാർത്ഥ പതിപ്പിന്റെ പ്രവർത്തന അൽഗോരിതം ഇതിലും ലളിതമായിരുന്നു: സേവനം മിനിറ്റിൽ ഒരിക്കൽ ഉണർന്നു, ഒരൊറ്റ ഫയലിൽ നിന്ന് (/etc/lib/crontab) ടാസ്‌ക്കുകളുള്ള ഒരു ടേബിൾ വായിക്കുകയും ഇതിനായി നിർവ്വഹിക്കുകയും ചെയ്യുന്നു. നിലവിലെ നിമിഷത്തിൽ ചെയ്യേണ്ട ജോലികൾ സൂപ്പർ യൂസർ ചെയ്യുക.

തുടർന്ന്, ലളിതവും ഉപയോഗപ്രദവുമായ സേവനത്തിന്റെ മെച്ചപ്പെടുത്തിയ പതിപ്പുകൾ എല്ലാ യുണിക്‌സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും വിതരണം ചെയ്തു.

ക്രോണ്ടാബ് ഫോർമാറ്റിന്റെ സാമാന്യവൽക്കരിച്ച വിവരണങ്ങളും യൂട്ടിലിറ്റിയുടെ പ്രവർത്തനത്തിന്റെ അടിസ്ഥാന തത്വങ്ങളും 1992-ൽ യുണിക്സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ പ്രധാന സ്റ്റാൻഡേർഡായ POSIX-ൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, അങ്ങനെ ഒരു ഡി ഫാക്ടോ സ്റ്റാൻഡേർഡിൽ നിന്നുള്ള ക്രോൺ ഒരു ഡി ജൂർ സ്റ്റാൻഡേർഡായി മാറി.

1987-ൽ, പോൾ വിക്സി, Unix ഉപയോക്താക്കളുടെ ക്രോണിനോടുള്ള അവരുടെ ആഗ്രഹങ്ങളെക്കുറിച്ച് സർവേ നടത്തി, ഡെമണിന്റെ മറ്റൊരു പതിപ്പ് പുറത്തിറക്കി, അത് പരമ്പരാഗത ക്രോണിന്റെ ചില പ്രശ്നങ്ങൾ പരിഹരിക്കുകയും ടേബിൾ ഫയലുകളുടെ വാക്യഘടന വിപുലീകരിക്കുകയും ചെയ്തു.

Vixie ക്രോണിന്റെ മൂന്നാം പതിപ്പ് POSIX ആവശ്യകതകൾ നിറവേറ്റാൻ തുടങ്ങി, കൂടാതെ, പ്രോഗ്രാമിന് ഒരു ലിബറൽ ലൈസൻസ് ഉണ്ടായിരുന്നു, അല്ലെങ്കിൽ README ലെ ആഗ്രഹങ്ങൾ ഒഴികെ ഒരു ലൈസൻസും ഇല്ലായിരുന്നു: രചയിതാവ് ഗ്യാരണ്ടി നൽകുന്നില്ല, രചയിതാവിന്റെ പേര് ഇല്ലാതാക്കാൻ കഴിയില്ല, കൂടാതെ സോഴ്സ് കോഡിനൊപ്പം മാത്രമേ പ്രോഗ്രാം വിൽക്കാൻ കഴിയൂ. ഈ ആവശ്യകതകൾ ആ വർഷങ്ങളിൽ ജനപ്രീതി നേടിയ സ്വതന്ത്ര സോഫ്‌റ്റ്‌വെയറിന്റെ തത്വങ്ങളുമായി പൊരുത്തപ്പെടുന്നതായി മാറി, അതിനാൽ 90-കളുടെ തുടക്കത്തിൽ പ്രത്യക്ഷപ്പെട്ട ചില പ്രധാന ലിനക്‌സ് വിതരണങ്ങൾ വിക്‌സി ക്രോണിനെ തങ്ങളുടെ സിസ്റ്റം ഒന്നായി സ്വീകരിച്ചു, ഇന്നും അത് വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്നു.

പ്രത്യേകിച്ചും, Red Hat ഉം SUSE ഉം Vixie cron - cronie യുടെ ഒരു ഫോർക്ക് വികസിപ്പിച്ചെടുക്കുന്നു, കൂടാതെ Debian ഉം Ubuntu ഉം Vixie ക്രോണിന്റെ യഥാർത്ഥ പതിപ്പ് ധാരാളം പാച്ചുകളോടെ ഉപയോഗിക്കുന്നു.

നമുക്ക് ആദ്യം POSIX-ൽ വിവരിച്ചിരിക്കുന്ന ഉപയോക്തൃ യൂട്ടിലിറ്റി ക്രോണ്ടാബിനെ പരിചയപ്പെടാം, അതിനുശേഷം Vixie ക്രോണിൽ നൽകിയിരിക്കുന്ന സിന്റാക്സ് എക്സ്റ്റൻഷനുകളും ജനപ്രിയ ലിനക്സ് വിതരണങ്ങളിൽ Vixie ക്രോണിന്റെ വ്യതിയാനങ്ങളുടെ ഉപയോഗവും നോക്കാം. അവസാനമായി, കേക്കിലെ ചെറി ക്രോൺ ഡെമൺ ഉപകരണത്തിന്റെ വിശകലനമാണ്.

പോസിക്സ് ക്രോണ്ടാബ്

യഥാർത്ഥ ക്രോൺ എല്ലായ്പ്പോഴും സൂപ്പർഉപയോക്താവിനായി പ്രവർത്തിക്കുന്നുവെങ്കിൽ, ആധുനിക ഷെഡ്യൂളർമാർ പലപ്പോഴും സാധാരണ ഉപയോക്താക്കളുടെ ചുമതലകൾ കൈകാര്യം ചെയ്യുന്നു, അത് കൂടുതൽ സുരക്ഷിതവും സൗകര്യപ്രദവുമാണ്.

രണ്ട് പ്രോഗ്രാമുകളുടെ ഒരു കൂട്ടമായാണ് ക്രോണുകൾ വിതരണം ചെയ്യുന്നത്: നിരന്തരം പ്രവർത്തിക്കുന്ന ക്രോൺ ഡെമണും ഉപയോക്താക്കൾക്ക് ലഭ്യമായ ക്രോണ്ടാബ് യൂട്ടിലിറ്റിയും. സിസ്റ്റത്തിലെ ഓരോ ഉപയോക്താവിനും പ്രത്യേകമായി ടാസ്‌ക് ടേബിളുകൾ എഡിറ്റുചെയ്യാൻ രണ്ടാമത്തേത് നിങ്ങളെ അനുവദിക്കുന്നു, അതേസമയം ഡെമൺ ഉപയോക്താവിൽ നിന്നും സിസ്റ്റം ടേബിളുകളിൽ നിന്നും ടാസ്‌ക്കുകൾ സമാരംഭിക്കുന്നു.

В 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 ഫയലുകളാണ്, ഇത് യഥാക്രമം crontab-ലേക്ക് ആക്‌സസ് ഉള്ള ഉപയോക്താക്കളെയും പ്രോഗ്രാമിലേക്ക് ആക്‌സസ് ഇല്ലാത്ത ഉപയോക്താക്കളെയും ലിസ്റ്റ് ചെയ്യുന്നു. സ്റ്റാൻഡേർഡ് ഈ ഫയലുകളുടെ സ്ഥാനം ഒരു തരത്തിലും നിയന്ത്രിക്കുന്നില്ല.

സ്റ്റാൻഡേർഡ് അനുസരിച്ച്, ലോഞ്ച് ചെയ്ത പ്രോഗ്രാമുകളിലേക്ക് കുറഞ്ഞത് നാല് എൻവയോൺമെന്റ് വേരിയബിളുകളെങ്കിലും നൽകണം:

1. ഹോം - ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറി.
2. LOGNAME — ഉപയോക്തൃ ലോഗിൻ.
3. നിങ്ങൾക്ക് സ്റ്റാൻഡേർഡ് സിസ്റ്റം യൂട്ടിലിറ്റികൾ കണ്ടെത്താനാകുന്ന പാതയാണ് PATH.
4. ഷെൽ — ഉപയോഗിച്ച കമാൻഡ് ഇന്റർപ്രെറ്ററിലേക്കുള്ള പാത.

ഈ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ എവിടെ നിന്ന് വരുന്നു എന്നതിനെക്കുറിച്ച് POSIX ഒന്നും പറയുന്നില്ല എന്നത് ശ്രദ്ധേയമാണ്.

ബെസ്റ്റ് സെല്ലർ - Vixie cron 3.0pl1

3.0-ൽ comp.sources.unix മെയിലിംഗ് ലിസ്റ്റിൽ അവതരിപ്പിച്ച Vixie cron 1pl1992 ആണ് ജനപ്രിയ ക്രോൺ വേരിയന്റുകളുടെ പൊതു പൂർവ്വികൻ. ഈ പതിപ്പിന്റെ പ്രധാന സവിശേഷതകൾ ഞങ്ങൾ കൂടുതൽ വിശദമായി പരിഗണിക്കും.

വിക്സി ക്രോൺ രണ്ട് പ്രോഗ്രാമുകളിലാണ് വരുന്നത് (ക്രോൺ, ക്രോണ്ടാബ്). പതിവുപോലെ, സിസ്റ്റം ടാസ്‌ക് ടേബിളിൽ നിന്നും വ്യക്തിഗത ഉപയോക്തൃ ടാസ്‌ക് ടേബിളുകളിൽ നിന്നും ടാസ്‌ക്കുകൾ വായിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനും ഡെമൺ ഉത്തരവാദിയാണ്, കൂടാതെ ഉപയോക്തൃ പട്ടികകൾ എഡിറ്റുചെയ്യുന്നതിനുള്ള ഉത്തരവാദിത്തം ക്രോണ്ടാബ് യൂട്ടിലിറ്റിയാണ്.

ടാസ്‌ക് ടേബിളും കോൺഫിഗറേഷൻ ഫയലുകളും

സൂപ്പർ യൂസർ ടാസ്‌ക് ടേബിൾ /etc/crontab-ൽ സ്ഥിതി ചെയ്യുന്നു. സിസ്റ്റം ടേബിളിന്റെ വാക്യഘടന വിക്സി ക്രോണിന്റെ വാക്യഘടനയുമായി പൊരുത്തപ്പെടുന്നു, അതിലെ ആറാമത്തെ കോളം ആരുടെ പേരിൽ ടാസ്‌ക് സമാരംഭിച്ചിരിക്കുന്നുവോ ഉപയോക്താവിന്റെ പേര് സൂചിപ്പിക്കുന്നു എന്നതൊഴിച്ചാൽ:

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

സാധാരണ ഉപയോക്തൃ ടാസ്‌ക് ടേബിളുകൾ /var/cron/tabs/username-ൽ സ്ഥിതി ചെയ്യുന്നു, അതേ വാക്യഘടനയും ഉപയോഗിക്കുന്നു. നിങ്ങൾ ഒരു ഉപയോക്താവായി crontab യൂട്ടിലിറ്റി പ്രവർത്തിപ്പിക്കുമ്പോൾ, എഡിറ്റ് ചെയ്യപ്പെടുന്ന ഫയലുകൾ ഇവയാണ്.

crontab-ലേക്ക് ആക്‌സസ് ഉള്ള ഉപയോക്താക്കളുടെ ലിസ്റ്റുകൾ നിയന്ത്രിക്കുന്നത് /var/cron/allow, /var/cron/deny എന്നീ ഫയലുകളിൽ ആണ്, അവിടെ നിങ്ങൾ ഒരു പ്രത്യേക വരിയിൽ ഉപയോക്തൃ നാമം നൽകേണ്ടതുണ്ട്.

വിപുലീകരിച്ച വാക്യഘടന

പോസിക്സ് ക്രോണ്ടാബുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ, പോൾ വിക്സിയുടെ പരിഹാരത്തിൽ യൂട്ടിലിറ്റിയുടെ ടാസ്‌ക് ടേബിളുകളുടെ വാക്യഘടനയിൽ വളരെ ഉപയോഗപ്രദമായ നിരവധി പരിഷ്‌ക്കരണങ്ങൾ അടങ്ങിയിരിക്കുന്നു.

ഒരു പുതിയ പട്ടിക വാക്യഘടന ലഭ്യമാണ്: ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ആഴ്‌ചയിലെ ദിവസങ്ങളോ മാസങ്ങളോ പേര് പ്രകാരം വ്യക്തമാക്കാൻ കഴിയും (തിങ്കൾ, ചൊവ്വ, മുതലായവ):

# Запускается ежеминутно по понедельникам и вторникам в январе
* * * 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

ടാസ്ക് എക്സിക്യൂഷൻ പരിസ്ഥിതി

പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകളുടെ പരിസ്ഥിതി മാറ്റാൻ Vixie ക്രോൺ നിങ്ങളെ അനുവദിക്കുന്നു.

പരിസ്ഥിതി വേരിയബിളുകൾ USER, LOGNAME, HOME എന്നിവ കേവലം ഡെമൺ നൽകിയതല്ല, മറിച്ച് ഒരു ഫയലിൽ നിന്ന് എടുത്തതാണ് പാസ്സ്വേർഡ്. PATH വേരിയബിൾ "/usr/bin:/bin" ആയും SHELL വേരിയബിൾ "/bin/sh" ആയും സജ്ജീകരിച്ചിരിക്കുന്നു. LOGNAME ഒഴികെയുള്ള എല്ലാ വേരിയബിളുകളുടെയും മൂല്യങ്ങൾ ഉപയോക്തൃ പട്ടികകളിൽ മാറ്റാവുന്നതാണ്.

ചില എൻവയോൺമെന്റ് വേരിയബിളുകൾ (പ്രത്യേകിച്ച് ഷെൽ, ഹോം എന്നിവ) ടാസ്ക് പ്രവർത്തിപ്പിക്കുന്നതിന് ക്രോൺ തന്നെ ഉപയോഗിക്കുന്നു. ഇഷ്‌ടാനുസൃത ടാസ്‌ക്കുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് സ്റ്റാൻഡേർഡ് sh-ന് പകരം ബാഷ് ഉപയോഗിക്കുന്നത് എങ്ങനെയായിരിക്കാം:

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

ആത്യന്തികമായി, ടേബിളിൽ നിർവചിച്ചിരിക്കുന്ന എല്ലാ എൻവയോൺമെന്റ് വേരിയബിളുകളും (ക്രോൺ ഉപയോഗിക്കുന്നു അല്ലെങ്കിൽ പ്രോസസ്സിന് ആവശ്യമാണ്) റണ്ണിംഗ് ടാസ്ക്കിലേക്ക് കൈമാറും.

ഫയലുകൾ എഡിറ്റുചെയ്യുന്നതിന്, വിഷ്വൽ അല്ലെങ്കിൽ എഡിറ്റർ എൻവയോൺമെന്റ് വേരിയബിളിൽ വ്യക്തമാക്കിയ എഡിറ്റർ crontab ഉപയോഗിക്കുന്നു. ക്രോണ്ടാബ് പ്രവർത്തിപ്പിച്ച പരിതസ്ഥിതിയിൽ ഈ വേരിയബിളുകൾ നിർവചിച്ചിട്ടില്ലെങ്കിൽ, "/usr/ucb/vi" ഉപയോഗിക്കുന്നു (ucb ഒരുപക്ഷേ കാലിഫോർണിയ സർവകലാശാല, ബെർക്ക്‌ലി).

ഡെബിയൻ, ഉബുണ്ടു എന്നിവയിൽ ക്രോൺ

ഡെബിയൻ, ഡെറിവേറ്റീവ് ഡിസ്ട്രിബ്യൂഷനുകളുടെ ഡെവലപ്പർമാർ പുറത്തിറക്കി വളരെ പരിഷ്കരിച്ച പതിപ്പ് വിക്സി ക്രോൺ പതിപ്പ് 3.0pl1. ടേബിൾ ഫയലുകളുടെ വാക്യഘടനയിൽ വ്യത്യാസങ്ങളൊന്നുമില്ല; ഉപയോക്താക്കൾക്ക് ഇത് ഒരേ വിക്സി ക്രോൺ ആണ്. ഏറ്റവും വലിയ പുതിയ ഫീച്ചർ: പിന്തുണ സിസ്‌ലോഗ്, എസ്ഇലിനക്സ് и 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 എന്നിവയിലെ ക്രോണി

ക്രോണി — ഫോർക്ക് വിക്സി ക്രോൺ പതിപ്പ് 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. POSIX-കംപ്ലയന്റ് നോൺ-ഇന്ററാക്ടീവ് മോഡിൽ പ്രവർത്തിക്കുന്ന അതേ ബാഷ് ആണ് /bin/sh.

വിക്സി ക്രോൺ ഉപകരണം

വിക്സി ക്രോണുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ ക്രോണിന്റെ ആധുനിക പിൻഗാമികൾ സമൂലമായി മാറിയിട്ടില്ല, പക്ഷേ പ്രോഗ്രാമിന്റെ തത്വങ്ങൾ മനസിലാക്കാൻ ആവശ്യമില്ലാത്ത പുതിയ സവിശേഷതകൾ ഇപ്പോഴും നേടിയിട്ടുണ്ട്. ഈ വിപുലീകരണങ്ങളിൽ പലതും മോശമായി രൂപകൽപ്പന ചെയ്‌തതും കോഡിനെ ആശയക്കുഴപ്പത്തിലാക്കുന്നതുമാണ്. പോൾ വിക്സിയുടെ യഥാർത്ഥ ക്രോൺ സോഴ്സ് കോഡ് വായിക്കാൻ സന്തോഷമുണ്ട്.

അതിനാൽ, വികസനത്തിന്റെ രണ്ട് ശാഖകൾക്കും പൊതുവായുള്ള ഒരു ക്രോൺ പ്രോഗ്രാമിന്റെ ഉദാഹരണം ഉപയോഗിച്ച് ക്രോൺ ഉപകരണം വിശകലനം ചെയ്യാൻ ഞാൻ തീരുമാനിച്ചു - 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 Unix-ൽ നിന്നുള്ള യഥാർത്ഥ ക്രോൺ വളരെ ലളിതമായി പ്രവർത്തിച്ചു: ഇത് ഒരു ലൂപ്പിൽ കോൺഫിഗറേഷൻ വീണ്ടും വായിക്കുകയും നിലവിലെ മിനിറ്റിന്റെ ചുമതലകൾ ഒരു സൂപ്പർ യൂസറായി സമാരംഭിക്കുകയും അടുത്ത മിനിറ്റിന്റെ ആരംഭം വരെ ഉറങ്ങുകയും ചെയ്തു. പഴയ മെഷീനുകളിലെ ഈ ലളിതമായ സമീപനത്തിന് വളരെയധികം വിഭവങ്ങൾ ആവശ്യമായിരുന്നു.

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;
}

ക്രോൺ_സ്ലീപ്പ് ഫംഗ്‌ഷൻ ടാസ്‌ക്കുകൾ എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിൽ നേരിട്ട് ഉൾപ്പെട്ടിരിക്കുന്നു, job_runqueue (ടാസ്‌ക്കുകൾ എണ്ണി പ്രവർത്തിപ്പിക്കുക), 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;
}

അടിസ്ഥാനപരമായി ക്രോൺ അതാണ്. ഞാൻ ചില രസകരമായ വിശദാംശങ്ങൾ ഒഴിവാക്കി, ഉദാഹരണത്തിന്, വിദൂര ഉപയോക്താക്കൾക്കുള്ള അക്കൗണ്ടിംഗ്, പക്ഷേ ഞാൻ പ്രധാന കാര്യം രൂപരേഖ നൽകി.

Afterword

യുണിക്സ് ലോകത്തെ ഏറ്റവും മികച്ച പാരമ്പര്യങ്ങളിൽ നിർമ്മിച്ച, അതിശയകരമാംവിധം ലളിതവും ഉപയോഗപ്രദവുമായ പ്രോഗ്രാമാണ് ക്രോൺ. അവൾ അധികമായി ഒന്നും ചെയ്യുന്നില്ല, പക്ഷേ ഇപ്പോൾ നിരവധി പതിറ്റാണ്ടുകളായി അവൾ തന്റെ ജോലി അത്ഭുതകരമായി ചെയ്യുന്നു. ഉബുണ്ടുവിനൊപ്പം വരുന്ന പതിപ്പിനായുള്ള കോഡ് പരിശോധിക്കാൻ ഒരു മണിക്കൂറിൽ കൂടുതൽ എടുത്തില്ല, എനിക്ക് ഒരുപാട് സന്തോഷം തോന്നി! അത് നിങ്ങളുമായി പങ്കുവെക്കാൻ സാധിച്ചു എന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

എനിക്ക് നിങ്ങളെക്കുറിച്ച് അറിയില്ല, എന്നാൽ ആധുനിക പ്രോഗ്രാമിംഗ്, അതിസങ്കീർണ്ണവും അമിതമായ അമൂർത്തവും ഉള്ള പ്രവണത, വളരെക്കാലമായി അത്തരം ലാളിത്യത്തിന് അനുയോജ്യമല്ലെന്ന് മനസ്സിലാക്കുന്നതിൽ എനിക്ക് അൽപ്പം സങ്കടമുണ്ട്.

ക്രോണിന് നിരവധി ആധുനിക ഇതരമാർഗങ്ങളുണ്ട്: ഡിപൻഡൻസികൾ ഉപയോഗിച്ച് സങ്കീർണ്ണമായ സിസ്റ്റങ്ങൾ ഓർഗനൈസുചെയ്യാൻ systemd-ടൈമറുകൾ നിങ്ങളെ അനുവദിക്കുന്നു, ടാസ്‌ക്കുകൾ വഴി വിഭവ ഉപഭോഗം കൂടുതൽ വഴക്കത്തോടെ നിയന്ത്രിക്കാൻ fcron നിങ്ങളെ അനുവദിക്കുന്നു. എന്നാൽ വ്യക്തിപരമായി, ഏറ്റവും ലളിതമായ ക്രോണ്ടാബ് എനിക്ക് എപ്പോഴും മതിയായിരുന്നു.

ചുരുക്കത്തിൽ, Unix-നെ സ്നേഹിക്കുക, ലളിതമായ പ്രോഗ്രാമുകൾ ഉപയോഗിക്കുക, നിങ്ങളുടെ പ്ലാറ്റ്‌ഫോമിനായി മന വായിക്കാൻ മറക്കരുത്!

അവലംബം: www.habr.com