ഫാളിംഗ് ഡൗൺ ദ റാബിറ്റ് ഹോൾ: ഒരു വാർണിഷ് റീലോഡ് പരാജയത്തിന്റെ കഥ - ഭാഗം 1

ഘോഷിനശങ്ക, തന്റെ ജീവിതം അതിനെ ആശ്രയിച്ചിരിക്കുന്നു എന്ന മട്ടിൽ, കഴിഞ്ഞ 20 മിനിറ്റ് ബട്ടണുകളിൽ ചുറ്റിക്കറങ്ങുമ്പോൾ, അവന്റെ കണ്ണുകളിൽ ഒരു അർദ്ധ വന്യമായ നോട്ടവും ഒരു കുസൃതി ചിരിയുമായി എന്റെ നേരെ തിരിഞ്ഞു - "ചേട്ടാ, എനിക്ക് മനസ്സിലായി."

"ഇവിടെ നോക്കൂ," സ്‌ക്രീനിലെ ഒരു ചിഹ്നത്തിലേക്ക് ചൂണ്ടിക്കാണിച്ചുകൊണ്ട് അദ്ദേഹം പറയുന്നു, "ഞാൻ നിങ്ങൾക്ക് അയച്ചത് ഞങ്ങൾ ഇവിടെ ചേർത്താൽ, കോഡിന്റെ മറ്റൊരു വിഭാഗത്തിലേക്ക് ചൂണ്ടിക്കാണിച്ച്, "എന്റെ ചുവന്ന തൊപ്പി ഞാൻ വാതുവയ്ക്കുന്നു. പ്രദർശിപ്പിക്കും."

അൽപ്പം ആശയക്കുഴപ്പത്തിലും ക്ഷീണത്തിലും, ഞങ്ങൾ കുറച്ചുകാലമായി പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുന്ന സെഡ് എക്സ്പ്രഷൻ ഞാൻ പരിഷ്ക്കരിച്ചു, ഫയൽ സേവ് ചെയ്ത് റൺ ചെയ്യുക systemctl varnish reload. പിശക് സന്ദേശം അപ്രത്യക്ഷമായി...

"ഞാൻ സ്ഥാനാർത്ഥിയുമായി കൈമാറ്റം ചെയ്ത ഇമെയിലുകൾ," എന്റെ സഹപ്രവർത്തകൻ തുടർന്നു, അവന്റെ ചിരി സന്തോഷത്തിന്റെ യഥാർത്ഥ പുഞ്ചിരിയായി വളർന്നപ്പോൾ, "ഇത് അതേ പ്രശ്‌നമാണെന്ന് പെട്ടെന്ന് എനിക്ക് മനസ്സിലായി!"

എല്ലാം എങ്ങനെ ആരംഭിച്ചു

bash, awk, sed, systemd എന്നിവ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിനെക്കുറിച്ചുള്ള ഒരു ധാരണ ലേഖനം അനുമാനിക്കുന്നു. വാർണിഷിനെക്കുറിച്ചുള്ള അറിവ് അഭികാമ്യമാണ്, പക്ഷേ ആവശ്യമില്ല.
സ്‌നിപ്പെറ്റുകളിലെ ടൈംസ്റ്റാമ്പുകൾ മാറ്റി.
കൂടെ എഴുതിയത് ഘോഷിനശങ്ക.
രണ്ടാഴ്ച മുമ്പ് ഇംഗ്ലീഷിൽ പ്രസിദ്ധീകരിച്ച മൂലകൃതിയുടെ വിവർത്തനമാണ് ഈ വാചകം; വിവർത്തനം ബോയിക്കോഡൻ.

