კლასიკა წერდა, რომ ბედნიერი საათები არ უყურებენ. იმ ველურ დროში არც პროგრამისტები არსებობდნენ და არც Unix, მაგრამ დღეს პროგრამისტებმა დანამდვილებით იციან: cron თვალყურს ადევნებს დროს მათ ნაცვლად.

Command ხაზის კომუნალური პროგრამები ჩემთვის სისუსტე და შრომაა. sed, awk, wc, cut და სხვა ძველი პროგრამები ყოველდღიურად იმართება სკრიპტებით ჩვენს სერვერებზე. ბევრი მათგანი შექმნილია როგორც ამოცანები cron-ისთვის, 70-იანი წლების განრიგისთვის.

დიდი ხნის განმავლობაში ვიყენებდი cron-ს ზედაპირულად, დეტალებში შესვლის გარეშე, მაგრამ ერთ დღეს, როდესაც სკრიპტის გაშვებისას შეცდომას წავაწყდი, გადავწყვიტე საფუძვლიანად შემესწავლა. ასე გამოჩნდა ეს სტატია, რომლის წერისას გავეცანი POSIX crontab-ს, Cron-ის მთავარ ვარიანტებს პოპულარული Linux დისტრიბუციებში და ზოგიერთი მათგანის სტრუქტურას.

იყენებთ Linux-ს და აწარმოებთ cron ამოცანებს? გაინტერესებთ სისტემის განაცხადის არქიტექტურა Unix-ში? მაშინ ჩვენ გზაში ვართ!

ინფორმაციის

• სახეობების წარმოშობა
• POSIX კრონტაბი
• ბესტსელერი - Vixie cron 3.0pl1
• cron Debian-ზე და Ubuntu-ზე
• cronie Red Hat-ზე, Fedora-სა და CentOS-ზე
• cronie SLES-ში და openSUSE-ში
• Vixie cron მოწყობილობა
• Afterword

სახეობების წარმოშობა

მომხმარებლის ან სისტემის პროგრამების პერიოდული შესრულება აშკარა აუცილებლობაა ყველა ოპერაციულ სისტემაში. ამიტომ, პროგრამისტებმა გააცნობიერეს სერვისების საჭიროება, რომელიც მათ საშუალებას აძლევს ცენტრალიზებულად დაგეგმონ და შეასრულონ ამოცანები დიდი ხნის წინ.

Unix-ის მსგავსი ოპერაციული სისტემები სათავეს იღებს Unix 7 ვერსიიდან, რომელიც შეიქმნა გასული საუკუნის 70-იან წლებში Bell Labs-ში, მათ შორის ცნობილი კენ ტომპსონის მიერ. Unix-ის მე-7 ვერსიაში ასევე შედის cron, სერვისი სუპერმომხმარებლის დავალებების რეგულარულად შესრულებისთვის.

ტიპიური თანამედროვე cron მარტივი პროგრამაა, მაგრამ ორიგინალური ვერსიის ოპერაციული ალგორითმი კიდევ უფრო მარტივი იყო: სერვისი იღვიძებდა წუთში ერთხელ, კითხულობდა ცხრილს ამოცანებით ერთი ფაილიდან (/etc/lib/crontab) და ასრულებდა სუპერმომხმარებელი ის დავალებები, რომლებიც უნდა შესრულებულიყო მიმდინარე მომენტში.

შემდგომში, მარტივი და სასარგებლო სერვისის გაუმჯობესებული ვერსიები მიეწოდება ყველა Unix-ის მსგავს ოპერაციულ სისტემას.

კრონტაბის ფორმატის განზოგადებული აღწერილობები და კომუნალური მუშაობის ძირითადი პრინციპები 1992 წელს შევიდა Unix-ის მსგავსი ოპერაციული სისტემების მთავარ სტანდარტში - POSIX და ამგვარად, კრონი დე ფაქტო სტანდარტიდან გახდა დე იურე სტანდარტი.

1987 წელს პოლ ვიქსიმ, რომელმაც გამოკითხა Unix-ის მომხმარებლები cron-ის სურვილების შესახებ, გამოუშვა დემონის კიდევ ერთი ვერსია, რომელმაც გამოასწორა ტრადიციული cron-ის ზოგიერთი პრობლემა და გააფართოვა ცხრილის ფაილების სინტაქსი.

