ಸಂತೋಷದ ಗಂಟೆಗಳು ವೀಕ್ಷಿಸುವುದಿಲ್ಲ ಎಂದು ಕ್ಲಾಸಿಕ್ ಬರೆದಿದ್ದಾರೆ. ಆ ಕಾಡು ಕಾಲದಲ್ಲಿ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು ಅಥವಾ ಯುನಿಕ್ಸ್ ಇರಲಿಲ್ಲ, ಆದರೆ ಇಂದು ಪ್ರೋಗ್ರಾಮರ್‌ಗಳಿಗೆ ಖಚಿತವಾಗಿ ತಿಳಿದಿದೆ: ಕ್ರಾನ್ ಅವರ ಬದಲಿಗೆ ಸಮಯವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ.

ಕಮಾಂಡ್ ಲೈನ್ ಉಪಯುಕ್ತತೆಗಳು ನನಗೆ ದೌರ್ಬಲ್ಯ ಮತ್ತು ಕೆಲಸ ಎರಡೂ. sed, awk, wc, cut ಮತ್ತು ಇತರ ಹಳೆಯ ಕಾರ್ಯಕ್ರಮಗಳು ಪ್ರತಿದಿನ ನಮ್ಮ ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಂದ ನಡೆಸಲ್ಪಡುತ್ತವೆ. ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಕ್ರಾನ್‌ಗಾಗಿ ಕಾರ್ಯಗಳಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲ್ಪಟ್ಟಿವೆ, ಮೂಲತಃ 70 ರ ದಶಕದ ಶೆಡ್ಯೂಲರ್.

ದೀರ್ಘಕಾಲದವರೆಗೆ ನಾನು ವಿವರಗಳಿಗೆ ಹೋಗದೆ ಕ್ರಾನ್ ಅನ್ನು ಮೇಲ್ನೋಟಕ್ಕೆ ಬಳಸಿದ್ದೇನೆ, ಆದರೆ ಒಂದು ದಿನ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ ನಾನು ದೋಷವನ್ನು ಎದುರಿಸಿದಾಗ, ನಾನು ಅದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಶೀಲಿಸಲು ನಿರ್ಧರಿಸಿದೆ. ಈ ಲೇಖನವು ಹೇಗೆ ಕಾಣಿಸಿಕೊಂಡಿತು, ಇದನ್ನು ಬರೆಯುವಾಗ ನನಗೆ POSIX crontab, ಜನಪ್ರಿಯ ಲಿನಕ್ಸ್ ವಿತರಣೆಗಳಲ್ಲಿನ ಮುಖ್ಯ ಕ್ರಾನ್ ಆಯ್ಕೆಗಳು ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಕೆಲವು ರಚನೆಯ ಪರಿಚಯವಾಯಿತು.

ನೀವು Linux ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಾ ಮತ್ತು ಕ್ರಾನ್ ಕಾರ್ಯಗಳನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತಿದ್ದೀರಾ? Unix ನಲ್ಲಿ ಸಿಸ್ಟಮ್ ಅಪ್ಲಿಕೇಶನ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿ ನೀವು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೀರಾ? ನಂತರ ನಾವು ನಮ್ಮ ದಾರಿಯಲ್ಲಿದ್ದೇವೆ!

ಪರಿವಿಡಿ

ಜಾತಿಗಳ ಮೂಲ
POSIX ಕ್ರಾಂಟಾಬ್
ಉತ್ತಮ ಮಾರಾಟಗಾರ - ವಿಕ್ಸಿ ಕ್ರಾನ್ 3.0pl1
ಡೆಬಿಯನ್ ಮತ್ತು ಉಬುಂಟು ಮೇಲೆ ಕ್ರಾನ್
Red Hat, Fedora ಮತ್ತು CentOS ನಲ್ಲಿ ಕ್ರೋನಿ
SLES ಮತ್ತು openSUSE ನಲ್ಲಿ ಕ್ರೋನಿ
ವಿಕ್ಸಿ ಕ್ರಾನ್ ಸಾಧನ
ನಂತರದ

ಜಾತಿಗಳ ಮೂಲ

ಬಳಕೆದಾರ ಅಥವಾ ಸಿಸ್ಟಮ್ ಪ್ರೋಗ್ರಾಂಗಳ ಆವರ್ತಕ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಎಲ್ಲಾ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳಲ್ಲಿ ಒಂದು ಸ್ಪಷ್ಟ ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ಆದ್ದರಿಂದ, ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಬಹಳ ಹಿಂದೆಯೇ ಕಾರ್ಯಗಳನ್ನು ಕೇಂದ್ರೀಯವಾಗಿ ಯೋಜಿಸಲು ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅನುಮತಿಸುವ ಸೇವೆಗಳ ಅಗತ್ಯವನ್ನು ಅರಿತುಕೊಂಡರು.

Unix-ರೀತಿಯ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳು ತಮ್ಮ ಮೂಲವನ್ನು ಆವೃತ್ತಿ 7 Unix ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತವೆ, ಇದನ್ನು ಕಳೆದ ಶತಮಾನದ 70 ರ ದಶಕದಲ್ಲಿ ಬೆಲ್ ಲ್ಯಾಬ್ಸ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಯಿತು, ಪ್ರಸಿದ್ಧ ಕೆನ್ ಥಾಂಪ್ಸನ್ ಸೇರಿದಂತೆ. ಆವೃತ್ತಿ 7 ಯುನಿಕ್ಸ್ ಕ್ರಾನ್ ಅನ್ನು ಸಹ ಒಳಗೊಂಡಿತ್ತು, ಇದು ನಿಯಮಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಸೂಪರ್ಯೂಸರ್ ಕಾರ್ಯಗಳಿಗಾಗಿ ಸೇವೆಯಾಗಿದೆ.

