Scríobh an clasaiceach nach bhfuil uaireanta sona ag breathnú. Sna hamanna fiáine sin ní raibh ríomhchláraitheoirí ná Unix ann, ach tá a fhios ag ríomhchláraitheoirí inniu go cinnte: coimeádfaidh cron súil ar am ina n-ionad.

Is laige agus is core domsa iad fóntais na n-orduithe. Reáchtálann scripteanna sed, awk, wc, cut agus seanchláir eile ar ár bhfreastalaithe gach lá. Tá go leor acu deartha mar thascanna do cron, sceidealóir ó na 70í ó dhúchas.

Ar feadh i bhfad d'úsáid mé cron go superficial, gan dul isteach i sonraí, ach lá amháin, nuair a tháinig mé ar earráid agus script á rith agam, chinn mé féachaint isteach go críochnúil. Seo mar a bhí an t-alt seo le feiceáil, agus é á scríobh tháinig mé ar an eolas faoi POSIX crontab, na príomhroghanna cron i dáiltí coitianta Linux agus struchtúr cuid acu.

An bhfuil tú ag baint úsáide as Linux agus ag rith tascanna cron? An bhfuil suim agat in ailtireacht feidhmchláir chórais in Unix? Ansin táimid ar ár mbealach!

Ábhar

• Bunús na speiceas
• POSIX crontab
• Díoltóir is fearr - Vixie cron 3.0pl1
• cron ar Debian agus Ubuntu
• cronie ar Red Hat, Fedora agus CentOS
• cronie i SLES agus openSUSE
• Vixie cron gléas
• Afterword

Bunús na speiceas

Is léir go ndéantar cláir úsáideoirí nó córais a fhorghníomhú go tréimhsiúil i ngach córas oibriúcháin. Dá bhrí sin, thuig ríomhchláraitheoirí go raibh gá le seirbhísí a ligeann dóibh tascanna a phleanáil agus a chur i gcrích go lárnach i bhfad ó shin.

Rianaíonn córais oibriúcháin cosúil le Unix a mbunús siar go Leagan 7 Unix, a forbraíodh sna 70í den chéid seo caite ag Bell Labs, lena n-áirítear an cáiliúil Ken Thompson. Chuimsigh Leagan 7 Unix cron freisin, seirbhís chun tascanna sár-úsáideoirí a rith go rialta.

Is clár simplí é cron nua-aimseartha tipiciúil, ach bhí algartam oibriúcháin an bhunleagan níos simplí fós: dhúisigh an tseirbhís uair sa nóiméad, léigh tábla le tascanna ó chomhad amháin (/etc/lib/crontab) agus rinneadh é don superuser na tascanna sin ba chóir a bheith déanta faoi láthair .

Ina dhiaidh sin, soláthraíodh leaganacha feabhsaithe den tseirbhís shimplí agus úsáideach le gach córas oibriúcháin atá cosúil le Unix.

Áiríodh tuairiscí ginearálaithe ar fhormáid crontab agus bunphrionsabail oibríocht an áirgiúlachta i bpríomhchaighdeán na gcóras oibriúcháin atá cosúil le Unix - POSIX - i 1992, agus mar sin tháinig cron ó chaighdeán de facto ina chaighdeán de jure.

I 1987, d'eisigh Paul Vixie, tar éis suirbhé a dhéanamh ar úsáideoirí Unix faoina mianta le haghaidh cron, leagan eile den deamhan a cheartaigh cuid de na fadhbanna a bhaineann le cron traidisiúnta agus a mhéadaigh comhréir na gcomhad tábla.

De réir an tríú leagan de Vixie cron thosaigh chun freastal ar riachtanais POSIX, ina theannta sin, bhí an clár ceadúnas liobrálacha, nó in áit nach raibh aon cheadúnas ar chor ar bith, ach amháin i gcás na mianta sa README: ní thugann an t-údar ráthaíochtaí, ainm an údair. Ní féidir é a scriosadh, agus ní féidir an clár a dhíol ach le cód foinse. D'éirigh leis na ceanglais seo a bheith ag luí le prionsabail na mbogearraí saor in aisce a bhí ag éirí níos coitianta sna blianta sin, agus mar sin ghlac cuid de na príomh-dháiltí Linux a bhí le feiceáil go luath sna 90idí Vixie cron mar a gcóras amháin agus tá siad fós á bhforbairt inniu.

Go háirithe, forbraíonn Red Hat agus SUSE forc de Vixie cron - cronie, agus úsáideann Debian agus Ubuntu an t-eagrán bunaidh de Vixie cron le go leor paistí.