മറ്റൊരു ചൂടുള്ള ശരത്കാല പ്രഭാതത്തിൽ പനോരമിക് ജാലകങ്ങളിലൂടെ സൂര്യൻ പ്രകാശിക്കുന്നു, പുതുതായി തയ്യാറാക്കിയ കഫീൻ അടങ്ങിയ ഒരു കപ്പ് പാനീയം കീബോർഡിൽ നിന്ന് മാറി നിൽക്കുന്നു, നിങ്ങളുടെ പ്രിയപ്പെട്ട സിംഫണി ശബ്ദങ്ങൾ നിങ്ങളുടെ ഹെഡ്‌ഫോണുകളിൽ മുഴങ്ങുന്നു, മെക്കാനിക്കൽ കീബോർഡുകളുടെ ബഹളത്തെ മുക്കിക്കളയുന്നു, ആദ്യ പ്രവേശനം കാൻബൻ ബോർഡിലെ ബാക്ക്‌ലോഗ് ടിക്കറ്റുകളുടെ പട്ടികയിൽ "വാർണിഷ്രെലോഡ് അന്വേഷിക്കുക" sh: പ്രതിധ്വനി: സ്റ്റേജിംഗിലെ I/O പിശക്" (സ്റ്റേജിംഗിലെ "varnishreload sh: echo: I/O പിശക്" അന്വേഷിക്കുക) എന്ന നിർഭാഗ്യകരമായ ശീർഷകത്തിൽ കളിയായി തിളങ്ങുന്നു. വാർണിഷിന്റെ കാര്യം വരുമ്പോൾ, ഈ കേസിലെ പോലെ എന്തെങ്കിലും പ്രശ്‌നങ്ങൾ ഉണ്ടാക്കിയില്ലെങ്കിൽപ്പോലും, പിശകുകൾക്ക് ഇടമുണ്ട്, സാധ്യമല്ല.

പരിചയമില്ലാത്തവർക്കായി വാർണിഷ്രെലോഡ്, ഇത് കോൺഫിഗറേഷൻ റീലോഡ് ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഒരു ലളിതമായ ഷെൽ സ്ക്രിപ്റ്റാണ് വാർണിഷ് - വിസിഎൽ എന്നും വിളിക്കുന്നു.

ടിക്കറ്റിന്റെ തലക്കെട്ട് സൂചിപ്പിക്കുന്നത് പോലെ, സ്റ്റേജിലെ ഒരു സെർവറിലാണ് പിശക് സംഭവിച്ചത്, സ്റ്റേജിലെ വാർണിഷ് റൂട്ടിംഗ് ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് എനിക്ക് ഉറപ്പായതിനാൽ, ഇത് ഒരു ചെറിയ പിശകായിരിക്കുമെന്ന് ഞാൻ അനുമാനിച്ചു. അതിനാൽ, ഇതിനകം അടച്ച ഔട്ട്പുട്ട് സ്ട്രീമിൽ അവസാനിച്ച ഒരു സന്ദേശം മാത്രം. 30 മിനിറ്റിൽ താഴെ സമയത്തിനുള്ളിൽ ഞാൻ ടിക്കറ്റ് തയ്യാറായി എന്ന് അടയാളപ്പെടുത്തും എന്ന പൂർണ്ണ വിശ്വാസത്തോടെ ഞാൻ ടിക്കറ്റ് എടുക്കുന്നു, ബോർഡ് മറ്റൊരു ചപ്പുചവറുകൾ മായ്‌ക്കുന്നതിന് മുതുകിൽ തട്ടുകയും കൂടുതൽ പ്രധാനപ്പെട്ട കാര്യങ്ങളിലേക്ക് മടങ്ങുകയും ചെയ്യുന്നു.

മണിക്കൂറിൽ 200 കിലോമീറ്റർ വേഗതയിൽ മതിലിൽ ഇടിച്ചു

ഫയൽ തുറക്കുന്നു varnishreload, Debian Stretch പ്രവർത്തിക്കുന്ന സെർവറുകളിൽ ഒന്നിൽ, 200 വരികളിൽ താഴെ നീളമുള്ള ഒരു ഷെൽ സ്ക്രിപ്റ്റ് ഞാൻ കണ്ടു.

സ്ക്രിപ്റ്റിലൂടെ കടന്നുപോയി, ടെർമിനലിൽ നിന്ന് നേരിട്ട് ഒന്നിലധികം തവണ പ്രവർത്തിപ്പിക്കുമ്പോൾ പ്രശ്‌നങ്ങളുണ്ടാക്കുന്ന ഒന്നും ഞാൻ ശ്രദ്ധിച്ചില്ല.

എല്ലാത്തിനുമുപരി, ഇത് ഒരു സ്റ്റേജാണ്, ഇത് പൊട്ടിയാലും ആരും പരാതിപ്പെടില്ല, കൊള്ളാം.. അമിതമല്ല. ഞാൻ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിച്ച് ടെർമിനലിൽ എന്താണ് എഴുതപ്പെടുക എന്ന് നോക്കുന്നു, പക്ഷേ പിശകുകൾ ഇനി ദൃശ്യമാകില്ല.

