Klasiķis rakstīja, ka laimīgās stundas neskaties. Tajos mežonīgos laikos nebija ne programmētāju, ne Unix, taču mūsdienās programmētāji droši zina: cron viņu vietā sekos laikam.

Komandrindas utilītas man ir gan vājums, gan darbs. sed, awk, wc, cut un citas vecās programmas katru dienu tiek darbinātas ar skriptiem mūsu serveros. Daudzi no tiem ir paredzēti kā uzdevumi cron, plānotājam, kas sākotnēji bija 70. gados.

Ilgu laiku cron lietoju virspusēji, neiedziļinoties detaļās, taču kādu dienu, kad saskāros ar kļūdu, izpildot skriptu, nolēmu to kārtīgi izpētīt. Šādi parādījās šis raksts, bet rakstot es iepazinos ar POSIX crontab, galvenajām cron opcijām populārajos Linux izplatījumos un dažu no tām struktūru.

Vai izmantojat Linux un veicat cron uzdevumus? Vai jūs interesē sistēmas lietojumprogrammu arhitektūra Unix versijā? Tad mēs esam ceļā!

saturs

Sugas izcelsme
POSIX crontab
Vislabāk pārdotais — Vixie cron 3.0pl1
cron uz Debian un Ubuntu
draugs Red Hat, Fedora un CentOS
draugs SLES un openSUSE
Vixie cron ierīce
Pēcvārds

Sugas izcelsme

Periodiska lietotāju vai sistēmas programmu izpilde ir acīmredzama nepieciešamība visās operētājsistēmās. Tāpēc programmētāji jau sen saprata, ka ir nepieciešami pakalpojumi, kas ļauj centralizēti plānot un izpildīt uzdevumus.

Unix līdzīgu operētājsistēmu pirmsākumi meklējami Unix 7. versijā, ko pagājušā gadsimta 70. gados izstrādāja Bell Labs, tostarp slavenais Kens Tompsons. Unix versijā 7 bija iekļauts arī cron — pakalpojums regulārai superlietotāja uzdevumu izpildei.

Tipiska mūsdienu cron ir vienkārša programma, taču sākotnējās versijas darbības algoritms bija vēl vienkāršāks: pakalpojums pamodās reizi minūtē, nolasīja tabulu ar uzdevumiem no viena faila (/etc/lib/crontab) un veica superlietotājam tos uzdevumus, kas bija jāveic pašreizējā brīdī.

Pēc tam ar visām Unix līdzīgām operētājsistēmām tika piegādātas uzlabotas vienkāršā un noderīga pakalpojuma versijas.

Vispārināti crontab formāta apraksti un utilītas darbības pamatprincipi tika iekļauti galvenajā Unix līdzīgu operētājsistēmu standartā - POSIX - 1992. gadā, un tādējādi cron no de facto standarta kļuva par de jure standartu.

1987. gadā Pols Viksijs, aptaujājis Unix lietotājus par viņu vēlmēm attiecībā uz cron, izlaida citu dēmona versiju, kas izlaboja dažas tradicionālās cron problēmas un paplašināja tabulu failu sintaksi.

Līdz ar trešo Vixie cron versiju sāka atbilst POSIX prasībām, turklāt programmai bija liberāla licence vai drīzāk licences nebija vispār, izņemot README vēlmes: autors nedod garantijas, autora vārds nevar izdzēst, un programmu var pārdot tikai kopā ar pirmkodu. Šīs prasības izrādījās saderīgas ar tajos gados arvien populārākās bezmaksas programmatūras principiem, tāpēc daži no galvenajiem Linux izplatījumiem, kas parādījās 90. gadu sākumā, izmantoja Vixie cron kā savu sistēmu un joprojām to izstrādā.

Jo īpaši Red Hat un SUSE izstrādā Vixie cron - cronie dakšiņu, un Debian un Ubuntu izmanto sākotnējo Vixie cron izdevumu ar daudziem ielāpiem.

Vispirms iepazīsimies ar POSIX aprakstīto lietotāja utilītu crontab, pēc tam apskatīsim Vixie cron nodrošinātos sintakses paplašinājumus un Vixie cron variāciju izmantošanu populārajos Linux izplatījumos. Un visbeidzot, ķirsis uz kūkas ir cron dēmona ierīces analīze.