Cuirfimid aithne ar dtús ar an crontab fóntais úsáideora a bhfuil cur síos air in POSIX, agus ina dhiaidh sin féachfaimid ar na síntí comhréire a chuirtear ar fáil i Vixie cron agus úsáid éagsúlachtaí de Vixie cron i dáiltí coitianta Linux. Agus ar deireadh, is é an silíní ar an gcíste an anailís ar an bhfeiste daemon cron.

POSIX crontab

Má d'oibrigh an cron bunaidh i gcónaí don superuser, is minic a dhéileálann sceidealóirí nua-aimseartha le tascanna gnáthúsáideoirí, atá níos sábháilte agus níos áisiúla.

Soláthraítear Crons mar thacar de dhá chlár: an deamhan cron a bhíonn ar siúl de shíor agus an áirgiúlacht crontab atá ar fáil d'úsáideoirí. Ligeann an dara ceann duit táblaí tascanna a bhaineann go sonrach le gach úsáideoir sa chóras a chur in eagar, agus seolann an deamhan tascanna ó tháblaí úsáideora agus córais.

В POSIX caighdeánach ní dhéantar cur síos ar iompar an deamhan ar aon bhealach agus ní dhéantar ach an clár úsáideora a fhoirmiú crontab. Ar ndóigh, tá sé intuigthe go bhfuil meicníochtaí ann chun tascanna úsáideora a sheoladh, ach ní dhéantar cur síos mionsonraithe orthu.

Trí ghlaoch ar an bhfóntas crontab, is féidir leat ceithre rud a dhéanamh: tábla tascanna an úsáideora a chur in eagar san eagarthóir, an tábla a luchtú ó chomhad, an tábla tascanna reatha a thaispeáint, agus an tábla tasc a ghlanadh. Samplaí den chaoi a n-oibríonn an áirgiúlacht crontab:

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

Nuair a ghlaoitear air crontab -e úsáidfear an t-eagarthóir atá sonraithe san athróg timpeallachta caighdeánach EDITOR.

Déantar cur síos ar na tascanna féin san fhormáid seo a leanas:

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

Na chéad chúig réimse de na taifid: nóiméad [1..60], uair an chloig [0..23], laethanta na míosa [1...31], míonna [1..12], laethanta na seachtaine [0. .6], áit a bhfuil 0 Dé Domhnaigh. Is líne é an réimse deiridh, séú, a dhéanfaidh an t-ateangaire caighdeánach ordaithe.

Sna chéad chúig réimse, is féidir luachanna a liostú scartha le camóga:

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

Nó le fleiscín:

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

Tá rochtain úsáideoirí ar sceidealú tascanna á rialú i POSIX ag na comhaid cron.allow agus cron.deny, a liostaíonn úsáideoirí a bhfuil rochtain acu ar crontab agus úsáideoirí gan rochtain ar an gclár, faoi seach. Ní rialaíonn an caighdeán suíomh na gcomhad seo ar bhealach ar bith.

De réir an chaighdeáin, ní mór ceithre athróg comhshaoil ​​ar a laghad a chur ar aghaidh chuig cláir seolta:

1. BAILE - eolaire baile an úsáideora.
2. LOGNAME — logáil isteach úsáideora.
3. Is é PATH an cosán inar féidir leat gnáthfhóntais chórais a aimsiú.
4. SHELL - cosán chuig an ateangaire ordaithe a úsáidtear.

Go háirithe, ní deir POSIX aon rud faoin áit a dtagann na luachanna do na hathróga seo.

Díoltóir is fearr - Vixie cron 3.0pl1

Is é Vixie cron 3.0pl1, a tugadh isteach i liosta seoltaí comp.sources.unix sa bhliain 1992, sinsear coitianta na n-athraithe cron coitianta. Déanfaimid machnamh níos mine ar phríomhghnéithe an leagan seo.

Tagann Vixie cron in dhá chlár (cron agus crontab). Mar is gnách, tá an deamhan freagrach as tascanna a léamh agus a reáchtáil ó thábla tascanna an chórais agus táblaí tascanna úsáideoirí aonair, agus tá an fóntais crontab freagrach as táblaí úsáideoirí a eagarthóireacht.

Tábla tascanna agus comhaid cumraíochta

Tá tábla tasc an tsár-úsáideoir suite in /etc/crontab. Freagraíonn comhréir tábla an chórais do chomhréir Vixie cron, ach amháin go léiríonn an séú colún ann ainm an úsáideora a bhfuil an tasc á sheoladh faoina cheann:

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

Tá táblaí tascanna úsáideora rialta suite in /var/cron/tabs/username agus úsáideann siad an chomhréir chéanna. Nuair a ritheann tú an áirgiúlacht crontab mar úsáideoir, is iad seo na comhaid atá curtha in eagar.

