Klasikoak idatzi zuen ordu zoriontsuak ez duela ikusten. Garai basati haietan ez zegoen ez programatzailerik ez Unix, baina gaur programatzaileek ziur dakite: cron-ek denboraren jarraipena egingo du haien ordez.

Komando-lerroko utilitateak ahulezia eta lan bat dira niretzat. sed, awk, wc, cut eta beste programa zahar batzuk gure zerbitzarietako scriptek exekutatzen dituzte egunero. Horietako asko 70eko hamarkadako cron-entzako zeregin gisa diseinatuta daude.

Denbora luzez cron azaletik erabili nuen, xehetasunetan sartu gabe, baina egun batean, script bat exekutatzen ari nintzenean errore bat aurkitu nuenean, ondo aztertzea erabaki nuen. Honela agertu zen artikulu hau, idazten ari nintzen bitartean POSIX crontab, Linux banaketa ezagunetako cron aukera nagusiak eta horietako batzuen egitura ezagutu nuen.

Linux erabiltzen ari al zara eta cron zereginak exekutatzen ari al zara? Unix-en sistema-aplikazioen arkitektura interesatzen zaizu? Orduan, bidean goaz!

Edukia

Espezieen jatorria
POSIX crontab
Salduena - Vixie cron 3.0pl1
cron Debian eta Ubuntu-n
Red Hat, Fedora eta CentOS-en lagunak
cronie SLES eta openSUSE-n
Vixie cron gailua
afterword

Espezieen jatorria

Erabiltzaileen edo sistemaren programak aldizkako exekuzioa beharrezkoa da sistema eragile guztietan. Hori dela eta, programatzaileak aspaldi konturatu ziren zereginak zentralki planifikatzeko eta exekutatzeko aukera ematen duten zerbitzuen beharraz.

Unix moduko sistema eragileek beren jatorria 7. bertsioan dute jatorria, joan den mendeko 70eko hamarkadan Bell Labs-en garatua, Ken Thompson ospetsuak barne. 7. bertsioak Unix-ek cron ere barne hartzen zuen, supererabiltzaileen zereginak aldizka exekutatzeko zerbitzua.

Cron moderno tipiko bat programa sinple bat da, baina jatorrizko bertsioaren funtzionamendu-algoritmoa are sinpleagoa zen: zerbitzua minutuan behin esnatzen zen, fitxategi bakarreko zereginekin taula bat irakurri zuen (/etc/lib/crontab) eta egin zen. supererabiltzailea une honetan egin beharko liratekeen zereginak .

Gerora, zerbitzu sinple eta erabilgarriaren bertsio hobetuak Unix antzeko sistema eragile guztiekin hornitu ziren.

Crontab formatuaren deskribapen orokorrak eta utilitatearen funtzionamenduaren oinarrizko printzipioak Unix antzeko sistema eragileen estandar nagusian - POSIX - sartu ziren 1992an, eta horrela de facto estandar batetik cron de jure estandar bihurtu zen.

1987an, Paul Vixiek, Unix-eko erabiltzaileei cron-en nahiei buruz galdekatu ondoren, cron tradizionalaren arazo batzuk zuzendu eta taula-fitxategien sintaxia zabaldu zuen deabruaren beste bertsio bat kaleratu zuen.

Vixie cron-en hirugarren bertsioan POSIX baldintzak betetzen hasi zen, gainera, programak lizentzia liberala zuen, edo hobeto esanda, ez zegoen inolako lizentziarik, IRAKURRI-n nahiak izan ezik: egileak ez du bermerik ematen, egilearen izena. ezin da ezabatu, eta programa iturburu-kodearekin batera bakarrik sal daiteke. Baldintza hauek urte haietan ospea hartzen ari zen software librearen printzipioekin bateragarriak izan ziren, beraz, 90eko hamarkadaren hasieran agertu ziren Linux banaketa gako batzuek Vixie cron hartu zuten sistema gisa eta gaur egun oraindik garatzen ari dira.

