Klasikas rašė, kad laimingos valandos nežiūri. Tais laukiniais laikais nebuvo nei programuotojų, nei Unix, tačiau šiandien programuotojai tikrai žino: cron seks laiką vietoj jų.

Komandinės eilutės paslaugos man yra ir silpnybė, ir darbas. sed, awk, wc, cut ir kitos senos programos yra paleidžiamos pagal scenarijus mūsų serveriuose kiekvieną dieną. Daugelis jų yra sukurti kaip užduotys, skirtos cron, planuokliui, kilusiam iš 70-ųjų.

Ilgą laiką cron naudojau paviršutiniškai, nesigilindamas į smulkmenas, bet vieną dieną, kai paleidęs scenarijų susidūriau su klaida, nusprendžiau ją nuodugniai išnagrinėti. Taip atsirado šis straipsnis, kurį rašydamas susipažinau su POSIX crontab, pagrindinėmis cron parinktimis populiariuose Linux distribucijose ir kai kurių iš jų struktūra.

Ar naudojate Linux ir vykdote cron užduotis? Ar domitės sistemos programų architektūra Unix? Tada mes jau pakeliui!

Turinys

Rūšių kilmė
POSIX crontab
Geriausiai parduodamas – Vixie cron 3.0pl1
cron Debian ir Ubuntu
draugė „Red Hat“, „Fedora“ ir „CentOS“.
cronie SLES ir openSUSE
„Vixie cron“ įrenginys
Afterword

Rūšių kilmė

Periodiškas vartotojo ar sistemos programų vykdymas yra akivaizdi būtinybė visose operacinėse sistemose. Todėl programuotojai jau seniai suprato paslaugų, leidžiančių centralizuotai planuoti ir vykdyti užduotis, poreikį.

Į „Unix“ panašios operacinės sistemos kilo nuo 7 versijos Unix, sukurtos praėjusio amžiaus aštuntajame dešimtmetyje „Bell Labs“, įskaitant garsųjį Keną Thompsoną. 70 versijoje Unix taip pat buvo cron – paslauga, skirta reguliariai vykdyti supervartotojo užduotis.

Įprasta šiuolaikinė cron yra paprasta programa, tačiau pradinės versijos veikimo algoritmas buvo dar paprastesnis: paslauga atsibusdavo kartą per minutę, nuskaitydavo lentelę su užduotimis iš vieno failo (/etc/lib/crontab) ir atlikdavo supervartotojas tas užduotis, kurios turėjo būti atliktos šiuo metu.

Vėliau patobulintos paprastos ir naudingos paslaugos versijos buvo pateiktos su visomis Unix tipo operacinėmis sistemomis.

Apibendrinti crontab formato aprašymai ir pagrindiniai komunalinės paslaugos veikimo principai buvo įtraukti į pagrindinį Unix tipo operacinių sistemų standartą – POSIX – 1992 m., todėl cron iš de facto standarto tapo de jure standartu.

1987 m. Paulas Vixie, apklausęs Unix naudotojus apie jų pageidavimus cron, išleido kitą demono versiją, kuri ištaisė kai kurias tradicinio cron problemas ir išplėtė lentelių failų sintaksę.

Trečioji Vixie cron versija pradėjo atitikti POSIX reikalavimus, be to, programa turėjo liberalią licenciją, tiksliau, jos nebuvo, išskyrus pageidavimus README: autorius nesuteikia garantijų, autoriaus vardas. negalima ištrinti, o programą galima parduoti tik kartu su šaltinio kodu. Paaiškėjo, kad šie reikalavimai yra suderinami su tais metais populiarėjančios nemokamos programinės įrangos principais, todėl kai kurie pagrindiniai „Linux“ platinimai, pasirodę 90-ųjų pradžioje, paėmė „Vixie cron“ kaip savo sistemą ir vis dar ją kuria.

Visų pirma, „Red Hat“ ir „SUSE“ kuria „Vixie cron - cronie“ šakutę, o „Debian“ ir „Ubuntu“ naudoja originalų „Vixie cron“ leidimą su daugybe pataisų.