ವಿಶಿಷ್ಟವಾದ ಆಧುನಿಕ ಕ್ರಾನ್ ಒಂದು ಸರಳವಾದ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ, ಆದರೆ ಮೂಲ ಆವೃತ್ತಿಯ ಆಪರೇಟಿಂಗ್ ಅಲ್ಗಾರಿದಮ್ ಇನ್ನೂ ಸರಳವಾಗಿದೆ: ಸೇವೆಯು ನಿಮಿಷಕ್ಕೊಮ್ಮೆ ಎಚ್ಚರವಾಯಿತು, ಒಂದೇ ಫೈಲ್ (/etc/lib/crontab) ನಿಂದ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಟೇಬಲ್ ಅನ್ನು ಓದಿ ಪ್ರಸ್ತುತ ಕ್ಷಣದಲ್ಲಿ ನಿರ್ವಹಿಸಬೇಕಾದ ಕಾರ್ಯಗಳನ್ನು ಸೂಪರ್ಯೂಸರ್ ಮಾಡಿ.

ತರುವಾಯ, ಸರಳ ಮತ್ತು ಉಪಯುಕ್ತ ಸೇವೆಯ ಸುಧಾರಿತ ಆವೃತ್ತಿಗಳನ್ನು ಎಲ್ಲಾ Unix-ರೀತಿಯ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳೊಂದಿಗೆ ಸರಬರಾಜು ಮಾಡಲಾಯಿತು.

1992 ರಲ್ಲಿ ಯುನಿಕ್ಸ್ ತರಹದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಮುಖ್ಯ ಮಾನದಂಡದಲ್ಲಿ - POSIX - ಕ್ರಾಂಟಾಬ್ ಸ್ವರೂಪದ ಸಾಮಾನ್ಯ ವಿವರಣೆಗಳು ಮತ್ತು ಉಪಯುಕ್ತತೆಯ ಕಾರ್ಯಾಚರಣೆಯ ಮೂಲ ತತ್ವಗಳನ್ನು ಸೇರಿಸಲಾಯಿತು ಮತ್ತು ಆದ್ದರಿಂದ ವಸ್ತುತಃ ಮಾನದಂಡದಿಂದ ಕ್ರಾನ್ ಡಿ ಜ್ಯೂರ್ ಮಾನದಂಡವಾಯಿತು.

1987 ರಲ್ಲಿ, ಪೌಲ್ ವಿಕ್ಸಿ, ಯುನಿಕ್ಸ್ ಬಳಕೆದಾರರನ್ನು ಕ್ರಾನ್‌ಗಾಗಿ ಅವರ ಇಚ್ಛೆಯ ಬಗ್ಗೆ ಸಮೀಕ್ಷೆ ಮಾಡಿದ ನಂತರ, ಸಾಂಪ್ರದಾಯಿಕ ಕ್ರಾನ್‌ನ ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಸರಿಪಡಿಸಿದ ಮತ್ತು ಟೇಬಲ್ ಫೈಲ್‌ಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಿದ ಡೀಮನ್‌ನ ಮತ್ತೊಂದು ಆವೃತ್ತಿಯನ್ನು ಬಿಡುಗಡೆ ಮಾಡಿದರು.

ವಿಕ್ಸಿ ಕ್ರಾನ್‌ನ ಮೂರನೇ ಆವೃತ್ತಿಯು POSIX ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸಲು ಪ್ರಾರಂಭಿಸಿತು, ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಉದಾರ ಪರವಾನಗಿಯನ್ನು ಹೊಂದಿತ್ತು, ಅಥವಾ README ನಲ್ಲಿನ ಶುಭಾಶಯಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಪರವಾನಗಿ ಇರಲಿಲ್ಲ: ಲೇಖಕರು ಖಾತರಿಗಳನ್ನು ನೀಡುವುದಿಲ್ಲ, ಲೇಖಕರ ಹೆಸರು ಅಳಿಸಲಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಮೂಲ ಕೋಡ್‌ನೊಂದಿಗೆ ಮಾತ್ರ ಮಾರಾಟ ಮಾಡಬಹುದು. ಈ ಅವಶ್ಯಕತೆಗಳು ಆ ವರ್ಷಗಳಲ್ಲಿ ಜನಪ್ರಿಯತೆಯನ್ನು ಗಳಿಸುತ್ತಿದ್ದ ಉಚಿತ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ತತ್ವಗಳೊಂದಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ, ಆದ್ದರಿಂದ 90 ರ ದಶಕದ ಆರಂಭದಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡ ಕೆಲವು ಪ್ರಮುಖ ಲಿನಕ್ಸ್ ವಿತರಣೆಗಳು ವಿಕ್ಸಿ ಕ್ರಾನ್ ಅನ್ನು ತಮ್ಮ ಸಿಸ್ಟಮ್ ಒಂದನ್ನಾಗಿ ತೆಗೆದುಕೊಂಡವು ಮತ್ತು ಇಂದಿಗೂ ಅದನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿವೆ.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, Red Hat ಮತ್ತು SUSE ಗಳು Vixie cron - cronie ನ ಫೋರ್ಕ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತವೆ ಮತ್ತು Debian ಮತ್ತು Ubuntu ವಿಕ್ಸಿ ಕ್ರಾನ್ನ ಮೂಲ ಆವೃತ್ತಿಯನ್ನು ಹಲವು ಪ್ಯಾಚ್‌ಗಳೊಂದಿಗೆ ಬಳಸುತ್ತವೆ.