Bereziki, Red Hat eta SUSEk Vixie cron - cronie fork bat garatzen dute, eta Debian eta Ubuntuk Vixie cron-en jatorrizko edizioa erabiltzen dute adabaki askorekin.

Lehenik eta behin POSIX-en deskribatutako erabiltzailearen erabilgarritasun crontab-a ezagutuko dugu, ondoren Vixie cron-en eskaintzen diren sintaxi-luzapenak eta Vixie cron-en aldaerak Linux banaketa ezagunetan erabiltzen diren aztertuko dugu. Eta azkenik, pastelaren gerezia cron daemon gailuaren analisia da.

POSIX crontab

Jatorrizko cronak supererabiltzailearentzat beti funtzionatzen bazuen, programatzaile modernoek maiz erabiltzaile arrunten zereginei aurre egiten diete, eta hori seguruagoa eta erosoagoa da.

Crons bi programen multzo gisa hornitzen dira: etengabe exekutatzen ari den cron deabrua eta erabiltzaileen eskura dagoen crontab utilitatea. Azken horri esker, sistemako erabiltzaile bakoitzari dagozkion ataza-taulak edita ditzakezu, eta deabruak erabiltzaile eta sistema-tauletatik zereginak abiarazten ditu.

В POSIX estandarra deabruaren portaera ez da inola ere deskribatzen eta erabiltzailearen programa soilik formalizatzen da crontab. Erabiltzaile-zereginak abiarazteko mekanismoen existentzia inplizitua dago, noski, baina ez da zehatz deskribatzen.

Crontab utilitateari deituz, lau gauza egin ditzakezu: erabiltzailearen ataza-taula editatu editorean, taula fitxategi batetik kargatu, uneko ataza-taula erakutsi eta ataza-taula garbitu. Crontab utilitatearen funtzionamenduaren adibideak:

crontab -e # редактировать таблицу задач
crontab -l # показать таблицу задач
crontab -r # удалить таблицу задач
crontab path/to/file.crontab # загрузить таблицу задач из файла

Deitzean crontab -e ingurune-aldagai estandarrean zehaztutako editorea erabiliko da EDITOR.

Zereginak beraiek formatu honetan deskribatzen dira:

# строки-комментарии игнорируются
#
# задача, выполняемая ежеминутно
* * * * * /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

Erregistroen lehenengo bost eremuak: minutuak [1..60], orduak [0..23], hileko egunak [1..31], hilabeteak [1..12], asteko egunak [0. .6], non 0 igandea den. Azkeneko, seigarren eremua, komandoen interprete estandarrak exekutatuko duen lerroa da.

Lehenengo bost eremuetan, balioak komaz bereizita zerrendatu daitezke:

# задача, выполняемая в первую и десятую минуты каждого часа
1,10 * * * * /path/to/exec -a -b -c

Edo marratxo batekin:

# задача, выполняемая в каждую из первых десяти минут каждого часа
0-9 * * * * /path/to/exec -a -b -c

Erabiltzaileen atazak antolatzeko sarbidea POSIXen arautzen da cron.allow eta cron.deny fitxategiek, crontab-erako sarbidea duten erabiltzaileak eta programarako sarbidea ez duten erabiltzaileak zerrendatzen dituztenak, hurrenez hurren. Arauak ez du inola ere artxibo horien kokapena arautzen.

Estandarraren arabera, gutxienez lau ingurune-aldagai pasatu behar dira abiarazitako programetara:

HOME - erabiltzailearen hasierako direktorioa.
LOGNAME — erabiltzailearen saioa.
PATH sistemaren utilitate estandarrak aurki ditzakezun bidea da.
SHELL — erabilitako komandoen interpretearen bidea.

Nabarmentzekoa, POSIXek ez du ezer esaten aldagai horien balioak nondik datozen.

Salduena - Vixie cron 3.0pl1

