ProHoster > Blog > Administratioun > Cron am Linux: Geschicht, Benotzung an Apparat

Cron am Linux: Geschicht, Benotzung an Apparat

Cron am Linux: Geschicht, Benotzung an Apparat

De Klassiker huet geschriwwen datt glécklech Stonnen net kucken. An deene wilde Zäite waren et weder Programméierer nach Unix, awer haut wëssen Programméierer sécher: Cron wäert d'Zäit verfollegen amplaz hinnen.

Kommando Linn Utilities si souwuel eng Schwächt an eng Aarbecht fir mech. sed, awk, wc, cut an aner al Programmer gi vun Scripten op eise Serveren all Dag lafen. Vill vun hinnen sinn als Aufgaben fir Cron entworf, e Scheduler ursprénglech aus de 70er.

Laang Zäit hunn ech cron iwwerflächlech benotzt, ouni an Detailer ze goen, awer enges Daags, wéi ech e Feeler begéint hunn beim Laafen vun engem Skript, hunn ech decidéiert et grëndlech nozekucken. Dëst ass wéi dësen Artikel erschéngt, wärend ech et schreiwen hunn ech vertraut mat POSIX crontab, d'Haapt Cron Optiounen a populäre Linux Verdeelungen an d'Struktur vun e puer vun hinnen.

Benotzt Dir Linux a laaft Cron Aufgaben? Sidd Dir un der Systemapplikatiounsarchitektur an Unix interesséiert? Da si mir ënnerwee!

Inhalt

Urspronk vun Aarten

Periodesch Ausféierung vu Benotzer- oder Systemprogrammer ass eng offensichtlech Noutwennegkeet an all Betribssystemer. Dofir hunn d'Programméierer d'Bedierfnes fir Servicer realiséiert, déi et hinnen erlaben zentral Aufgaben viru laanger Zäit ze plangen an auszeféieren.

Unix-ähnlech Betribssystemer verfollegen hir Originen zréck op d'Versioun 7 Unix, entwéckelt an de 70er vum leschte Joerhonnert bei Bell Labs, och vum berühmten Ken Thompson. Versioun 7 Unix enthält och Cron, e Service fir regelméisseg Superuser Aufgaben ze lafen.

En typesche modernen Cron ass en einfache Programm, awer de Betribsalgorithmus vun der Originalversioun war nach méi einfach: de Service ass eemol pro Minutt erwächt, en Dësch mat Aufgaben aus enger eenzeger Datei gelies (/etc/lib/crontab) a fir de superuser déi Aufgaben déi am aktuelle Moment solle gemaach ginn.

Duerno goufen verbessert Versioune vum einfachen an nëtzlechen Service mat all Unix-ähnlechen Betribssystemer geliwwert.

Generaliséiert Beschreiwunge vum Crontab-Format an d'Basisprinzipien vun der Operatioun vum Utility goufen am Haaptstandard vun Unix-ähnleche Betribssystemer - POSIX - am Joer 1992 abegraff, an domat gouf Cron aus engem de facto Standard e de jure Standard.

Am 1987 huet de Paul Vixie, no Unix Benotzer iwwer hir Wënsch fir Cron, eng aner Versioun vum Daemon verëffentlecht, deen e puer vun de Probleemer vum traditionelle Cron korrigéiert an d'Syntax vun Tabelledateien ausgebaut huet.

Vun der drëtter Versioun vun Vixie Cron ugefaang POSIX Ufuerderunge ze treffen, Zousätzlech, de Programm hat eng liberal Lizenz, oder éischter et war keng Lizenz iwwerhaapt, ausser de Wënsch an der README: den Auteur gëtt keng Garantien, den Auteur säin Numm kann net geläscht ginn, an de Programm kann nëmmen zesumme mat Quelltext verkaf ginn. Dës Ufuerderunge hu sech als kompatibel mat de Prinzipien vun der gratis Software erausgestallt, déi an deene Joeren Popularitéit gewonnen huet, sou datt e puer vun de Schlëssel Linux Verdeelungen, déi an de fréien 90er opgetaucht sinn, Vixie Cron als hire System geholl hunn an et haut nach entwéckelen.

Besonnesch Red Hat an SUSE entwéckelen eng Gabel vu Vixie cron - cronie, an Debian an Ubuntu benotzen d'Original Editioun vu Vixie cron mat ville Patches.