അധിക ശ്രമങ്ങളൊന്നുമില്ലാതെ എനിക്ക് പിശക് പുനർനിർമ്മിക്കാൻ കഴിയില്ലെന്ന് ഉറപ്പാക്കാൻ കുറച്ച് റൺസ് കൂടി നടത്തി, ഈ സ്ക്രിപ്റ്റ് എങ്ങനെ മാറ്റാമെന്നും അത് ഇപ്പോഴും ഒരു പിശക് സൃഷ്ടിക്കുമെന്നും ഞാൻ മനസ്സിലാക്കാൻ തുടങ്ങി.

സ്ക്രിപ്റ്റിന് STDOUT അസാധുവാക്കാൻ കഴിയുമോ (ഉപയോഗിക്കുന്നത് > &-)? അല്ലെങ്കിൽ STDERR? ഇവ രണ്ടും അവസാനം പ്രവർത്തിച്ചില്ല.

പ്രത്യക്ഷത്തിൽ systemd എങ്ങനെയെങ്കിലും സ്റ്റാർട്ടപ്പ് പരിതസ്ഥിതിയിൽ മാറ്റം വരുത്തുന്നു, പക്ഷേ എങ്ങനെ, എന്തുകൊണ്ട്?
ഞാൻ വിം തുറന്ന് എഡിറ്റ് ചെയ്യുന്നു varnishreload, ചേർക്കുന്നു set -x സ്‌ക്രിപ്‌റ്റിന്റെ ഡീബഗ് ഔട്ട്‌പുട്ട് കുറച്ച് വെളിച്ചം വീശുമെന്ന് പ്രതീക്ഷിക്കുന്ന ഷെബാങ്ങിന് കീഴിൽ.

ഫയൽ ശരിയാക്കി, അതിനാൽ ഞാൻ വാർണിഷ് വീണ്ടും ലോഡുചെയ്‌തു, മാറ്റം എല്ലാം പൂർണ്ണമായും തകർത്തതായി കാണുന്നു... എക്‌സ്‌ഹോസ്റ്റ് ഒരു പൂർണ്ണമായ കുഴപ്പമാണ്, അതിൽ ടൺ സി-പോലുള്ള കോഡ് ഉണ്ട്. ടെർമിനലിൽ സ്ക്രോൾ ചെയ്‌താൽ പോലും അത് എവിടെ തുടങ്ങുന്നു എന്ന് കണ്ടെത്താൻ പര്യാപ്തമല്ല. ഞാൻ ആകെ ആശയക്കുഴപ്പത്തിലാണ്. ഒരു സ്ക്രിപ്റ്റിൽ ലോഞ്ച് ചെയ്യുന്ന പ്രോഗ്രാമുകളുടെ പ്രവർത്തനത്തെ ഡീബഗ്ഗിംഗ് മോഡ് ബാധിക്കുമോ? ഇല്ല, ഇത് അസംബന്ധമാണ്. ഷെല്ലിലെ ബഗ്? സാധ്യമായ നിരവധി സാഹചര്യങ്ങൾ വ്യത്യസ്ത ദിശകളിലേക്ക് കാക്കപ്പൂക്കളെപ്പോലെ എന്റെ തലയിലൂടെ ഓടുന്നു. കഫീൻ അടങ്ങിയ പാനീയത്തിന്റെ കപ്പ് തൽക്ഷണം ശൂന്യമായി, സ്റ്റോക്ക് നിറയ്ക്കാൻ അടുക്കളയിലേക്കുള്ള ഒരു പെട്ടെന്നുള്ള യാത്ര... ഞങ്ങൾ പോകുന്നു. ഞാൻ സ്‌ക്രിപ്റ്റ് തുറന്ന് ഷെബാംഗിനെ സൂക്ഷ്മമായി പരിശോധിക്കുന്നു: #!/bin/sh.

/bin/sh - ഇത് ബാഷിനുള്ള ഒരു സിംലിങ്ക് മാത്രമാണ്, അതിനാൽ സ്ക്രിപ്റ്റ് POSIX-അനുയോജ്യമായ മോഡിൽ വ്യാഖ്യാനിക്കപ്പെടുന്നു, അല്ലേ? അങ്ങനെ അല്ല! ഡെബിയനിലെ ഡിഫോൾട്ട് ഷെൽ ഡാഷ് ആണ്, അത് കൃത്യമായി കാണപ്പെടുന്നു. പരാമർശിക്കുന്നു /bin/sh.

# ls -l /bin/sh
lrwxrwxrwx 1 root root 4 Jan 24  2017 /bin/sh -> dash

