De klassiker skreau dat lokkige oeren net sjen. Yn dy wylde tiden wiene der noch programmeurs noch Unix, mar hjoed de dei witte programmeurs it wis: cron sil de tiid byhâlde ynstee fan harren.

Utilities foar kommandorigel binne sawol in swakte as in kar foar my. sed, awk, wc, cut en oare âlde programma's wurde útfierd troch skripts op ús tsjinners alle dagen. In protte fan harren binne ûntworpen as taken foar cron, in planner oarspronklik út 'e jierren '70.

Ik brûkte in lange tiid cron oerflakkich, sûnder yn details te gean, mar op in dei, doe't ik in flater tsjinkaam by it útfieren fan in skript, besleat ik it goed nei te sjen. Dit is hoe't dit artikel ferskynde, wylst ik it skreau, waard ik bekend mei POSIX crontab, de wichtichste cron-opsjes yn populêre Linux-distribúsjes en de struktuer fan guon fan har.

Brûk jo Linux en rinne cron-taken? Binne jo ynteressearre yn systeemapplikaasje-arsjitektuer yn Unix? Dan binne wy ​​ûnderweis!

Ynhâld

• Oarsprong fan soarten
• POSIX crontab
• Bêste ferkeaper - Vixie cron 3.0pl1
• cron op Debian en Ubuntu
• cronie op Red Hat, Fedora en CentOS
• cronie yn SLES en openSUSE
• Vixie cron apparaat
• Nei wurd

Oarsprong fan soarten

Periodyk útfiering fan brûkers- of systeemprogramma's is in foar de hân lizzende needsaak yn alle bestjoeringssystemen. Dêrom realisearre programmeurs de needsaak foar tsjinsten dy't har mooglik meitsje om taken sintraal te plannen en út te fieren in lange tiid lyn.

Unix-like bestjoeringssystemen trace har oarsprong werom nei Ferzje 7 Unix, ûntwikkele yn 'e jierren '70 fan' e foarige ieu by Bell Labs, ynklusyf troch de ferneamde Ken Thompson. Ferzje 7 Unix omfette ek cron, in tsjinst foar it regelmjittich útfieren fan superuser-taken.

In typysk moderne cron is in ienfâldich programma, mar it bestjoeringsalgoritme fan 'e orizjinele ferzje wie noch ienfâldiger: de tsjinst waard ien kear yn' e minút wekker, lies in tabel mei taken út ien bestân (/etc/lib/crontab) en útfierd foar de superuser dy taken dy't op it hjoeddeiske momint moatte wurde útfierd.

Dêrnei waarden ferbettere ferzjes fan 'e ienfâldige en nuttige tsjinst levere mei alle Unix-like bestjoeringssystemen.

Algemiene beskriuwingen fan it crontab-formaat en de basisprinsipes fan 'e wurking fan it nut waarden opnommen yn' e haadstandert fan Unix-lykas bestjoeringssystemen - POSIX - yn 1992, en sadwaande waard cron fan in de facto standert in de jure standert.

Yn 1987 liet Paul Vixie, nei't Unix-brûkers ûndersocht hawwe oer har winsken foar cron, in oare ferzje fan 'e daemon frij dy't guon fan' e problemen fan tradisjonele cron korrizjearre en de syntaksis fan tabelbestannen útwreide.

Troch de tredde ferzje fan Vixie cron begon te foldwaan oan POSIX-easken, boppedat hie it programma in liberale lisinsje, of leaver, d'r wie hielendal gjin lisinsje, útsein de winsken yn 'e README: de skriuwer jout gjin garânsjes, de namme fan' e auteur kin net wiske wurde, en it programma kin allinnich ferkocht wurde tegearre mei boarne koade. Dizze easken die bliken kompatibel te wêzen mei de prinsipes fan fergese software dy't yn dy jierren populêr waard, dus guon fan 'e wichtige Linux-distribúsjes dy't ferskynden yn' e iere jierren '90 namen Vixie cron as har systeem ien en ûntwikkelje it hjoed noch.

Benammen Red Hat en SUSE ûntwikkelje in gabel fan Vixie cron - cronie, en Debian en Ubuntu brûke de orizjinele edysje fan Vixie cron mei in protte patches.