POSIX ನಲ್ಲಿ ವಿವರಿಸಲಾದ ಬಳಕೆದಾರ ಉಪಯುಕ್ತತೆಯ ಕ್ರೊಂಟಾಬ್ ಅನ್ನು ನಾವು ಮೊದಲು ತಿಳಿದುಕೊಳ್ಳೋಣ, ಅದರ ನಂತರ ನಾವು Vixie ಕ್ರಾನ್‌ನಲ್ಲಿ ಒದಗಿಸಲಾದ ಸಿಂಟ್ಯಾಕ್ಸ್ ವಿಸ್ತರಣೆಗಳನ್ನು ಮತ್ತು ಜನಪ್ರಿಯ Linux ವಿತರಣೆಗಳಲ್ಲಿ Vixie ಕ್ರಾನ್‌ನ ಬದಲಾವಣೆಗಳ ಬಳಕೆಯನ್ನು ನೋಡೋಣ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಕೇಕ್ ಮೇಲೆ ಚೆರ್ರಿ ಕ್ರಾನ್ ಡೀಮನ್ ಸಾಧನದ ವಿಶ್ಲೇಷಣೆಯಾಗಿದೆ.

POSIX ಕ್ರಾಂಟಾಬ್

ಮೂಲ ಕ್ರಾನ್ ಯಾವಾಗಲೂ ಸೂಪರ್‌ಯೂಸರ್‌ಗಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಆಧುನಿಕ ಶೆಡ್ಯೂಲರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಮಾನ್ಯ ಬಳಕೆದಾರರ ಕಾರ್ಯಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುತ್ತಾರೆ, ಅದು ಹೆಚ್ಚು ಸುರಕ್ಷಿತ ಮತ್ತು ಅನುಕೂಲಕರವಾಗಿರುತ್ತದೆ.

ಕ್ರಾನ್‌ಗಳನ್ನು ಎರಡು ಪ್ರೋಗ್ರಾಂಗಳ ಒಂದು ಸೆಟ್‌ನಂತೆ ಸರಬರಾಜು ಮಾಡಲಾಗುತ್ತದೆ: ನಿರಂತರವಾಗಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಕ್ರಾನ್ ಡೀಮನ್ ಮತ್ತು ಬಳಕೆದಾರರಿಗೆ ಲಭ್ಯವಿರುವ ಕ್ರಾಂಟಾಬ್ ಉಪಯುಕ್ತತೆ. ಎರಡನೆಯದು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಪ್ರತಿ ಬಳಕೆದಾರರಿಗೆ ನಿರ್ದಿಷ್ಟವಾದ ಕಾರ್ಯ ಕೋಷ್ಟಕಗಳನ್ನು ಸಂಪಾದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಡೀಮನ್ ಬಳಕೆದಾರ ಮತ್ತು ಸಿಸ್ಟಮ್ ಟೇಬಲ್‌ಗಳಿಂದ ಕಾರ್ಯಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.

В 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 ಗೆ ಪ್ರವೇಶ ಹೊಂದಿರುವ ಬಳಕೆದಾರರನ್ನು ಮತ್ತು ಪ್ರೋಗ್ರಾಂಗೆ ಪ್ರವೇಶವಿಲ್ಲದ ಬಳಕೆದಾರರನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ಮಾನದಂಡವು ಈ ಫೈಲ್‌ಗಳ ಸ್ಥಳವನ್ನು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ನಿಯಂತ್ರಿಸುವುದಿಲ್ಲ.

ಮಾನದಂಡದ ಪ್ರಕಾರ, ಪ್ರಾರಂಭಿಸಲಾದ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಕನಿಷ್ಠ ನಾಲ್ಕು ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ರವಾನಿಸಬೇಕು:

ಹೋಮ್ - ಬಳಕೆದಾರರ ಹೋಮ್ ಡೈರೆಕ್ಟರಿ.
LOGNAME — ಬಳಕೆದಾರ ಲಾಗಿನ್.
PATH ಎನ್ನುವುದು ನೀವು ಪ್ರಮಾಣಿತ ಸಿಸ್ಟಮ್ ಉಪಯುಕ್ತತೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವ ಮಾರ್ಗವಾಗಿದೆ.
ಶೆಲ್ - ಬಳಸಿದ ಕಮಾಂಡ್ ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ ಮಾರ್ಗ.

ಗಮನಾರ್ಹವಾಗಿ, ಈ ಅಸ್ಥಿರಗಳ ಮೌಲ್ಯಗಳು ಎಲ್ಲಿಂದ ಬರುತ್ತವೆ ಎಂಬುದರ ಕುರಿತು POSIX ಏನನ್ನೂ ಹೇಳುವುದಿಲ್ಲ.

ಉತ್ತಮ ಮಾರಾಟಗಾರ - ವಿಕ್ಸಿ ಕ್ರಾನ್ 3.0pl1

ಜನಪ್ರಿಯ ಕ್ರಾನ್ ರೂಪಾಂತರಗಳ ಸಾಮಾನ್ಯ ಪೂರ್ವಜರೆಂದರೆ Vixie cron 3.0pl1, ಇದನ್ನು 1992 ರಲ್ಲಿ comp.sources.unix ಮೇಲಿಂಗ್ ಪಟ್ಟಿಯಲ್ಲಿ ಪರಿಚಯಿಸಲಾಯಿತು. ಈ ಆವೃತ್ತಿಯ ಮುಖ್ಯ ಲಕ್ಷಣಗಳನ್ನು ನಾವು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಪರಿಗಣಿಸುತ್ತೇವೆ.

ವಿಕ್ಸಿ ಕ್ರಾನ್ ಎರಡು ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಬರುತ್ತದೆ (ಕ್ರಾನ್ ಮತ್ತು ಕ್ರಾಂಟಾಬ್). ಎಂದಿನಂತೆ, ಸಿಸ್ಟಮ್ ಟಾಸ್ಕ್ ಟೇಬಲ್ ಮತ್ತು ವೈಯಕ್ತಿಕ ಬಳಕೆದಾರ ಟಾಸ್ಕ್ ಟೇಬಲ್‌ಗಳಿಂದ ಕಾರ್ಯಗಳನ್ನು ಓದಲು ಮತ್ತು ಚಲಾಯಿಸಲು ಡೀಮನ್ ಜವಾಬ್ದಾರನಾಗಿರುತ್ತಾನೆ ಮತ್ತು ಬಳಕೆದಾರರ ಕೋಷ್ಟಕಗಳನ್ನು ಸಂಪಾದಿಸಲು ಕ್ರಾಂಟಾಬ್ ಉಪಯುಕ್ತತೆಯು ಜವಾಬ್ದಾರವಾಗಿರುತ್ತದೆ.