ഒരു ടെസ്റ്റ് എന്ന നിലയിൽ, ഞാൻ ഷെബാംഗ് മാറ്റി #!/bin/bash, ഇല്ലാതാക്കി set -x വീണ്ടും ശ്രമിച്ചു. അവസാനമായി, വാർണിഷ് റീബൂട്ട് ചെയ്യുമ്പോൾ, ഔട്ട്പുട്ടിൽ സഹിക്കാവുന്ന ഒരു പിശക് പ്രത്യക്ഷപ്പെട്ടു:

Jan 01 12:00:00 hostname varnishreload[32604]: /usr/sbin/varnishreload: line 124: echo: write error: Broken pipe
Jan 01 12:00:00 hostname varnishreload[32604]: VCL 'reload_20190101_120000_32604' compiled

ലൈൻ 124, ഇതാ!

114 find_vcl_file() {
115         VCL_SHOW=$(varnishadm vcl.show -v "$VCL_NAME" 2>&1) || :
116         VCL_FILE=$(
117                 echo "$VCL_SHOW" |
118                 awk '$1 == "//" && $2 == "VCL.SHOW" {print; exit}' | {
119                         # all this ceremony to handle blanks in FILE
120                         read -r DELIM VCL_SHOW INDEX SIZE FILE
121                         echo "$FILE"
122                 }
123         ) || :
124
125         if [ -z "$VCL_FILE" ]
126         then
127                 echo "$VCL_SHOW" >&2
128                 fail "failed to get the VCL file name"
129         fi
130
131         echo "$VCL_FILE"
132 }

പക്ഷേ, 124 വരി തീർത്തും ശൂന്യവും താൽപ്പര്യമില്ലാത്തതുമാണ്. ലൈൻ 116-ൽ ആരംഭിക്കുന്ന ഒരു മൾട്ടിലൈൻ സ്ട്രിംഗിന്റെ ഭാഗമായാണ് പിശക് സംഭവിച്ചതെന്ന് എനിക്ക് ഊഹിക്കാവുന്നതേയുള്ളൂ.
ആത്യന്തികമായി വേരിയബിളിൽ എന്താണ് എഴുതിയിരിക്കുന്നത്? VCL_FILE മുകളിലെ സബ്-ഷെൽ നടപ്പിലാക്കുന്നതിന്റെ ഫലമായി?

തുടക്കത്തിൽ, ഇത് വേരിയബിളിന്റെ ഉള്ളടക്കങ്ങൾ അയയ്ക്കുന്നു VLC_SHOW, പൈപ്പ് വഴിയുള്ള കമാൻഡ് അനുസരിച്ച്, ലൈൻ 115-ൽ സൃഷ്ടിച്ചു. എന്നിട്ട് അവിടെ എന്താണ് സംഭവിക്കുന്നത്?

ഒന്നാമതായി, അത് അവിടെ ഉപയോഗിക്കുന്നു varnishadm, പുനരാരംഭിക്കാതെ വാർണിഷ് സജ്ജീകരിക്കുന്നതിന്, വാർണിഷ് ഇൻസ്റ്റലേഷൻ പാക്കേജിന്റെ ഭാഗമാണ്.

ഉപസംഘം vcl.show -v ൽ വ്യക്തമാക്കിയ മുഴുവൻ വിസിഎൽ കോൺഫിഗറേഷനും ഔട്ട്പുട്ട് ചെയ്യാൻ ഉപയോഗിക്കുന്നു ${VCL_NAME}, STDOUT ലേക്ക്.

നിലവിലെ സജീവമായ VCL കോൺഫിഗറേഷനും മെമ്മറിയിലുള്ള വാർണിഷ് റൂട്ടിംഗ് കോൺഫിഗറേഷനുകളുടെ മുൻ പതിപ്പുകളും പ്രദർശിപ്പിക്കുന്നതിന്, നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിക്കാം. varnishadm vcl.list, ഇതിന്റെ ഔട്ട്‌പുട്ട് ചുവടെയുള്ളതിന് സമാനമായിരിക്കും:

discarded   cold/busy       1 reload_20190101_120000_11903
discarded   cold/busy       2 reload_20190101_120000_12068
discarded   cold/busy       16 reload_20190101_120000_12259
discarded   cold/busy       16 reload_20190101_120000_12299
discarded   cold/busy       28 reload_20190101_120000_12357
active      auto/warm       32 reload_20190101_120000_12397
available   auto/warm       0 reload_20190101_120000_12587

വേരിയബിൾ മൂല്യം ${VCL_NAME} സ്ക്രിപ്റ്റിന്റെ മറ്റൊരു ഭാഗത്ത് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട് varnishreload നിലവിൽ സജീവമായ VCL ഉണ്ടെങ്കിൽ, അതിന്റെ പേരിലേക്ക്. ഈ സാഹചര്യത്തിൽ അത് "reload_20190101_120000_12397" ആയിരിക്കും.

