បុរាណ​សរសេរ​ថា​ម៉ោង​សប្បាយ​មិន​មើល។ នៅក្នុងសម័យកាលដ៏ព្រៃផ្សៃទាំងនោះ មិនមានអ្នកសរសេរកម្មវិធី ឬ Unix នោះទេ ប៉ុន្តែអ្នកសរសេរកម្មវិធីសព្វថ្ងៃនេះដឹងច្បាស់ថា៖ cron នឹងតាមដានពេលវេលាជំនួសឱ្យពួកគេ។

ឧបករណ៍ប្រើប្រាស់បន្ទាត់ពាក្យបញ្ជាគឺជាចំណុចខ្សោយ និងជាការងារសម្រាប់ខ្ញុំ។ sed, awk, wc, cut និងកម្មវិធីចាស់ៗផ្សេងទៀតត្រូវបានដំណើរការដោយ scripts នៅលើ servers របស់យើងជារៀងរាល់ថ្ងៃ។ ពួកគេជាច្រើនត្រូវបានរចនាឡើងជាភារកិច្ចសម្រាប់ cron ដែលជាកម្មវិធីកំណត់ពេលមានដើមកំណើតពីទសវត្សរ៍ទី 70 ។

អស់រយៈពេលជាយូរដែលខ្ញុំបានប្រើ cron លើផ្ទៃដោយមិនបានចូលទៅក្នុងព័ត៌មានលម្អិត ប៉ុន្តែថ្ងៃមួយ នៅពេលដែលខ្ញុំជួបប្រទះកំហុសនៅពេលដំណើរការស្គ្រីប ខ្ញុំបានសម្រេចចិត្តពិនិត្យមើលវាឱ្យបានហ្មត់ចត់។ នេះជារបៀបដែលអត្ថបទនេះបានបង្ហាញខ្លួន ខណៈពេលដែលកំពុងសរសេរវាខ្ញុំបានស្គាល់ POSIX crontab ដែលជាជម្រើស cron ដ៏សំខាន់នៅក្នុងការចែកចាយលីនុចដ៏ពេញនិយម និងរចនាសម្ព័ន្ធមួយចំនួននៃពួកគេ។

តើអ្នកកំពុងប្រើលីនុច និងដំណើរការកិច្ចការ cron មែនទេ? តើអ្នកចាប់អារម្មណ៍លើស្ថាបត្យកម្មកម្មវិធីប្រព័ន្ធនៅក្នុងយូនីកទេ? បន្ទាប់មកយើងកំពុងធ្វើដំណើរ!

មាតិកា

• ប្រភពដើមនៃប្រភេទសត្វ
• POSIX crontab
• លក់ដាច់បំផុត - Vixie cron 3.0pl1
• cron នៅលើ Debian និង Ubuntu
• cronie នៅលើ Red Hat, Fedora និង CentOS
• cronie នៅក្នុង SLES និង openSUSE
• ឧបករណ៍ Vixie cron
• Afterword

ប្រភពដើមនៃប្រភេទសត្វ

ការប្រតិបត្តិតាមកាលកំណត់នៃកម្មវិធីអ្នកប្រើប្រាស់ ឬប្រព័ន្ធគឺជាការចាំបាច់ជាក់ស្តែងនៅក្នុងប្រព័ន្ធប្រតិបត្តិការទាំងអស់។ ដូច្នេះហើយ អ្នកសរសេរកម្មវិធីបានដឹងពីតម្រូវការសម្រាប់សេវាកម្មដែលអនុញ្ញាតឱ្យពួកគេរៀបចំផែនការកណ្តាល និងប្រតិបត្តិការងារតាំងពីយូរយារណាស់មកហើយ។

ប្រព័ន្ធប្រតិបត្តិការដូច Unix តាមដានប្រភពដើមរបស់ពួកគេត្រឡប់ទៅកំណែ 7 Unix ដែលត្រូវបានបង្កើតឡើងក្នុងទសវត្សរ៍ទី 70 នៃសតវត្សទីចុងក្រោយនៅ Bell Labs រួមទាំងដោយ Ken Thompson ដ៏ល្បីល្បាញផងដែរ។ កំណែ 7 Unix ក៏រួមបញ្ចូលផងដែរនូវ cron ដែលជាសេវាកម្មសម្រាប់ដំណើរការជាប្រចាំនូវ superuser tasks ។