ಟಾಸ್ಕ್ ಟೇಬಲ್ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು

ಸೂಪರ್ಯೂಸರ್ ಟಾಸ್ಕ್ ಟೇಬಲ್ /etc/crontab ನಲ್ಲಿ ಇದೆ. ಸಿಸ್ಟಮ್ ಟೇಬಲ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ವಿಕ್ಸಿ ಕ್ರಾನ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗೆ ಅನುರೂಪವಾಗಿದೆ, ಅದರಲ್ಲಿರುವ ಆರನೇ ಕಾಲಮ್ ಅದರ ಪರವಾಗಿ ಕಾರ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸುವ ಬಳಕೆದಾರರ ಹೆಸರನ್ನು ಸೂಚಿಸುತ್ತದೆ:

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

ನಿಯಮಿತ ಬಳಕೆದಾರ ಕಾರ್ಯ ಕೋಷ್ಟಕಗಳು /var/cron/tabs/username ನಲ್ಲಿ ನೆಲೆಗೊಂಡಿವೆ ಮತ್ತು ಅದೇ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತವೆ. ನೀವು ಬಳಕೆದಾರರಾಗಿ ಕ್ರೊಂಟಾಬ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಚಲಾಯಿಸಿದಾಗ, ಇವುಗಳನ್ನು ಸಂಪಾದಿಸಲಾದ ಫೈಲ್‌ಗಳಾಗಿವೆ.

crontab ಗೆ ಪ್ರವೇಶ ಹೊಂದಿರುವ ಬಳಕೆದಾರರ ಪಟ್ಟಿಗಳನ್ನು /var/cron/allow ಮತ್ತು /var/cron/deny ಫೈಲ್‌ಗಳಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಅಲ್ಲಿ ನೀವು ಬಳಕೆದಾರರ ಹೆಸರನ್ನು ಪ್ರತ್ಯೇಕ ಸಾಲಿನಲ್ಲಿ ನಮೂದಿಸಬೇಕಾಗುತ್ತದೆ.

ವಿಸ್ತೃತ ಸಿಂಟ್ಯಾಕ್ಸ್

POSIX crontab ಗೆ ಹೋಲಿಸಿದರೆ, ಪಾಲ್ ವಿಕ್ಸಿಯ ಪರಿಹಾರವು ಉಪಯುಕ್ತತೆಯ ಕಾರ್ಯ ಕೋಷ್ಟಕಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗೆ ಹಲವಾರು ಉಪಯುಕ್ತ ಮಾರ್ಪಾಡುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ಹೊಸ ಟೇಬಲ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಲಭ್ಯವಾಗಿದೆ: ಉದಾಹರಣೆಗೆ, ನೀವು ವಾರದ ದಿನಗಳು ಅಥವಾ ತಿಂಗಳುಗಳನ್ನು ಹೆಸರಿನ ಮೂಲಕ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು (ಸೋಮ, ಮಂಗಳವಾರ, ಮತ್ತು ಹೀಗೆ):

# Запускается ежеминутно по понедельникам и вторникам в январе
* * * 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 ಕ್ರಾನ್ ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

USER, LOGNAME ಮತ್ತು HOME ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಡೀಮನ್‌ನಿಂದ ಸರಳವಾಗಿ ಒದಗಿಸಲಾಗಿಲ್ಲ, ಆದರೆ ಫೈಲ್‌ನಿಂದ ತೆಗೆದುಕೊಳ್ಳಲಾಗಿದೆ ಪಾಸ್ವರ್ಡ್. PATH ವೇರಿಯೇಬಲ್ ಅನ್ನು "/usr/bin:/bin" ಗೆ ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು SHELL ವೇರಿಯೇಬಲ್ ಅನ್ನು "/bin/sh" ಗೆ ಹೊಂದಿಸಲಾಗಿದೆ. LOGNAME ಹೊರತುಪಡಿಸಿ ಎಲ್ಲಾ ವೇರಿಯೇಬಲ್‌ಗಳ ಮೌಲ್ಯಗಳನ್ನು ಬಳಕೆದಾರರ ಕೋಷ್ಟಕಗಳಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು.

ಕೆಲವು ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು (ಮುಖ್ಯವಾಗಿ ಶೆಲ್ ಮತ್ತು ಹೋಮ್) ಕಾರ್ಯವನ್ನು ಚಲಾಯಿಸಲು ಕ್ರಾನ್ ಸ್ವತಃ ಬಳಸುತ್ತದೆ. ಕಸ್ಟಮ್ ಕಾರ್ಯಗಳನ್ನು ಚಲಾಯಿಸಲು ಸ್ಟ್ಯಾಂಡರ್ಡ್ sh ಬದಲಿಗೆ ಬ್ಯಾಷ್ ಅನ್ನು ಬಳಸುವುದು ಹೇಗಿರಬಹುದು:

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

ಅಂತಿಮವಾಗಿ, ಕೋಷ್ಟಕದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಎಲ್ಲಾ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು (ಕ್ರಾನ್‌ನಿಂದ ಬಳಸಲಾಗುತ್ತದೆ ಅಥವಾ ಪ್ರಕ್ರಿಯೆಯಿಂದ ಅಗತ್ಯವಿದೆ) ಚಾಲನೆಯಲ್ಲಿರುವ ಕಾರ್ಯಕ್ಕೆ ರವಾನಿಸಲಾಗುತ್ತದೆ.