Litte wy earst yn 'e kunde komme mei de crontab foar brûkersprogramma beskreaun yn POSIX, wêrnei't wy sille sjen nei de syntaksis-útwreidings dy't yn Vixie cron wurde levere en it gebrûk fan farianten fan Vixie cron yn populêre Linux-distribúsjes. En úteinlik is de kers op 'e taart de analyze fan it cron daemon-apparaat.

POSIX crontab

As de orizjinele cron altyd wurke foar de superuser, moderne planners omgean faak mei taken fan gewoane brûkers, dat is feiliger en handiger.

Crons wurde levere as in set fan twa programma's: de konstant rinnende cron-daemon en it crontab-hulpprogramma beskikber foar brûkers. De lêste lit jo taaktabellen spesifyk foar elke brûker yn it systeem bewurkje, wylst de daemon taken fan brûkers- en systeemtabellen lanseart.

В POSIX standert it gedrach fan 'e daemon wurdt op gjin inkelde manier beskreaun en allinich it brûkersprogramma is formalisearre crontab. It bestean fan meganismen foar it starten fan brûkerstaken wurdt fansels ymplisearre, mar net yn detail beskreaun.

Troch it crontab-hulpprogramma op te roppen, kinne jo fjouwer dingen dwaan: de taaktabel fan de brûker yn 'e bewurker bewurkje, de tabel út in bestân laden, de aktuele taaktabel sjen litte en de taaktabel wiskje. Foarbylden fan hoe't it crontab-hulpprogramma wurket:

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

Wannear't neamd crontab -e de bewurker oantsjutte yn de standert omjouwingsfariabele sil brûkt wurde EDITOR.

De taken sels wurde beskreaun yn it folgjende formaat:

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

De earste fiif fjilden fan 'e records: minuten [1..60], oeren [0..23], dagen fan 'e moanne [1..31], moannen [1..12], dagen fan' e wike [0. .6], dêr't 0 is snein. It lêste, seisde, fjild is in rigel dy't sil wurde útfierd troch de standert kommando-interpreter.

Yn 'e earste fiif fjilden kinne wearden wurde neamd skieden troch komma's:

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

Of mei in koppelteken:

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

Brûkers tagong ta taakplanning wurdt regele yn POSIX troch de cron.allow- en cron.deny-bestannen, dy't respektivelik brûkers listje mei tagong ta crontab en brûkers sûnder tagong ta it programma. De standert regelet de lokaasje fan dizze bestannen op gjin inkelde manier.

Neffens de standert moatte op syn minst fjouwer omjouwingsfariabelen wurde trochjûn oan lansearre programma's:

1. HOME - brûker syn thús triemtafel.
2. LOGNAME - brûkersoanmelding.
3. PATH is it paad wêr't jo standert systeemhulpprogramma's kinne fine.
4. SHELL - paad nei de brûkte kommando-tolk.

Opmerklik seit POSIX neat oer wêr't de wearden foar dizze fariabelen weikomme.

Bêste ferkeaper - Vixie cron 3.0pl1

De mienskiplike foarfaar fan populêre cron-farianten is Vixie cron 3.0pl1, yntrodusearre yn 'e comp.sources.unix-mailinglist yn 1992. Wy sille beskôgje de wichtichste skaaimerken fan dizze ferzje yn mear detail.

Vixie cron komt yn twa programma's (cron en crontab). Lykas gewoanlik is de daemon ferantwurdlik foar it lêzen en útfieren fan taken fan 'e systeemtaaktafel en yndividuele brûkerstaaktabellen, en it crontab-hulpprogramma is ferantwurdlik foar it bewurkjen fan brûkerstabellen.

Taak tabel en konfiguraasje triemmen

De superuser taaktabel leit yn /etc/crontab. De syntaksis fan 'e systeemtabel komt oerien mei de syntaksis fan Vixie cron, mei útsûndering dat de sechsde kolom dêryn de namme oanjout fan de brûker ûnder waans namme de taak wurdt lansearre:

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