cron ទំនើបធម្មតាគឺជាកម្មវិធីដ៏សាមញ្ញមួយ ប៉ុន្តែក្បួនដោះស្រាយប្រតិបត្តិការនៃកំណែដើមគឺកាន់តែសាមញ្ញជាងមុន៖ សេវាកម្មភ្ញាក់ឡើងម្តងក្នុងមួយនាទី អានតារាងជាមួយនឹងកិច្ចការពីឯកសារតែមួយ (/etc/lib/crontab) និងដំណើរការសម្រាប់ superuser កិច្ចការទាំងនោះដែលគួរត្រូវបានអនុវត្តនៅពេលនេះ។

ក្រោយមក កំណែដែលបានកែលម្អនៃសេវាកម្មសាមញ្ញ និងមានប្រយោជន៍ត្រូវបានផ្គត់ផ្គង់ជាមួយប្រព័ន្ធប្រតិបត្តិការដូច Unix ទាំងអស់។

ការពិពណ៌នាទូទៅនៃទម្រង់ crontab និងគោលការណ៍ជាមូលដ្ឋាននៃប្រតិបត្តិការរបស់ឧបករណ៍ប្រើប្រាស់ត្រូវបានរួមបញ្ចូលនៅក្នុងស្តង់ដារសំខាន់នៃប្រព័ន្ធប្រតិបត្តិការដូច Unix - POSIX - ក្នុងឆ្នាំ 1992 ហើយដូច្នេះ cron ពីស្តង់ដារ de facto បានក្លាយជាស្តង់ដារ de jure ។

នៅឆ្នាំ 1987 លោក Paul Vixie ដោយបានស្ទង់មតិអ្នកប្រើប្រាស់ Unix អំពីបំណងប្រាថ្នារបស់ពួកគេសម្រាប់ cron បានចេញផ្សាយកំណែមួយផ្សេងទៀតនៃដេមិនដែលកែតម្រូវបញ្ហាមួយចំនួននៃ cron ប្រពៃណី និងពង្រីកវាក្យសម្ព័ន្ធនៃឯកសារតារាង។

ដោយកំណែទីបីនៃ Vixie cron បានចាប់ផ្តើមបំពេញតាមតម្រូវការ POSIX លើសពីនេះទៀតកម្មវិធីនេះមានអាជ្ញាប័ណ្ណសេរីឬផ្ទុយទៅវិញមិនមានអាជ្ញាប័ណ្ណអ្វីទាំងអស់លើកលែងតែបំណងប្រាថ្នានៅក្នុង README: អ្នកនិពន្ធមិនផ្តល់ការធានាទេឈ្មោះអ្នកនិពន្ធ មិនអាចលុបបានទេ ហើយកម្មវិធីអាចលក់បានតែជាមួយកូដប្រភពប៉ុណ្ណោះ។ តម្រូវការទាំងនេះបានប្រែទៅជាត្រូវគ្នាជាមួយនឹងគោលការណ៍នៃកម្មវិធីឥតគិតថ្លៃដែលកំពុងទទួលបានប្រជាប្រិយភាពនៅក្នុងឆ្នាំទាំងនោះ ដូច្នេះការចែកចាយលីនុចសំខាន់ៗមួយចំនួនដែលបានបង្ហាញខ្លួននៅដើមទសវត្សរ៍ទី 90 បានយក Vixie cron ជាប្រព័ន្ធរបស់ពួកគេ ហើយនៅតែកំពុងអភិវឌ្ឍវានៅថ្ងៃនេះ។

ជាពិសេស Red Hat និង SUSE បង្កើតសមនៃ Vixie cron - cronie ហើយ Debian និង Ubuntu ប្រើការបោះពុម្ពដើមរបស់ Vixie cron ជាមួយនឹងបំណះជាច្រើន។

ដំបូងយើងស្គាល់ឧបករណ៍ប្រើប្រាស់ crontab ដែលបានពិពណ៌នានៅក្នុង POSIX បន្ទាប់មកយើងនឹងពិនិត្យមើលផ្នែកបន្ថែមវាក្យសម្ព័ន្ធដែលមាននៅក្នុង Vixie cron និងការប្រើប្រាស់បំរែបំរួលនៃ Vixie cron ក្នុងការចែកចាយលីនុចដ៏ពេញនិយម។ ហើយទីបំផុត cherry នៅលើនំគឺជាការវិភាគនៃឧបករណ៍ cron daemon ។