Vixie-ს მესამე ვერსიით, კრონმა დაიწყო POSIX მოთხოვნების დაკმაყოფილება, გარდა ამისა, პროგრამას ჰქონდა ლიბერალური ლიცენზია, უფრო სწორად, საერთოდ არ იყო ლიცენზია, გარდა README-ში არსებული სურვილებისა: ავტორი არ იძლევა გარანტიებს, ავტორის სახელს. არ შეიძლება წაიშალოს და პროგრამის გაყიდვა შესაძლებელია მხოლოდ წყაროს კოდთან ერთად. ეს მოთხოვნები თავსებადი აღმოჩნდა თავისუფალი პროგრამული უზრუნველყოფის პრინციპებთან, რომელიც პოპულარობას იძენს იმ წლებში, ასე რომ, ზოგიერთი ძირითადი Linux დისტრიბუცია, რომელიც გამოჩნდა 90-იანი წლების დასაწყისში, მიიღო Vixie cron, როგორც მათი სისტემა და დღემდე ავითარებს მას.

კერძოდ, Red Hat და SUSE ავითარებენ Vixie cron-ის ჩანგლს - cronie, ხოლო Debian და Ubuntu იყენებენ Vixie cron-ის ორიგინალურ გამოცემას მრავალი პაჩებით.

ჯერ გავეცნოთ POSIX-ში აღწერილ მომხმარებლის უტილიტა crontab-ს, რის შემდეგაც გადავხედავთ Vixie cron-ში მოწოდებულ სინტაქსურ გაფართოებებს და Vixie cron-ის ვარიაციების გამოყენებას Linux-ის პოპულარულ დისტრიბუციებში. და ბოლოს, ალუბალი ტორტზე არის cron daemon მოწყობილობის ანალიზი.

POSIX კრონტაბი

თუ ორიგინალური cron ყოველთვის მუშაობდა სუპერმომხმარებლისთვის, თანამედროვე გრაფიკები ხშირად უმკლავდებიან ჩვეულებრივი მომხმარებლების ამოცანებს, რაც უფრო უსაფრთხო და მოსახერხებელია.

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. SHELL - გზა გამოყენებული ბრძანების თარჯიმნისკენ.

აღსანიშნავია, რომ POSIX არაფერს ამბობს იმის შესახებ, თუ საიდან მოდის ამ ცვლადების მნიშვნელობები.

ბესტსელერი - Vixie cron 3.0pl1

პოპულარული cron ვარიანტების საერთო წინაპარი არის Vixie cron 3.0pl1, რომელიც დაინერგა comp.sources.unix საფოსტო სიაში 1992 წელს. ჩვენ უფრო დეტალურად განვიხილავთ ამ ვერსიის ძირითად მახასიათებლებს.

Vixie cron გამოდის ორ პროგრამაში (cron და crontab). ჩვეულებისამებრ, დემონი პასუხისმგებელია ამოცანების წაკითხვაზე და გაშვებაზე სისტემის ამოცანების ცხრილიდან და ინდივიდუალური მომხმარებლის დავალების ცხრილებიდან, ხოლო crontab უტილიტა პასუხისმგებელია მომხმარებლის ცხრილების რედაქტირებაზე.

დავალების ცხრილი და კონფიგურაციის ფაილები

სუპერმომხმარებლის ამოცანების ცხრილი მდებარეობს /etc/crontab-ში. სისტემის ცხრილის სინტაქსი შეესაბამება Vixie cron-ის სინტაქსს, იმ გამონაკლისით, რომ მასში მეექვსე სვეტი მიუთითებს იმ მომხმარებლის სახელზე, რომლის სახელითაც დაიწყო დავალება:

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

ჩვეულებრივი მომხმარებლის დავალების ცხრილები განთავსებულია /var/cron/tabs/username-ში და იყენებს იგივე სინტაქსს. როდესაც იყენებთ crontab პროგრამას, როგორც მომხმარებელი, ეს არის ფაილები, რომლებიც რედაქტირებულია.

Crontab-ზე წვდომის მქონე მომხმარებლების სიები იმართება /var/cron/allow და /var/cron/deny ფაილებში, სადაც თქვენ უბრალოდ უნდა შეიყვანოთ მომხმარებლის სახელი ცალკე ხაზში.

გაფართოებული სინტაქსი

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 გარემოს ცვლადში მითითებულ რედაქტორს. თუ გარემოში, სადაც კრონტაბი იყო გაშვებული, არ აქვს ეს ცვლადები განსაზღვრული, მაშინ გამოიყენება "/usr/ucb/vi" (ucb არის ალბათ კალიფორნიის უნივერსიტეტი, ბერკლი).

