הקלאסיקה כתבה ששעות שמחות לא צופים. בזמנים הפרועים ההם לא היו מתכנתים ולא יוניקס, אבל היום מתכנתים יודעים בוודאות: cron יעקוב אחר הזמן במקומם.

כלי עזר של שורת הפקודה הם גם חולשה וגם מטלה עבורי. sed, awk, wc, cut ותוכניות ישנות אחרות מופעלות על ידי סקריפטים בשרתים שלנו מדי יום. רבים מהם מתוכננים כמשימות עבור cron, מתזמן במקור משנות ה-70.

במשך זמן רב השתמשתי ב-cron בצורה שטחית, מבלי להיכנס לפרטים, אבל יום אחד, כשנתקלתי בשגיאה בהפעלת סקריפט, החלטתי לבדוק את זה לעומק. כך הופיע המאמר הזה, תוך כדי כתיבתו הכרתי את POSIX crontab, אפשרויות הקרון העיקריות בהפצות לינוקס פופולריות ואת המבנה של חלקן.

האם אתה משתמש בלינוקס ומפעיל משימות cron? האם אתה מתעניין בארכיטקטורת יישומי מערכת ביוניקס? אז אנחנו בדרך!

תוכן

• מוצא המינים
• POSIX crontab
• הנמכר ביותר - Vixie cron 3.0pl1
• cron על דביאן ואובונטו
• מקורב ב-Red Hat, Fedora ו- CentOS
• מקורב ב-SLES וב-openSUSE
• מכשיר Vixie cron
• אחרית דבר

מוצא המינים

הפעלה תקופתית של תוכניות משתמש או מערכת היא הכרח ברור בכל מערכות ההפעלה. לכן, מתכנתים הבינו את הצורך בשירותים המאפשרים להם לתכנן ולבצע משימות באופן מרכזי לפני זמן רב.

מערכות הפעלה דמויות Unix עוקבות אחר מקורותיהן לגרסה 7 Unix, שפותחה בשנות ה-70 של המאה הקודמת ב-Bell Labs, כולל על ידי קן תומפסון המפורסם. גרסה 7 Unix כללה גם cron, שירות להפעלת משימות משתמש-על באופן קבוע.

קרון מודרני טיפוסי הוא תוכנה פשוטה, אבל אלגוריתם ההפעלה של הגרסה המקורית היה אפילו פשוט יותר: השירות התעורר פעם בדקה, קרא טבלה עם משימות מקובץ בודד (/etc/lib/crontab) וביצע עבור משתמש-על את המשימות שהיו אמורות להתבצע ברגע הנוכחי.

לאחר מכן, גרסאות משופרות של השירות הפשוט והשימושי סופקו עם כל מערכות ההפעלה דמויות יוניקס.

תיאורים כלליים של פורמט crontab והעקרונות הבסיסיים של פעולת כלי השירות נכללו בתקן הראשי של מערכות הפעלה דמויות Unix - POSIX - בשנת 1992, וכך הפך cron מתקן דה פקטו לתקן דה יורה.

בשנת 1987, פול Vixie, לאחר שסקר את משתמשי יוניקס לגבי רצונותיהם עבור cron, הוציא גרסה נוספת של הדמון שתיקנה חלק מהבעיות של cron המסורתי והרחיבה את התחביר של קבצי טבלה.

בגרסה השלישית של Vixie cron החלה לעמוד בדרישות POSIX, בנוסף, לתוכנית היה רישיון ליברלי, או ליתר דיוק לא היה רישיון כלל, למעט המשאלות ב-README: המחבר אינו נותן ערבויות, שם המחבר לא ניתן למחוק, והתוכנית יכולה להימכר רק יחד עם קוד מקור. הדרישות הללו התבררו כתואמות לעקרונות התוכנה החופשית שצברו פופולריות באותן שנים, כך שחלק מההפצות המרכזיות של לינוקס שהופיעו בתחילת שנות ה-90 לקחו את Vixie cron כמערכת אחת שלהם ועדיין מפתחות אותה כיום.

במיוחד, Red Hat ו-SUSE מפתחים מזלג של Vixie cron - cron, ודביאן ואובונטו משתמשות במהדורה המקורית של Vixie cron עם תיקונים רבים.