Loosst eis als éischt d'Benotzer Utility crontab kennen, déi am POSIX beschriwwe gëtt, duerno wäerte mir d'Syntaxverlängerunge kucken, déi am Vixie cron geliwwert ginn an d'Benotzung vu Variatiounen vu Vixie cron a populäre Linux Verdeelungen. A schlussendlech ass d'Kiischt um Kuch d'Analyse vum Cron Daemon Apparat.

POSIX crontab

Wann den ursprénglechen Cron ëmmer fir de Superuser geschafft huet, këmmeren modern Scheduler dacks mat Aufgaben vun gewéinleche Benotzer, wat méi sécher a praktesch ass.

Crons ginn als Set vun zwee Programmer geliwwert: de stänneg lafende Cron-Daemon an d'Crontab-Utility verfügbar fir d'Benotzer. Déi lescht erlaabt Iech Tasktabellen spezifesch fir all Benotzer am System z'änneren, während den Daemon Aufgaben aus Benotzer- a Systemtabellen lancéiert.

В POSIX Standard d'Behuele vum Daemon gëtt op kee Fall beschriwwen an nëmmen de Benotzerprogramm ass formaliséiert crontab. D'Existenz vu Mechanismen fir d'Start vun BenotzerAufgaben ass natierlech implizéiert, awer net am Detail beschriwwen.

Andeems Dir de Crontab Utility nennt, kënnt Dir véier Saache maachen: d'Tasktabell vum Benotzer am Editor änneren, d'Tabell aus enger Datei lueden, déi aktuell Tasktabel weisen an d'Tasktabell läschen. Beispiller vu wéi de crontab Utility funktionnéiert:

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

Wann genannt crontab -e den Redakter spezifizéiert an der Standard Ëmfeld Variabel gëtt benotzt EDITOR.

D'Aufgaben selwer ginn am folgende Format beschriwwen:

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

Déi éischt fënnef Felder vun de Rekorder: Minutten [1..60], Stonnen [0..23], Deeg vum Mount [1..31], Méint [1..12], Deeg vun der Woch [0. .6], wou 0 Sonndeg ass. Dat lescht, sechsten, Feld ass eng Zeil déi vum Standard Kommando Dolmetscher ausgefouert gëtt.

An den éischte fënnef Felder kënnen Wäerter getrennt vu Komma opgelëscht ginn:

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

Oder mat engem Bindestrich:

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

Benotzer Zougang zu Task Scheduling ass am POSIX vun der cron.allow an cron.deny Fichieren reglementéiert, déi Benotzer mat Zougang zu crontab an Benotzer ouni Zougang zu de Programm Lëscht, respektiv. De Standard reguléiert op kee Fall d'Plaz vun dësen Dateien.

Geméiss dem Standard mussen op d'mannst véier Ëmfeldvariablen u lancéiert Programmer weiderginn:

  1. HOME - den Heemverzeechnes vum Benotzer.
  2. LOGNAME - Benotzer Login.
  3. PATH ass de Wee wou Dir Standard System Utilities fannt.
  4. SHELL - Wee zum benotzte Kommando Dolmetscher.

Notamment seet POSIX näischt iwwer wou d'Wäerter fir dës Variablen hierkommen.

Beschte Verkeefer - Vixie Cron 3.0pl1

De gemeinsame Virfahre vu populäre Cron Varianten ass Vixie Cron 3.0pl1, agefouert an der comp.sources.unix Mailing Lëscht am Joer 1992. Mir wäerten d'Haaptmerkmale vun dëser Versioun méi detailléiert betruechten.

Vixie cron kënnt an zwee Programmer (cron an crontab). Wéi gewinnt ass den Daemon verantwortlech fir d'Liesen an d'Ausféierung vun Aufgaben aus der Systemtask-Tabelle an eenzelne Benotzer-Task-Tabellen, an d'Crontab-Utility ass verantwortlech fir d'Benotzertabellen z'änneren.

Aufgab Dësch an Configuratioun Fichieren

D'Superuser Task Tabell ass an /etc/crontab. D'Syntax vum Systemtabel entsprécht der Syntax vum Vixie cron, mat Ausnam datt déi sechst Kolonn dran den Numm vum Benotzer uginn, ënner deem d'Aufgab lancéiert gëtt:

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

Regelméisseg Benotzer Task Dëscher sinn an /var/cron/tabs/username lokaliséiert a benotzen déiselwecht Syntax. Wann Dir de crontab Utility als Benotzer leeft, sinn dës Dateien déi geännert ginn.

D'Lëschte vun de Benotzer mat Zougang zu Crontab ginn an den /var/cron/allow an /var/cron/deny Dateien geréiert, wou Dir just de Benotzernumm an enger separater Linn aginn musst.