Regelmjittige brûkerstaaktabellen lizze yn /var/cron/tabs/brûkersnamme en brûke deselde syntaksis. As jo ​​​​it crontab-hulpprogramma as brûker útfiere, binne dit de bestannen dy't wurde bewurke.

De listen mei brûkers mei tagong ta crontab wurde beheard yn 'e /var/cron/allow en /var/cron/deny-bestannen, wêr't jo gewoan de brûkersnamme yn in aparte rigel moatte ynfiere.

Utwreide syntaksis

Yn ferliking mei POSIX crontab befettet de oplossing fan Paul Vixey ferskate heul nuttige oanpassingen oan 'e syntaksis fan' e taaktabellen fan it nut.

In nije tabelsyntaksis is beskikber wurden: jo kinne bygelyks dagen fan 'e wike of moannen opjaan by namme (moandei, di, ensfh.):

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

Jo kinne de stap opjaan wêrmei't taken wurde lansearre:

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

Stappen en yntervallen kinne wurde mingd:

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

Yntuïtive alternativen foar de gewoane syntaksis wurde stipe (herstart, jierliks, jierliks, moanliks, wykliks, deistich, middernacht, oere):

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

Taak útfiering omjouwing

Vixie cron kinne jo de omjouwing feroarje fan rinnende applikaasjes.

De omjouwingsfariabelen USER, LOGNAME en HOME wurde net gewoan levere troch de daemon, mar wurde nommen út in bestân passwd. De PATH-fariabele is ynsteld op "/usr/bin:/bin" en de SHELL-fariabele is ynsteld op "/bin/sh". De wearden fan alle fariabelen útsein LOGNAME kinne wurde feroare yn brûkerstabellen.

Guon omjouwingsfariabelen (benammen SHELL en HOME) wurde brûkt troch cron sels om de taak út te fieren. Hjir is wat it brûken fan bash ynstee fan standert sh om oanpaste taken út te fieren kin der útsjen:

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

Uteinlik sille alle omjouwingsfariabelen definieare yn 'e tabel (brûkt troch cron of nedich troch it proses) wurde trochjûn nei de rinnende taak.

Om bestannen te bewurkjen, brûkt crontab de bewurker oantsjutte yn 'e VISUAL of EDITOR omjouwingsfariabele. As de omjouwing dêr't crontab waard útfierd dizze fariabelen net definiearre hat, dan wurdt "/usr/ucb/vi" brûkt (ucb is wierskynlik de Universiteit fan Kalifornje, Berkeley).

cron op Debian en Ubuntu

De ûntwikkelders fan Debian en derivative distribúsjes hawwe frijlitten tige wizige ferzje Vixie cron ferzje 3.0pl1. D'r binne gjin ferskillen yn 'e syntaksis fan tabelbestannen; foar brûkers is it deselde Vixie cron. Grutste nije funksje: Stipe syslog, SELinux и PAM.

Minder opfallend, mar taastbere feroarings omfetsje de lokaasje fan konfiguraasjebestannen en taaktabellen.

Brûkertabellen yn Debian lizze yn 'e map /var/spool/cron/crontabs, de systeemtabel is der noch - yn /etc/crontab. Debian-pakket-spesifike taaktabellen wurde pleatst yn /etc/cron.d, wêrfan de cron-daemon se automatysk lêst. Brûkers tagongskontrôle wurdt regele troch de /etc/cron.allow- en /etc/cron.deny-bestannen.

De standert shell is noch /bin/sh, dy't yn Debian in lytse POSIX-kompatibele shell is dash, lansearre sûnder konfiguraasje te lêzen (yn net-ynteraktive modus).

Cron sels yn 'e lêste ferzjes fan Debian wurdt lansearre fia systemd, en de startkonfiguraasje kin besjoen wurde yn /lib/systemd/system/cron.service. D'r is neat spesjaal yn 'e tsjinstkonfiguraasje; elk subtilere taakbehear kin dien wurde fia omjouwingsfariabelen dy't direkt yn 'e crontab fan elke brûker ferklearre wurde.

cronie op RedHat, Fedora en CentOS

crony - foarke fan Vixie cron ferzje 4.1. Lykas yn Debian is de syntaksis net feroare, mar stipe foar PAM en SELinux, wurkje yn in kluster, tracking fan bestannen mei inotify en oare funksjes is tafoege.