Pirmiausia susipažinkime su POSIX aprašytu vartotojo įrankiu crontab, po to apžvelgsime Vixie cron pateiktus sintaksės plėtinius ir Vixie cron variantų naudojimą populiariuose Linux platinimuose. Ir galiausiai, vyšnia ant torto yra cron demono įrenginio analizė.

POSIX crontab

Jei originalus cron visada veikė supervartotojui, šiuolaikiniai planuotojai dažnai sprendžia paprastų vartotojų užduotis, o tai yra saugesnė ir patogiau.

Crons tiekiamas kaip dviejų programų rinkinys: nuolat veikiantis cron demonas ir vartotojams prieinama programa crontab. Pastarasis leidžia redaguoti kiekvienam sistemos vartotojui būdingas užduočių lenteles, o demonas paleidžia užduotis iš vartotojų ir sistemos lentelių.

В POSIX standartas demono elgesys niekaip neaprašomas ir formalizuojama tik vartotojo programa crontab. Žinoma, naudotojo užduočių paleidimo mechanizmų buvimas yra numanomas, bet nėra išsamiai aprašytas.

Iškvietę crontab įrankį galite atlikti keturis dalykus: redaguoti vartotojo užduočių lentelę redaktoriuje, įkelti lentelę iš failo, parodyti esamą užduočių lentelę ir išvalyti užduočių lentelę. Pavyzdžiai, kaip veikia crontab programa:

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

Kai skambina crontab -e bus naudojamas standartiniame aplinkos kintamajame nurodytas redaktorius EDITOR.

Pačios užduotys aprašytos tokiu formatu:

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

Pirmieji penki įrašų laukai: minutės [1..60], valandos [0..23], mėnesio dienos [1..31], mėnesiai [1..12], savaitės dienos [0. .6], kur 0 yra sekmadienis. Paskutinis, šeštas, laukas yra eilutė, kurią vykdys standartinis komandų interpretatorius.

Pirmuosiuose penkiuose laukuose reikšmės gali būti išvardytos, atskirtos kableliais:

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

Arba su brūkšneliu:

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

Vartotojų prieigą prie užduočių planavimo POSIX sistemoje reguliuoja cron.allow ir cron.deny failai, kuriuose atitinkamai išvardijami vartotojai, turintys prieigą prie crontab, ir vartotojai, neturintys prieigos prie programos. Standartas niekaip nereglamentuoja šių failų vietos.

Pagal standartą paleidžiamoms programoms turi būti perduoti bent keturi aplinkos kintamieji:

HOME – vartotojo namų katalogas.
LOGNAME – vartotojo prisijungimas.
PATH yra kelias, kuriame galite rasti standartines sistemos priemones.
SHELL – kelias į naudojamą komandų interpretatorių.

Pažymėtina, kad POSIX nieko nesako apie tai, iš kur gaunamos šių kintamųjų reikšmės.

Geriausiai parduodamas – Vixie cron 3.0pl1

Bendras populiarių cron variantų protėvis yra Vixie cron 3.0pl1, pristatytas comp.sources.unix adresų sąraše 1992 m. Išsamiau apsvarstysime pagrindines šios versijos ypatybes.

Vixie cron yra dviejų programų (cron ir crontab). Kaip įprasta, demonas yra atsakingas už užduočių skaitymą ir vykdymą iš sistemos užduočių lentelės ir atskirų vartotojo užduočių lentelių, o programa crontab – už vartotojų lentelių redagavimą.

Užduočių lentelė ir konfigūracijos failai

Supervartotojo užduočių lentelė yra /etc/crontab. Sistemos lentelės sintaksė atitinka Vixie cron sintaksę, išskyrus tai, kad šeštajame jos stulpelyje nurodomas vartotojo, kurio vardu paleidžiama užduotis, vardas:

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

Įprastos vartotojo užduočių lentelės yra /var/cron/tabs/username ir naudoja tą pačią sintaksę. Kai paleidžiate crontab paslaugų programą kaip vartotojas, tai yra failai, kurie yra redaguojami.

Vartotojų, turinčių prieigą prie crontab, sąrašai tvarkomi failuose /var/cron/allow ir /var/cron/deny, kur tereikia atskiroje eilutėje įvesti vartotojo vardą.