cron Debian-ზე და Ubuntu-ზე

Debian-ის და წარმოებული დისტრიბუციის დეველოპერებმა გამოუშვეს ძალიან შეცვლილი ვერსია Vixie cron ვერსია 3.0pl1. ცხრილის ფაილების სინტაქსში განსხვავებები არ არის; მომხმარებლებისთვის ეს იგივე Vixie cronა. ყველაზე დიდი ახალი ფუნქცია: მხარდაჭერა syslog, SELinux и PAM.

ნაკლებად შესამჩნევი, მაგრამ ხელშესახები ცვლილებები მოიცავს კონფიგურაციის ფაილების მდებარეობას და ამოცანების ცხრილებს.

Debian-ში მომხმარებლის ცხრილები მდებარეობს /var/spool/cron/crontabs დირექტორიაში, სისტემის ცხრილი ისევ იქ არის - /etc/crontab-ში. Debian პაკეტის სპეციფიკური დავალების ცხრილები მოთავსებულია /etc/cron.d-ში, საიდანაც cron დემონი ავტომატურად კითხულობს მათ. მომხმარებლის წვდომის კონტროლი კონტროლდება /etc/cron.allow და /etc/cron.deny ფაილებით.

ნაგულისხმევი გარსი კვლავ არის /bin/sh, რომელიც Debian-ში არის პატარა POSIX-თან თავსებადი გარსი. dash, გაშვებულია რაიმე კონფიგურაციის წაკითხვის გარეშე (არაინტერაქტიულ რეჟიმში).

თავად Cron Debian-ის უახლეს ვერსიებში გაშვებულია systemd-ის საშუალებით, ხოლო გაშვების კონფიგურაცია შეგიძლიათ ნახოთ /lib/systemd/system/cron.service-ში. სერვისის კონფიგურაციაში განსაკუთრებული არაფერია; ნებისმიერი უფრო დახვეწილი დავალების მართვა შეიძლება განხორციელდეს გარემოს ცვლადების საშუალებით, რომლებიც პირდაპირ გამოცხადებულია თითოეული მომხმარებლის კრონტაბში.

cronie RedHat-ზე, Fedora-სა და CentOS-ზე

ქრონი — ჩანგალი Vixie cron ვერსია 4.1. როგორც Debian-ში, სინტაქსი არ შეცვლილა, მაგრამ დამატებულია PAM-ისა და SELinux-ის მხარდაჭერა, კლასტერში მუშაობა, ფაილების თვალყურის დევნება inotify-ის და სხვა ფუნქციების გამოყენებით.

ნაგულისხმევი კონფიგურაცია არის ჩვეულებრივ ადგილებში: სისტემის ცხრილი არის /etc/crontab-ში, პაკეტები ათავსებენ თავიანთ ცხრილებს /etc/cron.d-ში, მომხმარებლის ცხრილები გადადიან /var/spool/cron/crontabs-ში.

დემონი მუშაობს systemd კონტროლის ქვეშ, სერვისის კონფიგურაცია არის /lib/systemd/system/crond.service.

Red Hat-ის მსგავს დისტრიბუციებზე /bin/sh ნაგულისხმევად გამოიყენება გაშვებისას, რაც არის სტანდარტული bash. უნდა აღინიშნოს, რომ cron სამუშაოების გაშვებისას /bin/sh-ით, bash shell იწყება 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 კოდის წაკითხვა სასიამოვნოა.

ამიტომ, მე გადავწყვიტე გამეანალიზებინა cron მოწყობილობა cron პროგრამის მაგალითის გამოყენებით, რომელიც საერთოა განვითარების ორივე ფილიალისთვის - Vixie cron 3.0pl1. მე გავამარტივებ მაგალითებს ifdef-ების ამოღებით, რომლებიც ართულებს კითხვას და გამოტოვებს მცირე დეტალებს.

დემონის მუშაობა შეიძლება დაიყოს რამდენიმე ეტაპად:

1. პროგრამის ინიციალიზაცია.
2. შესასრულებელი ამოცანების სიის შეგროვება და განახლება.
3. მთავარი cron loop მუშაობს.
4. დაიწყე დავალება.

მოდით შევხედოთ მათ თანმიმდევრობით.

ინიციალიზაცია