De standertkonfiguraasje is op 'e gewoane plakken: de systeemtabel is yn /etc/crontab, pakketten sette har tabellen yn /etc/cron.d, brûkerstabellen gean yn /var/spool/cron/crontabs.

De daemon rint ûnder systemd kontrôle, de tsjinst konfiguraasje is /lib/systemd/system/crond.service.

Op Red Hat-like distribúsjes wurdt /bin/sh standert brûkt by it opstarten, dat is de standert bash. It moat opmurken wurde dat by it útfieren fan cron-banen fia /bin/sh, de bash-shell begjint yn POSIX-kompatibele modus en lêst gjin ekstra konfiguraasje, rint yn net-ynteraktive modus.

cronie yn SLES en openSUSE

De Dútske distribúsje SLES en syn derivative openSUSE brûke deselde cronie. De daemon hjir wurdt ek lansearre ûnder systemd, de tsjinst konfiguraasje leit yn /usr/lib/systemd/system/cron.service. Konfiguraasje: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh is deselde bash dy't rint yn POSIX-kompatibele net-ynteraktive modus.

Vixie cron apparaat

Moderne neikommelingen fan cron binne net radikaal feroare yn ferliking mei Vixie cron, mar hawwe dochs nije funksjes krigen dy't net nedich binne om de prinsipes fan it programma te begripen. In protte fan dizze tafoegings binne min ûntwurpen en betiizje de koade. De orizjinele cron-boarnekoade fan Paul Vixey is in genot om te lêzen.

Dêrom besleat ik it cron-apparaat te analysearjen mei it foarbyld fan in cron-programma mienskiplik foar beide tûken fan ûntwikkeling - Vixie cron 3.0pl1. Ik sil de foarbylden ferienfâldigje troch ifdefs te ferwiderjen dy't it lêzen komplisearje en lytse details weilitte.

It wurk fan 'e demon kin ferdield wurde yn ferskate stadia:

1. Programma inisjalisaasje.
2. It sammeljen en bywurkjen fan de list mei taken om út te fieren.
3. Main cron loop rint.
4. Begjin in taak.

Litte wy se yn folchoarder besjen.

Inisjalisaasje

As it is begon, nei it kontrolearjen fan de prosesarguminten, ynstalleart cron de SIGCHLD- en SIGHUP-sinjaalhannelers. De earste makket in log-yngong oer it beëinigjen fan it bernproses, de twadde slút de triembeskriuwing fan it logbestân:

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

De cron-daemon rint altyd allinich op it systeem, allinich as in superuser en fan 'e haad cron-map. De folgjende oproppen meitsje in slotbestân mei de PID fan it daemonproses, soargje derfoar dat de brûker korrekt is en feroarje de aktuele map nei de wichtichste:

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

It standertpaad is ynsteld, dat sil brûkt wurde by it starten fan prosessen:

setenv("PATH", _PATH_DEFPATH, 1);

Dan wurdt it proses "daemonisearre": it makket in bernkopy fan it proses troch foarke te roppen en in nije sesje yn it bernproses (oprop setsid). It âlderproses is net mear nedich, en it giet út:

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

Beëiniging fan it âlderproses makket it slot op it slotbestân frij. Derneist is it nedich om de PID yn it bestân by it bern te aktualisearjen. Hjirnei wurdt de taakdatabase ynfolle:

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

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

Dan giet cron troch nei de haadwurksyklus. Mar dêrfoar is it de muoite wurdich om te sjen nei it laden fan de taaklist.

It sammeljen en bywurkjen fan de taaklist

De funksje load_database is ferantwurdlik foar it laden fan de list mei taken. It kontrolearret de crontab fan it haadsysteem en de map mei brûkersbestannen. As de triemmen en triemtafel net feroare binne, wurdt de taaklist net opnij lêzen. Oars begjint in nije list fan taken te foarmjen.

It laden fan in systeembestân mei spesjale triem- en tabelnammen:

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

Brûkerstabellen yn in loop laden:

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

Dêrnei wurdt de âlde databank ferfongen troch in nije.