Déantar na liostaí úsáideoirí a bhfuil rochtain acu ar crontab a bhainistiú sna comhaid /var/cron/allow agus /var/cron/deny, áit nach gá duit ach an t-ainm úsáideora a chur isteach i líne ar leith.

Comhréir leathnaithe

I gcomparáid le POSIX crontab, tá roinnt modhnuithe an-úsáideacha i réiteach Paul Vixey ar chomhréir thasctháblaí na bhfóntas.

Tá comhréir tábla nua curtha ar fáil: mar shampla, is féidir leat laethanta na seachtaine nó míonna a shonrú de réir ainm (Luan, Máirt, agus mar sin de):

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

Is féidir leat an chéim trína seoltar tascanna a shonrú:

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

Is féidir céimeanna agus eatraimh a mheascadh:

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

Tacaítear le roghanna iomasach seachas an ghnáthchomhréir (atosaigh, go bliantúil, go bliantúil, go míosúil, go seachtainiúil, go laethúil, go meán oíche, in aghaidh na huaire):

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

Timpeallacht fhorghníomhaithe tascanna

Ceadaíonn Vixie cron duit an timpeallacht a bhaineann le feidhmchláir a rith a athrú.

Ní hamháin go soláthraíonn an deamhan na hathróga timpeallachta USER, LOGNAME agus HOME, ach tógtar ó chomhad iad passwd. Tá an athróg PATH socraithe go “/usr/bin:/bin” agus tá an athróg SHELL socraithe go “/bin/sh”. Is féidir luachanna na n-athróg go léir seachas LOGNAME a athrú i dtáblaí úsáideora.

Úsáideann cron féin roinnt athróg timpeallachta (SHELL agus HOME go háirithe) chun an tasc a rith. Seo an chuma a bheadh ​​ar úsáid bash in ionad sh caighdeánach chun tascanna saincheaptha a rith:

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

I ndeireadh na dála, cuirfear ar aghaidh chuig an tasc reatha gach athróg timpeallachta a shainítear sa tábla (a úsáideann cron nó a theastaíonn ón bpróiseas).

Chun comhaid a chur in eagar, úsáideann crontab an t-eagarthóir atá sonraithe san athróg timpeallachta VISUAL or EDITOR. Mura bhfuil na hathróga seo sainmhínithe ag an timpeallacht inar ritheadh ​​crontab, úsáidtear "/usr/ucb/vi" (is dócha gurb é Ollscoil California, Berkeley í ucb).

cron ar Debian agus Ubuntu

D'eisigh forbróirí Debian agus dáiltí díorthacha leagan an-athraithe Vixie cron leagan 3.0pl1. Níl aon difríochtaí i gcomhréir na gcomhad tábla; d'úsáideoirí is é an Vixie cron céanna é. Gné Nua is Mó: Tacaíocht syslog, SELinux и PAM.

I measc na n-athruithe nach bhfuil chomh suntasach ach inláimhsithe tá suíomh na gcomhad cumraíochta agus na táblaí tascanna.

Tá táblaí úsáideora i Debian suite san eolaire /var/spool/cron/crontabs, tá tábla an chórais fós ann - in /etc/crontab. Cuirtear táblaí tascanna pacáiste-shonracha Debian in /etc/cron.d, as a léann an deamhan cron iad go huathoibríoch. Tá rialú rochtana úsáideora á rialú ag na comhaid /etc/cron.allow agus /etc/cron.deny.

Is é / bin/sh an bhlaosc réamhshocraithe fós, ar blaosc bheag é i Debian a chomhlíonann POSIX Fleasc, a seoladh gan aon chumraíocht a léamh (i mód neamh-idirghníomhach).

Seoltar Cron féin sna leaganacha is déanaí de Debian trí systemd, agus is féidir an chumraíocht seolta a fheiceáil i /lib/systemd/system/cron.service. Níl aon rud speisialta i gcumraíocht na seirbhíse; is féidir aon bhainistíocht tasc níos caolchúisí a dhéanamh trí athróga timpeallachta a dhearbhaítear go díreach i gcrontab gach úsáideora.

cronie ar RedHat, Fedora agus CentOS

crony — forc de Vixie cron leagan 4.1. Mar atá i Debian, níor athraigh an chomhréir, ach cuireadh tacaíocht do PAM agus SELinux, ag obair i mbraisle, ag rianú comhaid ag baint úsáide as inotify agus gnéithe eile.