בואו נכיר תחילה את ה-User Utility crontab המתואר ב-POSIX, ולאחר מכן נבחן את הרחבות התחביר הניתנות ב-Vixie cron ואת השימוש בווריאציות של Vixie cron בהפצות לינוקס פופולריות. ולבסוף, הדובדבן שעל העוגה הוא הניתוח של מכשיר הקרון דמון.

POSIX crontab

אם הקרון המקורי תמיד עבד עבור משתמש העל, מתזמנים מודרניים מתמודדים לעתים קרובות עם משימות של משתמשים רגילים, וזה בטוח ונוח יותר.

Crons מסופקים כסט של שתי תוכניות: דמון ה-cron הפועל ללא הרף וכלי השירות crontab הזמינה למשתמשים. האחרון מאפשר לך לערוך טבלאות משימות ספציפיות לכל משתמש במערכת, בעוד הדמון משיק משימות מטבלאות משתמש ומערכת.

В תקן POSIX ההתנהגות של הדמון אינה מתוארת בשום צורה ורק תוכנית המשתמש רשמית crontab. קיומם של מנגנונים להפעלת משימות משתמש משתמע, כמובן, אך אינו מתואר בפירוט.

על ידי קריאה לכלי השירות crontab, אתה יכול לעשות ארבעה דברים: לערוך את טבלת המשימות של המשתמש בעורך, לטעון את הטבלה מקובץ, להציג את טבלת המשימות הנוכחית ולנקות את טבלת המשימות. דוגמאות לאופן הפעולה של כלי השירות crontab:

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

כשמתקשרים crontab -e ייעשה שימוש בעורך המצוין במשתנה הסביבה הסטנדרטי EDITOR.

המשימות עצמן מתוארות בפורמט הבא:

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

חמשת השדות הראשונים של הרשומות: דקות [1..60], שעות [0..23], ימי החודש [1..31], חודשים [1..12], ימי השבוע [0. .6], כאשר 0 הוא יום ראשון. השדה האחרון, השישי, הוא שורה שתתבצע על ידי מתורגמן הפקודות הסטנדרטי.

בחמשת השדות הראשונים, ניתן לרשום ערכים מופרדים בפסיקים:

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

או עם מקף:

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

גישת המשתמש לתזמון המשימות מוסדרת ב-POSIX על ידי הקבצים cron.allow ו-cron.deny, המפרטים משתמשים עם גישה ל-crontab ומשתמשים ללא גישה לתוכנית, בהתאמה. התקן אינו מסדיר את מיקום הקבצים הללו בשום אופן.

על פי התקן, יש להעביר לפחות ארבעה משתני סביבה לתוכניות שהושקו:

1. HOME - ספריית הבית של המשתמש.
2. LOGNAME - התחברות משתמש.
3. PATH הוא הנתיב שבו אתה יכול למצוא כלי עזר סטנדרטיים למערכת.
4. SHELL - נתיב אל מתורגמן הפקודות בשימוש.

יש לציין, POSIX לא אומר דבר על מהיכן מגיעים הערכים של משתנים אלה.

הנמכר ביותר - Vixie cron 3.0pl1

האב הקדמון המשותף של גרסאות קרון פופולריות הוא Vixie cron 3.0pl1, שהוצג ברשימת התפוצה comp.sources.unix ב-1992. נשקול את התכונות העיקריות של גרסה זו ביתר פירוט.

Vixie cron מגיע בשתי תוכניות (cron ו-crontab). כרגיל, הדמון אחראי על קריאה והרצה של משימות מטבלת המשימות של המערכת ומטבלאות משימות משתמש בודדות, וכלי השירות crontab אחראי לעריכת טבלאות משתמשים.

טבלת משימות וקבצי תצורה

טבלת המשימות של משתמש-על ממוקמת ב-/etc/crontab. התחביר של טבלת המערכת מתאים לתחביר של Vixie cron, למעט שהעמודה השישית בה מציינת את שם המשתמש שתחתיו המשימה מופעלת:

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

טבלאות משימות משתמש רגילות ממוקמות ב- /var/cron/tabs/username ומשתמשות באותו תחביר. כאשר אתה מפעיל את כלי השירות crontab כמשתמש, אלו הם הקבצים שנערכים.