ಫೈಲ್‌ಗಳನ್ನು ಎಡಿಟ್ ಮಾಡಲು, ಕ್ರೊಂಟಾಬ್ ವಿಷುಯಲ್ ಅಥವಾ ಎಡಿಟರ್ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸಂಪಾದಕವನ್ನು ಬಳಸುತ್ತದೆ. ಕ್ರಾಂಟಾಬ್ ರನ್ ಆಗಿರುವ ಪರಿಸರವು ಈ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸದಿದ್ದರೆ, ನಂತರ "/usr/ucb/vi" ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ (ucb ಬಹುಶಃ ಕ್ಯಾಲಿಫೋರ್ನಿಯಾ ವಿಶ್ವವಿದ್ಯಾಲಯ, ಬರ್ಕ್ಲಿ).

ಡೆಬಿಯನ್ ಮತ್ತು ಉಬುಂಟು ಮೇಲೆ ಕ್ರಾನ್

ಡೆಬಿಯನ್ ಮತ್ತು ವ್ಯುತ್ಪನ್ನ ವಿತರಣೆಗಳ ಅಭಿವರ್ಧಕರು ಬಿಡುಗಡೆ ಮಾಡಿದ್ದಾರೆ ಹೆಚ್ಚು ಮಾರ್ಪಡಿಸಿದ ಆವೃತ್ತಿ ವಿಕ್ಸಿ ಕ್ರಾನ್ ಆವೃತ್ತಿ 3.0pl1. ಟೇಬಲ್ ಫೈಲ್‌ಗಳ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಲ್ಲಿ ಯಾವುದೇ ವ್ಯತ್ಯಾಸಗಳಿಲ್ಲ; ಬಳಕೆದಾರರಿಗೆ ಇದು ಒಂದೇ ವಿಕ್ಸಿ ಕ್ರಾನ್ ಆಗಿದೆ. ದೊಡ್ಡ ಹೊಸ ವೈಶಿಷ್ಟ್ಯ: ಬೆಂಬಲ ಸಿಸ್ಲಾಗ್, SELinux и PAM.

ಕಡಿಮೆ ಗಮನಿಸಬಹುದಾದ, ಆದರೆ ಸ್ಪಷ್ಟವಾದ ಬದಲಾವಣೆಗಳು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು ಮತ್ತು ಟಾಸ್ಕ್ ಟೇಬಲ್‌ಗಳ ಸ್ಥಳವನ್ನು ಒಳಗೊಂಡಿವೆ.

Debian ನಲ್ಲಿ ಬಳಕೆದಾರ ಕೋಷ್ಟಕಗಳು /var/spool/cron/crontabs ಡೈರೆಕ್ಟರಿಯಲ್ಲಿವೆ, ಸಿಸ್ಟಮ್ ಟೇಬಲ್ ಇನ್ನೂ ಇದೆ - /etc/crontab ನಲ್ಲಿ. ಡೆಬಿಯನ್ ಪ್ಯಾಕೇಜ್-ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯ ಕೋಷ್ಟಕಗಳನ್ನು /etc/cron.d ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಕ್ರಾನ್ ಡೀಮನ್ ಅವುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಓದುತ್ತದೆ. ಬಳಕೆದಾರ ಪ್ರವೇಶ ನಿಯಂತ್ರಣವನ್ನು /etc/cron.allow ಮತ್ತು /etc/cron.deny ಫೈಲ್‌ಗಳಿಂದ ನಿಯಂತ್ರಿಸಲಾಗುತ್ತದೆ.

ಡೀಫಾಲ್ಟ್ ಶೆಲ್ ಇನ್ನೂ /bin/sh ಆಗಿದೆ, ಇದು ಡೆಬಿಯನ್‌ನಲ್ಲಿ ಸಣ್ಣ POSIX-ಕಾಂಪ್ಲೈಂಟ್ ಶೆಲ್ ಆಗಿದೆ ಡ್ಯಾಶ್, ಯಾವುದೇ ಸಂರಚನೆಯನ್ನು ಓದದೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ (ಇಂಟರಾಕ್ಟಿವ್ ಅಲ್ಲದ ಮೋಡ್‌ನಲ್ಲಿ).

ಡೆಬಿಯನ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಕ್ರಾನ್ ಅನ್ನು systemd ಮೂಲಕ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಉಡಾವಣಾ ಸಂರಚನೆಯನ್ನು /lib/systemd/system/cron.service ನಲ್ಲಿ ವೀಕ್ಷಿಸಬಹುದು. ಸೇವಾ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ ವಿಶೇಷವಾದದ್ದೇನೂ ಇಲ್ಲ; ಪ್ರತಿ ಬಳಕೆದಾರರ ಕ್ರಾಂಟಾಬ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಘೋಷಿಸಲಾದ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳ ಮೂಲಕ ಯಾವುದೇ ಸೂಕ್ಷ್ಮ ಕಾರ್ಯ ನಿರ್ವಹಣೆಯನ್ನು ಮಾಡಬಹುದು.

RedHat, Fedora ಮತ್ತು CentOS ನಲ್ಲಿ ಕ್ರೋನಿ

ಕ್ರೋನಿ - ವಿಕ್ಸಿ ಕ್ರಾನ್ ಆವೃತ್ತಿ 4.1 ರ ಫೋರ್ಕ್. ಡೆಬಿಯನ್‌ನಲ್ಲಿರುವಂತೆ, ಸಿಂಟ್ಯಾಕ್ಸ್ ಬದಲಾಗಿಲ್ಲ, ಆದರೆ PAM ಮತ್ತು SELinux ಗೆ ಬೆಂಬಲ, ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, inotify ಮತ್ತು ಇತರ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕಿಂಗ್ ಸೇರಿಸಲಾಗಿದೆ.