Verlängert Syntax

Am Verglach mam POSIX crontab enthält dem Paul Vixey seng Léisung verschidde ganz nëtzlech Ännerunge fir d'Syntax vun den Tasktabellen vum Utility.

Eng nei Tabellsyntax ass verfügbar ginn: Dir kënnt zum Beispill Deeg vun der Woch oder Méint mam Numm uginn (Mon, Di, a sou weider):

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

Dir kënnt de Schrëtt spezifizéieren duerch déi Aufgaben lancéiert ginn:

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

Schrëtt an Intervalle kënne gemëscht ginn:

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

Intuitiv Alternativen zu der üblecher Syntax ginn ënnerstëtzt (Neistart, jäerlech, jäerlech, monatlech, wëchentlech, deeglech, Mëtternuecht, all Stonn):

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

Aufgab Ausféierung Ëmfeld

Vixie cron erlaabt Iech d'Ëmfeld vun den Uwendungen z'änneren.

D'Ëmfeldsvariablen USER, LOGNAME an HOME ginn net einfach vum Daemon geliwwert, mee aus enger Datei geholl passwd. D'PATH Variabel ass op "/usr/bin:/bin" gesat an d'SHELL Variabel ass op "/bin/sh" gesat. D'Wäerter vun all Variablen ausser LOGNAME kënnen an de Benotzertabellen geännert ginn.

E puer Ëmfeldvariablen (virun allem SHELL an HOME) gi vum Cron selwer benotzt fir d'Aufgab auszeféieren. Hei ass wéi Dir Bash benotzt anstatt Standard sh fir personaliséiert Aufgaben auszeféieren kéint ausgesinn:

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

Schlussendlech ginn all Ëmfeldvariablen, déi an der Tabell definéiert sinn (benotzt vum Cron oder vum Prozess gebraucht) un déi lafend Aufgab weiderginn.

