ફોલિંગ ડાઉન ધ રેબિટ હોલ: એક વાર્નિશ રીબૂટ ભૂલની વાર્તા - ભાગ 1

ભૂતિનુશંકા, અગાઉની 20 મિનિટ માટે બટનો પર ધબકારા કર્યા પછી, જાણે તેનું જીવન તેના પર નિર્ભર છે, તેની આંખોમાં અર્ધ-જંગલી અભિવ્યક્તિ અને સ્લી સ્મિત સાથે મારી તરફ વળે છે - "દોસ્ત, મને લાગે છે કે હું સમજી ગયો છું."

"અહીં જુઓ," તે સ્ક્રીન પરના પ્રતીકોમાંથી એક તરફ ઇશારો કરીને કહે છે, "હું તમને મારી લાલ ટોપી પર શરત લગાવું છું, જો અમે તમને અહીં જે મોકલ્યું છે તે ઉમેરીશું," કોડના બીજા વિભાગ તરફ નિર્દેશ કરીને, "ભૂલ હવે પ્રદર્શિત થશે નહીં."

થોડો મૂંઝવણભર્યો અને થાકેલા, હું સેડ સ્ટેટમેન્ટમાં ફેરફાર કરું છું જેના પર અમે થોડા સમયથી કામ કરી રહ્યા છીએ, ફાઇલ સાચવો અને ચલાવો systemctl varnish reload. ભૂલ સંદેશ અદૃશ્ય થઈ ગયો છે...

"મેં ઉમેદવાર સાથે ઈમેઈલની આપ-લે કરી," મારા સાથીદારે ચાલુ રાખ્યું, કારણ કે તેની સ્મિત આનંદથી ભરપૂર અસલી સ્મિતમાં ફેરવાઈ જાય છે, "અચાનક મને ખબર પડી કે આ બરાબર એ જ સમસ્યા છે!"

તે બધું કેવી રીતે શરૂ થયું

લેખ કેવી રીતે bash, awk, sed અને systemd કામ કરે છે તેની સમજ ધારે છે. વાર્નિશનું જ્ઞાન પ્રાધાન્ય છે પરંતુ જરૂરી નથી.
સ્નિપેટ્સમાં ટાઇમસ્ટેમ્પ બદલવામાં આવ્યા છે.
સાથે લખાયેલ ભૂતિનુશંકા.
આ લખાણ બે અઠવાડિયા પહેલા અંગ્રેજીમાં પ્રકાશિત થયેલ મૂળનો અનુવાદ છે; અનુવાદ બોયકોડેન.

અન્ય ગરમ પાનખરની સવારે વિહંગમ બારીઓમાંથી સૂર્ય ઝળકે છે, તાજા ઉકાળેલા કેફીનયુક્ત પીણાંનો એક કપ કીબોર્ડથી દૂર રહે છે, હેડફોનમાં યાંત્રિક કીબોર્ડના ગડગડાટ પર અવાજોની મનપસંદ સિમ્ફની વાગે છે, અને કાનબન બોર્ડ પર બેકલોગ ટિકિટની યાદીમાં પ્રથમ એન્ટ્રી છે: "હું ખૂબ જ રમુજી શીર્ષક સાથે. સ્ટેજિંગમાં ઓ એરર” (સ્ટેજમાં “varnishreload sh : echo: I/O એરર”ની તપાસ કરો). જ્યારે વાર્નિશની વાત આવે છે, ત્યાં કોઈ ભૂલો નથી અને હોઈ શકતી નથી, પછી ભલે તે કોઈ સમસ્યામાં પરિણમતી ન હોય, જેમ કે આ કિસ્સામાં.

જેઓ પરિચિત નથી તેમના માટે વાર્નિશલોડ, આ એક સરળ શેલ સ્ક્રિપ્ટ છે જેનો ઉપયોગ રૂપરેખાંકન ફરીથી લોડ કરવા માટે થાય છે વાર્નિશ - VCL પણ કહેવાય છે.

ટિકિટનું શીર્ષક સૂચવે છે તેમ, સ્ટેજમાંના એક સર્વર પર ભૂલ આવી હતી, અને મને વિશ્વાસ હતો કે સ્ટેજમાં વાર્નિશનું રૂટીંગ યોગ્ય રીતે કામ કરી રહ્યું છે, તેથી મેં ધાર્યું કે આ એક નાની ભૂલ હશે. તેથી, ફક્ત એક સંદેશ જે પહેલાથી બંધ આઉટપુટ પ્રવાહમાં આવ્યો. હું મારા માટે ટિકિટ લઉં છું, સંપૂર્ણ વિશ્વાસ સાથે કે હું તેને 30 મિનિટથી ઓછા સમયમાં તૈયાર કરીશ, આગામી જંકના બોર્ડને સાફ કરવા માટે મારી જાતને ખભા પર થપાવીશ અને વધુ મહત્વપૂર્ણ બાબતો પર પાછા આવીશ.

200 કિમી/કલાકની ઝડપે દિવાલ સાથે અથડાવું

ફાઇલ ખોલી રહ્યા છીએ varnishreload, ડેબિયન સ્ટ્રેચ ચલાવતા સર્વરમાંથી એક પર, મેં 200 થી ઓછી લીટીઓ લાંબી શેલ સ્ક્રિપ્ટ જોઈ.

સ્ક્રિપ્ટ દ્વારા ચાલતા, મને એવું કંઈ દેખાતું નહોતું કે જે તેને ટર્મિનલથી સીધી ઘણી વખત ચલાવતી વખતે સમસ્યા ઊભી કરી શકે.