ಡೀಫಾಲ್ಟ್ ಕಾನ್ಫಿಗರೇಶನ್ ಸಾಮಾನ್ಯ ಸ್ಥಳಗಳಲ್ಲಿದೆ: ಸಿಸ್ಟಮ್ ಟೇಬಲ್ /etc/crontab ನಲ್ಲಿದೆ, ಪ್ಯಾಕೇಜುಗಳು ತಮ್ಮ ಕೋಷ್ಟಕಗಳನ್ನು /etc/cron.d ನಲ್ಲಿ ಇರಿಸುತ್ತವೆ, ಬಳಕೆದಾರ ಕೋಷ್ಟಕಗಳು /var/spool/cron/crontabs ನಲ್ಲಿ ಹೋಗುತ್ತವೆ.

ಡೀಮನ್ systemd ನಿಯಂತ್ರಣದಲ್ಲಿ ಚಲಿಸುತ್ತದೆ, ಸೇವಾ ಸಂರಚನೆಯು /lib/systemd/system/crond.service ಆಗಿದೆ.

Red Hat-ರೀತಿಯ ವಿತರಣೆಗಳಲ್ಲಿ, /bin/sh ಅನ್ನು ಪ್ರಾರಂಭದಲ್ಲಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಪ್ರಮಾಣಿತ ಬ್ಯಾಷ್ ಆಗಿದೆ. /bin/sh ಮೂಲಕ ಕ್ರಾನ್ ಜಾಬ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವಾಗ, ಬ್ಯಾಷ್ ಶೆಲ್ POSIX-ಕಂಪ್ಲೈಂಟ್ ಮೋಡ್‌ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಓದುವುದಿಲ್ಲ, ಸಂವಾದಾತ್ಮಕವಲ್ಲದ ಮೋಡ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ಗಮನಿಸಬೇಕು.

SLES ಮತ್ತು openSUSE ನಲ್ಲಿ ಕ್ರೋನಿ

ಜರ್ಮನ್ ವಿತರಣೆ SLES ಮತ್ತು ಅದರ ವ್ಯುತ್ಪನ್ನ openSUSE ಒಂದೇ ಕ್ರೋನಿಯನ್ನು ಬಳಸುತ್ತದೆ. ಇಲ್ಲಿರುವ ಡೀಮನ್ ಅನ್ನು systemd ಅಡಿಯಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ, ಸೇವಾ ಸಂರಚನೆಯು /usr/lib/systemd/system/cron.service ನಲ್ಲಿದೆ. ಕಾನ್ಫಿಗರೇಶನ್: /etc/crontab, /etc/cron.d, /var/spool/cron/tabs. /bin/sh POSIX-ಕಂಪ್ಲೈಂಟ್ ನಾನ್-ಇಂಟರಾಕ್ಟಿವ್ ಮೋಡ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅದೇ ಬ್ಯಾಷ್ ಆಗಿದೆ.

ವಿಕ್ಸಿ ಕ್ರಾನ್ ಸಾಧನ

ವಿಕ್ಸಿ ಕ್ರಾನ್‌ಗೆ ಹೋಲಿಸಿದರೆ ಕ್ರಾನ್ನ ಆಧುನಿಕ ವಂಶಸ್ಥರು ಆಮೂಲಾಗ್ರವಾಗಿ ಬದಲಾಗಿಲ್ಲ, ಆದರೆ ಕಾರ್ಯಕ್ರಮದ ತತ್ವಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅಗತ್ಯವಿಲ್ಲದ ಹೊಸ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಇನ್ನೂ ಪಡೆದುಕೊಂಡಿದ್ದಾರೆ. ಈ ಹಲವು ವಿಸ್ತರಣೆಗಳು ಕಳಪೆಯಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲ್ಪಟ್ಟಿವೆ ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಗೊಂದಲಗೊಳಿಸುತ್ತವೆ. ಪಾಲ್ ವಿಕ್ಸಿಯವರ ಮೂಲ ಕ್ರಾನ್ ಸೋರ್ಸ್ ಕೋಡ್ ಓದಲು ಸಂತೋಷವಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಅಭಿವೃದ್ಧಿಯ ಎರಡೂ ಶಾಖೆಗಳಿಗೆ ಸಾಮಾನ್ಯವಾದ ಕ್ರಾನ್ ಪ್ರೋಗ್ರಾಂನ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ರಾನ್ ಸಾಧನವನ್ನು ವಿಶ್ಲೇಷಿಸಲು ನಾನು ನಿರ್ಧರಿಸಿದೆ - Vixie cron 3.0pl1. ಓದುವಿಕೆಯನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸುವ ಮತ್ತು ಚಿಕ್ಕ ವಿವರಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವ ifdefs ಅನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ನಾನು ಉದಾಹರಣೆಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತೇನೆ.

ರಾಕ್ಷಸನ ಕೆಲಸವನ್ನು ಹಲವಾರು ಹಂತಗಳಾಗಿ ವಿಂಗಡಿಸಬಹುದು:

ಕಾರ್ಯಕ್ರಮದ ಪ್ರಾರಂಭ.
ರನ್ ಮಾಡಬೇಕಾದ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಮತ್ತು ನವೀಕರಿಸುವುದು.
ಮುಖ್ಯ ಕ್ರಾನ್ ಲೂಪ್ ಚಾಲನೆಯಲ್ಲಿದೆ.
ಕಾರ್ಯವನ್ನು ಪ್ರಾರಂಭಿಸಿ.

ಅವುಗಳನ್ನು ಕ್ರಮವಾಗಿ ನೋಡೋಣ.

ಆರಂಭ

ಪ್ರಾರಂಭಿಸಿದಾಗ, ಪ್ರಕ್ರಿಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿದ ನಂತರ, ಕ್ರಾನ್ SIGCHLD ಮತ್ತು SIGHUP ಸಿಗ್ನಲ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. ಮೊದಲನೆಯದು ಮಕ್ಕಳ ಪ್ರಕ್ರಿಯೆಯ ಮುಕ್ತಾಯದ ಬಗ್ಗೆ ಲಾಗ್ ನಮೂದನ್ನು ಮಾಡುತ್ತದೆ, ಎರಡನೆಯದು ಲಾಗ್ ಫೈಲ್‌ನ ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್ ಅನ್ನು ಮುಚ್ಚುತ್ತದೆ:

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