വലിയ, വേരിയബിൾ ${VCL_SHOW} വാർണിഷിനുള്ള പൂർണ്ണമായ കോൺഫിഗറേഷൻ അടങ്ങിയിരിക്കുന്നു, ഇപ്പോൾ വ്യക്തമാണ്. ഡാഷ് ഔട്ട്പുട്ട് എന്തുകൊണ്ടാണെന്ന് ഇപ്പോൾ ഞാൻ ഒടുവിൽ മനസ്സിലാക്കുന്നു set -x വളരെ തകർന്നതായി മാറി - അതിൽ തത്ഫലമായുണ്ടാകുന്ന കോൺഫിഗറേഷന്റെ ഉള്ളടക്കം ഉൾപ്പെടുന്നു.

ഒരു സമ്പൂർണ്ണ VCL കോൺഫിഗറേഷൻ പലപ്പോഴും പല ഫയലുകളിൽ നിന്നും ഒരുമിച്ച് ചേർക്കാൻ കഴിയുമെന്ന് മനസ്സിലാക്കേണ്ടത് പ്രധാനമാണ്. ചില കോൺഫിഗറേഷൻ ഫയലുകൾ മറ്റുള്ളവയിൽ എവിടെയാണ് ഉൾപ്പെടുത്തിയിരിക്കുന്നതെന്ന് തിരിച്ചറിയാൻ സി-സ്റ്റൈൽ കമന്റുകൾ ഉപയോഗിക്കുന്നു, അതാണ് ഇനിപ്പറയുന്ന കോഡ് സ്‌നിപ്പെറ്റിന്റെ അർത്ഥം.
ഉൾപ്പെടുത്തിയ ഫയലുകൾ വിവരിക്കുന്ന അഭിപ്രായങ്ങളുടെ വാക്യഘടന ഇനിപ്പറയുന്ന ഫോർമാറ്റിലാണ്:

// VCL.SHOW <NUM> <NUM> <FILENAME>

ഈ സന്ദർഭത്തിൽ അക്കങ്ങൾ പ്രധാനമല്ല, ഫയൽ നാമത്തിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്.

ലൈൻ 116-ൽ ആരംഭിക്കുന്ന കമാൻഡുകളുടെ ചതുപ്പിൽ ആത്യന്തികമായി എന്താണ് സംഭവിക്കുന്നത്?
നമുക്കത് കണ്ടെത്താം.
ടീം നാല് ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു:

1. ലളിതം echo, വേരിയബിളിന്റെ മൂല്യം പ്രിന്റ് ചെയ്യുന്നു ${VCL_SHOW}

   echo "$VCL_SHOW"

2. awk, ഒരു വരി (റെക്കോർഡ്) തിരയുന്നു, അവിടെ വാചകം തകർത്തതിന് ശേഷം ആദ്യത്തെ ഫീൽഡ് "//" ആണ്, രണ്ടാമത്തേത് "VCL.SHOW" ആണ്.
   ഈ പാറ്റേണുകളുമായി പൊരുത്തപ്പെടുന്ന ആദ്യ വരി Awk എഴുതുകയും തുടർന്ന് പ്രോസസ്സിംഗ് ഉടനടി നിർത്തുകയും ചെയ്യും.

   awk '$1 == "//" && $2 == "VCL.SHOW" {print; exit}'

3. ഫീൽഡ് മൂല്യങ്ങളെ സ്‌പെയ്‌സുകളാൽ വേർതിരിച്ച അഞ്ച് വേരിയബിളുകളായി സംഭരിക്കുന്ന കോഡിന്റെ ഒരു ബ്ലോക്ക്. അഞ്ചാമത്തെ FILE വേരിയബിളിന് ബാക്കിയുള്ള വരികൾ ലഭിക്കുന്നു. അവസാനമായി, അവസാന എക്കോ വേരിയബിളിന്റെ ഉള്ളടക്കങ്ങൾ എഴുതുന്നു ${FILE}.

   { read -r DELIM VCL_SHOW INDEX SIZE FILE; echo "$FILE" }

4. 1 മുതൽ 3 വരെയുള്ള എല്ലാ ഘട്ടങ്ങളും ഒരു സബ്ഷെല്ലിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നതിനാൽ, മൂല്യം ഔട്ട്പുട്ട് ചെയ്യുന്നു $FILE ഒരു വേരിയബിളിൽ എഴുതപ്പെടും VCL_FILE.