POSIX crontab

Ja sākotnējais cron vienmēr strādāja superlietotājam, mūsdienu plānotāji bieži vien nodarbojas ar parasto lietotāju uzdevumiem, kas ir drošāk un ērtāk.

Crons tiek piegādāts kā divu programmu komplekts: pastāvīgi darbojas cron dēmons un lietotājiem pieejamā utilīta crontab. Pēdējais ļauj rediģēt uzdevumu tabulas, kas raksturīgas katram sistēmas lietotājam, savukārt dēmons palaiž uzdevumus no lietotāju un sistēmas tabulām.

В POSIX standarts dēmona uzvedība nav aprakstīta nekādā veidā un tiek formalizēta tikai lietotāja programma crontab. Lietotāja uzdevumu palaišanas mehānismu esamība, protams, ir netieša, bet nav detalizēti aprakstīta.

Izsaucot crontab utilītu, varat veikt četras darbības: rediģēt lietotāja uzdevumu tabulu redaktorā, ielādēt tabulu no faila, parādīt pašreizējo uzdevumu tabulu un notīrīt uzdevumu tabulu. Piemēri, kā darbojas utilīta crontab:

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

Kad sauc crontab -e tiks izmantots standarta vides mainīgajā norādītais redaktors EDITOR.

Paši uzdevumi ir aprakstīti šādā formātā:

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

Pirmie pieci ierakstu lauki: minūtes [1..60], stundas [0..23], mēneša dienas [1..31], mēneši [1..12], nedēļas dienas [0. .6], kur 0 ir svētdiena. Pēdējais, sestais, lauks ir rinda, kuru izpildīs standarta komandu tulks.

Pirmajos piecos laukos vērtības var norādīt, atdalot tās ar komatiem:

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

Vai ar defisi:

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

Lietotāju piekļuvi uzdevumu plānošanai POSIX regulē cron.allow un cron.deny faili, kuros ir attiecīgi uzskaitīti lietotāji, kuriem ir piekļuve crontab, un lietotāji, kuriem nav piekļuves programmai. Standarts nekādā veidā neregulē šo failu atrašanās vietu.

Saskaņā ar standartu palaistām programmām ir jānodod vismaz četri vides mainīgie:

HOME - lietotāja mājas direktorijs.
LOGNAME — lietotāja pieteikšanās.
PATH ir ceļš, kurā varat atrast standarta sistēmas utilītas.
SHELL — ceļš uz izmantoto komandu tulku.

Jo īpaši POSIX neko nesaka par to, no kurienes nāk šo mainīgo vērtības.

Vislabāk pārdotais — Vixie cron 3.0pl1

Populāro cron variantu kopīgs priekštecis ir Vixie cron 3.0pl1, kas tika ieviests comp.sources.unix adresātu sarakstā 1992. gadā. Mēs sīkāk apsvērsim šīs versijas galvenās iezīmes.

Vixie cron ir pieejams divās programmās (cron un crontab). Kā parasti, dēmons ir atbildīgs par uzdevumu nolasīšanu un izpildi no sistēmas uzdevumu tabulas un atsevišķu lietotāju uzdevumu tabulām, bet utilīta crontab ir atbildīga par lietotāju tabulu rediģēšanu.

Uzdevumu tabula un konfigurācijas faili

Superlietotāja uzdevumu tabula atrodas mapē /etc/crontab. Sistēmas tabulas sintakse atbilst Vixie cron sintaksei, izņemot to, ka sestajā kolonnā tajā norādīts tā lietotāja vārds, kura vārdā uzdevums tiek palaists:

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

Parastās lietotāju uzdevumu tabulas atrodas mapē /var/cron/tabs/username un izmanto to pašu sintaksi. Palaižot utilītu crontab kā lietotājs, šie ir faili, kas tiek rediģēti.

To lietotāju saraksti, kuriem ir piekļuve crontab, tiek pārvaldīti failos /var/cron/allow un /var/cron/deny, kur atsevišķā rindā jāievada lietotājvārds.