Cron aldaera ezagunen arbaso arrunta Vixie cron 3.0pl1 da, comp.sources.unix posta-zerrendan 1992an sartua. Bertsio honen ezaugarri nagusiak zehatzago aztertuko ditugu.

Vixie cron bi programetan dator (cron eta crontab). Ohi bezala, deabrua sistemaren ataza-taularen eta banakako erabiltzailearen zereginen taulako atazak irakurtzeaz eta exekutatzen arduratzen da, eta crontab utilitatea erabiltzaile-taulak editatzeaz arduratzen da.

Zereginen taula eta konfigurazio fitxategiak

Supererabiltzaile atazen taula /etc/crontab-en dago. Sistema-taularen sintaxia Vixie cron-en sintaxiarekin bat dator, bertako seigarren zutabeak zeregina abiarazten duen erabiltzailearen izena adierazten duela izan ezik:

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

Erabiltzaileen ohiko zereginen taulak /var/cron/tabs/username-n daude eta sintaxi bera erabiltzen dute. Crontab utilitatea erabiltzaile gisa exekutatzen duzunean, hauek dira editatzen diren fitxategiak.

Crontab-erako sarbidea duten erabiltzaileen zerrendak /var/cron/allow eta /var/cron/deny fitxategietan kudeatzen dira, non erabiltzaile-izena lerro batean sartu besterik ez duzu egin behar.

Sintaxi hedatua

POSIX crontab-arekin alderatuta, Paul Vixey-ren irtenbideak erabilgarritasun-zereginen taulen sintaxian oso aldaketa erabilgarriak ditu.

Taularen sintaxi berri bat erabilgarri dago: adibidez, asteko egunak edo hilabeteak izenez zehaztu ditzakezu (aste, aste, eta abar):

# Запускается ежеминутно по понедельникам и вторникам в январе
* * * Jan Mon,Tue /path/to/exec

Zereginak abiarazteko urratsa zehaztu dezakezu:

# Запускается с шагом в две минуты
*/2 * * * Mon,Tue /path/to/exec

Urratsak eta tarteak nahastu daitezke:

# Запускается с шагом в две минуты в первых десять минут каждого часа
0-10/2 * * * * /path/to/exec

Ohiko sintaxiaren alternatiba intuitiboak onartzen dira (berrabiarazi, urtero, urtero, hilero, astero, egunero, gauerdian, orduro):

# Запускается после перезагрузки системы
@reboot /exec/on/reboot
# Запускается раз в день
@daily /exec/daily
# Запускается раз в час
@hourly /exec/daily

Ataza exekutatzeko ingurunea

Vixie cron-ek exekutatzen diren aplikazioen ingurunea aldatzeko aukera ematen du.

USER, LOGNAME eta HOME ingurune-aldagaiak ez ditu deabruak soilik ematen, fitxategi batetik hartzen dira baizik. passwd. PATH aldagaia "/usr/bin:/bin" gisa ezarrita dago eta SHELL aldagaia "/bin/sh". LOGNAME izan ezik aldagai guztien balioak alda daitezke erabiltzaileen tauletan.

Inguruneko aldagai batzuk (batez ere SHELL eta HOME) cron-ek erabiltzen ditu ataza exekutatzeko. Hona hemen zeregin pertsonalizatuak exekutatzeko bash sh estandarraren ordez erabiltzeak nolakoa izan daitekeen:

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

Azken finean, taulan definitutako ingurune-aldagai guztiak (cron-ek erabiltzen dituena edo prozesuak behar dituena) exekutatzen ari den atazara pasatuko dira.

Fitxategiak editatzeko, crontab-ek VISUAL edo EDITOR ingurune-aldagaian zehaztutako editorea erabiltzen du. Crontab exekutatu zen inguruneak aldagai hauek definituta ez baditu, "/usr/ucb/vi" erabiliko da (ucb Kaliforniako Unibertsitatea, Berkeleykoa, ziurrenik).

cron Debian eta Ubuntu-n