ലൈൻ 119-ലെ കമന്റ് സൂചിപ്പിക്കുന്നത് പോലെ, VCL ഫയലുകൾ അവയുടെ പേരുകളിൽ സ്‌പെയ്‌സുകളുള്ള റഫറൻസ് ചെയ്യുന്ന കേസുകൾ വിശ്വസനീയമായി കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഏക ഉദ്ദേശ്യമാണ് ഇത് ചെയ്യുന്നത്.

ഇതിന്റെ യഥാർത്ഥ പ്രോസസ്സിംഗ് ലോജിക്ക് ഞാൻ കമന്റ് ചെയ്തിട്ടുണ്ട് ${VCL_FILE} കമാൻഡ് സീക്വൻസ് മാറ്റാൻ ശ്രമിച്ചു, പക്ഷേ അത് ഒന്നും നയിച്ചില്ല. എല്ലാം എനിക്ക് നന്നായി പ്രവർത്തിച്ചു, പക്ഷേ ഞാൻ സേവനം ആരംഭിച്ചപ്പോൾ അത് ഒരു പിശക് നൽകി.

സ്‌ക്രിപ്റ്റ് സ്വമേധയാ പ്രവർത്തിപ്പിക്കുമ്പോൾ പിശക് പുനർനിർമ്മിക്കാൻ കഴിയില്ലെന്ന് തോന്നുന്നു, അതേസമയം 30 മിനിറ്റ് ഇതിനകം ആറ് തവണ കാലഹരണപ്പെട്ടു, കൂടാതെ, ഉയർന്ന മുൻഗണനയുള്ള ഒരു ടാസ്‌ക് പ്രത്യക്ഷപ്പെട്ടു, മറ്റ് കാര്യങ്ങൾ മാറ്റിവച്ചു. ആഴ്‌ചയിലെ ബാക്കി സമയം പലതരത്തിലുള്ള ജോലികളാൽ നിറഞ്ഞിരുന്നു, സെഡിനെക്കുറിച്ചുള്ള ഒരു റിപ്പോർട്ടും ഒരു സ്ഥാനാർത്ഥിയുമായുള്ള അഭിമുഖവും കൊണ്ട് അത് ചെറുതായി നേർപ്പിച്ചു. പിശകുള്ള പ്രശ്നം varnishreload കാലത്തിന്റെ മണലിൽ തിരിച്ചെടുക്കാനാവാത്തവിധം നഷ്ടപ്പെട്ടു.

നിങ്ങളുടെ സെഡ്-ഫൂ... യഥാർത്ഥത്തിൽ... മാലിന്യമാണ്

അടുത്ത ആഴ്‌ച എനിക്ക് തികച്ചും സൗജന്യമായ ഒരു ദിവസം ഉണ്ടായിരുന്നു, അതിനാൽ ഈ ടിക്കറ്റ് വീണ്ടും കൈകാര്യം ചെയ്യാൻ ഞാൻ തീരുമാനിച്ചു. എന്റെ മസ്തിഷ്കത്തിൽ, ഈ സമയമത്രയും ചില പശ്ചാത്തല പ്രക്രിയകൾ ഈ പ്രശ്‌നത്തിന് പരിഹാരം തേടുന്നുണ്ടെന്ന് ഞാൻ പ്രതീക്ഷിച്ചു, ഇത്തവണ എന്താണ് സംഭവിക്കുന്നതെന്ന് എനിക്ക് തീർച്ചയായും മനസ്സിലാകും.

കഴിഞ്ഞ തവണ കോഡ് മാറ്റുന്നത് സഹായിക്കാത്തതിനാൽ, 116 വരിയിൽ നിന്ന് അത് മാറ്റിയെഴുതാൻ ഞാൻ തീരുമാനിച്ചു. ഏതായാലും നിലവിലുള്ള കോഡ് മണ്ടത്തരമായിരുന്നു. കൂടാതെ അത് ഉപയോഗിക്കേണ്ട ആവശ്യമില്ല read.