Paplašināta sintakse

Salīdzinot ar POSIX crontab, Paul Vixey risinājums satur vairākas ļoti noderīgas utilīta uzdevumu tabulu sintakses modifikācijas.

Ir kļuvusi pieejama jauna tabulas sintakse: piemēram, varat norādīt nedēļas dienas vai mēnešus pēc nosaukuma (pirmdiena, otrdiena utt.):

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

Varat norādīt darbību, kurā uzdevumi tiek palaisti:

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

Soļus un intervālus var sajaukt:

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

Tiek atbalstītas intuitīvas alternatīvas parastajai sintaksei (reboot, reizi gadā, gadā, mēnesī, nedēļā, katru dienu, pusnakts, stundu):

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

Uzdevumu izpildes vide

Vixie cron ļauj mainīt darbojošos lietojumprogrammu vidi.

Vides mainīgos USER, LOGNAME un HOME nenodrošina vienkārši dēmons, bet tie tiek ņemti no faila passwd. Mainīgais PATH ir iestatīts uz "/usr/bin:/bin", bet mainīgais SHELL ir iestatīts uz "/bin/sh". Visu mainīgo vērtības, izņemot LOGNAME, var mainīt lietotāju tabulās.

Dažus vides mainīgos (jo īpaši SHELL un HOME) pats cron izmanto uzdevuma izpildei. Lūk, kā var izskatīties bash, nevis standarta sh, lai izpildītu pielāgotus uzdevumus:

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

Galu galā visi tabulā definētie vides mainīgie (ko izmanto cron vai nepieciešami procesam) tiks nodoti izpildošajam uzdevumam.

Lai rediģētu failus, crontab izmanto redaktoru, kas norādīts vides mainīgajā VISUAL vai EDITOR. Ja vidē, kurā tika palaists crontab, šie mainīgie nav definēti, tiek izmantots "/usr/ucb/vi" (ucb, iespējams, ir Kalifornijas universitāte Bērklijā).

cron uz Debian un Ubuntu

Debian un atvasināto izplatījumu izstrādātāji ir izlaiduši ļoti modificēta versija Vixie cron versija 3.0pl1. Tabulas failu sintaksē nav atšķirību, lietotājiem tas ir tas pats Vixie cron. Lielākā jaunā funkcija: atbalsts syslog, SELinux и PAM.

Mazāk pamanāmas, bet taustāmas izmaiņas ietver konfigurācijas failu un uzdevumu tabulu atrašanās vietu.

Debian lietotāju tabulas atrodas direktorijā /var/spool/cron/crontabs, sistēmas tabula joprojām ir tur - mapē /etc/crontab. Debian pakotnēm specifiskās uzdevumu tabulas tiek ievietotas /etc/cron.d, no kurienes cron dēmons tās automātiski nolasa. Lietotāju piekļuves kontroli kontrolē faili /etc/cron.allow un /etc/cron.deny.

Noklusējuma apvalks joprojām ir /bin/sh, kas Debian ir mazs ar POSIX saderīgs apvalks domuzīme, palaists, neizlasot nevienu konfigurāciju (neinteraktīvā režīmā).

Pati Cron jaunākajās Debian versijās tiek palaista, izmantojot systemd, un palaišanas konfigurāciju var skatīt mapē /lib/systemd/system/cron.service. Pakalpojuma konfigurācijā nav nekā īpaša; jebkuru smalkāku uzdevumu pārvaldību var veikt, izmantojot vides mainīgos, kas deklarēti tieši katra lietotāja crontab.

draugs RedHat, Fedora un CentOS

cronie — Vixie cron versijas 4.1 dakša. Tāpat kā Debian, sintakse nav mainījusies, bet ir pievienots PAM un SELinux atbalsts, darbs klasterī, failu izsekošana, izmantojot inotify un citas funkcijas.

Noklusējuma konfigurācija ir parastajās vietās: sistēmas tabula atrodas mapē /etc/crontab, pakotnes ievieto tabulas mapē /etc/cron.d, lietotāju tabulas atrodas mapē /var/spool/cron/crontabs.