Išplėstinė sintaksė

Palyginti su POSIX crontab, Paul Vixey sprendimas turi keletą labai naudingų paslaugų užduočių lentelių sintaksės modifikacijų.

Atsirado nauja lentelės sintaksė: pavyzdžiui, galite nurodyti savaitės dienas ar mėnesius pagal pavadinimą (pirmadienis, antradienis ir pan.):

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

Galite nurodyti veiksmą, per kurį paleidžiamos užduotys:

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

Žingsnius ir intervalus galima maišyti:

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

Palaikomos intuityvios įprastos sintaksės alternatyvos (perkrovimas, kasmet, kasmet, kas mėnesį, kas savaitę, kasdien, vidurnaktis, kas valandą):

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

Užduočių vykdymo aplinka

Vixie cron leidžia keisti veikiančių programų aplinką.

Aplinkos kintamuosius USER, LOGNAME ir HOME pateikia ne tik demonas, bet jie yra paimti iš failo passwd. Kintamasis PATH nustatytas į „/usr/bin:/bin“, o SHELL kintamasis – „/bin/sh“. Visų kintamųjų, išskyrus LOGNAME, reikšmes galima keisti vartotojų lentelėse.

Kai kuriuos aplinkos kintamuosius (ypač SHELL ir HOME) užduočiai vykdyti naudoja pats cron. Štai kaip gali atrodyti bash, o ne standartinio sh naudojimas tinkintoms užduotims vykdyti:

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

Galiausiai visi lentelėje apibrėžti aplinkos kintamieji (naudojami cron arba reikalingi procesui) bus perduoti vykdomai užduočiai.

Norėdami redaguoti failus, crontab naudoja redaktorių, nurodytą VISUAL arba EDITOR aplinkos kintamajame. Jei aplinkoje, kurioje buvo paleistas crontab, šie kintamieji nėra apibrėžti, tada naudojamas „/usr/ucb/vi“ (UCb tikriausiai yra Kalifornijos universitetas, Berklis).

cron Debian ir Ubuntu

Debian ir išvestinių platinimų kūrėjai išleido labai modifikuota versija Vixie cron 3.0pl1 versija. Lentelės failų sintaksėje nėra skirtumų, tai yra ta pati Vixie cron. Didžiausia nauja funkcija: palaikymas sistemos dienoraštis, Selinux и PAM.

Mažiau pastebimi, bet apčiuopiami pakeitimai apima konfigūracijos failų ir užduočių lentelių vietą.

Vartotojų lentelės Debian'e yra /var/spool/cron/crontabs kataloge, sistemos lentelė vis dar yra - /etc/crontab. „Debian“ paketui būdingos užduočių lentelės dedamos į /etc/cron.d, iš kur cron demonas jas automatiškai nuskaito. Vartotojo prieigos valdymas yra valdomas failais /etc/cron.allow ir /etc/cron.deny.

Numatytasis apvalkalas vis dar yra /bin/sh, kuris Debian'e yra mažas POSIX suderinamas apvalkalas brūkšnys, paleistas neperskaičius jokios konfigūracijos (neinteraktyviuoju režimu).

Pati Cron naujausiose Debian versijose paleidžiama per systemd, o paleidimo konfigūraciją galima peržiūrėti aplanke /lib/systemd/system/cron.service. Paslaugos konfigūracijoje nėra nieko ypatingo; bet koks subtilesnis užduočių valdymas gali būti atliekamas naudojant aplinkos kintamuosius, deklaruotus tiesiogiai kiekvieno vartotojo langelyje.

draugė „RedHat“, „Fedora“ ir „CentOS“.

Cronie — „Vixie cron“ 4.1 versijos šakutė. Kaip ir Debian'e, sintaksė nepasikeitė, tačiau buvo pridėtas PAM ir SELinux palaikymas, darbas klasteryje, failų sekimas naudojant inotify ir kitos funkcijos.

Numatytoji konfigūracija yra įprastose vietose: sistemos lentelė yra /etc/crontab, paketai deda lenteles į /etc/cron.d, vartotojų lentelės patenka į /var/spool/cron/crontabs.