רשימות המשתמשים עם גישה ל-crontab מנוהלות בקבצים /var/cron/allow ו-/var/cron/deny, שם אתה רק צריך להזין את שם המשתמש בשורה נפרדת.

תחביר מורחב

בהשוואה ל- POSIX crontab, הפתרון של Paul Vixey מכיל מספר שינויים שימושיים מאוד לתחביר של טבלאות המשימות של כלי השירות.

תחביר טבלה חדש הפך לזמין: לדוגמה, אתה יכול לציין ימים בשבוע או חודשים לפי שם (שני, ג' וכן הלאה):

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

אתה יכול לציין את השלב שבו משימות יושקו:

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

ניתן לערבב שלבים ומרווחים:

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

חלופות אינטואיטיביות לתחביר הרגיל נתמכות (אתחול מחדש, שנתי, שנתי, חודשי, שבועי, יומי, חצות, שעה):

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

סביבת ביצוע משימות

Vixie cron מאפשר לך לשנות את סביבת ההפעלה של יישומים.

משתני הסביבה USER, LOGNAME ו-HOME אינם מסופקים רק על ידי הדמון, אלא לקוחים מקובץ פסח. המשתנה PATH מוגדר ל-"/usr/bin:/bin" והמשתנה SHELL מוגדר ל-"/bin/sh". ניתן לשנות את הערכים של כל המשתנים מלבד LOGNAME בטבלאות משתמש.

משתני סביבה מסוימים (בעיקר SHELL ו-HOME) משמשים את cron עצמה להפעלת המשימה. כך עשוי להיראות שימוש ב-bash במקום ב-sh רגיל להפעלת משימות מותאמות אישית:

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

בסופו של דבר, כל משתני הסביבה המוגדרים בטבלה (בשימוש על ידי cron או הדרושים בתהליך) יועברו למשימה הפועלת.

כדי לערוך קבצים, crontab משתמש בעורך שצוין במשתנה הסביבה VISUAL או EDITOR. אם הסביבה שבה בוצעה crontab לא מגדירים את המשתנים האלה, אז נעשה שימוש ב-"/usr/ucb/vi" (ucb היא כנראה אוניברסיטת קליפורניה, ברקלי).

cron על דביאן ואובונטו

המפתחים של Debian והפצות נגזרות פרסמו גרסה שונה מאוד Vixie cron גרסה 3.0pl1. אין הבדלים בתחביר של קבצי טבלה; עבור משתמשים זה אותו Vixie cron. התכונה החדשה הגדולה ביותר: תמיכה syslog, SELinux и PAM.

שינויים פחות בולטים אך מוחשיים כוללים את המיקום של קבצי תצורה וטבלאות משימות.

טבלאות משתמש בדביאן ממוקמות בספריית /var/spool/cron/crontabs, טבלת המערכת עדיין שם - ב- /etc/crontab. טבלאות משימות ספציפיות לחבילות דביאן ממוקמות ב-/etc/cron.d, משם דמון ה-cron קורא אותן אוטומטית. בקרת גישת המשתמש נשלטת על ידי הקבצים /etc/cron.allow ו-/etc/cron.deny.

מעטפת ברירת המחדל היא עדיין /bin/sh, אשר בדביאן היא מעטפת קטנה תואמת POSIX קורטוב, הושק ללא קריאת תצורה כלשהי (במצב לא אינטראקטיבי).

Cron עצמו בגרסאות האחרונות של דביאן מושק באמצעות systemd, וניתן לראות את תצורת ההשקה ב-/lib/systemd/system/cron.service. אין שום דבר מיוחד בתצורת השירות; כל ניהול משימות עדין יותר יכול להתבצע באמצעות משתני סביבה המוצהרים ישירות ב-crontab של כל משתמש.

מקורב ב-RedHat, Fedora ו- CentOS

קרוני - מזלג של Vixie cron גרסה 4.1. כמו בדביאן, התחביר לא השתנה, אך נוספה תמיכה ב-PAM ו-SELinux, עבודה באשכול, מעקב אחר קבצים באמצעות inotify ותכונות נוספות.

תצורת ברירת המחדל היא במקומות הרגילים: טבלת המערכת נמצאת ב-/etc/crontab, חבילות שמות את הטבלאות שלהן ב-/etc/cron.d, טבלאות משתמש נכנסות ל-/var/spool/cron/crontabs.

הדמון פועל תחת בקרת מערכת, תצורת השירות היא /lib/systemd/system/crond.service.

בהפצות דמויות Red Hat, /bin/sh משמש כברירת מחדל בעת ההפעלה, שהוא ה-bash הסטנדרטי. יש לציין כי בעת הפעלת משימות cron דרך /bin/sh, מעטפת ה-bash מתחילה במצב תואם POSIX ואינה קוראת כל תצורה נוספת, פועלת במצב לא אינטראקטיבי.

מקורב ב-SLES וב-openSUSE

ההפצה הגרמנית SLES והנגזרת שלה openSUSE משתמשות באותו מקורב. הדמון כאן מופעל גם תחת systemd, תצורת השירות ממוקמת ב- /usr/lib/systemd/system/cron.service. תצורה: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh הוא אותו bash הפועל במצב לא אינטראקטיבי תואם POSIX.

מכשיר Vixie cron

צאצאיו המודרניים של cron לא השתנו באופן קיצוני בהשוואה ל-Vixie cron, אך עדיין רכשו תכונות חדשות שאינן נדרשות כדי להבין את עקרונות התוכנית. רבים מההרחבות הללו מעוצבות בצורה גרועה ומבלבלות את הקוד. תענוג לקרוא את קוד מקור הקרון המקורי מאת פול ויקסי.

לכן, החלטתי לנתח את מכשיר ה-cron באמצעות הדוגמה של תוכנית cron המשותפת לשני ענפי הפיתוח - Vixie cron 3.0pl1. אני אפשט את הדוגמאות על ידי הסרת ifdefs שמסבכים את הקריאה והשמטת פרטים קטנים.

ניתן לחלק את עבודת השד למספר שלבים:

1. אתחול התוכנית.
2. איסוף ועדכון רשימת המשימות להפעלה.
3. לולאת קרון ראשית פועלת.
4. התחל משימה.

בואו נסתכל עליהם לפי הסדר.

אתחול

כאשר מתחילים, לאחר בדיקת ארגומנטי התהליך, cron מתקין את מטפלי האותות SIGCHLD ו-SIGHUP. הראשון עורך רישום ביומן לגבי סיום תהליך הצאצא, השני סוגר את מתאר הקובץ של קובץ היומן:

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

ה-cron daemon תמיד פועל לבד על המערכת, רק בתור משתמש-על ומתיקיית ה-cron הראשית. השיחות הבאות יוצרות קובץ נעילה עם ה-PID של תהליך הדמון, ודא שהמשתמש נכון ושנו את הספרייה הנוכחית לספרייה הראשית:

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

נתיב ברירת המחדל מוגדר, אשר ישמש בעת התחלת תהליכים:

setenv("PATH", _PATH_DEFPATH, 1);

לאחר מכן התהליך עובר "דמוניזציה": הוא יוצר עותק צאצא של התהליך על ידי קריאה לפורק והפעלה חדשה בתהליך הילד (קריאת setsid). תהליך ההורה אינו נחוץ עוד והוא יוצא:

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

סיום תהליך האב משחרר את הנעילה בקובץ הנעילה. בנוסף, נדרש לעדכן את ה-PID בקובץ לילד. לאחר מכן, ממלאים את מסד הנתונים של המשימות:

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

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

ואז קרון עובר למחזור העבודה הראשי. אבל לפני כן, כדאי להציץ בטעינת רשימת המשימות.

איסוף ועדכון רשימת המשימות

הפונקציה load_database אחראית לטעינת רשימת המשימות. זה בודק את הקרונטאב הראשי של המערכת ואת הספרייה עם קבצי המשתמש. אם הקבצים והספרייה לא השתנו, רשימת המשימות לא תיקרא מחדש. אחרת, רשימה חדשה של משימות מתחילה להיווצר.

טעינת קובץ מערכת עם שמות קבצים וטבלאות מיוחדים:

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

טעינת טבלאות משתמשים בלולאה:

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

לאחר מכן מסד הנתונים הישן מוחלף בחדש.

בדוגמאות שלמעלה, הקריאה לפונקציה process_crontab מאמתת שקיים משתמש התואם לשם קובץ הטבלה (אלא אם הוא משתמש-על) ולאחר מכן קורא ל-load_user. האחרון כבר קורא את הקובץ עצמו שורה אחר שורה:

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

כאן, או שמשתנה הסביבה מוגדר (שורות בצורת VAR=value) באמצעות הפונקציות load_env / env_set, או שתיאור המשימה נקרא (* * * * * /path/to/exec) באמצעות הפונקציה load_entry.

ישות הכניסה שמחזירה load_entry היא המשימה שלנו, שממוקמת ברשימת המשימות הכללית. הפונקציה עצמה מבצעת ניתוח מילולי של פורמט הזמן, אך אנו מעוניינים יותר ביצירת משתני סביבה ופרמטרים של השקת משימות:

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

הלולאה הראשית פועלת עם רשימת המשימות הנוכחית.

לולאה ראשית

הקרון המקורי מגרסה 7 Unix עבד די פשוט: הוא קרא מחדש את התצורה בלולאה, השיק את המשימות של הדקה הנוכחית כמשתמש-על, וישן עד תחילת הדקה הבאה. גישה פשוטה זו במכונות ישנות דרשה משאבים רבים מדי.

הוצעה גרסה חלופית ב-SysV, שבה הדמון הלך לישון או עד הדקה הקרובה עבורה הוגדרה המשימה, או למשך 30 דקות. פחות משאבים נצרכו לקריאה חוזרת של התצורה ובדיקת משימות במצב זה, אך עדכון מהיר של רשימת המשימות הפך לבלתי נוח.

Vixie cron חזרה לבדוק רשימות משימות פעם בדקה, למרבה המזל עד סוף שנות ה-80 היו הרבה יותר משאבים במכונות 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;
}