POSIX crontab

ប្រសិនបើ cron ដើមតែងតែធ្វើការសម្រាប់ superuser អ្នកកំណត់ពេលទំនើបតែងតែដោះស្រាយជាមួយនឹងភារកិច្ចរបស់អ្នកប្រើធម្មតា ដែលមានសុវត្ថិភាព និងងាយស្រួលជាង។

Crons ត្រូវបានផ្គត់ផ្គង់ជាសំណុំនៃកម្មវិធីពីរ៖ cron daemon ដែលដំណើរការឥតឈប់ឈរ និងឧបករណ៍ប្រើប្រាស់ crontab ដែលមានសម្រាប់អ្នកប្រើប្រាស់។ ក្រោយមកទៀតអនុញ្ញាតឱ្យអ្នកកែសម្រួលតារាងភារកិច្ចជាក់លាក់ចំពោះអ្នកប្រើប្រាស់នីមួយៗនៅក្នុងប្រព័ន្ធ ខណៈពេលដែលដេមិនបើកដំណើរការភារកិច្ចពីតារាងអ្នកប្រើប្រាស់ និងប្រព័ន្ធ។

В ស្តង់ដារ POSIX ឥរិយាបថរបស់ដេមិនមិនត្រូវបានពិពណ៌នាតាមវិធីណាមួយឡើយ ហើយមានតែកម្មវិធីអ្នកប្រើប្រាស់ប៉ុណ្ណោះដែលត្រូវបានធ្វើជាផ្លូវការ crontab. អត្ថិភាពនៃយន្តការសម្រាប់ការចាប់ផ្តើមភារកិច្ចរបស់អ្នកប្រើគឺជាការពិតណាស់ បង្កប់ន័យ ប៉ុន្តែមិនត្រូវបានពិពណ៌នាលម្អិតទេ។

ដោយការហៅឧបករណ៍ប្រើប្រាស់ crontab អ្នកអាចធ្វើកិច្ចការបួនយ៉ាង៖ កែសម្រួលតារាងភារកិច្ចរបស់អ្នកប្រើក្នុងកម្មវិធីនិពន្ធ ផ្ទុកតារាងពីឯកសារ បង្ហាញតារាងកិច្ចការបច្ចុប្បន្ន និងជម្រះតារាងកិច្ចការ។ ឧទាហរណ៍នៃរបៀបដែលឧបករណ៍ប្រើប្រាស់ 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. HOME - ថតផ្ទះរបស់អ្នកប្រើ។
2. LOGNAME — ចូល​ដោយ​អ្នក​ប្រើ។
3. PATH គឺជាផ្លូវដែលអ្នកអាចស្វែងរកឧបករណ៍ប្រើប្រាស់ប្រព័ន្ធស្តង់ដារ។
4. សែល - ផ្លូវទៅកាន់អ្នកបកប្រែពាក្យបញ្ជាដែលបានប្រើ។

គួរកត់សម្គាល់ថា POSIX មិននិយាយអ្វីអំពីកន្លែងដែលតម្លៃសម្រាប់អថេរទាំងនេះមកពីណាទេ។

លក់ដាច់បំផុត - Vixie cron 3.0pl1

បុព្វបុរសទូទៅនៃវ៉ារ្យ៉ង់ cron ដ៏ពេញនិយមគឺ Vixie cron 3.0pl1 ដែលបានណែនាំនៅក្នុងបញ្ជីសំបុត្ររួម comp.sources.unix ក្នុងឆ្នាំ 1992 ។ យើងនឹងពិចារណាលក្ខណៈពិសេសចម្បងនៃកំណែនេះនៅក្នុងលម្អិតបន្ថែមទៀត។

Vixie cron មានពីរកម្មវិធី (cron និង crontab) ។ ដូចធម្មតា ដេមិនទទួលខុសត្រូវចំពោះការអាន និងដំណើរការកិច្ចការពីតារាងកិច្ចការប្រព័ន្ធ និងតារាងភារកិច្ចអ្នកប្រើប្រាស់នីមួយៗ ហើយឧបករណ៍ប្រើប្រាស់ crontab ទទួលខុសត្រូវក្នុងការកែសម្រួលតារាងអ្នកប្រើប្រាស់។

តារាងភារកិច្ច និងឯកសារកំណត់រចនាសម្ព័ន្ធ

