Die klassieke het geskryf dat gelukkige ure nie waargeneem word nie. In daardie wilde tye was daar nog geen programmeerders of Unix nie, maar deesdae weet programmeerders vir seker: in plaas daarvan sal cron die tyd dophou.
Command line nutsprogramme is beide swakheid en roetine vir my. sed, awk, wc, cut en ander ou programme word daagliks deur skrifte op ons bedieners bestuur. Baie van hulle is ontwerp as take vir cron, 'n skeduleerder uit die 70's.
Ek het cron lank oppervlakkig gebruik, sonder om in die besonderhede te delf, maar op 'n dag, toe ek 'n fout in die gesig gestaar het met die uitvoer van die draaiboek, het ek besluit om dit deeglik te ondersoek. Dit is hoe hierdie artikel ontstaan het, waartydens ek kennis gemaak het met die POSIX crontab, die belangrikste cron-opsies in gewilde Linux-verspreidings, en die ontwerp van sommige daarvan.
Gebruik jy Linux en hardloop take in cron? Stel u belang in die argitektuur van stelseltoepassings in Unix? Dan is ons op pad!
inhoud
Oorsprong van spesies
Periodieke uitvoering van gebruikers- of stelselprogramme is 'n ooglopende noodsaaklikheid in alle bedryfstelsels. Daarom het programmeerders die behoefte aan dienste erken wat gesentraliseerde beplanning en uitvoering van take vir 'n baie lang tyd moontlik maak.
Unix-agtige bedryfstelsels spoor hul afkoms terug na weergawe 7 Unix, ontwikkel in die 70's van die vorige eeu by Bell Labs, insluitend die bekende Ken Thompson. Weergawe 7 Unix word ook saam met cron gestuur, 'n diens om supergebruikertake gereeld uit te voer.
'n Tipiese moderne cron is 'n eenvoudige program, maar die algoritme van die oorspronklike weergawe was selfs eenvoudiger: die diens het een keer per minuut wakker geword, 'n tabel met take van 'n enkele lêer (/etc/lib/crontab) gelees en vir die supergebruiker uitgevoer daardie take wat in die huidige minuut voltooi moes gewees het.
Daarna is verbeterde weergawes van die eenvoudige en nuttige diens saam met alle Unix-agtige bedryfstelsels gestuur.
Algemene beskrywings van die crontab-formaat en die basiese beginsels van die nut in 1992 is ingesluit in die hoofstandaard vir Unix-agtige bedryfstelsels - POSIX - en dus het cron van die de facto standaard die de jure standaard geword.
In 1987 het Paul Vixie, nadat hy Unix-gebruikers gepols het oor cron-wense, 'n ander weergawe van die daemon vrygestel wat sommige van die probleme van tradisionele cron opgelos het en die sintaksis van tabellêers uitgebrei het.
Teen die derde weergawe van Vixie het cron begin om aan die vereistes van POSIX te voldoen, en die program het ook 'n liberale lisensie gehad, of liewer, daar was geen lisensie nie, behalwe vir die wense in die README: die skrywer gee nie waarborge nie, die skrywer se naam kan nie uitgevee word nie, en die program kan slegs saam met bronkode verkoop word. Hierdie vereistes blyk versoenbaar te wees met die beginsels van gratis sagteware, wat in daardie jare gewild geword het, so sommige van die sleutel Linux-verspreidings wat in die vroeë 90's verskyn het, het Vixie cron as 'n stelsel een geneem en ontwikkel dit steeds.
In die besonder ontwikkel Red Hat en SUSE 'n vurk van Vixie cron - cronie, terwyl Debian en Ubuntu die oorspronklike uitgawe van Vixie cron met baie pleisters gebruik.
Kom ons kyk eers na die POSIX-gebruikergedefinieerde crontab-nutsding, en kyk dan na die sintaksisuitbreidings wat in Vixie cron bekendgestel is en die gebruik van Vixie cron-variasies in gewilde Linux-verspreidings. En uiteindelik is die kersie op die koek besig om die toestel van die cron-demoon uitmekaar te haal.
POSIX crontab
Terwyl die oorspronklike cron altyd vir die supergebruiker gehardloop het, is moderne skeduleers meer geneig om gereelde gebruikerstake te hanteer, wat veiliger en geriefliker is.
Crons kom met 'n stel van twee programme: 'n voortdurend lopende cron daemon en 'n gebruiker-toeganklike crontab nut. Laasgenoemde laat jou toe om taaktabelle spesifiek vir elke gebruiker in die stelsel te wysig, terwyl die daemon take vanaf gebruiker- en stelseltabelle laat loop.
В die gedrag van die daemoon word op geen manier beskryf nie en slegs die gebruikerprogram is geformaliseer . Die bestaan van meganismes vir die bekendstelling van gebruikerstake word natuurlik geïmpliseer, maar nie in detail beskryf nie.
Daar is vier dinge wat gedoen kan word deur die crontab-nutsding te roep: wysig die gebruiker se taaktabel in die redigeerder, laai die tabel uit 'n lêer, wys die huidige taaktabel en maak die taaktabel skoon. Voorbeelde van die crontab-nut:
crontab -e # редактировать таблицу задач
crontab -l # показать таблицу задач
crontab -r # удалить таблицу задач
crontab path/to/file.crontab # загрузить таблицу задач из файлаWanneer gebel word crontab -e die redigeerder gespesifiseer in die standaard omgewingsveranderlike sal gebruik word EDITOR.
Die take self word in die volgende formaat beskryf:
# строки-комментарии игнорируются
#
# задача, выполняемая ежеминутно
* * * * * /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.logDie eerste vyf velde van rekords: minute [1..60], ure [0..23], dae van die maand [1..31], maande [1..12], dae van die week [0.. 6], waar 0 — Sondag. Die laaste, sesde, veld is 'n reël wat uitgevoer sal word deur die standaard opdrag tolk.
In die eerste vyf velde kan waardes geskei word deur kommas:
# задача, выполняемая в первую и десятую минуты каждого часа
1,10 * * * * /path/to/exec -a -b -cOf met 'n koppelteken:
# задача, выполняемая в каждую из первых десяти минут каждого часа
0-9 * * * * /path/to/exec -a -b -cGebruikerstoegang tot taakskedulering word in POSIX gereguleer deur die cron.allow- en cron.deny-lêers, wat onderskeidelik gebruikers met crontab-toegang en gebruikers sonder programtoegang lys. Die standaard reguleer op geen manier die ligging van hierdie lêers nie.
Begin programme, volgens die standaard, moet ten minste vier omgewingsveranderlikes geslaag word:
- HOME is die gebruiker se tuisgids.
- LOGNAME - gebruikersaanmelding.
- PATH - die pad waar jy die standaard stelsel nutsprogramme kan vind.
- SHELL is die pad na die gebruikte dop.
Veral, POSIX sê niks oor waar die waardes vir hierdie veranderlikes vandaan kom nie.
Topverkoper - Vixie cron 3.0pl1
Die gemeenskaplike voorouer van gewilde cron-variante is Vixie cron 3.0pl1, wat in 1992 in die comp.sources.unix-poslys bekendgestel is. Ons sal die hoofkenmerke van hierdie weergawe in meer besonderhede oorweeg.
Vixie cron kom in twee programme (cron en crontab). Soos gewoonlik is die daemon verantwoordelik vir die lees en uitvoer van take vanaf die stelseltaaktabel en individuele gebruikertaaktabelle, terwyl die crontab-nutsding verantwoordelik is vir die redigering van gebruikerstabelle.
Taaktabel en konfigurasielêers
Die supergebruiker-taaktabel is geleë in /etc/crontab. Die sintaksis van die stelseltabel stem ooreen met die sintaksis van Vixie cron, met die uitsondering dat die sesde kolom die naam aandui van die gebruiker namens wie die taak van stapel gestuur word:
# Запускается ежеминутно от пользователя vlad
* * * * * vlad /path/to/execGereelde gebruikertaaktabelle is geleë in /var/cron/tabs/gebruikersnaam en gebruik 'n algemene sintaksis. Wanneer jy die crontab-nutsding as 'n gebruiker laat loop, is dit hierdie lêers wat geredigeer word.
Die lyste van gebruikers wat toegang tot crontab het, word bestuur in die /var/cron/allow- en /var/cron/deny-lêers, waar dit genoeg is om die gebruikersnaam op 'n aparte reël in te voer.
Uitgebreide sintaksis
In vergelyking met die POSIX crontab, bevat Paul Wixey se oplossing 'n paar baie nuttige wysigings aan die sintaksis van die taaktabelle van die hulpprogram.
'n Nuwe tabelsintaksis het beskikbaar geword: jy kan byvoorbeeld die dae van die week of maande by die naam spesifiseer (Ma, Di, ensovoorts):
# Запускается ежеминутно по понедельникам и вторникам в январе
* * * Jan Mon,Tue /path/to/execU kan die stap spesifiseer waardeur take van stapel gestuur word:
# Запускается с шагом в две минуты
*/2 * * * Mon,Tue /path/to/execStappe en intervalle kan gemeng word:
# Запускается с шагом в две минуты в первых десять минут каждого часа
0-10/2 * * * * /path/to/execIntuïtiewe alternatiewe vir die gewone sintaksis word ondersteun (herlaai, jaarliks, jaarliks, maandeliks, weekliks, daagliks, middernag, uurliks):
# Запускается после перезагрузки системы
@reboot /exec/on/reboot
# Запускается раз в день
@daily /exec/daily
# Запускается раз в час
@hourly /exec/dailyTaakuitvoering omgewing
Vixie cron laat jou toe om die omgewing van geloodsde toepassings te verander.
Die omgewingsveranderlikes USER, LOGNAME en HOME word nie net deur die daemon verskaf nie, maar word uit die lêer geneem . Die PATH-veranderlike is ingestel op "/usr/bin:/bin" en die SHELL-veranderlike is ingestel op "/bin/sh". Die waardes van alle veranderlikes behalwe LOGNAME kan in gebruikerstabelle verander word.
Sommige omgewingsveranderlikes (hoofsaaklik SHELL en HOME) word deur cron self gebruik om 'n taak te begin. Hier is hoe die gebruik van bash in plaas van die verstek sh om gebruikerstake uit te voer, kan lyk:
SHELL=/bin/bash
HOME=/tmp/
# exec будет запущен bash-ем в /tmp/
* * * * * /path/to/execUiteindelik sal alle omgewingsveranderlikes wat in die tabel gedefinieer word (óf deur cron gebruik of deur die proses benodig word) na die lopende taak oorgedra word.
Om lêers te wysig, gebruik crontab die redigeerder gespesifiseer in die VISUAL of EDITOR omgewingsveranderlike. As die omgewing waar crontab uitgevoer is nie hierdie veranderlikes gedefinieer het nie, word "/usr/ucb/vi" gebruik (ucb is waarskynlik die Universiteit van Kalifornië, Berkeley).
cron op Debian en Ubuntu
Debian en afgeleide ontwikkelaars het vrygestel weergawe van Vixie cron 3.0pl1. Daar is geen verskille in die sintaksis van tabellêers nie; vir gebruikers is dit dieselfde Vixie cron. Grootste nuwe kenmerke: Ondersteuning , и .
Van die minder opvallende, maar tasbare veranderinge - die ligging van die konfigurasielêers en taaktabelle.
Gebruikerstabelle in Debian is in die /var/spool/cron/crontabs-gids geleë, die stelseltabel is steeds daar - in /etc/crontab. Debian-pakketspesifieke taaktabelle word in /etc/cron.d geplaas, waaruit die cron-daemoon hulle outomaties lees. Gebruikerstoegangsbeheer word beheer deur die /etc/cron.allow- en /etc/cron.deny-lêers.
Die verstek dop is steeds /bin/sh, wat in Debian 'n klein POSIX-voldoende dop is , van stapel gestuur sonder om enige konfigurasie te lees (in nie-interaktiewe modus).
Cron self in onlangse weergawes van Debian word via systemd bestuur, en die opstartkonfigurasie kan gevind word in /lib/systemd/system/cron.service. Daar is niks spesiaals in die dienskonfigurasie nie, enige fyner taakbestuur kan gedoen word deur omgewingsveranderlikes wat direk in die crontab van elke gebruiker verklaar word.
cronie op RedHat, Fedora en CentOS
- vurk van Vixie cron weergawe 4.1. Soos in Debian, het die sintaksis nie verander nie, maar het ondersteuning vir PAM en SELinux bygevoeg, werk in 'n groepering, monitering van lêers met inotify, en ander kenmerke.
Die verstekkonfigurasie is op die gewone plekke: die stelseltabel is in /etc/crontab, pakkette plaas hul tabelle in /etc/cron.d, gebruikerstabelle gaan na /var/spool/cron/crontabs.
Die daemon loop onder systemd, die dienskonfigurasie is /lib/systemd/system/crond.service.
Op Red Hat-agtige verspreidings is die standaard opstart /bin/sh, wat die standaard bash is. Let daarop dat wanneer cron-take via /bin/sh uitgevoer word, die bash-dop in POSIX-aaneenlopende modus begin en geen bykomende konfigurasie lees nie, loop in nie-interaktiewe modus.
cronie in SLES en openSUSE
Die Duitse SLES-verspreiding en sy openSUSE-afgeleide gebruik dieselfde cronie. Die daemoon hier loop ook onder systemd, die dienskonfigurasie is in /usr/lib/systemd/system/cron.service. Konfigurasie: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh is dieselfde bash wat in POSIX-aaneenlopende nie-interaktiewe modus loop.
Vixie cron toestel
Moderne afstammelinge van cron het nie radikaal verander in vergelyking met Vixie cron nie, maar het steeds nuwe kenmerke gekry wat nie nodig is om die beginsels van die program te verstaan nie. Baie van hierdie uitbreidings is slordig en verwar die kode. Die oorspronklike cron-bronkode deur Paul Wixie is 'n plesier om te lees.
Daarom het ek besluit om die cron-toestel te ontleed deur gebruik te maak van die voorbeeld van 'n program wat algemeen is vir beide takke van cron-ontwikkeling - Vixie cron 3.0pl1. Ek sal die voorbeelde vereenvoudig deur ifdefs te verwyder wat lees moeilik maak en sekondêre besonderhede weg te laat.
Die werk van die demoon kan in verskeie fases verdeel word:
- Program inisialisering.
- Versamel en werk die lys take wat uitgevoer moet word op.
- Die werk van die hoof cron lus.
- Begin 'n taak.
Kom ons neem hulle in volgorde.
Inisialisering
By opstart, nadat die prosesargumente nagegaan is, installeer cron die SIGCHLD- en SIGHUP-seinhanteerders. Die eerste een teken 'n inskrywing oor die beëindiging van die kinderproses aan, die tweede een sluit die lêerbeskrywing van die loglêer:
signal(SIGCHLD, sigchld_handler);
signal(SIGHUP, sighup_handler);Die cron daemon in die stelsel loop altyd alleen, slegs in die rol van supergebruiker en vanaf die hoof cron gids. Die volgende oproepe skep 'n slotlêer met die PID van die daemonproses, maak seker dat die gebruiker korrek is, en verander die huidige gids na die hoofgids:
acquire_daemonlock(0);
set_cron_uid();
set_cron_cwd();Die verstekpad is ingestel, wat gebruik sal word wanneer prosesse begin word:
setenv("PATH", _PATH_DEFPATH, 1);Verder word die proses "gedamoniseer": dit skep 'n kinderkopie van die proses deur vurk te roep en 'n nuwe sessie in die kinderproses (deur setsid te roep). Die ouerproses is nie meer nodig nie - en dit gaan uit:
switch (fork()) {
case -1:
/* критическая ошибка и завершение работы */
exit(0);
break;
case 0:
/* дочерний процесс */
(void) setsid();
break;
default:
/* родительский процесс завершает работу */
_exit(0);
}
As die ouerproses beëindig word, word die slot op die slotlêer vrygestel. Daarbenewens moet jy die PID in die lêer opdateer na 'n kind. Daarna word die databasis van take gevul:
/* повторный захват лока */
acquire_daemonlock(0);
/* Заполнение БД */
database.head = NULL;
database.tail = NULL;
database.mtime = (time_t) 0;
load_database(&database);Dan beweeg cron na die hoofwerklus. Maar voor dit is dit die moeite werd om te kyk na die laai van die taaklys.
Versamel en opdatering van die lys take
Die load_database-funksie is verantwoordelik vir die laai van die lys take. Dit kontroleer die hoofstelsel se crontab- en gebruikerslêersgids. As die lêers en gids nie verander het nie, word die lys take nie herlees nie. Andersins begin 'n nuwe lys take vorm.
Laai 'n stelsellêer met spesiale lêer- en tabelname:
/* если файл системной таблицы изменился, перечитываем */
if (syscron_stat.st_mtime) {
process_crontab("root", "*system*",
SYSCRONTAB, &syscron_stat,
&new_db, old_db);
}Laai gepasmaakte tabelle in 'n lus:
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);
}
Daarna word die ou databasis deur 'n nuwe een vervang.
In die voorbeelde hierbo, kontroleer die oproep na process_crontab vir die bestaan van 'n gebruiker wat ooreenstem met die tabel se lêernaam (tensy dit die supergebruiker is) en roep dan load_user. Laasgenoemde lees reeds die lêer self reël vir reël:
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 word óf die omgewingsveranderlike gestel (stringe soos VAR=waarde) deur die load_env / env_set funksies, óf die taakbeskrywing (* * * * * /path/to/exec) word deur die load_entry-funksie gelees.
Die inskrywingsentiteit wat load_entry terugstuur, is ons taak, wat in die algemene lys take geplaas word. In die funksie self word 'n breedvoerige ontleding van die tydformaat uitgevoer, maar ons is meer geïnteresseerd in die vorming van omgewingsveranderlikes en taakbekendstellingparameters:
/* пользователь и группа для запуска задачи берутся из 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);Met die werklike lys take werk die hooflus.
Hooflus
Die oorspronklike cron van Weergawe 7 Unix het baie eenvoudig gewerk: dit het die konfigurasie in 'n lus hergelees, die take van die huidige minuut as die supergebruiker begin en tot die begin van die volgende minuut geslaap. Hierdie eenvoudige benadering op ouer masjiene het te veel hulpbronne vereis.
In SysV is 'n alternatiewe weergawe voorgestel waar die daemoon óf tot die naaste minuut waarvoor die taak gedefinieer is, óf vir 30 minute slaap. Hulpbronne vir die herlees van die opstelling en die kontrolering van take in hierdie modus het minder verbruik, maar dit het ongerieflik geword om die lys take vinnig op te dateer.
Vixie cron het teruggekeer om taaklyste een keer per minuut na te gaan, aangesien daar teen die einde van die 80's baie meer hulpbronne op standaard Unix-masjiene was:
/* первичная загрузка задач */
load_database(&database);
/* запустить задачи, поставленные к выполнению после перезагрузки системы */
run_reboot_jobs(&database);
/* сделать TargetTime началом ближайшей минуты */
cron_sync();
while (TRUE) {
/* выполнить задачи, после чего спать до TargetTime с поправкой на время, потраченное на задачи */
cron_sleep();
/* перечитать конфигурацию */
load_database(&database);
/* собрать задачи для данной минуты */
cron_tick(&database);
/* перевести TargetTime на начало следующей минуты */
TargetTime += 60;
}
Die cron_sleep-funksie is direk betrokke by die uitvoering van take, en noem die funksies job_runqueue (opsomming en begin van take) en do_command (begin elke individuele taak). Die laaste funksie is die moeite werd om in meer detail te ontleed.
Begin 'n taak
Die do_command-funksie word in goeie Unix-styl gedoen, dit wil sê, dit doen 'n vurk om 'n taak asynchronies uit te voer. Die ouerproses gaan voort om take uit te voer, die kinderproses berei die taakproses voor:
switch (fork()) {
case -1:
/*не смогли выполнить fork */
break;
case 0:
/* дочерний процесс: на всякий случай еще раз пробуем захватить главный лок */
acquire_daemonlock(1);
/* переходим к формированию процесса задачи */
child_process(e, u);
/* по завершению дочерний процесс заканчивает работу */
_exit(OK_EXIT);
break;
default:
/* родительский процесс продолжает работу */
break;
}Daar is baie logika in child_process: dit neem die standaard uitvoer- en foutstrome op homself, sodat dit dan na die pos gestuur kan word (as die MAILTO-omgewingsveranderlike in die taaktabel gespesifiseer is), en uiteindelik wag dit vir die taak se hoofproses om te voltooi.
Die taakproses word gevorm deur 'n ander vurk:
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;
}Dit, in die algemeen, is die hele cron. Ek het 'n paar interessante besonderhede weggelaat, byvoorbeeld om rekening te hou met afgeleë gebruikers, maar het die hoofsaak uiteengesit.
nawoord
Cron is 'n verbasend eenvoudige en nuttige program, gemaak in die beste tradisies van die Unix-wêreld. Sy doen niks ekstra nie, maar sy doen haar werk nou al vir etlike dekades merkwaardig. Dit het minder as 'n uur geneem om die kode te hersien vir die weergawe wat saam met Ubuntu verskeep word, en ek het baie pret gehad! Ek hoop ek kon dit met julle deel.
Ek weet nie van jou nie, maar ek is 'n bietjie hartseer om te besef dat moderne programmering, met sy neiging om te ingewikkeld en oorabstrak te wees, lankal nie meer bevorderlik is vir sulke eenvoud nie.
Daar is baie moderne alternatiewe vir cron: systemd-timers laat jou toe om komplekse stelsels met afhanklikhede te organiseer, in fcron kan jy die hulpbronverbruik van take meer buigsaam reguleer. Maar persoonlik was die eenvoudigste crontab nog altyd vir my genoeg.
Kortom, hou van Unix, gebruik eenvoudige programme, en moenie vergeet om die mana vir jou platform te lees nie!
Bron: will.com