Demonas veikia valdant systemd, paslaugos konfigūracija yra /lib/systemd/system/crond.service.

Red Hat panašiuose paskirstymuose /bin/sh yra naudojamas pagal numatytuosius nustatymus paleidžiant, o tai yra standartinis bash. Reikėtų pažymėti, kad vykdant cron užduotis per /bin/sh, bash apvalkalas paleidžiamas su POSIX suderinamu režimu ir neskaito jokios papildomos konfigūracijos, veikiant neinteraktyviu režimu.

cronie SLES ir openSUSE

Vokiškas platinimas SLES ir jo darinys openSUSE naudoja tą patį draugą. Demonas čia taip pat paleistas pagal systemd, paslaugos konfigūracija yra /usr/lib/systemd/system/cron.service. Konfigūracija: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh yra tas pats bash, veikiantis su POSIX suderinamu neinteraktyviu režimu.

„Vixie cron“ įrenginys

Šiuolaikiniai cron palikuonys, palyginti su Vixie cron, kardinaliai nepasikeitė, tačiau vis tiek įgijo naujų funkcijų, kurių nereikia norint suprasti programos principus. Daugelis šių plėtinių yra prastai suprojektuoti ir painioja kodą. Malonu skaityti originalų „cron“ šaltinio kodą, kurį sukūrė Paulas Vixey.

Todėl nusprendžiau išanalizuoti cron įrenginį naudodamas abiem kūrimo šakoms bendros cron programos pavyzdį – Vixie cron 3.0pl1. Supaprastinsiu pavyzdžius pašalindamas ifdefs, kurie apsunkina skaitymą, ir praleisdamas smulkias detales.

Demono darbą galima suskirstyti į kelis etapus:

Programos inicijavimas.
Vykdomų užduočių sąrašo rinkimas ir atnaujinimas.
Pagrindinė cron kilpa veikia.
Pradėkite užduotį.

Pažvelkime į juos eilės tvarka.

Inicijavimas

Paleidęs, patikrinęs proceso argumentus, cron įdiegia SIGCHLD ir SIGHUP signalų tvarkykles. Pirmasis įrašo žurnalo įrašą apie antrinio proceso nutraukimą, antrasis uždaro žurnalo failo deskriptorių:

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

Cron demonas visada veikia vienas sistemoje, tik kaip supervartotojas ir iš pagrindinio cron katalogo. Šie skambučiai sukuria užrakto failą su demono proceso PID, įsitikinkite, kad vartotojas yra teisingas, ir pakeiskite dabartinį katalogą į pagrindinį:

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

Nustatytas numatytasis kelias, kuris bus naudojamas paleidžiant procesus:

setenv("PATH", _PATH_DEFPATH, 1);

Tada procesas yra „daemonizuojamas“: jis sukuria antrinę proceso kopiją iškviesdamas fork ir naują seansą antriniame procese (skambinant setsid). Pirminio proceso nebereikia ir jis išeina:

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

Nutraukus pirminį procesą, užrakto failo užraktas atleidžiamas. Be to, reikia atnaujinti vaiko PID faile. Po to užpildoma užduočių duomenų bazė:

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

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

Tada cron pereina prie pagrindinio darbo ciklo. Tačiau prieš tai verta pasidomėti užduočių sąrašo įkėlimu.

Užduočių sąrašo rinkimas ir atnaujinimas

Funkcija load_database yra atsakinga už užduočių sąrašo įkėlimą. Jis patikrina pagrindinį sistemos crontab ir katalogą su vartotojo failais. Jei failai ir katalogas nepasikeitė, užduočių sąrašas iš naujo neskaitomas. Priešingu atveju pradeda formuotis naujas užduočių sąrašas.

Sistemos failo su specialiais failų ir lentelių pavadinimais įkėlimas:

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

Vartotojų lentelių įkėlimas ciklu:

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

Po to senoji duomenų bazė pakeičiama nauja.

Aukščiau pateiktuose pavyzdžiuose funkcijos process_crontab iškvietimas patikrina, ar egzistuoja vartotojas, atitinkantis lentelės failo pavadinimą (nebent jis yra supervartotojas), ir tada iškviečia load_user. Pastarasis jau skaito patį failą eilutė po eilutės:

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