Fir Dateien z'änneren, benotzt crontab den Editor, deen an der VISUAL oder EDITOR Ëmfeldvariabel spezifizéiert ass. Wann d'Ëmfeld wou crontab leeft dës Variabelen net definéiert hunn, da gëtt "/usr/ucb/vi" benotzt (ucb ass wahrscheinlech d'Universitéit vu Kalifornien, Berkeley).

cron op Debian an Ubuntu

D'Entwéckler vun Debian an derivative Verdeelungen hunn verëffentlecht héich geännert Versioun Vixie Cron Versioun 3.0pl1. Et gi keng Differenzen an der Syntax vun Dëschdateien; fir Benotzer ass et deeselwechte Vixie Cron. Gréissten Neie Feature: Ënnerstëtzung syslog, SELinux и posin.

Manner merkbar, awer konkret Ännerungen enthalen d'Plaz vun Konfiguratiounsdateien an Tasktabellen.

Benotzertabellen an Debian sinn am /var/spool/cron/crontabs Verzeichnis, de Systemtabel ass nach ëmmer do - an /etc/crontab. Debian Package-spezifesch Task Dëscher ginn an /etc/cron.d plazéiert, vu wou de Cron Daemon se automatesch liest. Benotzer Zougang Kontroll gëtt vun de /etc/cron.allow an /etc/cron.deny Dateien kontrolléiert.

D'Standard Shell ass nach ëmmer /bin/sh, wat an Debian eng kleng POSIX-kompatibel Shell ass Bindestrich, lancéiert ouni Konfiguratioun ze liesen (am net-interaktiven Modus).

Cron selwer an de leschte Versioune vun Debian gëtt iwwer Systemd gestart, an d'Startkonfiguratioun kann an /lib/systemd/system/cron.service gekuckt ginn. Et gëtt näischt Besonnesches an der Servicekonfiguratioun; all méi subtil Aufgabemanagement kann duerch Ëmfeldvariablen gemaach ginn, déi direkt an der Crontab vun all Benotzer deklaréiert ginn.

cronie op RedHat, Fedora an CentOS

Cronie - Gabel vu Vixie Cron Versioun 4.1. Wéi an Debian huet d'Syntax net geännert, awer d'Ënnerstëtzung fir PAM an SELinux, an engem Cluster schaffen, Tracking Dateien mat Inotify an aner Features gouf bäigefüügt.

D'Standardkonfiguratioun ass op den übleche Plazen: de Systemtabel ass an /etc/crontab, Packagen setzen hir Dëscher an /etc/cron.d, Benotzertabellen ginn an /var/spool/cron/crontabs.

Den Daemon leeft ënner systemdéiert Kontroll, d'Servicekonfiguratioun ass /lib/systemd/system/crond.service.

Op Red Hat-ähnleche Verdeelungen, / bin / sh gëtt als Standard beim Startup benotzt, wat de Standard Bash ass. Et sollt bemierkt datt wann Dir Cron Jobs iwwer / bin / sh leeft, fänkt d'Bash-Shell am POSIX-konforme Modus un a liest keng zousätzlech Konfiguratioun, leeft am net-interaktiven Modus.

cronie an SLES an openSUSE

Déi däitsch Verdeelung SLES a seng Derivat openSUSE benotzen déiselwecht Cronie. Den Daemon hei gëtt och ënner systemd gestart, d'Servicekonfiguratioun ass an /usr/lib/systemd/system/cron.service. Konfiguratioun: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh ass dee selwechte Bash deen am POSIX-kompatibel net-interaktiven Modus leeft.

Vixie Cron Apparat

Modern Nokommen vu Cron hunn net radikal geännert am Verglach zum Vixie Cron, awer nach ëmmer nei Features erfaasst déi net erfuerderlech sinn fir d'Prinzipien vum Programm ze verstoen. Vill vun dësen Extensiounen si schlecht entworf a verwiesselen de Code. Den originelle Cron Quellcode vum Paul Vixey ass e Genoss ze liesen.

Dofir hunn ech decidéiert de Cron-Apparat ze analyséieren mam Beispill vun engem Cron-Programm gemeinsam fir béid Entwécklungszweige - Vixie cron 3.0pl1. Ech wäert d'Beispiller vereinfachen andeems ech Ifdefs ewechhuelen déi d'Liesen komplizéiere a kleng Detailer ausgoen.

D'Aarbecht vum Dämon kann an e puer Etappen opgedeelt ginn:

  1. Programm Initialiséierung.
  2. Sammelen an Aktualiséierung vun der Lëscht vun Aufgaben ze lafen.
  3. Main Cron Loop lafen.
  4. Start eng Aufgab.

Loosst eis se an Uerdnung kucken.

Initialiséierung

Wann ugefaangen, no der Iwwerpréiwung vun de Prozess Argumenter, cron installéiert der SIGCHLD an SIGHUP Signal Handler. Déi éischt mécht e Log-Entrée iwwer d'Kënnegung vum Kandprozess, deen zweeten schléisst den Dateideskriptor vun der Logdatei:

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

De Cron Daemon leeft ëmmer eleng um System, nëmmen als Superuser an aus dem Haapt Cron Verzeichnis. Déi folgend Uriff erstellen eng Sperrdatei mat der PID vum Daemon-Prozess, vergewëssert Iech datt de Benotzer richteg ass a ännert den aktuellen Verzeechnes op den Haapt:

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

De Standardwee ass festgeluecht, dee benotzt gëtt wann Dir Prozesser start:

setenv("PATH", _PATH_DEFPATH, 1);

Da gëtt de Prozess "daemoniséiert": et erstellt eng Kannerkopie vum Prozess andeems Dir Gabel rufft an eng nei Sessioun am Kandprozess (ruffen setsid). Den Elterendeel ass net méi gebraucht, an et geet eraus:

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

D'Kënnegung vum Elterenprozess verëffentlecht d'Spär op der Spärdatei. Zousätzlech ass et néideg d'PID an der Datei op d'Kand ze aktualiséieren. Duerno gëtt d'Taskdatebank ausgefëllt:

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

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

Da geet Cron op den Haaptaarbechtszyklus. Awer virdru ass et derwäert e Bléck op d'Tasklëscht ze lueden.

Sammelen an Aktualiséierung vun der Aufgab Lëscht

D'Funktioun load_database ass verantwortlech fir d'Lëscht vun den Aufgaben ze lueden. Et kontrolléiert den Haaptsystem Crontab an den Verzeechnes mat Benotzerdateien. Wann d'Dateien an den Dossier net geännert hunn, gëtt d'Tasklëscht net nei gelies. Soss fänkt eng nei Lëscht vun Aufgaben un.

Luede eng Systemdatei mat speziellen Datei- an Tabellnamen:

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

Luede Benotzertabellen an enger Loop:

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

Duerno gëtt déi al Datebank duerch eng nei ersat.

An de Beispiller hei uewen, verifizéiert de process_crontab Funktiounsruff datt e Benotzer deen den Dëschdateiernumm entsprécht existéiert (ausser et ass e Superuser) a rifft dann load_user. Déi lescht liest schonn d'Datei selwer Linn fir Zeil:

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

Hei gëtt entweder d'Ëmweltvariabel gesat (Linnen vun der Form VAR = Wäert) mat de Funktiounen load_env / env_set, oder d'Taskbeschreiwung gëtt gelies (* * * * * /path/to/exec) mat der load_entry Funktioun.

D'Entrée Entitéit déi load_entry zréckkënnt ass eis Aufgab, déi an der allgemenger Lëscht vun Aufgaben plazéiert ass. D'Funktioun selwer mécht e verbose Parsing vum Zäitformat, awer mir si méi interesséiert fir d'Bildung vun Ëmfeldvariablen an Taskstartparameter:

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

D'Haaptschleife funktionnéiert mat der aktueller Lëscht vun Aufgaben.

Main Loop

Den ursprénglechen Cron vun der Versioun 7 Unix huet ganz einfach geschafft: et huet d'Konfiguratioun an enger Loop nei gelies, d'Aufgaben vun der aktueller Minutt als Superuser gestart a geschlof bis den Ufank vun der nächster Minutt. Dës einfach Approche op eeler Maschinnen erfuerdert ze vill Ressourcen.

Eng alternativ Versioun gouf am SysV proposéiert, an där den Daemon schlofen ass, entweder bis déi nootste Minutt, fir déi d'Aufgab definéiert gouf, oder fir 30 Minutten. Manner Ressourcen goufen verbraucht fir d'Konfiguratioun nei ze liesen an d'Aufgaben an dësem Modus ze kontrolléieren, awer séier d'Aktualiséierung vun der Lëscht vun den Aufgaben gouf onbequem.

Vixie Cron ass zréck fir d'Tasklëschten eemol d'Minutt ze kontrolléieren, glécklecherweis um Enn vun den 80er waren et wesentlech méi Ressourcen op Standard Unix Maschinnen:

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

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

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

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

D'cron_sleep Funktioun ass direkt an der Ausféierung vun Aufgaben involvéiert, rufft d'job_runqueue (enumeréieren a lafen Aufgaben) an do_command (ausféieren all eenzel Aufgab) Funktiounen. Déi lescht Funktioun ass derwäert méi detailléiert ze ënnersichen.

Lafen eng Aufgab

D'do_command Funktioun gëtt a gudden Unix-Stil ausgefouert, dat heescht, et mécht eng Gabel fir d'Aufgab asynchron auszeféieren. Den Elterenprozess setzt weider Aufgaben un, de Kannerprozess preparéiert den Aufgabeprozess:

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

Et gëtt zimmlech vill Logik am child_process: et hëlt Standardoutput a Fehlerstreamen op sech selwer, fir se dann op d'Mail ze schécken (wann d'MAILTO Ëmfeldvariabel an der Tasktabel uginn ass), a schliisslech waart op den Haapt Prozess vun der Aufgab ze kompletéieren.