តារាងភារកិច្ចរបស់ superuser មានទីតាំងនៅ /etc/crontab ។ វាក្យសម្ព័ន្ធនៃតារាងប្រព័ន្ធត្រូវគ្នានឹងវាក្យសម្ព័ន្ធរបស់ Vixie cron លើកលែងតែជួរទីប្រាំមួយនៅក្នុងវាបង្ហាញពីឈ្មោះរបស់អ្នកប្រើដែលជំនួសឱ្យកិច្ចការត្រូវបានចាប់ផ្តើម៖

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

តារាងភារកិច្ចអ្នកប្រើប្រាស់ធម្មតាមានទីតាំងនៅ /var/cron/tabs/username ហើយប្រើវាក្យសម្ព័ន្ធដូចគ្នា។ នៅពេលអ្នកដំណើរការឧបករណ៍ប្រើប្រាស់ crontab ជាអ្នកប្រើប្រាស់ ទាំងនេះគឺជាឯកសារដែលត្រូវបានកែសម្រួល។

បញ្ជីអ្នកប្រើប្រាស់ដែលមានសិទ្ធិចូលប្រើ crontab ត្រូវបានគ្រប់គ្រងក្នុង /var/cron/allow និង /var/cron/deny files ដែលអ្នកគ្រាន់តែបញ្ចូលឈ្មោះអ្នកប្រើប្រាស់ក្នុងបន្ទាត់ដាច់ដោយឡែកមួយ។

វាក្យសម្ព័ន្ធបន្ថែម

បើប្រៀបធៀបទៅនឹង POSIX crontab ដំណោះស្រាយរបស់ Paul Vixey មានការកែប្រែដ៏មានប្រយោជន៍ជាច្រើនចំពោះវាក្យសម្ព័ន្ធនៃតារាងកិច្ចការរបស់ឧបករណ៍ប្រើប្រាស់។

វាក្យសម្ព័ន្ធតារាងថ្មីបានក្លាយទៅជាមានហើយ៖ ឧទាហរណ៍ អ្នកអាចបញ្ជាក់ថ្ងៃនៃសប្តាហ៍ ឬខែតាមឈ្មោះ (ច័ន្ទ អង្គារ និងដូច្នេះនៅលើ):

# Запускается ежеминутно по понедельникам и вторникам в январе
* * * 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 cron អនុញ្ញាតឱ្យអ្នកផ្លាស់ប្តូរបរិយាកាសនៃកម្មវិធីដែលកំពុងដំណើរការ។

អថេរ​បរិស្ថាន USER, LOGNAME និង HOME មិន​ត្រូវ​បាន​ផ្តល់​ដោយ​ដេមិន​សាមញ្ញ​ទេ ប៉ុន្តែ​ត្រូវ​បាន​យក​ចេញ​ពី​ឯកសារ passwd. អថេរ PATH ត្រូវបានកំណត់ទៅ "/usr/bin:/bin" ហើយអថេរ SHELL ត្រូវបានកំណត់ទៅជា "/bin/sh"។ តម្លៃនៃអថេរទាំងអស់ លើកលែងតែ LOGNAME អាចត្រូវបានផ្លាស់ប្តូរនៅក្នុងតារាងអ្នកប្រើប្រាស់។

អថេរបរិស្ថានមួយចំនួន (ជាពិសេស SHELL និង HOME) ត្រូវបានប្រើដោយ cron ខ្លួនវាដើម្បីដំណើរការភារកិច្ច។ នេះជាអ្វីដែលការប្រើ bash ជំនួសឱ្យ sh ស្តង់ដារ ដើម្បីដំណើរការភារកិច្ចផ្ទាល់ខ្លួនអាចមើលទៅដូចនេះ៖

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

នៅទីបំផុត អថេរបរិស្ថានទាំងអស់ដែលបានកំណត់ក្នុងតារាង (ប្រើដោយ cron ឬត្រូវការដោយដំណើរការ) នឹងត្រូវបានបញ្ជូនទៅកិច្ចការដែលកំពុងដំណើរការ។

ដើម្បីកែសម្រួលឯកសារ crontab ប្រើកម្មវិធីនិពន្ធដែលបានបញ្ជាក់នៅក្នុងអថេរបរិស្ថាន VISUAL ឬ EDITOR ។ ប្រសិនបើបរិស្ថានដែល crontab ត្រូវបានដំណើរការមិនមានអថេរទាំងនេះដែលបានកំណត់នោះ "/usr/ucb/vi" ត្រូវបានប្រើ (ucb គឺប្រហែលជាសាកលវិទ្យាល័យកាលីហ្វ័រញ៉ា ប៊ឺកឡេ)។

