De Klassiekers zeiden dat gelukkige mensen de tijd niet in de gaten houden. In die wilde tijden waren er nog geen programmeurs en geen Unix, maar tegenwoordig weten programmeurs zeker: in plaats van hen houdt cron de tijd in de gaten.
Commandoregelhulpmiddelen zijn voor mij tegelijkertijd een zwakte en een routine. sed, awk, wc, cut en andere oude programma's worden dagelijks via scripts op onze servers uitgevoerd. Veel van deze zijn ingericht als taken voor cron, de planner van de jaren '70.
Lang heb ik cron oppervlakkig gebruikt, zonder in de details te duiken, maar op een dag, toen ik een fout tegenkwam bij het uitvoeren van een script, besloot ik diepgaand onderzoek te doen. Zo ontstond dit artikel, waarin ik me verdiepte in de POSIX crontab, de belangrijkste versies van cron in populaire Linux-distributies en de werking van sommige ervan.
Gebruik je Linux en voer je taken uit in cron? Ben je geïnteresseerd in de architectuur van systeemapplicaties in Unix? Dan zijn we een goede match!
Inhoud
De oorsprong van soorten
Periodieke uitvoering van gebruikers- of systeemprogramma's is een duidelijke noodzaak in alle besturingssystemen. Daarom hebben programmeurs al lang de behoefte erkend aan diensten die het mogelijk maken om centraal taken te plannen en uit te voeren.
Unix-achtige besturingssystemen stammen af van Version 7 Unix, dat in de jaren '70 werd ontwikkeld in Bell Labs, onder andere door de beroemde Ken Thompson. Samen met Version 7 Unix werd ook cron geleverd, een dienst voor het regelmatig uitvoeren van taken door de superuser.
Een typische moderne cron is een eenvoudig programma, maar het algoritme van de originele versie was nog eenvoudiger: de dienst werd elke minuut wakker, las de taken uit een enkel bestand (\/etc\/lib\/crontab) en voerde de taken voor de superuser uit die op dat moment uitgevoerd moesten worden.
Vervolgens werden verbeterde versies van deze eenvoudige en nuttige dienst meegeleverd met alle Unix-achtige besturingssystemen.
De gegeneraliseerde beschrijvingen van het crontab-formaat en de basisprincipes van de werking van de utiliteit werden in 1992 opgenomen in de hoofdstandaard voor Unix-achtige besturingssystemen — POSIX — en zo werd cron de jure een standaard.
In 1987, Paul Vixie surveyed Unix users about their wishes for cron and released another version of the daemon, fixing some of the traditional cron issues and expanding the syntax of the table files.
By the third version, Vixie cron met the POSIX requirements, and the program featured a liberal license, or rather, there was no license at all, except for the wishes in the README: the author gives no guarantees, the author's name cannot be removed, and the program can only be sold with the source code. These requirements turned out to be compatible with the principles of free software, which was gaining popularity in those years. Therefore, some key early 90s Linux distributions adopted Vixie cron as their system standard and continue to develop it.
In particular, Red Hat and SUSE developed a fork of Vixie cron called cronie, while Debian and Ubuntu use the original edition of Vixie cron with many patches.
Let's start by introducing the user utility crontab as described in POSIX, after which we'll discuss the syntax extensions presented in Vixie cron and the use of Vixie cron variations in popular Linux distributions. And, finally, the cherry on top — an analysis of the cron daemon's structure.
POSIX crontab
While the original cron always operated for the superuser, modern schedulers more often deal with tasks of regular users, which is safer and more convenient.
Cron consists of a pair of programs: a constantly running cron daemon and a user-accessible utility called crontab. The latter allows editing task tables specific to each user in the system, while the daemon executes tasks from both user and system tables.
In does not describe the behavior of the daemon, and only formalizes the user program . The existence of mechanisms for launching user tasks is, of course, implied, but not described in detail.
The crontab utility allows you to do four things: edit the user's task table in an editor, load a table from a file, show the current task table, and clear the task table. Examples of crontab utility operations:
crontab -e # edit the task table
crontab -l # show the task table
crontab -r # delete the task table
crontab path/to/file.crontab # load the task table from a fileWhen calling crontab -e de editor die is opgegeven in de standaardomgeving variabele zal worden gebruikt EDITOR.
De taken zelf worden in het volgende formaat beschreven:
# строки-комментарии игнорируются
#
# задача, выполняемая ежеминутно
* * * * * /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.logDe eerste vijf velden van de records: minuten [1..60], uren [0..23], dagen van de maand [1..31], maanden [1..12], dagen van de week [0..6], waarbij 0 zondag is. Het laatste, zesde veld is een string die zal worden uitgevoerd door de standaardopdrachtinterpreter.
In de eerste vijf velden kunnen waarden door een komma worden gescheiden:
# задача, выполняемая в первую и десятую минуты каждого часа
1,10 * * * * /path/to/exec -a -b -cOf door een streepje:
# задача, выполняемая в каждую из первых десяти минут каждого часа
0-9 * * * * /path/to/exec -a -b -cToegang van gebruikers tot taakplanning wordt geregeld in de POSIX-bestanden cron.allow en cron.deny, waarin respectievelijk gebruikers met toegang tot crontab en gebruikers zonder toegang tot het programma worden vermeld. De locatie van deze bestanden wordt niet standaard gereguleerd.
De programma's die worden uitgevoerd, moeten volgens de standaard minstens vier omgevingsvariabelen ontvangen:
- HOME — de thuismap van de gebruiker.
- LOGNAME — de login van de gebruiker.
- PATH — het pad waarlangs de standaard systeemhulpmiddelen kunnen worden gevonden.
- SHELL — het pad naar de gebruikte opdrachtinterpreter.
Opmerkelijk is dat POSIX niets zegt over waar de waarden voor deze variabelen vandaan komen.
Bestverkocht — Vixie cron 3.0pl1
De voorouder van populaire cron-varianten is Vixie cron 3.0pl1, die werd geïntroduceerd in de nieuwsbrief comp.sources.unix in 1992. De belangrijkste mogelijkheden van deze versie zullen we nu verder bekijken.
Vixie cron wordt geleverd in twee programma's (cron en crontab). Zoals gebruikelijk is de daemon verantwoordelijk voor het lezen en uitvoeren van taken uit de systeemtabel en de taaktabellen van individuele gebruikers, terwijl de crontab-utiliteit verantwoordelijk is voor het bewerken van de gebruikers tabellen.
Taaktafel en configuratiebestanden
De taaktafel van de supergebruiker bevindt zich in /etc/crontab. De syntaxis van de systeemtabel komt overeen met de syntaxis van Vixie cron met de aanvulling dat in de zesde kolom de gebruikersnaam wordt vermeld waaronder de taak wordt uitgevoerd:
# Запускается ежеминутно от пользователя vlad
* * * * * vlad /path/to/execDe taaktabellen van gewone gebruikers bevinden zich in /var/cron/tabs/gebruikersnaam en gebruiken de algemene syntaxis. Bij het starten van de crontab-utiliteit vanuit de gebruikersnaam worden precies deze bestanden bewerkt.
Het beheer van lijsten van gebruikers met toegang tot crontab vindt plaats in de bestanden /var/cron/allow en /var/cron/deny, waar eenvoudigweg de gebruikersnaam in een aparte regel kan worden toegevoegd.
Uitgebreide syntaxis
In vergelijking met POSIX crontab bevat de oplossing van Paul Vixie verschillende uiterst nuttige wijzigingen in de syntaxis van de taaktabellen van de utiliteit.
Er is een nieuwe syntaxis voor tabellen beschikbaar: bijvoorbeeld, je kunt de dagen van de week of maanden met naam opgeven (ma, di, enzovoort):
# Запускается ежеминутно по понедельникам и вторникам в январе
* * * Jan Mon,Tue /path/to/execJe kunt de stap opgeven waarmee taken worden uitgevoerd:
# Запускается с шагом в две минуты
*/2 * * * Mon,Tue /path/to/execStappen en intervallen kunnen worden gemengd:
# Запускается с шагом в две минуты в первых десять минут каждого часа
0-10/2 * * * * /path/to/execIntuïtieve alternatieven voor de gebruikelijke syntaxis worden ondersteund (herstarten, jaarlijks, jaarlijks, maandelijks, wekelijks, dagelijks, middernacht, elk uur):
# Запускается после перезагрузки системы
@reboot /exec/on/reboot
# Запускается раз в день
@daily /exec/daily
# Запускается раз в час
@hourly /exec/dailyUitvoeringsomgeving van taken
Vixie cron maakt het mogelijk om de omgeving van de uitvoerende toepassingen te wijzigen.
De omgevingsvariabelen USER, LOGNAME en HOME worden niet alleen door de daemon geleverd, maar komen uit het bestand . De variabele PATH krijgt de waarde "/usr/bin:/bin" en SHELL krijgt "/bin/sh". De waarden van alle variabelen, behalve LOGNAME, kunnen worden gewijzigd in de gebruikerslijsten.
Sommige omgevingsvariabelen (vooral SHELL en HOME) worden door cron zelf gebruikt om een taak uit te voeren. Dit is hoe het gebruik van bash in plaats van de standaard sh voor het uitvoeren van gebruikers.tasks eruit kan zien:
SHELL=/bin/bash
HOME=/tmp/
# exec wordt uitgevoerd door bash in /tmp/
* * * * * /path/to/execUiteindelijk zullen alle in de tabel gedefinieerde omgevingsvariabelen (gebruikt door cron of vereist door het proces) worden doorgegeven aan de uitvoerende taak.
Voor het bewerken van bestanden met de crontab-tool wordt de editor gebruikt die is opgegeven in de omgevingsvariabele VISUAL of EDITOR. Als deze variabelen niet zijn gedefinieerd in de omgeving waar crontab is gestart, wordt "/usr/ucb/vi" gebruikt (ucb staat waarschijnlijk voor University of California, Berkeley).
cron in Debian en Ubuntu
Ontwikkelaars van Debian en afgeleide distributies hebben een van Vixie cron 3.0pl1. Er zijn geen verschillen in de syntaxis van de tabelfiles, voor gebruikers is het dezelfde Vixie cron. De belangrijkste nieuwe mogelijkheden: ondersteuning voor , en .
Van de minder opvallende, maar voelbare veranderingen — de locatie van configuratiebestanden en taaktabellen.
Gebruikerstabellen in Debian bevinden zich in de directory /var/spool/cron/crontabs, de systeemtabel bevindt zich nog steeds in /etc/crontab. Pakketspecifieke taaktabellen van Debian worden geplaatst in /etc/cron.d, van waar de cron-daemon ze automatisch leest. Toegangbeheer voor gebruikers wordt geregeld via de bestanden /etc/cron.allow en /etc/cron.deny.
Als standaardcommand shell wordt nog steeds /bin/sh gebruikt, waarvan de rol in Debian wordt vervuld door een kleine POSIX-compatibele shell , die wordt uitgevoerd zonder enige configuratie te lezen (in niet-interactieve modus).
De cron in de nieuwste versies van Debian wordt gestart via systemd, en de opstartconfiguratie is te vinden in /lib/systemd/system/cron.service. Er is niets bijzonders aan de serviceconfiguratie; een meer verfijnde taakbeheer kan worden uitgevoerd via omgevingsvariabelen die direct in de crontab van elke gebruiker zijn gedeclareerd.
cronie in RedHat, Fedora en CentOS
— een fork van Vixie cron versie 4.1. Net als in Debian is de syntaxis niet veranderd, maar is er ondersteuning voor PAM en SELinux toegevoegd, alsook de mogelijkheid om in een cluster te werken, bestanden te volgen met inotify en andere functies.
De standaardconfiguratie bevindt zich op de gebruikelijke plaatsen: de systeemtabel in /etc/crontab, pakketten plaatsen hun tabellen in /etc/cron.d, en gebruikers tabellen belanden in /var/spool/cron/crontabs.
De daemon wordt gestart onder beheer van systemd, de serviceconfiguratie is /lib/systemd/system/crond.service.
In Red Hat-achtige distributies wordt bij de standaardopstart /bin/sh gebruikt, waarbij de standaard bash fungeert. Opmerkelijk is dat bij het starten van cron-taken via /bin/sh de bash-shell in POSIX-compatibele modus wordt gestart en geen aanvullende configuratie leest, waardoor deze in niet-interactieve modus werkt.
cronie in SLES en openSUSE
De Duitse distributie SLES en zijn afgeleide openSUSE gebruiken dezelfde cronie. De daemon wordt hier ook gestart onder systemd, de serviceconfiguratie is te vinden in /usr/lib/systemd/system/cron.service. De configuratie: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. Als /bin/sh functioneert dezelfde bash, uitgevoerd in een POSIX-compatibele niet-interactieve modus.
De werking van Vixie cron
Moderne afstammelingen van cron zijn in vergelijking met Vixie cron niet drastisch veranderd, maar hebben wel nieuwe mogelijkheden verworven die niet noodzakelijk zijn voor het begrijpen van de werking van het programma. Veel van deze extensies zijn slordig vormgegeven en verwarren de code. De originele broncode van cron, uitgevoerd door Paul Vixie, is een waar genot om te lezen.
Om deze reden heb ik besloten de werking van cron te analyseren aan de hand van de versie die voor beide takken van de cron-ontwikkeling gemeenschappelijk is — Vixie cron 3.0pl1. Ik zal de voorbeelden vereenvoudigen door verwarrende ifdef's weg te laten en secundaire details te verduidelijken.
Het werk van de daemon kan in verschillende fasen worden verdeeld:
- Initialisatie van het programma.
- Verzamelen en bijwerken van de lijst met taken om uit te voeren.
- Uitvoering van de hoofdloop van cron.
- Taak starten.
Laten we ze in volgorde bekijken.
Initialisatie
Bij het starten, na het controleren van de argumenten, stelt het cron-proces signal handlers in voor SIGCHLD en SIGHUP. De eerste logt het beëindigen van het kindproces, de tweede sluit de bestandsdescriptor van het logbestand.
signal(SIGCHLD, sigchld_handler);
signal(SIGHUP, sighup_handler);De cron-daemon draait altijd als een enkele instantie met superuser-rechten vanuit de hoofdmap van cron. De volgende aanroepen creëren een lockbestand met de PID van het daemonproces, controleren of de gebruiker correct is en veranderen de huidige map naar de hoofdmap:
acquire_daemonlock(0);
set_cron_uid();
set_cron_cwd();Er wordt een standaardpad ingesteld dat gebruikt zal worden bij het starten van processen:
setenv("PATH", _PATH_DEFPATH, 1);Daarna wordt het proces 'gedemoniseerd': het maakt een dochterkopie van het proces met een fork-aanroep en een nieuwe sessie in het dochterproces (door setsid aan te roepen). In het ouderproces is er geen verdere noodzaak — en dit stopt:
switch (fork()) {
case -1:
\/\* kritieke fout en beëindigen *\/\
exit(0);
break;
case 0:
\/\* dochterproces *\/\
(void) setsid();
break;
default:
\/\* ouderproces eindigt *\/\
_exit(0);
}
Het beëindigen van het ouderproces vrijgeeft de lock in het lockbestand. Bovendien moet de PID in het bestand worden bijgewerkt naar die van het kindproces. Hierna wordt de takenbasis gevuld:
/* повторный захват лока */
acquire_daemonlock(0);
/* Заполнение БД */
database.head = NULL;
database.tail = NULL;
database.mtime = (time_t) 0;
load_database(&database);Daarna gaat cron naar de hoofdwerkcyclus. Maar voordat dat gebeurt, is het goed om te kijken naar de laadlijst van taken.
Verzamelen en bijwerken van de takenlijst
De functie load_database is verantwoordelijk voor het laden van de takenlijst. Deze controleert de hoofd systeem crontab en de map met gebruikersbestanden. Als de bestanden en de map niet zijn veranderd, wordt de takenlijst niet opnieuw gelezen. In het andere geval begint er een nieuwe takenlijst te vormen.
Laden van het systeembestand met speciale bestandsnamen en tabellen:
/* если файл системной таблицы изменился, перечитываем */
if (syscron_stat.st_mtime) {
process_crontab("root", "*system*",
SYSCRONTAB, &syscron_stat,
&new_db, old_db);
}Laden van gebruikers-tabellen in een lus:
while (NULL != (dp = readdir(dir))) {
char fname[MAXNAMLEN+1],
tabname[MAXNAMLEN+1];
\/\* lees geen bestanden met een punt *\/\
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);
}
Daarna wordt de oude database vervangen door de nieuwe.
In de bovenstaande voorbeelden controleert de aanroep van de functie process_crontab of de gebruiker bestaat die verband houdt met de naam van het tabelbestand (tenzij het een superuser is), waarna load_user wordt aangeroepen. Laatstgenoemde leest het bestand regel voor regel.
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;
}
}Hier wordt ofwel een omgevingsvariabele ingesteld (strings van het type VAR=value) door de functies load_env / env_set, of een taakbeschrijving gelezen (* * * * * /path/to/exec) door de functie load_entry.
Entiteit entry, die door load_entry wordt geretourneerd, is onze taak die in de globale takenlijst wordt geplaatst. In de functie wordt het tijdsformaat uitgebreid geparsed; wij zijn echter meer geïnteresseerd in het vormen van omgevingsvariabelen en de opstartparameters van de taak:
/* пользователь и группа для запуска задачи берутся из 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);De hoofdcyclus werkt met de actuele lijst van taken.
Hoofdlus
De oorspronkelijke cron uit Version 7 Unix werkte heel eenvoudig: in een cyclus werd de configuratie opnieuw ingelezen, werden de taken van de huidige minuut uitgevoerd als superuser en sliep het tot het begin van de volgende minuut. Deze eenvoudige aanpak vereiste te veel middelen op oude machines.
In SysV werd een alternatieve versie voorgesteld, waarin de daemon sliep tot de dichtstbijzijnde minuut waarvoor een taak was gedefinieerd, of tot 30 minuten. Deze modus verbruikte minder middelen voor het opnieuw inlezen van de configuratie en het controleren van taken, maar het werd onhandig om de takenlijst snel bij te werken.
Vixie cron keerde terug naar het controleren van takenlijsten elke minuut, gelukkig was er tegen het einde van de jaren '80 veel meer middelen beschikbaar op standaard Unix-machines:
/* первичная загрузка задач */
load_database(&database);
/* запустить задачи, поставленные к выполнению после перезагрузки системы */
run_reboot_jobs(&database);
/* сделать TargetTime началом ближайшей минуты */
cron_sync();
while (TRUE) {
/* выполнить задачи, после чего спать до TargetTime с поправкой на время, потраченное на задачи */
cron_sleep();
/* перечитать конфигурацию */
load_database(&database);
/* собрать задачи для данной минуты */
cron_tick(&database);
/* перевести TargetTime на начало следующей минуты */
TargetTime += 60;
}
De functie cron_sleep is verantwoordelijk voor het daadwerkelijk uitvoeren van de taken. Deze roept de functies job_runqueue (doorlopen en starten van taken) en do_command (het starten van elke afzonderlijke taak) aan. De laatste functie verdient meer uitleg.
Taak starten
De functie do_command is goed uitgevoerd in Unix-stijl; voor asynchrone uitvoering van een taak maakt deze een fork. Het hoofdproces gaat door met het starten van taken, terwijl het kindproces de voorbereiding van het taakproces afhandelt:
switch (fork()) {
case -1:
/* kon geen fork uitvoeren */
break;
case 0:
/* kindproces: opnieuw proberen het hoofdslot te verwerven */
acquire_daemonlock(1);
/* ga verder met het vormen van het taakproces */
child_process(e, u);
/* na afloop beëindigt het kindproces zijn werk */
_exit(OK_EXIT);
break;
default:
/* hoofdproces gaat verder */
break;
}In child_process zit behoorlijk wat logica: het ontvangt standaard uit- en foutstromen om deze vervolgens naar e-mail te verzenden (indien in de takenlijst de omgevingsvariabele MAILTO is opgegeven), en tenslotte wacht het op de voltooiing van het hoofdprocestaken.
Het procestaken wordt gevormd door nog een fork:
switch (vfork()) {
case -1:
/* bij een fout wordt de uitvoering onmiddellijk beëindigd */
exit(ERROR_EXIT);
case 0:
/* het kleinkindproces vormt een nieuwe sessie, terminal, enz.
*/
(void) setsid();
/*
* hierna volgt een uitgebreide configuratie van de uitvoer van het proces, we laten deze voor de kortheid weg
*/
/* wijzig de directory, gebruiker en groep van de gebruiker,
* oftewel het proces is niet langer supergebruiker
*/
setgid(e->gid);
setuid(e->uid);
chdir(env_get("HOME", e->envp));
/* start het eigenlijke commando
*/
{
/* de omgevingsvariabele SHELL geeft de interpreter aan voor de uitvoering */
char *shell = env_get("SHELL", e->envp);
/* het proces wordt gestart zonder de omgevingsvariabelen van het bovenliggende proces door te geven,
* oftewel precies zoals beschreven in de takenlijst van de gebruiker */
execle(shell, shell, "-c", e->cmd, (char *)0, e->envp);
/* fout — en het proces is niet gestart? beëindiging van de uitvoering */
perror("execl");
_exit(ERROR_EXIT);
}
break;
default:
/* het proces blijft draaien: wacht op voltooiing en uitvoer */
break;
}Dat is eigenlijk de hele cron. Ik heb enkele interessante details weggelaten, zoals het rekening houden met externe gebruikers, maar de hoofdpunten heb ik behandeld.
Naschrift
Cron is een verrassend eenvoudig en nuttig programma, uitgevoerd in de beste tradities van de Unix-wereld. Het doet niets overbodigs, maar voert zijn werk al tientallen jaren voortreffelijk uit. Het bestuderen van de code van de versie die met Ubuntu wordt geleverd, nam niet meer dan een uur in beslag, en ik heb er veel plezier van gehad! Ik hoop dat ik dat met jullie heb kunnen delen.
Ik weet niet hoe het met jullie zit, maar het maakt me een beetje treurig om te beseffen dat moderne programmeren, met zijn neiging tot overcomplicatie en overabstractie, al lang geen plaats meer biedt voor deze eenvoud.
Er zijn tal van moderne alternatieven voor cron: systemd-timers stellen je in staat om complexe systemen met afhankelijkheden te organiseren, in fcron kun je flexibeler het resourcegebruik van taken regelen. Maar persoonlijk heb ik altijd genoeg gehad aan de eenvoudigste crontab.
Kortom, hou van Unix, gebruik eenvoudige programma's en vergeet niet de manpages voor jouw platform te lezen!
Bron: habr.com