പിശക് വീണ്ടും നോക്കുന്നു:
sh: echo: broken pipe - ഈ കമാൻഡിൽ രണ്ട് സ്ഥലങ്ങളിൽ പ്രതിധ്വനി ദൃശ്യമാകുന്നു, പക്ഷേ ആദ്യത്തേത് കൂടുതൽ സാധ്യതയുള്ള കുറ്റവാളിയാണെന്ന് ഞാൻ സംശയിക്കുന്നു (അല്ലെങ്കിൽ കുറഞ്ഞത് ഒരു പങ്കാളിയെങ്കിലും). Awk ആത്മവിശ്വാസം നൽകുന്നില്ല. അത് ശരിക്കും ആണെങ്കിൽ awk | {read; echo} ഡിസൈൻ ഈ പ്രശ്നങ്ങളിലേക്ക് നയിക്കുന്നു, എന്തുകൊണ്ട് അത് മാറ്റിസ്ഥാപിച്ചുകൂടാ? ഈ ഒറ്റവരി കമാൻഡ് awk-ന്റെ എല്ലാ സവിശേഷതകളും ഉപയോഗിക്കുന്നില്ല, കൂടാതെ ഈ അധികവും read ഇതുകൂടാതെ.

കഴിഞ്ഞ ആഴ്ച മുതൽ ഒരു റിപ്പോർട്ട് ഉണ്ടായിരുന്നു sed, പുതുതായി നേടിയ എന്റെ കഴിവുകൾ പരീക്ഷിക്കാനും ലളിതമാക്കാനും ഞാൻ ആഗ്രഹിച്ചു echo | awk | { read; echo} കൂടുതൽ മനസ്സിലാക്കാവുന്നതിലേക്ക് echo | sed. ഇത് തീർച്ചയായും ബഗ് തിരിച്ചറിയുന്നതിനുള്ള ഏറ്റവും നല്ല സമീപനമല്ലെങ്കിലും, കുറഞ്ഞത് എന്റെ സെഡ്-ഫൂ പരീക്ഷിക്കണമെന്നും പ്രശ്‌നത്തെക്കുറിച്ച് പുതിയ എന്തെങ്കിലും പഠിക്കണമെന്നും ഞാൻ കരുതി. വഴിയിൽ, സെഡ് ടോക്കിന്റെ രചയിതാവായ എന്റെ സഹപ്രവർത്തകനോട് കൂടുതൽ കാര്യക്ഷമമായ സെഡ് സ്ക്രിപ്റ്റ് കൊണ്ടുവരാൻ എന്നെ സഹായിക്കാൻ ഞാൻ ആവശ്യപ്പെട്ടു.

ഞാൻ ഉള്ളടക്കം ഉപേക്ഷിച്ചു varnishadm vcl.show -v "$VCL_NAME" ഒരു ഫയലിലേക്ക്, അതിനാൽ സർവീസ് റീബൂട്ടുകളുടെ ഒരു ബുദ്ധിമുട്ടും കൂടാതെ സെഡ് സ്ക്രിപ്റ്റ് എഴുതുന്നതിൽ എനിക്ക് ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ കഴിയും.

സെഡ് പ്രോസസ് ഇൻപുട്ട് എങ്ങനെ കണ്ടെത്താം എന്നതിന്റെ ഒരു ചെറിയ വിവരണം അവന്റെ ഗ്നു മാനുവൽ. സെഡ് ഉറവിടങ്ങളിൽ ചിഹ്നം n ഒരു ലൈൻ സെപ്പറേറ്ററായി വ്യക്തമായി വ്യക്തമാക്കിയിരിക്കുന്നു.

നിരവധി പാസുകളിലും എന്റെ സഹപ്രവർത്തകന്റെ ശുപാർശകളോടെയും ഞങ്ങൾ ഒരു സെഡ് സ്ക്രിപ്റ്റ് എഴുതി, അത് യഥാർത്ഥ വരി 116-ന്റെ അതേ ഫലം നൽകി.

ഇൻപുട്ട് ഡാറ്റയുള്ള ഒരു സാമ്പിൾ ഫയൽ ചുവടെയുണ്ട്:

> cat vcl-example.vcl
Text
// VCL.SHOW 0 1578 file with 3 spaces.vcl
More text
// VCL.SHOW 0 1578 file.vcl
Even more text
// VCL.SHOW 0 1578 file with TWOspaces.vcl
Final text

മുകളിലെ വിവരണത്തിൽ നിന്ന് ഇത് വ്യക്തമാകണമെന്നില്ല, പക്ഷേ ആദ്യ അഭിപ്രായത്തിൽ മാത്രമേ ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ളൂ // VCL.SHOW, കൂടാതെ ഇൻപുട്ട് ഡാറ്റയിൽ അവയിൽ പലതും ഉണ്ടായിരിക്കാം. അതുകൊണ്ടാണ് ആദ്യ മത്സരത്തിന് ശേഷം യഥാർത്ഥ awk അവസാനിക്കുന്നത്.