Debian eta banaketa deribatuen garatzaileek kaleratu dute oso aldatutako bertsioa Vixie cron bertsioa 3.0pl1. Taula-fitxategien sintaxian ez dago desberdintasunik; erabiltzaileentzat Vixie cron bera da. Ezaugarri berri handiena: euskarria syslog, SELinux и PAM.

Aldaketa ez hain nabarmenak, baina ukigarriak, konfigurazio-fitxategien eta ataza-taulen kokapena daude.

Debian-en erabiltzaile-taulak /var/spool/cron/crontabs direktorioan daude, sistema-taula oraindik hor dago - /etc/crontab-en. Debian paketeen ataza-taulak /etc/cron.d-en jartzen dira, eta hortik automatikoki irakurtzen ditu cron daemonak. Erabiltzaileen sarbide-kontrola /etc/cron.allow eta /etc/cron.deny fitxategiek kontrolatzen dute.

Lehenetsitako shell-a /bin/sh da oraindik, Debian-en POSIX-ekin bat datorren shell txiki bat dena marratxo, inolako konfiguraziorik irakurri gabe abiarazitakoa (modu ez-interaktiboan).

Debian-en azken bertsioetan Cron bera systemd bidez abiarazten da, eta abiarazteko konfigurazioa /lib/systemd/system/cron.service-n ikus daiteke. Zerbitzuaren konfigurazioan ez dago ezer berezirik; zereginen kudeaketa sotilagoa egin daiteke erabiltzaile bakoitzaren crontab-ean zuzenean deklaratutako ingurune-aldagaien bidez.

Cronie RedHat, Fedora eta CentOS-en

cronie - Vixie cron 4.1 bertsioaren sardexka. Debian-en bezala, sintaxia ez da aldatu, baina PAM eta SELinux-en laguntza, kluster batean lan egitea, inotify erabiliz fitxategien jarraipena eta beste ezaugarri batzuk gehitu dira.

Lehenetsitako konfigurazioa ohiko lekuetan dago: sistema-taula /etc/crontab-en dago, paketeek beren taulak /etc/cron.d-en jartzen dituzte, erabiltzaile-taulak /var/spool/cron/crontabs-en.

Deabrua systemd kontrolpean exekutatzen da, zerbitzuaren konfigurazioa /lib/systemd/system/crond.service da.

Red Hat-en antzeko banaketetan, /bin/sh lehenespenez erabiltzen da abiaraztean, hau da, bash estandarra. Kontuan izan behar da cron lanak /bin/sh bidez exekutatzen direnean, bash shell-a POSIX-ekin bateragarria den moduan abiarazten dela eta ez duela konfigurazio gehigarririk irakurtzen, modu interaktiboa ez den moduan exekutatzen dela.

cronie SLES eta openSUSE-n

SLES alemaniar banaketak eta openSUSE deribatuak cronie bera erabiltzen dute. Hemen deabrua systemd azpian ere abiarazten da, zerbitzuaren konfigurazioa /usr/lib/systemd/system/cron.service-n dago. Konfigurazioa: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh POSIX-ekin bat datorren modu ez-interaktiboan exekutatzen den bash bera da.

Vixie cron gailua

Cron-en ondorengo modernoak ez dira errotik aldatu Vixie cron-ekin alderatuta, baina hala ere programaren printzipioak ulertzeko beharrezkoak ez diren ezaugarri berriak eskuratu dituzte. Luzapen horietako asko gaizki diseinatuta daude eta kodea nahasten dute. Paul Vixeyren jatorrizko cron iturburu-kodea atsegina da irakurtzea.

Hori dela eta, cron gailua aztertzea erabaki nuen garapenaren bi adarretan komuna den cron programa baten adibidea erabiliz - Vixie cron 3.0pl1. Adibideak sinplifikatu egingo ditut irakurketa zailtzen duten ifdef-ak kenduz eta xehetasun txikiak baztertuz.

Deabruaren lana hainbat fasetan bana daiteke:

Programaren hasieratzea.
Exekutatu beharreko zereginen zerrenda biltzea eta eguneratzea.
Cron begizta nagusia martxan.
Hasi zeregin bat.

Ikus ditzagun ordenan.

Hasieraketa

Hasi denean, prozesuaren argumentuak egiaztatu ondoren, cron-ek SIGCHLD eta SIGHUP seinale-kudeatzaileak instalatzen ditu. Lehenengoak haurraren prozesuaren amaierari buruzko erregistro-sarrera egiten du, bigarrenak log-fitxategiaren fitxategi deskribatzailea ixten du:

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

Cron deabrua sisteman bakarrik exekutatzen da beti, supererabiltzaile gisa eta cron direktorio nagusitik. Ondorengo deiek blokeo-fitxategi bat sortzen dute daemon-prozesuaren PIDarekin, ziurtatu erabiltzailea zuzena dela eta aldatu uneko direktorioa nagusira:

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

Bide lehenetsia ezarri da, prozesuak abiarazteko erabiliko dena:

setenv("PATH", _PATH_DEFPATH, 1);

Ondoren, prozesua "daemonizatu" egiten da: prozesuaren kopia ume bat sortzen du fork deituz eta saio berri bat prozesu umean (setsid deituz). Jada ez da beharrezkoa guraso-prozesua, eta irteten da:

switch (fork()) {
case -1:
    /* критическая ошибка и завершение работы */
    exit(0);
break;
case 0:
    /* дочерний процесс */
    (void) setsid();
break;
default:
    /* родительский процесс завершает работу */
    _exit(0);
}

Guraso-prozesua amaitzeak blokeo-fitxategiaren blokeoa askatzen du. Horrez gain, haurrari fitxategiko PID eguneratzea beharrezkoa da. Horren ondoren, zereginen datu-basea betetzen da:

/* повторный захват лока */
acquire_daemonlock(0);

/* Заполнение БД  */
database.head = NULL;
database.tail = NULL;
database.mtime = (time_t) 0;
load_database(&database);

Ondoren, cron lan-ziklo nagusira pasatzen da. Baina aurretik, merezi du zereginen zerrenda kargatzeari begirada bat ematea.

Zereginen zerrenda biltzea eta eguneratzea

load_database funtzioa zereginen zerrenda kargatzeaz arduratzen da. Sistema nagusia crontab eta direktorioa erabiltzaile fitxategiekin egiaztatzen du. Fitxategiak eta direktorioa aldatu ez badira, zereginen zerrenda ez da berriro irakurtzen. Bestela, zereginen zerrenda berri bat osatzen hasiko da.

Fitxategi eta taula izen bereziekin sistema fitxategi bat kargatzea:

/* если файл системной таблицы изменился, перечитываем */
if (syscron_stat.st_mtime) {
    process_crontab("root", "*system*",
    SYSCRONTAB, &syscron_stat,
    &new_db, old_db);
}

Erabiltzaileen taulak begizta batean kargatzen:

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

Horren ondoren, datu-base zaharra berri batekin ordezkatzen da.

Goiko adibideetan, process_crontab funtzio deiak egiaztatzen du taularen fitxategi-izenarekin bat datorren erabiltzaile bat existitzen dela (supererabiltzailea ez bada behintzat) eta, ondoren, load_user deitzen du. Azken honek dagoeneko irakurtzen du fitxategia bera lerroz lerro:

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

Hemen, edo ingurune-aldagaia ezartzen da (VAR=balioa formako lerroak) load_env / env_set funtzioak erabiliz, edo zereginaren deskribapena irakurtzen da (* * * * * /path/to/exec) load_entry funtzioa erabiliz.

load_entry-k itzultzen duen sarrera-entitatea da gure zeregina, zereginen zerrenda orokorrean kokatzen dena. Funtzioak berak denbora-formatuaren analisi zehatza egiten du, baina gehiago interesatzen zaigu ingurune-aldagaiak eta zereginak abiarazteko parametroak sortzea:

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