Čia arba aplinkos kintamasis nustatomas (formos VAR=value eilutės) naudojant load_env / env_set funkcijas, arba nuskaitomas užduoties aprašymas (* * * * * /path/to/exec), naudojant funkciją load_entry.

Įrašo objektas, kurį grąžina load_entry, yra mūsų užduotis, įtraukta į bendrą užduočių sąrašą. Pati funkcija atlieka išsamią laiko formato analizę, tačiau mus labiau domina aplinkos kintamųjų ir užduočių paleidimo parametrų formavimas:

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

Pagrindinė kilpa veikia su dabartiniu užduočių sąrašu.

Pagrindinė kilpa

Originalus 7 versijos Unix cron veikė gana paprastai: perskaitė konfigūraciją cikle, paleido dabartinės minutės užduotis kaip supervartotojas ir miegojo iki kitos minutės pradžios. Šis paprastas metodas senesnėse mašinose reikalavo per daug išteklių.

SysV buvo pasiūlyta alternatyvi versija, kurioje demonas užmigo arba iki artimiausios minutės, kuriai buvo apibrėžta užduotis, arba 30 minučių. Mažiau išteklių buvo sunaudota perskaitant konfigūraciją ir tikrinant užduotis šiuo režimu, tačiau greitai atnaujinti užduočių sąrašą tapo nepatogu.

„Vixie cron“ kartą per minutę grįždavo prie užduočių sąrašų tikrinimo, laimei, iki devintojo dešimtmečio pabaigos standartiniuose „Unix“ įrenginiuose buvo daug daugiau išteklių:

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

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

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

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

Funkcija cron_sleep yra tiesiogiai susijusi su užduočių vykdymu, iškviečiant job_runqueue (užduočių išvardijimas ir vykdymas) ir do_command (paleisti kiekvieną atskirą užduotį) funkcijas. Paskutinę funkciją verta panagrinėti išsamiau.

Vykdyti užduotį

Funkcija do_command vykdoma geru Unix stiliumi, tai yra, ji atlieka užduotį asinchroniškai. Pirminis procesas toliau paleidžia užduotis, antrinis procesas rengia užduočių procesą:

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

Child_procese yra gana daug logikos: jis paima į save standartinius išvesties ir klaidų srautus, kad vėliau išsiųstų į paštą (jeigu MAILTO aplinkos kintamasis nurodytas užduočių lentelėje), ir galiausiai laukia pagrindinio užduoties užbaigimo procesas.

Užduoties procesą sudaro kita šakutė:

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

Tai iš esmės viskas, kas yra cron. Praleidau keletą įdomių detalių, pavyzdžiui, nutolusių vartotojų apskaitą, bet nubrėžiau pagrindinį dalyką.

Afterword

Cron yra stebėtinai paprasta ir naudinga programa, sukurta pagal geriausias Unix pasaulio tradicijas. Ji nieko papildomai nedaro, bet jau kelis dešimtmečius savo darbą atlieka nuostabiai. Susipažinimas su Ubuntu pateikiamos versijos kodu užtruko ne ilgiau nei valandą, o man buvo labai smagu! Tikiuosi, kad galėjau tuo pasidalinti su jumis.

Nežinau kaip jums, bet man šiek tiek liūdna suvokti, kad šiuolaikinis programavimas, turintis tendenciją pernelyg sudėtingai ir pernelyg abstraktiai, jau seniai nebuvo palankus tokiam paprastumui.

Yra daug modernių cron alternatyvų: systemd-timers leidžia organizuoti sudėtingas sistemas su priklausomybėmis, fcron leidžia lanksčiau reguliuoti išteklių suvartojimą pagal užduotis. Bet man asmeniškai visada užtekdavo paprasčiausio crontab.

Trumpai tariant, mylėkite Unix, naudokite paprastas programas ir nepamirškite perskaityti savo platformos mana!

Šaltinis: www.habr.com

„Cron“ sistemoje „Linux“: istorija, naudojimas ir įrenginys