ನಮ್ಮ ವೇಟ್ ಲೂಪ್ ತನ್ನಿಗಾಗಿಯೇ 35 ಗಂಟೆಗಳ ಕಾಲ ಕಾಯಿತು: SSH ಮೂಲಕ pgrep -f ಮತ್ತು pkill -f

ಆಪ್ಸ್2026-11-02

31 ಅಕ್ಟೋಬರ್‌ನಲ್ಲಿ ನಾವು SSH ಮೂಲಕ ಒಂದು ಸಣ್ಣ ಲೂಪ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದೆವು: ಇನ್ನೊಂದು ಯಂತ್ರದಲ್ಲಿರುವ ಅನುವಾದ ಕೆಲಸ ಮುಗಿಯುವವರೆಗೆ ಕಾಯಿರಿ, ನಂತರ ಫಾಲೋ-ಅಪ್ ಕೆಲಸವನ್ನು ಚಲಾಯಿಸಿ. ಅನುವಾದ ಕೆಲಸ ಆ ರಾತ್ರಿ ಮುಗಿಯಿತು. ಎರಡು ದಿನಗಳ ನಂತರ ನಾವು ಮತ್ತೆ ನೋಡಿದಾಗ, ಲೂಪ್ 35 ಗಂಟೆಗಳಿಂದ ಕಾಯುತ್ತಿತ್ತು ಮತ್ತು ಫಾಲೋ-ಅಪ್ ಎಂದಿಗೂ ಚಲಿಸಿರಲಿಲ್ಲ.

ಲೂಪ್ ಏನಾಗಿತ್ತು

ssh build-host 'while pgrep -f "i18n_job.py example.com" >/dev/null; do sleep 30; done; ./follow-up.sh'

pgrep -f ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಯ ಸಂಪೂರ್ಣ ಆಜ್ಞಾ ಸಾಲಿನ ವಿರುದ್ಧ ಒಂದು ಮಾದರಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ. SSH ಉಲ್ಲೇಖಿಸಲಾದ ಆಜ್ಞೆಯನ್ನು bash -c 'while pgrep -f "i18n_job.py example.com" …' ಎಂದು ಚಲಾಯಿಸುತ್ತದೆ, ಮತ್ತು ಆ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಮಾದರಿಯು ಇರುತ್ತದೆ. pgrep ತನ್ನದೇ ಆದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಫಲಿತಾಂಶಗಳಿಂದ ಹೊರಗಿಡುತ್ತದೆ, ಆದರೆ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಿದ ಶೆಲ್ ಅಲ್ಲ. ಆದ್ದರಿಂದ ಲೂಪ್ ಜೀವಂತವಾಗಿದ್ದರೆ, ಅದು ಒಂದು ಹೊಂದಾಣಿಕೆಯನ್ನು ಕಂಡುಹಿಡಿಯುತ್ತದೆ: ಅದೇ ತನ್ನದೇ ಆದದ್ದು.

ಅದರ ಜೋಡಿ: pkill -f ಅದು ಚಲಿಸುವ ಶೆಲ್ ಅನ್ನು ಕೊಲ್ಲುತ್ತದೆ

pkill -f ನೊಂದಿಗೆ ಅದೇ ವಿಷಯ ಸಂಭವಿಸುತ್ತದೆ, ಮತ್ತಷ್ಟು ಕೆಟ್ಟ ಫಲಿತಾಂಶಗಳೊಂದಿಗೆ:

ssh build-host 'pkill -f "worker.py --queue a"; nohup python3 worker.py --queue a &'

ಶೆಲ್‌ನ ಸ್ವಂತ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಮಾದರಿಯು ಇರುತ್ತದೆ, ಆದ್ದರಿಂದ pkill ಶೆಲ್ ಅನ್ನು ಕೊಲ್ಲುತ್ತದೆ. ವರ್ಕರ್ ನಿಲ್ಲಿಸಲ್ಪಡುತ್ತದೆ ಮತ್ತು ಮತ್ತೆಂದಿಗೂ ಪ್ರಾರಂಭಿಸಲ್ಪಡುವುದಿಲ್ಲ, ಮತ್ತು SSH ದೋಷ ಸಂದೇಶವಿಲ್ಲದೆ ಕೋಡ್ 255 ನೊಂದಿಗೆ ನಿರ್ಗಮಿಸುತ್ತದೆ. ಇದು ಉಲ್ಲೇಖ ಸಮಸ್ಯೆಯಂತೆ ಕಾಣುತ್ತದೆ, ಇದನ್ನು ನಾವು ಮೊದಲ ಬಾರಿಗೆ ಹಾಗೆಯೇ ತೆಗೆದುಕೊಂಡೆವು.

