பொறிகளை: உங்கள் பாஷ் ஸ்கிரிப்ட்களை மிகவும் வலுவானதாக ஆக்குங்கள்

தேசிய நெட்வொர்க்கில் உலாவல் நான் கண்டேன் சுவாரஸ்யமான கட்டுரை (நான் அதை உரைநடையில் இங்கு கொண்டு வருகிறேன், ஏனெனில் இது திறமையாக விளக்கப்பட்டுள்ளது) எங்களுடைய பாஷ் ஸ்கிரிப்ட்களைப் பயன்படுத்தி எவ்வாறு வலுவாக உருவாக்குவது என்பதை அதன் ஆசிரியர் நமக்குக் காட்டுகிறார் பொறிகள்.

பொறிகளால் உங்கள் பாஷ் ஸ்கிரிப்ட்களை மிகவும் வலுவானதாக ஆக்குங்கள்

ஒவ்வொரு ஆறு மணி நேரத்திற்கும் ஒவ்வொரு நாளும் இயங்கும் ஒரு பாஷ் ஸ்கிரிப்ட் உங்களிடம் உள்ளது என்று கற்பனை செய்து பாருங்கள், சில சமயங்களில் அது தோல்வியடைகிறது அல்லது அதே ஸ்கிரிப்ட் ஒரே நேரத்தில் இரண்டு முறை இயங்கும். இந்த இரண்டு சூழ்நிலைகளும் மிகவும் சங்கடமானவை, ஏனெனில் அவை மனித தலையீட்டை சரிசெய்ய வேண்டும் அல்லது சில நேரங்களில் அவற்றை நிவர்த்தி செய்ய முடியாது, இதனால் அமைப்பு ஒரு சீரற்ற நிலையில் உள்ளது. இதற்கு தீர்வு, மற்றவற்றுடன், பொறிகளைப் பயன்படுத்துவது.

பொறிகள் பாஷ் ஸ்கிரிப்ட்களின் வெளியீட்டைக் கட்டுப்படுத்த எளிய மற்றும் பயனுள்ள வழியாகும். அதே ஆரம்ப நிலைமைக்குச் செல்வோம், ஸ்கிரிப்ட் கைமுறையாக நிறுத்தப்பட்டால், எடுத்துக்காட்டாக ctrl-c உடன், வெளியீட்டு சமிக்ஞையைத் திருப்புவதில் குறுக்கிடப்படுகிறது

INT

அது முடிவடைந்தால்

kill

வெளியீடு இருக்கும்

TERM.

சாத்தியமான அனைத்து வெளியேறும் குறியீடுகளையும் காணலாம்

kill -l

இருப்பினும் அதிகம் பயன்படுத்தப்படுவது துல்லியமாக

INT, TERM, EXIT

ஸ்கிரிப்ட் இருந்தால், எடுத்துக்காட்டாக, கோப்புகளை ஒத்திசைத்தல்

rsync

ஸ்கிரிப்டை ஒரே நேரத்தில் இயக்க அனுமதிக்காத பூட்டு கோப்பை நம்புவதே மிகவும் விவேகமான விஷயம்:

LOCK = "/ var / run / rsync.lock" என்றால் [! -e $ LOCK]; பின்னர் $ LOCK rsync -avz foo bar rm $ LOCK ஐத் தொடவும் "rsync ஏற்கனவே இயங்குகிறது" fi

எளிய ஸ்பானிஷ் மொழியில், பூட்டு கோப்பு இருக்கிறதா என்று மேலே உள்ள ஸ்கிரிப்ட் சரிபார்க்கிறது, அது இல்லாவிட்டால், அது அதை உருவாக்கி அதனுடன் தொடர்புடைய கட்டளையை செயல்படுத்துகிறது, இறுதியாக பூட்டு கோப்பை நீக்குகிறது. கோப்பு இருந்தால், கட்டளை ஏற்கனவே இயங்குகிறது என்பதைக் குறிக்கும் ஸ்கிரிப்ட் பயனருக்கு ஒரு செய்தியை அனுப்புகிறது.

இருப்பினும் ஒரு சிக்கலான சூழ்நிலை இருக்கும்போது, ​​பூட்டு கோப்பு அகற்றப்படாமல், தேவையற்ற விளைவுகளை அழிக்கக்கூடும். தீர்வு மிகவும் எளிது:

LOCK = "/ var / run / rsync.lock" என்றால் [! -e $ LOCK]; பின்னர் "rm -f $ LOCK; வெளியேறு" INT TERM EXIT touch $ LOCK rsync -avz foo bar rm $ LOCK trap - INT TERM EXIT else echo "rsync ஏற்கனவே இயங்குகிறது" fi

இந்த தீர்வின் சிறப்பு என்னவென்றால், கட்டளை ஒரு பொறியில் இணைக்கப்பட்டுள்ளது, இதனால் ஒரு சமிக்ஞை பெறப்படும் போது

INT, TERM, EXIT

ஸ்கிரிப்ட் பூட்டு கோப்பை நிறுத்தி அழிக்கிறது.

பூட்டு கோப்பு சரிபார்க்கப்பட்ட நேரத்திற்கும் அது உருவாக்கப்பட்ட நேரத்திற்கும் இடையில் மேலே உள்ள ஸ்கிரிப்டில் போட்டி நிலைமை இருக்கக்கூடும் என்று சொல்வது மதிப்பு. ஏற்கனவே உள்ள கோப்பிற்கு திருப்பி விடாத வழிமாற்று மற்றும் பாஷின் நோக்ளோபர் பயன்முறையைப் பயன்படுத்துவது ஒரு சாத்தியமான தீர்வாகும்:

LOCK = "/ var / run / rsync.lock" if (set -o noclobber; echo $$> "$ LOCK") 2> / dev / null; பின்னர் 'rm -f "$ LOCK" ஐ பொறிக்கவும்; வெளியேறு $? ' INT TERM EXIT rsync -avz foo bar rm -f $ LOCK trap - INT TERM EXIT else echo "rsync ஏற்கனவே இயங்குகிறது: cat (cat $ LCK)" fi

பிந்தையவற்றின் தனித்தன்மை என்னவென்றால், நான் ஏற்கனவே கூறியது போலவே இது பயன்படுத்தப்படுகிறது, நோக்ளோபர் பயன்முறை மற்றும் பூட்டு கோப்பில் செயல்படுத்தப்படும் செயல்முறையின் PID உள்ளது.

போன்ற பிற தீர்வுகள் உள்ளன என்பதையும் குறிப்பிடுவது மதிப்பு

flock

o

solo

இருப்பினும் இந்த இடுகையில் நான் தீர்வுகளை பாஷின் சொந்த ஆதாரங்களுடன் பகிர்ந்து கொள்ள விரும்பினேன். இதன் மூலம் பொறிகளைப் பற்றி இன்னும் கொஞ்சம் அறியலாம் சிறந்த வழிகாட்டி.