# шаг первый, вывести только строки с комментариями
# используя возможности sed, определяется символ-разделитель с помощью конструкции '#' вместо обычно используемого '/', за счёт этого не придётся экранировать косые в искомом комментарии
# определяется регулярное выражение “// VCL.SHOW”, для поиска строк с определенным шаблоном
# флаг -n позаботится о том, чтобы sed не выводил все входные данные, как он это делает по умолчанию (см. ссылку выше)
# -E позволяет использовать расширенные регулярные выражения
> cat vcl-processor-1.sed
#// VCL.SHOW#p
> sed -En -f vcl-processor-1.sed vcl-example.vcl
// VCL.SHOW 0 1578 file with 3 spaces.vcl
// VCL.SHOW 0 1578 file.vcl
// VCL.SHOW 0 1578 file with TWOspaces.vcl

# шаг второй, вывести только имя файла
# используя команду “substitute”, с группами внутри регулярных выражений, отображается только нужная группa
# и это делается только для совпадений, ранее описанного поиска
> cat vcl-processor-2.sed
#// VCL.SHOW# {
    s#.* [0-9]+ [0-9]+ (.*)$#1#
    p
}
> sed -En -f vcl-processor-2.sed vcl-example.vcl
file with 3 spaces.vcl
file.vcl
file with TWOspaces.vcl

# шаг третий, получить только первый из результатов
# как и в случае с awk, добавляется немедленное завершения после печати первого найденного совпадения
> cat vcl-processor-3.sed
#// VCL.SHOW# {
    s#.* [0-9]+ [0-9]+ (.*)$#1#
    p
    q
}
> sed -En -f vcl-processor-3.sed vcl-example.vcl
file with 3 spaces.vcl

# шаг четвертый, схлопнуть всё в однострочник, используя двоеточия для разделения команд
> sed -En -e '#// VCL.SHOW#{s#.* [0-9]+ [0-9]+ (.*)$#1#p;q;}' vcl-example.vcl
file with 3 spaces.vcl

അതിനാൽ, വാർണിഷ്രെലോഡ് സ്ക്രിപ്റ്റിന്റെ ഉള്ളടക്കം ഇതുപോലെയായിരിക്കും:

VCL_FILE="$(echo "$VCL_SHOW" | sed -En '#// VCL.SHOW#{s#.*[0-9]+ [0-9]+ (.*)$#1#p;q;};')"

മേൽപ്പറഞ്ഞ യുക്തിയെ സംക്ഷിപ്തമായി ഇനിപ്പറയുന്ന രീതിയിൽ പ്രകടിപ്പിക്കാം:
സ്ട്രിംഗ് ഒരു സാധാരണ പദപ്രയോഗവുമായി പൊരുത്തപ്പെടുന്നുവെങ്കിൽ // VCL.SHOW, തുടർന്ന് ഈ വരിയിലെ രണ്ട് അക്കങ്ങളും ഉൾപ്പെടുന്ന വാചകം അത്യാഗ്രഹത്തോടെ വിഴുങ്ങുക, ഈ പ്രവർത്തനത്തിന് ശേഷം ശേഷിക്കുന്നതെല്ലാം സംരക്ഷിക്കുക. സംഭരിച്ച മൂല്യം എമിറ്റ് ചെയ്ത് പ്രോഗ്രാം അവസാനിപ്പിക്കുക.

ലളിതം, അല്ലേ?

സെഡ് സ്ക്രിപ്റ്റിലും അത് എല്ലാ ഒറിജിനൽ കോഡിനെയും മാറ്റിസ്ഥാപിച്ചതിലും ഞങ്ങൾ സന്തുഷ്ടരായിരുന്നു. എന്റെ എല്ലാ പരിശോധനകളും ആവശ്യമുള്ള ഫലങ്ങൾ നൽകി, അതിനാൽ ഞാൻ സെർവറിലെ "വാർണിഷ്രെലോഡ്" മാറ്റി വീണ്ടും പ്രവർത്തിപ്പിച്ചു systemctl reload varnish. മോശം തെറ്റ് echo: write error: Broken pipe ഞങ്ങളുടെ മുഖത്ത് വീണ്ടും ചിരിച്ചു. ടെർമിനലിന്റെ ഇരുണ്ട ശൂന്യതയിൽ ഒരു പുതിയ കമാൻഡിനായി കണ്ണിറുക്കുന്ന കഴ്സർ കാത്തിരിക്കുകയായിരുന്നു...

അവലംബം: www.habr.com