cron នៅលើ Debian និង Ubuntu

អ្នកអភិវឌ្ឍន៍នៃ Debian និងការចែកចាយដេរីវេបានចេញផ្សាយ កំណែដែលបានកែប្រែខ្ពស់។ Vixie cron កំណែ 3.0pl1 ។ មិនមានភាពខុសគ្នានៅក្នុងវាក្យសម្ព័ន្ធនៃឯកសារតារាងទេ សម្រាប់អ្នកប្រើប្រាស់វាគឺជា Vixie cron ដូចគ្នា។ មុខងារថ្មីធំបំផុត៖ គាំទ្រ syslog, SELinux и របស់ PAM.

មិនសូវកត់សម្គាល់ ប៉ុន្តែការផ្លាស់ប្តូរជាក់ស្តែងរួមមានទីតាំងនៃឯកសារកំណត់រចនាសម្ព័ន្ធ និងតារាងកិច្ចការ។

តារាងអ្នកប្រើប្រាស់នៅក្នុង Debian មានទីតាំងនៅក្នុងថត /var/spool/cron/crontabs តារាងប្រព័ន្ធនៅតែមាន - ក្នុង /etc/crontab ។ តារាងភារកិច្ចជាក់លាក់នៃកញ្ចប់ដេបៀនត្រូវបានដាក់ក្នុង /etc/cron.d ពីកន្លែងដែលដេមិន cron អានពួកវាដោយស្វ័យប្រវត្តិ។ ការគ្រប់គ្រងការចូលប្រើរបស់អ្នកប្រើប្រាស់ត្រូវបានគ្រប់គ្រងដោយឯកសារ /etc/cron.allow និង /etc/cron.deny ។

សែលលំនាំដើមនៅតែជា /bin/sh ដែលនៅក្នុង Debian គឺជាសែលតូចមួយដែលអនុលោមតាម POSIX សញ្ញាបើកដំណើរការដោយមិនអានការកំណត់ណាមួយ (នៅក្នុងរបៀបមិនអន្តរកម្ម)។

Cron ខ្លួនវាផ្ទាល់នៅក្នុងកំណែចុងក្រោយបំផុតរបស់ Debian ត្រូវបានបើកដំណើរការតាមរយៈ systemd ហើយការកំណត់រចនាសម្ព័ន្ធការបើកដំណើរការអាចត្រូវបានមើលនៅក្នុង /lib/systemd/system/cron.service ។ មិនមានអ្វីពិសេសនៅក្នុងការកំណត់រចនាសម្ព័ន្ធសេវាកម្មនោះទេ ការគ្រប់គ្រងកិច្ចការដែលស្រាលជាងនេះអាចត្រូវបានធ្វើតាមរយៈអថេរបរិស្ថានដែលបានប្រកាសដោយផ្ទាល់នៅក្នុង crontab របស់អ្នកប្រើនីមួយៗ។

cronie នៅលើ RedHat, Fedora និង CentOS

កិរិយា - សមនៃ Vixie cron កំណែ 4.1 ។ ដូចនៅក្នុង Debian វាក្យសម្ព័ន្ធមិនបានផ្លាស់ប្តូរទេ ប៉ុន្តែការគាំទ្រសម្រាប់ PAM និង SELinux ដែលធ្វើការនៅក្នុងចង្កោម ការតាមដានឯកសារដោយប្រើ inotify និងមុខងារផ្សេងទៀតត្រូវបានបន្ថែម។

ការកំណត់រចនាសម្ព័ន្ធលំនាំដើមគឺនៅក្នុងកន្លែងធម្មតា៖ តារាងប្រព័ន្ធគឺនៅក្នុង /etc/crontab កញ្ចប់ដាក់តារាងរបស់ពួកគេនៅក្នុង /etc/cron.d តារាងអ្នកប្រើប្រាស់ចូលទៅ /var/spool/cron/crontabs ។

ដេមិនដំណើរការក្រោមការគ្រប់គ្រងដោយប្រព័ន្ធ ការកំណត់រចនាសម្ព័ន្ធសេវាកម្មគឺ /lib/systemd/system/crond.service ។