დაწყებისას, პროცესის არგუმენტების შემოწმების შემდეგ, cron აყენებს SIGCHLD და SIGHUP სიგნალის დამმუშავებლებს. პირველი აკეთებს ჟურნალში ჩანაწერს ბავშვის პროცესის შეწყვეტის შესახებ, მეორე ხურავს log ფაილის ფაილის აღწერს:

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

cron daemon ყოველთვის მუშაობს მარტო სისტემაში, მხოლოდ სუპერმომხმარებლის სახით და მთავარი cron დირექტორიადან. შემდეგი ზარები ქმნის დაბლოკვის ფაილს დემონის პროცესის PID-ით, დარწმუნდით, რომ მომხმარებელი სწორია და შეცვალეთ მიმდინარე დირექტორია მთავარზე:

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

დაყენებულია ნაგულისხმევი გზა, რომელიც გამოყენებული იქნება პროცესების დაწყებისას:

setenv("PATH", _PATH_DEFPATH, 1);

შემდეგ პროცესი "დემონიზებულია": ის ქმნის პროცესის შვილობილ ასლს fork-ის გამოძახებით და ახალ სესიას ბავშვის პროცესში (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);

შემდეგ კრონი გადადის ძირითად სამუშაო ციკლზე. მანამდე კი, ღირს გადახედოთ ამოცანების სიის ჩატვირთვას.

ამოცანების სიის შეგროვება და განახლება

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

აქ ან გარემოს ცვლადი დაყენებულია (ფორმის VAR=მნიშვნელობის ხაზები) 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);

მთავარი მარყუჟი მუშაობს ამოცანების მიმდინარე სიასთან.

მთავარი მარყუჟი

ორიგინალური კრონი Unix 7 ვერსიიდან საკმაოდ მარტივად მუშაობდა: მან ხელახლა წაიკითხა კონფიგურაცია მარყუჟში, ამოქმედდა მიმდინარე წუთის ამოცანები, როგორც სუპერმომხმარებელი და ეძინა მომდევნო წუთის დაწყებამდე. ძველ მანქანებზე ეს მარტივი მიდგომა ძალიან ბევრ რესურსს მოითხოვდა.

ალტერნატიული ვერსია შესთავაზეს 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 ფუნქცია შესრულებულია კარგი Unix სტილში, ანუ აკეთებს ჩანგლს დავალების ასინქრონულად შესასრულებლად. მშობლის პროცესი აგრძელებს ამოცანების დაწყებას, ბავშვის პროცესი ამზადებს დავალების პროცესს:

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

ეს არის ძირითადად ყველაფერი cron არის. მე გამოვტოვე რამდენიმე საინტერესო დეტალი, მაგალითად, დისტანციური მომხმარებლების აღრიცხვა, მაგრამ მე გამოვკვეთე მთავარი.

Afterword

Cron არის საოცრად მარტივი და სასარგებლო პროგრამა, შექმნილი Unix-ის სამყაროს საუკეთესო ტრადიციებით. ის დამატებით არაფერს აკეთებს, მაგრამ უკვე რამდენიმე ათეული წელია საოცრად ასრულებს თავის საქმეს. Ubuntu-ს თანდართული ვერსიის კოდის მიღებას არაუმეტეს ერთი საათი დასჭირდა და მე ძალიან გავმხიარულდი! იმედია შევძელი გაგიზიაროთ.

მე არ ვიცი თქვენი, მაგრამ ცოტა სევდიანი ვარ იმის გაცნობიერებით, რომ თანამედროვე პროგრამირება, ზედმეტად გართულებისა და აბსტრაქტული ტენდენციით, დიდი ხანია არ უწყობს ხელს ასეთი სიმარტივისთვის.

cron-ის მრავალი თანამედროვე ალტერნატივა არსებობს: systemd-timers გაძლევთ საშუალებას მოაწყოთ რთული სისტემები დამოკიდებულებებით, fcron გაძლევთ საშუალებას უფრო მოქნილად დაარეგულიროთ რესურსების მოხმარება ამოცანების მიხედვით. მაგრამ პირადად ჩემთვის უმარტივესი კრონტაბი ყოველთვის საკმარისი იყო.

მოკლედ, გიყვართ Unix, გამოიყენეთ მარტივი პროგრამები და არ დაგავიწყდეთ წაიკითხოთ მანა თქვენი პლატფორმისთვის!

წყარო: www.habr.com