Tá an chumraíocht réamhshocraithe sna gnátháiteanna: tá tábla an chórais i /etc/crontab, cuireann pacáistí a gcuid táblaí in /etc/cron.d, téann táblaí úsáideora isteach /var/spool/cron/crontabs.

Ritheann an deamhan faoi rialú systemd, is é /lib/systemd/system/crond.service cumraíocht na seirbhíse.

Ar dháiltí cosúil le Red Hat, úsáidtear /bin/sh de réir réamhshocraithe ag am tosaithe, arb é an bash caighdeánach é. Ba chóir a thabhairt faoi deara, nuair a bhíonn jabanna cron á rith via /bin/sh, go dtosaíonn an bhlaosc bash i mód comhlíontach POSIX agus ní léann sé aon chumraíocht bhreise, ag rith i mód neamh-idirghníomhach.

cronie i SLES agus openSUSE

Úsáideann an dáileadh Gearmánach SLES agus a dhíorthach openSUSE an cronie céanna. Seoltar an deamhan anseo freisin faoi systemd, tá cumraíocht na seirbhíse suite i /usr/lib/systemd/system/cron.service. Cumraíocht: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. Is é / bin/sh an bash céanna a ritheann i mód neamh-idirghníomhach a chomhlíonann POSIX.

Vixie cron gléas

Níor athraigh sliocht nua-aimseartha cron go radacach i gcomparáid le Vixie cron, ach fós fuair gnéithe nua nach bhfuil ag teastáil chun prionsabail an chláir a thuiscint. Tá go leor de na síntí seo deartha go dona agus cuireann siad mearbhall ar an gcód. Is cúis áthais é an bunchód cron le Paul Vixey a léamh.

Mar sin, chinn mé anailís a dhéanamh ar an bhfeiste cron ag baint úsáide as an sampla de chlár cron atá coitianta don dá bhrainse forbartha - Vixie cron 3.0pl1. Déanfaidh mé na samplaí a shimpliú trí idefs a chuireann casta ar an léitheoireacht a bhaint agus mionsonraí a fhágáil ar lár.

Is féidir obair an diabhail a roinnt i roinnt céimeanna:

1. Tionscnamh clár.
2. Liosta na dtascanna atá le rith a bhailiú agus a nuashonrú.
3. Príomh lúb cron ag rith.
4. Tosaigh tasc.

Breathnaímid orthu in ord.

Tionscnamh

Nuair a thosaigh sé, tar éis na hargóintí próisis a sheiceáil, suiteálann cron na láimhseálaithe comharthaí SIGCHLD agus SIGHUP. Déanann an chéad cheann logáil isteach faoi fhoirceannadh an phróisis linbh, dúnann an dara ceann tuairisceoir comhaid an logchomhaid:

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

Ritheann an deamhan cron leis féin ar an gcóras i gcónaí, mar shárúsáideoir amháin agus ón bpríomh-eolaire cron. Cruthaíonn na glaonna seo a leanas comhad glas le PID an phróisis dheamhan, cinntigh go bhfuil an t-úsáideoir ceart agus athraigh an t-eolaire reatha go dtí an príomhcheann:

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

Socraítear an cosán réamhshocraithe, a úsáidfear agus próisis á thosú:

setenv("PATH", _PATH_DEFPATH, 1);

Ansin déantar an próiseas a “dheamhanú”: cruthaítear cóip linbh den phróiseas trí ghlaoch a chur ar fhorc agus seisiún nua sa phróiseas linbh (calling setsid). Níl an próiseas tuismitheora ag teastáil a thuilleadh, agus scoireann sé:

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

Scaoileann foirceannadh an phróisis tuismitheora an glas ar an gcomhad glasála. Ina theannta sin, tá sé riachtanach an PID sa chomhad a thabhairt cothrom le dáta don leanbh. Ina dhiaidh seo, líontar an bunachar sonraí tascanna:

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

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

Ansin bogann Cro ar aghaidh chuig an bpríomhthimthriall oibre. Ach roimhe sin, is fiú breathnú ar an liosta tascanna a luchtú.

An liosta tascanna a bhailiú agus a nuashonrú

Tá an fheidhm load_database freagrach as an liosta tascanna a lódáil. Seiceálann sé crontab an phríomhchórais agus an t-eolaire le comhaid úsáideora. Mura bhfuil na comhaid agus an t-eolaire athraithe, ní athléamh an liosta tascanna. Seachas sin, tosaíonn liosta nua tascanna a fhoirmiú.

Comhad córais a lódáil le hainmneacha comhaid agus tábla speisialta:

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

Táblaí úsáideora á lódáil i lúb:

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

Ina dhiaidh sin cuirtear ceann nua in ionad an tseanbhunachar sonraí.