છેવટે, આ એક તબક્કો છે, જો તે તૂટી જાય તો પણ, કોઈ ફરિયાદ કરશે નહીં, સારું ... વધુ પડતું નથી. હું સ્ક્રિપ્ટ ચલાવું છું અને જોઉં છું કે ટર્મિનલ પર શું લખવામાં આવશે, પરંતુ ભૂલો હવે દેખાતી નથી.

હું કેટલાક વધારાના પ્રયત્નો વિના ભૂલનું પુનઃઉત્પાદન કરી શકતો નથી તેની ખાતરી કરવા માટે થોડા વધુ દોડે છે, અને હું આ સ્ક્રિપ્ટને કેવી રીતે બદલવી તે શોધવાનું શરૂ કરું છું અને તે હજી પણ ભૂલ ફેંકી દે છે.

શું સ્ક્રિપ્ટ STDOUT (નો ઉપયોગ કરીને > &-)? અથવા STDERR? અંતે બંનેએ કામ કર્યું નહીં.

દેખીતી રીતે systemd રન પર્યાવરણને અમુક રીતે બદલે છે, પરંતુ કેવી રીતે અને શા માટે?
હું વિમ ચાલુ કરું છું અને સંપાદિત કરું છું varnishreload, ઉમેરી રહ્યા છે set -x શેબેંગની નીચે, આશા છે કે સ્ક્રિપ્ટના આઉટપુટને ડિબગ કરવાથી થોડો પ્રકાશ આવશે.

ફાઇલ ઠીક થઈ ગઈ છે, તેથી મેં વાર્નિશ ફરીથી લોડ કર્યું અને જોયું કે ફેરફારથી બધું જ તૂટી ગયું છે... એક્ઝોસ્ટ એ સંપૂર્ણ ગડબડ છે, જેમાં ટન C-જેવા કોડ છે. તે ક્યાંથી શરૂ થાય છે તે શોધવા માટે ટર્મિનલમાં સ્ક્રોલ કરવું પણ પૂરતું નથી. હું સંપૂર્ણપણે મૂંઝવણમાં છું. શું ડિબગ મોડ સ્ક્રિપ્ટમાં ચાલતા પ્રોગ્રામ્સના કામને અસર કરી શકે છે? કોઈ બકવાશ નહીં. શેલમાં ભૂલ છે? કેટલાક સંભવિત દૃશ્યો મારા માથામાં કોકરોચની જેમ જુદી જુદી દિશામાં ઉડી રહ્યા છે. કેફીનથી ભરપૂર પીણુંનો એક કપ ત્વરિતમાં ખાલી થઈ જાય છે, પુનઃ પુરવઠા માટે રસોડામાં ઝડપી સફર અને… ચાલો જઈએ. હું સ્ક્રિપ્ટ ખોલું છું અને શેબાંગને નજીકથી જોઉં છું: #!/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 રૂપરેખાંકન આઉટપુટ કરવા માટે વપરાય છે ${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 ના નામ પર, જો કોઈ હોય તો. આ કિસ્સામાં તે "રીલોડ_20190101_120000_12397" હશે.

ઠીક છે, ચલ. ${VCL_SHOW} વાર્નિશ માટે સંપૂર્ણ રૂપરેખાંકન સમાવે છે, અત્યાર સુધી સ્પષ્ટ છે. હવે હું આખરે સમજું છું કે શા માટે ડેશ આઉટપુટ સાથે set -x તે ખૂબ તૂટેલું હોવાનું બહાર આવ્યું - તેમાં પરિણામી ગોઠવણીની સામગ્રી શામેલ છે.

તે સમજવું અગત્યનું છે કે સંપૂર્ણ VCL રૂપરેખાંકન ઘણીવાર બહુવિધ ફાઇલોમાંથી એકસાથે કોબલ કરી શકાય છે. C-શૈલીની ટિપ્પણીઓનો ઉપયોગ એ વ્યાખ્યાયિત કરવા માટે થાય છે કે જ્યાં એક રૂપરેખાંકન ફાઈલ બીજીમાં સમાવવામાં આવી છે, અને કોડ સ્નિપેટની નીચેની લાઇન બરાબર તે જ છે.
સમાવિષ્ટ ફાઇલોનું વર્ણન કરતી ટિપ્પણીઓ માટેનું વાક્યરચના નીચે મુજબનું ફોર્મેટ ધરાવે છે:

// 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 મિનિટ પહેલાથી જ છ વખત સમાપ્ત થઈ ગઈ છે અને વધુમાં, એક ઉચ્ચ પ્રાથમિકતા કાર્ય દેખાયું છે, બાકીના કેસોને બાજુ પર ધકેલી દે છે. બાકીનું અઠવાડિયું વિવિધ કાર્યોથી ભરેલું હતું અને માત્ર sed પરની ચર્ચા અને ઉમેદવાર સાથેના ઇન્ટરવ્યુથી થોડું ઓછું હતું. માં ભૂલની સમસ્યા 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" ફાઇલ પર જેથી હું સેવા પુનઃપ્રારંભની કોઈપણ મુશ્કેલી વિના સેડ સ્ક્રિપ્ટ લખવા પર ધ્યાન કેન્દ્રિત કરી શકું.

sed ઇનપુટ કેવી રીતે હેન્ડલ કરે છે તેનું સંક્ષિપ્ત વર્ણન મળી શકે છે તેનું GNU મેન્યુઅલ. sed સ્ત્રોતોમાં, પ્રતીક 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

તેથી varnishreload સ્ક્રિપ્ટની સામગ્રી આના જેવી દેખાશે:

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