នៅលើការចែកចាយដូច Red Hat /bin/sh ត្រូវបានប្រើតាមលំនាំដើមនៅពេលចាប់ផ្តើម ដែលជាស្តង់ដារ bash ។ វាគួរតែត្រូវបានកត់សម្គាល់ថានៅពេលដំណើរការការងារ cron តាមរយៈ /bin/sh សែល bash ចាប់ផ្តើមនៅក្នុងរបៀបអនុលោមតាម POSIX និងមិនអានការកំណត់បន្ថែមណាមួយទេ ដំណើរការក្នុងរបៀបមិនអន្តរកម្ម។

cronie នៅក្នុង SLES និង openSUSE

ការចែកចាយរបស់អាឡឺម៉ង់ SLES និងដេរីវេរបស់វា OpenSUSE ប្រើ cronie ដូចគ្នា។ ដេមិននៅទីនេះក៏ត្រូវបានដាក់ឱ្យដំណើរការក្រោមប្រព័ន្ធ systemd ការកំណត់រចនាសម្ព័ន្ធសេវាកម្មមានទីតាំងនៅ /usr/lib/systemd/system/cron.service ។ ការកំណត់រចនាសម្ព័ន្ធ៖ /etc/crontab, /etc/cron.d, /var/spool/cron/tabs។ /bin/sh គឺជា bash ដូចគ្នាដែលដំណើរការនៅក្នុងរបៀបមិនអន្តរកម្មដែលអនុលោមតាម POSIX ។

ឧបករណ៍ Vixie cron

កូនចៅសម័យទំនើបនៃ cron មិនបានផ្លាស់ប្តូរយ៉ាងខ្លាំងបើប្រៀបធៀបទៅនឹង Vixie cron ប៉ុន្តែនៅតែទទួលបានលក្ខណៈពិសេសថ្មីដែលមិនតម្រូវឱ្យយល់ពីគោលការណ៍នៃកម្មវិធី។ ផ្នែកបន្ថែមទាំងនេះជាច្រើនត្រូវបានរចនាឡើងយ៉ាងលំបាក និងច្រឡំកូដ។ កូដប្រភព cron ដើមដោយ Paul Vixey គឺរីករាយក្នុងការអាន។

ដូច្នេះខ្ញុំបានសម្រេចចិត្តវិភាគឧបករណ៍ cron ដោយប្រើឧទាហរណ៍នៃកម្មវិធី cron ទូទៅសម្រាប់សាខាទាំងពីរនៃការអភិវឌ្ឍន៍ - Vixie cron 3.0pl1 ។ ខ្ញុំ​នឹង​សម្រួល​ឧទាហរណ៍​ដោយ​លុប ifdefs ដែល​ធ្វើ​ឱ្យ​ស្មុគស្មាញ​ដល់​ការ​អាន និង​លុប​ចោល​ព័ត៌មាន​លម្អិត​តូចតាច។

ការងាររបស់បិសាចអាចបែងចែកជាដំណាក់កាលជាច្រើន៖

1. ការចាប់ផ្តើមកម្មវិធី។
2. កំពុងប្រមូល និងធ្វើបច្ចុប្បន្នភាពបញ្ជីកិច្ចការដែលត្រូវដំណើរការ។
3. រង្វិលជុំ cron សំខាន់កំពុងដំណើរការ។
4. ចាប់ផ្តើមកិច្ចការមួយ។

តោះមើលពួកវាតាមលំដាប់លំដោយ។

ការចាប់ផ្តើម

នៅពេលចាប់ផ្តើម បន្ទាប់ពីពិនិត្យមើលអាគុយម៉ង់ដំណើរការ cron ដំឡើងឧបករណ៍ដោះស្រាយសញ្ញា SIGCHLD និង SIGHUP ។ ទីមួយបង្កើតកំណត់ហេតុអំពីការបញ្ចប់ដំណើរការកុមារ ទីពីរបិទកម្មវិធីពិពណ៌នាឯកសារនៃកំណត់ហេតុ៖

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

cron daemon តែងតែដំណើរការតែម្នាក់ឯងនៅលើប្រព័ន្ធ គ្រាន់តែជា superuser និងពី main cron directory ប៉ុណ្ណោះ។ ការហៅទូរសព្ទខាងក្រោមបង្កើតឯកសារចាក់សោជាមួយ PID នៃដំណើរការដេមិន សូមប្រាកដថាអ្នកប្រើប្រាស់ត្រឹមត្រូវ ហើយប្តូរថតបច្ចុប្បន្នទៅជាឯកសារសំខាន់៖

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