Sna samplaí thuas, fíoraíonn an glao feidhm process_crontab go bhfuil úsáideoir a mheaitseálann an t-ainm comhaid tábla ann (mura sár-úsáideoir é) agus ansin glaonn sé load_user. Léann an dara ceann an comhad féin líne ar líne cheana féin:

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

Anseo, socraítear an athróg timpeallachta (línte den fhoirm VAR = luach) ag baint úsáide as na feidhmeanna load_env / env_set, nó léitear an cur síos ar an tasc (* * * * * /path/to/exec) ag baint úsáide as an bhfeidhm load_entry.

Is é an t-aonán iontrála a sheolann load_entry ar ais ár dtasc, a chuirtear i liosta ginearálta na dtascanna. Déanann an fheidhm féin parsáil focal ar an bhformáid ama, ach tá níos mó suime againn i bhfoirmiú na n-athróg timpeallachta agus paraiméadair tasc-seolta:

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

Oibríonn an príomh-lúb leis an liosta tascanna atá ann faoi láthair.

Príomh Lúb

D'oibrigh an cron bunaidh ó Leagan 7 Unix go simplí: athléigh sé an chumraíocht i lúb, sheol sé tascanna an nóiméid reatha mar shár-úsáideoir, agus chodail sé go dtí tús an chéad nóiméad eile. Bhí an iomarca acmhainní ag teastáil ón gcur chuige simplí seo ar mheaisíní níos sine.

Moladh leagan eile in SysV, ina ndeachaigh an deamhan a chodladh go dtí an nóiméad is gaire dá raibh an tasc sainithe, nó ar feadh 30 nóiméad. Ídíodh níos lú acmhainní chun an chumraíocht a athléamh agus chun tascanna a sheiceáil sa mhodh seo, ach bhí sé deacair an liosta tascanna a nuashonrú go tapa.

D’fhill Vixie cron ar liostaí tascanna a sheiceáil uair sa nóiméad, ar an dea-uair faoi dheireadh na 80í bhí i bhfad níos mó acmhainní ar mheaisíní caighdeánacha Unix:

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

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

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

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

Tá baint dhíreach ag an bhfeidhm cron_sleep le tascanna a fhorghníomhú, ag glaoch ar na feidhmeanna job_runqueue (tascanna a ríomh agus a rith) agus do_command (reáchtáil gach tasc aonair). Is fiú an fheidhm dheireanach a scrúdú go mion.

Tasc a rith

Déantar an fheidhm do_command a fhorghníomhú i stíl mhaith Unix, is é sin, déanann sé forc chun an tasc a dhéanamh go neamhshioncronach. Leanann an próiseas tuismitheora tascanna a sheoladh, ullmhaíonn an leanbh an próiseas tasc:

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

Tá go leor loighce ag baint le child_process: glacann sé sruthanna caighdeánacha aschuir agus earráide air féin, chun é a sheoladh chuig ríomhphost ansin (má shonraítear athróg timpeallachta MAILTO sa tábla tascanna), agus, ar deireadh, fanann sé leis an bpríomhthábla próiseas an taisc a chur i gcrích.

Tá an próiseas tasc déanta ag forc eile:

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

Sin go bunúsach gach cron. D'fhág mé roinnt sonraí suimiúla ar lár, mar shampla, cuntasaíocht d'úsáideoirí iargúlta, ach thug mé breac-chuntas ar an rud is mó.

Afterword

Is clár iontach simplí agus úsáideach é Cron, a rinneadh i dtraidisiúin is fearr an domhain Unix. Ní dhéanann sí aon rud breise, ach tá sí ag déanamh a post iontach le blianta fada anuas. Níor ghlac sé níos mó ná uair an chloig le dul tríd an gcód don leagan a thagann le Ubuntu, agus bhí an-spraoi agam! Tá súil agam go raibh mé in ann é a roinnt leat.

Níl a fhios agam fút, ach tá mé rud beag brónach a thuiscint nach bhfuil cláir nua-aimseartha, lena gclaonadh ró-chasta agus ró-theibí, ag cuidiú le simplíocht den sórt sin le fada an lá.

Tá go leor roghanna nua-aimseartha ann seachas cron: ceadaíonn amadóirí systemd duit córais chasta a eagrú le spleáchais, ligeann fcron duit tomhaltas acmhainní de réir tascanna a rialáil ar bhealach níos solúbtha. Ach go pearsanta, bhí an crontab is simplí i gcónaí go leor dom.

I mbeagán focal, grá Unix, bain úsáid as cláir shimplí agus ná déan dearmad mana do ardán a léamh!

Foinse: will.com