ಕ್ರಾನ್ ಡೀಮನ್ ಯಾವಾಗಲೂ ಸಿಸ್ಟಂನಲ್ಲಿ ಏಕಾಂಗಿಯಾಗಿ ಚಲಿಸುತ್ತದೆ, ಸೂಪರ್ಯೂಸರ್ ಆಗಿ ಮತ್ತು ಮುಖ್ಯ ಕ್ರಾನ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ಮಾತ್ರ. ಕೆಳಗಿನ ಕರೆಗಳು ಡೀಮನ್ ಪ್ರಕ್ರಿಯೆಯ PID ಯೊಂದಿಗೆ ಲಾಕ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತವೆ, ಬಳಕೆದಾರರು ಸರಿಯಾಗಿದ್ದಾರೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮತ್ತು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಮುಖ್ಯಕ್ಕೆ ಬದಲಾಯಿಸಿ:

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

ಡೀಫಾಲ್ಟ್ ಮಾರ್ಗವನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ, ಇದನ್ನು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ ಬಳಸಲಾಗುತ್ತದೆ:

setenv("PATH", _PATH_DEFPATH, 1);

ನಂತರ ಪ್ರಕ್ರಿಯೆಯು "ಡೀಮೊನೈಸ್ಡ್" ಆಗಿದೆ: ಇದು ಫೋರ್ಕ್ ಅನ್ನು ಕರೆಯುವ ಮೂಲಕ ಪ್ರಕ್ರಿಯೆಯ ಮಗುವಿನ ನಕಲನ್ನು ಮತ್ತು ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಹೊಸ ಸೆಶನ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ (ಸೆಟ್ಸಿಡ್ಗೆ ಕರೆ ಮಾಡುವುದು). ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲ ಮತ್ತು ಅದು ನಿರ್ಗಮಿಸುತ್ತದೆ:

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

ಇಲ್ಲಿ, ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಅನ್ನು load_env / env_set ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಂದಿಸಲಾಗಿದೆ (ಫಾರ್ಮ್ VAR = ಮೌಲ್ಯದ ಸಾಲುಗಳು) ಅಥವಾ ಲೋಡ್_ಎಂಟ್ರಿ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯ ವಿವರಣೆಯನ್ನು ಓದಲಾಗುತ್ತದೆ (* * * * * /path/to/exec).

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 ಯುನಿಕ್ಸ್‌ನಿಂದ ಮೂಲ ಕ್ರಾನ್ ಸರಳವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಇದು ಲೂಪ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಮರು-ಓದಿತು, ಪ್ರಸ್ತುತ ನಿಮಿಷದ ಕಾರ್ಯಗಳನ್ನು ಸೂಪರ್‌ಯೂಸರ್‌ನಂತೆ ಪ್ರಾರಂಭಿಸಿತು ಮತ್ತು ಮುಂದಿನ ನಿಮಿಷದ ಪ್ರಾರಂಭದವರೆಗೆ ಮಲಗಿತು. ಹಳೆಯ ಗಣಕಗಳಲ್ಲಿನ ಈ ಸರಳ ವಿಧಾನಕ್ಕೆ ಹಲವಾರು ಸಂಪನ್ಮೂಲಗಳು ಬೇಕಾಗುತ್ತವೆ.

SysV ನಲ್ಲಿ ಪರ್ಯಾಯ ಆವೃತ್ತಿಯನ್ನು ಪ್ರಸ್ತಾಪಿಸಲಾಯಿತು, ಇದರಲ್ಲಿ ಡೀಮನ್ ಕಾರ್ಯವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ ಹತ್ತಿರದ ನಿಮಿಷದವರೆಗೆ ಅಥವಾ 30 ನಿಮಿಷಗಳವರೆಗೆ ನಿದ್ರಿಸುತ್ತಾನೆ. ಈ ಮೋಡ್‌ನಲ್ಲಿ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಮರು-ಓದಲು ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಕಡಿಮೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸೇವಿಸಲಾಗಿದೆ, ಆದರೆ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ತ್ವರಿತವಾಗಿ ನವೀಕರಿಸುವುದು ಅನಾನುಕೂಲವಾಯಿತು.

Vixie ಕ್ರಾನ್ ಒಂದು ನಿಮಿಷಕ್ಕೊಮ್ಮೆ ಕಾರ್ಯ ಪಟ್ಟಿಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಮರಳಿದರು, ಅದೃಷ್ಟವಶಾತ್ 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;
}

ಕ್ರಾನ್_ಸ್ಲೀಪ್ ಕಾರ್ಯವು ನೇರವಾಗಿ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಲ್ಲಿ ತೊಡಗಿಸಿಕೊಂಡಿದೆ, ಜಾಬ್_ರನ್‌ಕ್ಯೂ (ಕಾರ್ಯಗಳನ್ನು ಎಣಿಸಿ ಮತ್ತು ರನ್ ಮಾಡಿ) ಮತ್ತು ಡು_ಕಮಾಂಡ್ (ಪ್ರತಿಯೊಂದು ಕಾರ್ಯವನ್ನು ರನ್ ಮಾಡಿ) ಕಾರ್ಯಗಳನ್ನು ಕರೆಯುತ್ತದೆ. ಕೊನೆಯ ಕಾರ್ಯವನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ಪರಿಶೀಲಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ.

ಕಾರ್ಯವನ್ನು ನಡೆಸುವುದು