Dēmons darbojas Systemd kontrolē, pakalpojuma konfigurācija ir /lib/systemd/system/crond.service.

Red Hat līdzīgos izplatījumos startēšanas laikā pēc noklusējuma tiek izmantots /bin/sh, kas ir standarta bash. Jāņem vērā, ka, palaižot cron darbus caur /bin/sh, bash apvalks startē ar POSIX saderīgā režīmā un nelasa nekādu papildu konfigurāciju, darbojoties neinteraktīvā režīmā.

draugs SLES un openSUSE

Vācijas izplatīšana SLES un tā atvasinājums openSUSE izmanto vienu un to pašu draugu. Šeit esošais dēmons tiek palaists arī zem systemd, pakalpojuma konfigurācija atrodas mapē /usr/lib/systemd/system/cron.service. Konfigurācija: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh ir tas pats bash, kas darbojas ar POSIX saderīgā neinteraktīvā režīmā.

Vixie cron ierīce

Mūsdienu cron pēcteči nav radikāli mainījušies salīdzinājumā ar Vixie cron, taču joprojām ir ieguvuši jaunas funkcijas, kas nav nepieciešamas, lai saprastu programmas principus. Daudzi no šiem paplašinājumiem ir slikti izstrādāti un sajauc kodu. Ir patīkami lasīt Paula Vikseja oriģinālo cron pirmkodu.

Tāpēc es nolēmu analizēt cron ierīci, izmantojot abām attīstības nozarēm kopīgās cron programmas piemēru - Vixie cron 3.0pl1. Es vienkāršošu piemērus, noņemot ifdefs, kas sarežģī lasīšanu, un izlaižot nelielas detaļas.

Dēmona darbu var iedalīt vairākos posmos:

Programmas inicializācija.
Veicamo uzdevumu saraksta apkopošana un atjaunināšana.
Galvenā cron cilpa darbojas.
Sāciet uzdevumu.

Apskatīsim tos secībā.

Inicializācija

Startējot, pēc procesa argumentu pārbaudes cron instalē SIGCHLD un SIGHUP signālu apstrādātājus. Pirmais veic žurnāla ierakstu par bērna procesa pārtraukšanu, otrais aizver žurnālfaila faila deskriptoru:

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

Cron dēmons sistēmā vienmēr darbojas viens, tikai kā superlietotājs un no galvenā cron direktorija. Šādi zvani izveido bloķēšanas failu ar dēmona procesa PID, pārliecinieties, vai lietotājs ir pareizs, un mainiet pašreizējo direktoriju uz galveno:

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

Ir iestatīts noklusējuma ceļš, kas tiks izmantots, uzsākot procesus:

setenv("PATH", _PATH_DEFPATH, 1);

Pēc tam process tiek “dēmonizēts”: tas izveido procesa bērnkopiju, izsaucot fork, un jaunu sesiju bērna procesā (izsaucot setsid). Vecāku process vairs nav nepieciešams, un tas tiek aizvērts:

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

Vecāku procesa pārtraukšana atbrīvo bloķēšanas faila bloķēšanu. Turklāt bērnam ir jāatjaunina PID failā. Pēc tam uzdevumu datu bāze tiek aizpildīta:

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

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

Pēc tam cron pāriet uz galveno darba ciklu. Bet pirms tam ir vērts apskatīt uzdevumu saraksta ielādi.

Uzdevumu saraksta apkopošana un atjaunināšana

Funkcija load_database ir atbildīga par uzdevumu saraksta ielādi. Tas pārbauda galveno sistēmas crontab un direktoriju ar lietotāja failiem. Ja faili un direktorijs nav mainīti, uzdevumu saraksts netiek atkārtoti lasīts. Pretējā gadījumā sāk veidoties jauns uzdevumu saraksts.

Sistēmas faila ielāde ar īpašiem failu un tabulu nosaukumiem:

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

Lietotāju tabulu ielāde ciklā:

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

Pēc tam vecā datu bāze tiek aizstāta ar jaunu.

Iepriekš minētajos piemēros funkcijas process_crontab izsaukums pārbauda, vai pastāv lietotājs, kas atbilst tabulas faila nosaukumam (ja vien tas nav superlietotājs), un pēc tam izsauc load_user. Pēdējais jau nolasa pašu failu rindu pa rindiņai:

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