ផ្លូវលំនាំដើមត្រូវបានកំណត់ ដែលនឹងត្រូវបានប្រើនៅពេលចាប់ផ្តើមដំណើរការ៖

setenv("PATH", _PATH_DEFPATH, 1);

បន្ទាប់មកដំណើរការគឺ "daemonized"៖ វាបង្កើតច្បាប់ចម្លងកូននៃដំណើរការដោយការហៅ fork និងវគ្គថ្មីនៅក្នុងដំណើរការកុមារ (calling setsid)។ ដំណើរការមេលែងត្រូវការទៀតហើយ ហើយវាចេញ៖

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

បន្ទាប់មក cron បន្តទៅវដ្តការងារសំខាន់។ ប៉ុន្តែមុននោះវាមានតម្លៃមើលលើការផ្ទុកបញ្ជីភារកិច្ច។

ការប្រមូលនិងធ្វើបច្ចុប្បន្នភាពបញ្ជីភារកិច្ច

មុខងារ load_database ទទួលខុសត្រូវក្នុងការផ្ទុកបញ្ជីភារកិច្ច។ វាពិនិត្យប្រព័ន្ធមេ crontab និងថតឯកសារជាមួយឯកសារអ្នកប្រើប្រាស់។ ប្រសិនបើឯកសារ និងថតឯកសារមិនបានផ្លាស់ប្តូរទេ បញ្ជីកិច្ចការមិនត្រូវបានអានឡើងវិញទេ។ បើមិនដូច្នោះទេ បញ្ជីកិច្ចការថ្មីចាប់ផ្តើមបង្កើត។

កំពុងផ្ទុកឯកសារប្រព័ន្ធដែលមានឯកសារពិសេស និងឈ្មោះតារាង៖

/* если файл системной таблицы изменился, перечитываем */
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 ផ្ទៀងផ្ទាត់ថាអ្នកប្រើប្រាស់ដែលត្រូវគ្នានឹងឈ្មោះឯកសារតារាងមាន (លុះត្រាតែវាជា superuser) ហើយបន្ទាប់មកហៅ 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;
    }
}

នៅទីនេះ ទាំងអថេរបរិស្ថានត្រូវបានកំណត់ (បន្ទាត់នៃទម្រង់ VAR=value) ដោយប្រើមុខងារ load_env / env_set ឬការពិពណ៌នាការងារត្រូវបានអាន (* * * * * /path/to/exec) ដោយប្រើមុខងារ load_entry ។

ធាតុធាតុដែល load_entry ត្រឡប់គឺជាកិច្ចការរបស់យើង ដែលត្រូវបានដាក់ក្នុងបញ្ជីទូទៅនៃកិច្ចការ។ មុខងារខ្លួនវាអនុវត្តការញែកជាពាក្យសំដីនៃទម្រង់ពេលវេលា ប៉ុន្តែយើងចាប់អារម្មណ៍កាន់តែខ្លាំងលើការបង្កើតអថេរបរិស្ថាន និងប៉ារ៉ាម៉ែត្រចាប់ផ្តើមការងារ៖