Yn 'e foarbylden hjirboppe ferifiearret de process_crontab-funksjeoprop dat in brûker dy't oerienkomt mei de tabelbestânnamme bestiet (útsein as it in superuser is) en ropt dan load_user op. De lêste lêst de triem sels al rigel foar rigel:

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

Hjir is of de omjouwingsfariabele ynsteld (rigels fan 'e foarm VAR = wearde) mei de load_env / env_set funksjes, of de taakbeskriuwing wurdt lêzen (* * * * * /path/to/exec) mei de load_entry-funksje.

De yngongsentiteit dy't load_entry werombringt is ús taak, dy't pleatst wurdt yn 'e algemiene list mei taken. De funksje sels docht in verbose parsing fan it tiidformaat, mar wy binne mear ynteressearre yn 'e foarming fan omjouwingsfariabelen en taakstartparameters:

/* пользователь и группа для запуска задачи берутся из 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 haadloop wurket mei de aktuele list fan taken.

Main Loop

De orizjinele cron fan Ferzje 7 Unix wurke frij ienfâldich: it lies de konfiguraasje opnij yn in lus, lansearre de taken fan 'e hjoeddeistige minút as in superbrûker en sliepte oant it begjin fan' e folgjende minút. Dizze ienfâldige oanpak op âldere masines easke tefolle boarnen.

In alternative ferzje waard foarsteld yn SysV, wêryn de daemon gie yn 'e sliep of oant de tichtste minút wêrfoar de taak waard definiearre, of foar 30 minuten. Minder boarnen waarden konsumearre foar it opnij lêzen fan de konfiguraasje en it kontrolearjen fan taken yn dizze modus, mar fluch bywurkjen fan de list mei taken waard ûngemaklik.

Vixie cron kaam werom nei it kontrolearjen fan taaklisten ien kear yn 'e minút, gelokkich wiene d'r oan 'e ein fan' e jierren '80 signifikant mear boarnen op standert Unix-masines:

/* первичная загрузка задач */
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 funksje cron_sleep is direkt belutsen by it útfieren fan taken, ropt de funksjes job_runqueue (enumerate en útfiere taken) en do_command (rinne elke yndividuele taak). De lêste funksje is it wurdich om yn mear detail te ûndersiikjen.

In taak útfiere

De do_command-funksje wurdt útfierd yn goede Unix-styl, dat is, it docht in foarke om de taak asynchronysk út te fieren. It âlderproses giet troch mei it starten fan taken, it bernproses taret it taakproses op:

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

D'r is nochal in soad logika yn child_process: it nimt standert útfier- en flaterstreamen op himsels, om it dan nei e-post te stjoeren (as de MAILTO-omjouwingsfariabele is spesifisearre yn 'e taaktabel), en, as lêste, wachtet op' e haad proses fan 'e taak om te foltôgjen.

It taakproses wurdt foarme troch in oare gabel:

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

Dat is yn prinsipe alles wat cron is. Ik haw wat nijsgjirrige details weglitten, bygelyks accounting foar brûkers op ôfstân, mar ik sketste it wichtichste.

Nei wurd

Cron is in ferrassend ienfâldich en brûkber programma, makke yn 'e bêste tradysjes fan' e Unix-wrâld. Se docht neat ekstra, mar se docht har wurk al in pear desennia prachtich. It duorre net mear as in oere om yn 'e kunde te kommen mei de koade foar de ferzje dy't komt mei Ubuntu, en ik hie in protte wille! Ik hoopje dat ik it mei jo diele koe.

Ik wit net oer dy, mar ik bin in bytsje fertrietlik om te realisearjen dat moderne programmearring, mei syn oanstriid om te komplisearjend en te abstrakt, net befoarderlik west hat foar sa'n ienfâld foar in lange tiid.

D'r binne in protte moderne alternativen foar cron: systemd-timers kinne jo komplekse systemen organisearje mei ôfhinklikens, fcron kinne jo boarneferbrûk fleksibeler regelje troch taken. Mar persoanlik wie de ienfâldichste crontab altyd genôch foar my.

Koartsein, hâld fan Unix, brûk ienfâldige programma's en ferjit net de mana foar jo platfoarm te lêzen!

Boarne: www.habr.com