Šeit vai nu tiek iestatīts vides mainīgais (rindas formā VAR=value), izmantojot funkcijas load_env / env_set, vai arī uzdevuma apraksts tiek nolasīts (* * * * * /path/to/exec), izmantojot funkciju load_entry.

Ieraksta entītija, ko atgriež load_entry, ir mūsu uzdevums, kas tiek ievietots vispārējā uzdevumu sarakstā. Pati funkcija veic detalizētu laika formāta parsēšanu, bet mūs vairāk interesē vides mainīgo un uzdevumu palaišanas parametru veidošana:

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

Galvenā cilpa darbojas ar pašreizējo uzdevumu sarakstu.

Galvenā cilpa

Sākotnējais Unix 7. versijas krons darbojās pavisam vienkārši: cilpā atkārtoti nolasīja konfigurāciju, palaida pašreizējās minūtes uzdevumus kā superlietotājs un gulēja līdz nākamās minūtes sākumam. Šī vienkāršā pieeja vecākām mašīnām prasīja pārāk daudz resursu.

SysV tika piedāvāta alternatīva versija, kurā dēmons devās gulēt vai nu līdz tuvākajai minūtei, kurai uzdevums tika definēts, vai uz 30 minūtēm. Šajā režīmā konfigurācijas pārlasīšanai un uzdevumu pārbaudei tika patērēts mazāk resursu, taču ātri atjaunināt uzdevumu sarakstu kļuva neērti.

Vixie cron atgriezās pie uzdevumu sarakstu pārbaudes reizi minūtē, par laimi līdz 80. gadu beigām standarta Unix mašīnās bija ievērojami vairāk resursu:

/* первичная загрузка задач */
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 ir tieši iesaistīta uzdevumu izpildē, izsaucot funkcijas job_runqueue (uzskaitīt un palaist uzdevumus) un do_command (palaist katru atsevišķu uzdevumu). Pēdējo funkciju ir vērts izpētīt sīkāk.

Uzdevuma izpilde

Funkcija do_command tiek izpildīta labā Unix stilā, tas ir, tā veic dakšiņu, lai uzdevumu veiktu asinhroni. Vecāku process turpina palaist uzdevumus, bērnu process sagatavo uzdevuma procesu:

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

Bērnu_procesā ir diezgan daudz loģikas: tas uzņem standarta izvades un kļūdu straumes, lai pēc tam nosūtītu to uz pastu (ja uzdevumu tabulā ir norādīts MAILTO vides mainīgais), un, visbeidzot, gaida galveno uzdevuma izpildes process.

Uzdevuma procesu veido cita dakša:

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

Tas būtībā ir viss cron. Es izlaidu dažas interesantas detaļas, piemēram, attālo lietotāju uzskaiti, bet es iezīmēju galveno.

Pēcvārds

Cron ir pārsteidzoši vienkārša un noderīga programma, kas izveidota saskaņā ar labākajām Unix pasaules tradīcijām. Viņa neko papildus nedara, taču jau vairākus gadu desmitus viņa savu darbu dara lieliski. Ubuntu versijas koda iegūšana aizņēma ne vairāk kā stundu, un man bija ļoti jautri! Ceru, ka varēju tajā dalīties ar jums.

Es nezinu, kā jūs, bet man ir nedaudz skumji apzināties, ka mūsdienu programmēšana ar tendenci uz pārlieku sarežģītību un abstraktumu jau ilgu laiku nav veicinājusi šādu vienkāršību.

Cron ir daudz modernu alternatīvu: systemd-taimeri ļauj organizēt sarežģītas sistēmas ar atkarībām, fcron ļauj elastīgāk regulēt resursu patēriņu pēc uzdevumiem. Bet personīgi man vienmēr pietika ar vienkāršāko crontab.

Īsāk sakot, mīliet Unix, izmantojiet vienkāršas programmas un neaizmirstiet izlasīt savas platformas mana!

Avots: www.habr.com

Cron operētājsistēmā Linux: vēsture, lietošana un ierīce