Den Aufgabeprozess gëtt vun enger anerer Gabel geformt:

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 ass am Fong alles wat Cron ass. Ech hunn e puer interessant Detailer ewechgelooss, zum Beispill, Rechnung fir Fernbenotzer, awer ech hunn d'Haaptsaach duergestallt.

Afterword

Cron ass en iwwerraschend einfach an nëtzlech Programm, gemaach an de beschten Traditiounen vun der Unix Welt. Si mécht näischt extra, mee si mécht hir Aarbecht wonnerbar fir e puer Joerzéngten elo. Duerch de Code fir d'Versioun ze kommen, déi mat Ubuntu kënnt, huet net méi wéi eng Stonn gedauert, an ech hat vill Spaass! Ech hoffen ech konnt et mat Iech deelen.

Ech weess net iwwer Iech, awer ech sinn e bëssen traureg ze realiséieren datt modern Programméierung, mat senger Tendenz zu iwwerkomplizéiert an iwwerabstrakt, fir sou Einfachheet fir eng laang Zäit net förderlech war.

Et gi vill modern Alternativen zu Cron: systemd-Timer erlaabt Iech komplex Systemer mat Ofhängegkeeten z'organiséieren, fcron erlaabt Iech méi flexibel Ressourceverbrauch duerch Aufgaben ze regelen. Awer perséinlech war den einfachsten Crontab fir mech ëmmer genuch.

Kuerz gesot, Léift Unix, benotzt einfach Programmer a vergiesst net de Mana fir Är Plattform ze liesen!

Source: will.com

Setzt e Commentaire