Begizta nagusiak uneko zereginen zerrendarekin funtzionatzen du.

Begizta Nagusia

7. bertsioko Unix-eko jatorrizko cron-ak nahiko sinplea zuen: konfigurazioa berriro irakurtzen zuen begizta batean, uneko minutuko zereginak abiarazi zituen supererabiltzaile gisa eta lo egin zuen hurrengo minutuaren hasierara arte. Makina zaharretako ikuspegi sinple honek baliabide gehiegi behar zituen.

Bertsio alternatibo bat proposatu zen SysV-en, zeinean deabrua lo egiten joan zen, bai zeregina zehaztu zen minutu hurbilenera arte, edo 30 minutuz. Modu honetan konfigurazioa berriro irakurtzeko eta zereginak egiaztatzeko baliabide gutxiago kontsumitu ziren, baina zereginen zerrenda azkar eguneratzea deserosoa bihurtu zen.

Vixie cron minuturo behin zereginen zerrendak egiaztatzera itzultzen zen, zorionez 80ko hamarkadaren amaieran baliabide gehiago zeuden Unix makina estandarretan:

/* первичная загрузка задач */
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 funtzioak zuzenean parte hartzen du zereginak exekutatzen, job_runqueue (zereginak zenbatu eta exekutatu) eta do_command (zeregin bakoitza exekutatu) funtzioei deituz. Azken funtzioa xehetasun gehiago aztertzea merezi du.

Zeregin bat exekutatzen

do_command funtzioa Unix estilo onean exekutatzen da, hau da, sardexka bat egiten du zeregina modu asinkronoan egiteko. Guraso-prozesuak zereginak abiarazten jarraitzen du, ume-prozesuak zeregin-prozesua prestatzen du:

switch (fork()) {
case -1:
    /*не смогли выполнить fork */
    break;
case 0:
    /* дочерний процесс: на всякий случай еще раз пробуем захватить главный лок */
    acquire_daemonlock(1);
    /* переходим к формированию процесса задачи */
    child_process(e, u);
    /* по завершению дочерний процесс заканчивает работу */
    _exit(OK_EXIT);
    break;
default:
    /* родительский процесс продолжает работу */
    break;
}

Child_process-en logika dezente dago: irteera estandarrak eta errore-jarioak bere gain hartzen ditu, gero postara bidaltzeko (atazen taulan MAILTO ingurune-aldagaia zehaztuta badago), eta, azkenik, nagusiaren zain geratzen da. bete beharreko zereginaren prozesua.

Zereginaren prozesua beste sardexka batek osatzen du:

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

Hori da funtsean cron dena. Xehetasun interesgarri batzuk alde batera utzi nituen, adibidez, urruneko erabiltzaileen kontabilitatea, baina gauza nagusia zehaztu nuen.

afterword

Cron programa harrigarri sinple eta erabilgarria da, Unix munduko tradizio onenetan egina. Ez du ezer gehigarririk egiten, baina duela hainbat hamarkada ederki egiten ari da bere lana. Ubunturekin datorren bertsioaren kodea lortzeak ez zuen ordubete baino gehiago behar izan, eta asko dibertitu nintzen! Espero dut zurekin partekatu izana.

Ez dakit zuek, baina triste samarra nago konturatzeak programazio modernoak, gehiegi korapilatzeko eta gehiegizko abstrakziorako joerarekin, aspaldian ez duela horrelako soiltasunerako lagungarri izan.

Cron-en alternatiba moderno asko daude: systemd-timer-ek menpekotasunekin sistema konplexuak antolatzeko aukera ematen du, fcron-ek baliabideen kontsumoa zereginen arabera malgutasunez erregulatzeko aukera ematen du. Baina pertsonalki, crontab errazena beti izan zen nahikoa niretzat.

Laburbilduz, maite Unix, erabili programa sinpleak eta ez ahaztu zure plataformarako mana irakurtzea!

Iturria: www.habr.com

Cron Linux-en: historia, erabilera eta gailua