/* пользователь и группа для запуска задачи берутся из 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);

រង្វិលជុំសំខាន់ដំណើរការជាមួយបញ្ជីកិច្ចការបច្ចុប្បន្ន។

រង្វិលជុំសំខាន់

cron ដើមពីកំណែ 7 Unix ដំណើរការយ៉ាងសាមញ្ញ៖ វាអានឡើងវិញនូវការកំណត់នៅក្នុងរង្វិលជុំ ចាប់ផ្តើមកិច្ចការនៃនាទីបច្ចុប្បន្នជា superuser ហើយគេងរហូតដល់ការចាប់ផ្តើមនៃនាទីបន្ទាប់។ វិធីសាស្រ្តសាមញ្ញនេះនៅលើម៉ាស៊ីនចាស់ៗទាមទារធនធានច្រើនពេក។

កំណែជំនួសត្រូវបានស្នើឡើងនៅក្នុង SysV ដែលដេមិនចូលគេងរហូតដល់នាទីជិតបំផុតដែលកិច្ចការត្រូវបានកំណត់ ឬរយៈពេល 30 នាទី។ ធនធានតិចជាងមុនត្រូវបានប្រើប្រាស់សម្រាប់ការអានឡើងវិញនូវការកំណត់រចនាសម្ព័ន្ធ និងត្រួតពិនិត្យកិច្ចការនៅក្នុងរបៀបនេះ ប៉ុន្តែការធ្វើបច្ចុប្បន្នភាពបញ្ជីកិច្ចការយ៉ាងឆាប់រហ័សបានក្លាយជាការរអាក់រអួល។

Vixie cron ត្រឡប់ទៅពិនិត្យបញ្ជីកិច្ចការម្តងក្នុងមួយនាទី ជាសំណាងល្អនៅចុងបញ្ចប់នៃទសវត្សរ៍ទី 80 មានធនធានច្រើនជាងមុននៅលើម៉ាស៊ីន Unix ស្តង់ដារ៖

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

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

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

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

មុខងារ cron_sleep ត្រូវបានចូលរួមដោយផ្ទាល់ក្នុងការប្រតិបត្តិភារកិច្ច ដោយហៅមុខងារ 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;
}

មានតក្កវិជ្ជាច្រើនណាស់នៅក្នុងដំណើរការ child_process៖ វាត្រូវការលទ្ធផលស្តង់ដារ និងស្ទ្រីមកំហុសមកលើខ្លួនវា ដើម្បីផ្ញើវាទៅសំបុត្រ (ប្រសិនបើអថេរបរិស្ថាន 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;
}

នោះជាមូលដ្ឋានទាំងអស់ cron គឺ។ ខ្ញុំបានលុបព័ត៌មានលម្អិតគួរឱ្យចាប់អារម្មណ៍មួយចំនួន ឧទាហរណ៍ គណនេយ្យសម្រាប់អ្នកប្រើប្រាស់ពីចម្ងាយ ប៉ុន្តែខ្ញុំបានរៀបរាប់អំពីរឿងសំខាន់។

Afterword

Cron គឺជាកម្មវិធីដ៏សាមញ្ញ និងមានប្រយោជន៍គួរឱ្យភ្ញាក់ផ្អើល ដែលធ្វើឡើងនៅក្នុងប្រពៃណីដ៏ល្អបំផុតនៃពិភពលោក Unix ។ នាង​មិន​បាន​ធ្វើ​អ្វី​បន្ថែម​ទេ ប៉ុន្តែ​នាង​បាន​ធ្វើ​ការងារ​របស់​នាង​យ៉ាង​អស្ចារ្យ​អស់​ជា​ច្រើន​ទសវត្សរ៍​មក​ហើយ។ ការទទួលបានលេខកូដសម្រាប់កំណែដែលភ្ជាប់មកជាមួយអ៊ូប៊ុនទូចំណាយពេលមិនលើសពីមួយម៉ោងទេ ហើយខ្ញុំរីករាយណាស់! ខ្ញុំសង្ឃឹមថាខ្ញុំអាចចែករំលែកវាជាមួយអ្នក។

ខ្ញុំមិនដឹងអំពីអ្នកទេ ប៉ុន្តែខ្ញុំមានការសោកស្ដាយបន្តិចដែលដឹងថាកម្មវិធីទំនើប ដោយមានទំនោរទៅរកភាពស្មុគ្រស្មាញហួសហេតុ និងអរូបី វាមិនអំណោយផលដល់ភាពសាមញ្ញបែបនេះអស់រយៈពេលជាយូរមកហើយ។

មានជម្រើសទំនើបៗជាច្រើនចំពោះ cron៖ systemd-timers អនុញ្ញាតឱ្យអ្នករៀបចំប្រព័ន្ធស្មុគ្រស្មាញជាមួយនឹងភាពអាស្រ័យ fcron អនុញ្ញាតឱ្យអ្នកគ្រប់គ្រងការប្រើប្រាស់ធនធានកាន់តែបត់បែនតាមភារកិច្ច។ ប៉ុន្តែ​ដោយ​ផ្ទាល់​ខ្លួន crontab សាមញ្ញ​បំផុត​គឺ​តែង​តែ​គ្រប់​គ្រាន់​សម្រាប់​ខ្ញុំ​។

និយាយឱ្យខ្លី ស្រឡាញ់ Unix ប្រើកម្មវិធីសាមញ្ញ ហើយកុំភ្លេចអានម៉ាណាសម្រាប់វេទិការបស់អ្នក!

ប្រភព: www.habr.com