do_command ಕಾರ್ಯವನ್ನು ಉತ್ತಮ Unix ಶೈಲಿಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಕಾರ್ಯವನ್ನು ಅಸಮಕಾಲಿಕವಾಗಿ ನಿರ್ವಹಿಸಲು ಇದು ಫೋರ್ಕ್ ಮಾಡುತ್ತದೆ. ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಕಾರ್ಯಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವುದನ್ನು ಮುಂದುವರೆಸುತ್ತದೆ, ಮಗುವಿನ ಪ್ರಕ್ರಿಯೆಯು ಕಾರ್ಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಿದ್ಧಪಡಿಸುತ್ತದೆ:

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

ಚೈಲ್ಡ್_ಪ್ರೊಸೆಸ್‌ನಲ್ಲಿ ಸಾಕಷ್ಟು ತರ್ಕಗಳಿವೆ: ಅದು ಪ್ರಮಾಣಿತ ಔಟ್‌ಪುಟ್ ಮತ್ತು ದೋಷ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಸ್ವತಃ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನಂತರ ಅದನ್ನು ಮೇಲ್‌ಗೆ ಕಳುಹಿಸಲು (ಟಾಸ್ಕ್ ಟೇಬಲ್‌ನಲ್ಲಿ MAILTO ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದರೆ), ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಮುಖ್ಯಕ್ಕಾಗಿ ಕಾಯುತ್ತದೆ. ಪೂರ್ಣಗೊಳಿಸಲು ಕಾರ್ಯದ ಪ್ರಕ್ರಿಯೆ.

ಕಾರ್ಯ ಪ್ರಕ್ರಿಯೆಯು ಮತ್ತೊಂದು ಫೋರ್ಕ್ನಿಂದ ರೂಪುಗೊಳ್ಳುತ್ತದೆ:

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

ಅದು ಮೂಲಭೂತವಾಗಿ ಎಲ್ಲಾ ಕ್ರಾನ್ ಆಗಿದೆ. ನಾನು ಕೆಲವು ಆಸಕ್ತಿದಾಯಕ ವಿವರಗಳನ್ನು ಬಿಟ್ಟುಬಿಟ್ಟಿದ್ದೇನೆ, ಉದಾಹರಣೆಗೆ, ದೂರಸ್ಥ ಬಳಕೆದಾರರಿಗೆ ಲೆಕ್ಕಪತ್ರ ನಿರ್ವಹಣೆ, ಆದರೆ ನಾನು ಮುಖ್ಯ ವಿಷಯವನ್ನು ವಿವರಿಸಿದೆ.

ನಂತರದ

ಕ್ರಾನ್ ಆಶ್ಚರ್ಯಕರವಾದ ಸರಳ ಮತ್ತು ಉಪಯುಕ್ತ ಕಾರ್ಯಕ್ರಮವಾಗಿದೆ, ಇದನ್ನು ಯುನಿಕ್ಸ್ ಪ್ರಪಂಚದ ಅತ್ಯುತ್ತಮ ಸಂಪ್ರದಾಯಗಳಲ್ಲಿ ತಯಾರಿಸಲಾಗುತ್ತದೆ. ಅವಳು ಹೆಚ್ಚುವರಿ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ, ಆದರೆ ಹಲವಾರು ದಶಕಗಳಿಂದ ಅವಳು ತನ್ನ ಕೆಲಸವನ್ನು ಅದ್ಭುತವಾಗಿ ಮಾಡುತ್ತಿದ್ದಾಳೆ. ಉಬುಂಟುನೊಂದಿಗೆ ಬರುವ ಆವೃತ್ತಿಯ ಕೋಡ್ ಅನ್ನು ಪಡೆಯಲು ಒಂದು ಗಂಟೆಗಿಂತ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಲಿಲ್ಲ, ಮತ್ತು ನಾನು ಬಹಳಷ್ಟು ಆನಂದಿಸಿದೆ! ನಾನು ಅದನ್ನು ನಿಮ್ಮೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಯಿತು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

ನಿಮ್ಮ ಬಗ್ಗೆ ನನಗೆ ತಿಳಿದಿಲ್ಲ, ಆದರೆ ಆಧುನಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್, ಅತಿಯಾದ ಸಂಕೀರ್ಣ ಮತ್ತು ಅತಿಯಾದ ಅಮೂರ್ತತೆಯ ಪ್ರವೃತ್ತಿಯೊಂದಿಗೆ, ದೀರ್ಘಕಾಲದವರೆಗೆ ಅಂತಹ ಸರಳತೆಗೆ ಅನುಕೂಲಕರವಾಗಿಲ್ಲ ಎಂದು ಅರಿತುಕೊಳ್ಳಲು ನನಗೆ ಸ್ವಲ್ಪ ದುಃಖವಾಗಿದೆ.

ಕ್ರಾನ್‌ಗೆ ಅನೇಕ ಆಧುನಿಕ ಪರ್ಯಾಯಗಳಿವೆ: ಸಿಸ್ಟಮ್‌ಡಿ-ಟೈಮರ್‌ಗಳು ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಸಂಘಟಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ, ಕಾರ್ಯಗಳ ಮೂಲಕ ಸಂಪನ್ಮೂಲ ಬಳಕೆಯನ್ನು ಹೆಚ್ಚು ಮೃದುವಾಗಿ ನಿಯಂತ್ರಿಸಲು fcron ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಆದರೆ ವೈಯಕ್ತಿಕವಾಗಿ, ಸರಳವಾದ ಕ್ರಾಂಟಾಬ್ ಯಾವಾಗಲೂ ನನಗೆ ಸಾಕಾಗಿತ್ತು.

ಸಂಕ್ಷಿಪ್ತವಾಗಿ, Unix ಅನ್ನು ಪ್ರೀತಿಸಿ, ಸರಳ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬಳಸಿ ಮತ್ತು ನಿಮ್ಮ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಾಗಿ ಮನವನ್ನು ಓದಲು ಮರೆಯಬೇಡಿ!

ಮೂಲ: www.habr.com

ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಕ್ರಾನ್: ಇತಿಹಾಸ, ಬಳಕೆ ಮತ್ತು ಸಾಧನ