ಸೆಪ್ಟೆಂಬರ್ ಮತ್ತು ಅಕ್ಟೋಬರ್ ಕೊನೆಯ ನಡುವೆ ನಾವು ಕನಿಷ್ಠ ಹನ್ನೆರಡು ಬಾರಿ ಒಂದರಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದರಲ್ಲಿ ಸಿಲುಕಿಕೊಂಡೆವು: ಎಂದಿಗೂ ನಡೆಯದ ಪುನರಾರಂಭಗಳು, ಮೂರು ಮತ್ತು ಅರ್ಧ ಗಂಟೆಗಳ ಕಾಲ ಒಂದು ಪರಿಶೀಲನೆಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಂಡ ಲೂಪ್, ಇನ್ನೊಂದು 50 ನಿಮಿಷಗಳ ಕಾಲ ಅನುವಾದ ಕ್ಯೂ ಅನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಂಡಿತು, ಮತ್ತು ಇದು.

ಈಗ ನಾವು ಏನು ಮಾಡುತ್ತೇವೆ

• ಮಾದರಿಯಲ್ಲಿ ಬ್ರಾಕೆಟ್: pgrep -f "[i]18n_job.py example.com". ಒಂದು ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಯಾಗಿ, [i] ಅಕ್ಷರ i ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಕೆಲಸವು ಇನ್ನೂ ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತದೆ; ಶೆಲ್‌ನ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ [i] ಅಕ್ಷರಗಳು ಇರುತ್ತವೆ, ಇವುಗಳನ್ನು ಅಭಿವ್ಯಕ್ತಿಯು ಹೊಂದಿಸುವುದಿಲ್ಲ. ಸರಳ ಮಾದರಿಯು ಆ ಸಾಲಿನಲ್ಲಿ ಬೇರೆಲ್ಲೂ ಕಾಣಿಸದಿದ್ದರೆ ಮಾತ್ರ ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ: ಅದೇ ಸಾಲಿನಲ್ಲಿ ನಂತರದ ಪುನರಾರಂಭ ಆಜ್ಞೆಯು ಮತ್ತೆ ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತದೆ.
• ಪ್ರತ್ಯೇಕ SSH ಕರೆಗಳಲ್ಲಿ ಕಂಡುಹಿಡಿ, ನಿಲ್ಲಿಸಿ ಮತ್ತು ಪ್ರಾರಂಭಿಸಿ. ಒಂದು ಕರೆ pgrep -af ನೊಂದಿಗೆ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ, ಮುಂದಿನದು ಅದು ಮುದ್ರಿಸಿದ PID ಗಳನ್ನು ಕೊಲ್ಲುತ್ತದೆ, ಮೂರನೆಯದು ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
• ಮಾದರಿಯ ಮೇಲಲ್ಲ, PID ಮೇಲೆ ಕಾಯಿರಿ: tail --pid=1234 -f /dev/null, ಅಥವಾ while kill -0 1234; do sleep 30; done.
• ಇನ್ನೂ ಉತ್ತಮ, ಕೆಲಸವನ್ನು systemd ಗೆ ಒಪ್ಪಿಸಿ. ಅದನ್ನು ಯೂನಿಟ್ ಆಗಿ ಚಲಾಯಿಸಿ ಮತ್ತು systemctl is-active ಅನ್ನು ಕೇಳಿ, ಅಥವಾ systemd-run --wait ಬಳಸಿ ಪ್ರಾರಂಭಿಸಿ. ತಪ್ಪು ಮಾಡುವಂತಹ ಯಾವುದೇ ಪ್ಯಾಟರ್ನ್ ಇಲ್ಲ.
• ಪ್ರತಿ ಕಾಯುವಿಕೆಗೆ ಒಂದು ಗಡುವು ಇರಲಿ (timeout 3h) ಮತ್ತು ಅದು ಯಾವಾಗ ಸೋಲುತ್ತದೆ ಎಂಬುದನ್ನು ಹೇಳಬೇಕು. ಗಡುವಿಲ್ಲದ ಲೂಪ್ ಮೌನವಾಗಿ ವಿಫಲವಾಗುತ್ತದೆ.

Factory Floor, ನಮ್ಮ ಯಂತ್ರಗಳನ್ನು ಚಲಾಯಿಸುವ ಸಾಫ್ಟ್‌ವೇರ್ ಕಿಟ್, systemd ಯೂನಿಟ್‌ಗಳ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಅದು ಎಂದಿಗೂ ಕಮಾಂಡ್ ಲೈನ್ ಮೂಲಕ ಪ್ರಾಸೆಸ್ ಅನ್ನು ಹುಡುಕುವುದಿಲ್ಲ. ನಮಗೆ ತೊಂದರೆ ಕೊಟ್ಟ ಲೂಪ್‌ಗಳು ನಾವು ಕೈಯಾರೆ ಟೈಪ್ ಮಾಡಿದ್ದು.