פונקציית cron_sleep מעורבת ישירות בביצוע משימות, קריאה לפונקציות job_runqueue (enumerate and run tasks) ו-do_command (הפעל כל משימה בודדת). את הפונקציה האחרונה כדאי לבחון ביתר פירוט.

הפעלת משימה

הפונקציה do_command מבוצעת בסגנון Unix טוב, כלומר, היא עושה מזלג כדי לבצע את המשימה באופן אסינכרוני. תהליך ההורה ממשיך להשיק משימות, תהליך הילד מכין את תהליך המשימות:

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

יש די הרבה היגיון ב-child_process: הוא לוקח לעצמו זרמי פלט ושגיאות סטנדרטיים, כדי לשלוח אותו לדואר (אם משתנה הסביבה MAILTO מצוין בטבלת המשימות), ולבסוף, ממתין ל-main תהליך השלמת המשימה.

תהליך המשימה נוצר על ידי מזלג נוסף:

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

זה בעצם כל מה ש-cron הוא. השמטתי כמה פרטים מעניינים, למשל, התחשבנות במשתמשים מרוחקים, אבל ציינתי את העיקר.

אחרית דבר

Cron היא תוכנית פשוטה ושימושית להפתיע, שנעשתה במיטב המסורות של עולם יוניקס. היא לא עושה שום דבר נוסף, אבל היא עושה את העבודה שלה נפלא כבר כמה עשורים. העברת הקוד לגרסה שמגיעה עם אובונטו ארכה לא יותר משעה, והיה לי כיף גדול! אני מקווה שהצלחתי לחלוק את זה איתך.

אני לא יודע מה איתכם, אבל קצת עצוב לי להבין שתכנות מודרניות, עם הנטייה שלה לסבך יתר ולפשטות יתר על המידה, לא הועילה לפשטות כזו במשך זמן רב.

ישנן אלטרנטיבות מודרניות רבות ל-cron: מערכת טיימרים מאפשרים לך לארגן מערכות מורכבות עם תלות, fcron מאפשרת לווסת בצורה גמישה יותר את צריכת המשאבים לפי משימות. אבל באופן אישי, הקרונטאב הפשוט ביותר תמיד הספיק לי.

בקיצור, אהבו את יוניקס, השתמשו בתוכנות פשוטות ואל תשכחו לקרוא את המאנה לפלטפורמה שלכם!

מקור: www.habr.com