ਰੈਬਿਟ ਹੋਲ ਦੇ ਹੇਠਾਂ ਡਿੱਗਣਾ: ਇੱਕ ਵਾਰਨਿਸ਼ ਰੀਬੂਟ ਗਲਤੀ ਦੀ ਕਹਾਣੀ - ਭਾਗ 1

ਭੂਤਿਨੁਸ਼ੰਕਾ, ਪਿਛਲੇ 20 ਮਿੰਟਾਂ ਲਈ ਬਟਨਾਂ ਨੂੰ ਦਬਾਉਣ ਤੋਂ ਬਾਅਦ ਜਿਵੇਂ ਕਿ ਉਸਦੀ ਜ਼ਿੰਦਗੀ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ, ਉਸ ਦੀਆਂ ਅੱਖਾਂ ਵਿੱਚ ਅਰਧ-ਜੰਗਲੀ ਸਮੀਕਰਨ ਅਤੇ ਇੱਕ ਚੁਸਤ ਮੁਸਕਰਾਹਟ ਨਾਲ ਮੇਰੇ ਵੱਲ ਮੁੜਦਾ ਹੈ - "ਯਾਰ, ਮੈਨੂੰ ਲਗਦਾ ਹੈ ਕਿ ਮੈਂ ਸਮਝ ਗਿਆ ਹਾਂ।"

“ਇੱਥੇ ਦੇਖੋ,” ਉਹ ਸਕ੍ਰੀਨ ਦੇ ਇੱਕ ਅੱਖਰ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹੋਏ ਕਹਿੰਦਾ ਹੈ, “ਮੈਂ ਆਪਣੀ ਲਾਲ ਟੋਪੀ ਨਾਲ ਸੱਟਾ ਲਗਾਉਂਦਾ ਹਾਂ ਕਿ ਜੇ ਅਸੀਂ ਇੱਥੇ ਉਹੀ ਸ਼ਾਮਲ ਕਰੀਏ ਜੋ ਮੈਂ ਤੁਹਾਨੂੰ ਭੇਜਿਆ ਹੈ” - ਕੋਡ ਦੇ ਇੱਕ ਹੋਰ ਭਾਗ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਦੇ ਹੋਏ - “ਗਲਤੀ ਹੁਣ ਨਹੀਂ ਹੋਵੇਗੀ। ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਜਾਵੇ।"

ਥੋੜਾ ਜਿਹਾ ਉਲਝਣ ਅਤੇ ਥੱਕਿਆ ਹੋਇਆ, ਮੈਂ ਸੈਡ ਸਟੇਟਮੈਂਟ ਨੂੰ ਬਦਲਦਾ ਹਾਂ ਜਿਸ 'ਤੇ ਅਸੀਂ ਕੁਝ ਸਮੇਂ ਤੋਂ ਕੰਮ ਕਰ ਰਹੇ ਹਾਂ, ਫਾਈਲ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ, ਅਤੇ ਚਲਾਓ systemctl varnish reload. ਗਲਤੀ ਸੁਨੇਹਾ ਗਾਇਬ ਹੋ ਗਿਆ ਹੈ...

"ਮੈਂ ਉਮੀਦਵਾਰ ਨਾਲ ਈਮੇਲਾਂ ਦਾ ਆਦਾਨ-ਪ੍ਰਦਾਨ ਕੀਤਾ," ਮੇਰੇ ਸਹਿਕਰਮੀ ਨੇ ਜਾਰੀ ਰੱਖਿਆ, ਜਿਵੇਂ ਕਿ ਉਸਦੀ ਮੁਸਕਰਾਹਟ ਖੁਸ਼ੀ ਨਾਲ ਭਰੀ ਇੱਕ ਸੱਚੀ ਮੁਸਕਰਾਹਟ ਵਿੱਚ ਬਦਲ ਗਈ, "ਇਹ ਅਚਾਨਕ ਮੇਰੇ 'ਤੇ ਆ ਗਿਆ ਕਿ ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਸਮੱਸਿਆ ਹੈ!"

ਇਹ ਸਭ ਕਿਵੇਂ ਸ਼ੁਰੂ ਹੋਇਆ

ਲੇਖ ਇਹ ਸਮਝਦਾ ਹੈ ਕਿ bash, awk, sed ਅਤੇ systemd ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ। ਵਾਰਨਿਸ਼ ਦਾ ਗਿਆਨ ਤਰਜੀਹੀ ਹੈ ਪਰ ਲੋੜੀਂਦਾ ਨਹੀਂ ਹੈ।
ਸਨਿੱਪਟਾਂ ਵਿੱਚ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ।
ਨਾਲ ਲਿਖਿਆ ਗਿਆ ਭੂਤਿਨੁਸ਼ੰਕਾ.
ਇਹ ਲਿਖਤ ਦੋ ਹਫ਼ਤੇ ਪਹਿਲਾਂ ਅੰਗਰੇਜ਼ੀ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ ਮੂਲ ਦਾ ਅਨੁਵਾਦ ਹੈ; ਅਨੁਵਾਦ boyikoden.

ਇੱਕ ਹੋਰ ਨਿੱਘੀ ਪਤਝੜ ਦੀ ਸਵੇਰ ਨੂੰ ਪੈਨੋਰਾਮਿਕ ਵਿੰਡੋਜ਼ ਵਿੱਚੋਂ ਸੂਰਜ ਚਮਕਦਾ ਹੈ, ਤਾਜ਼ੇ ਬਰੂਏਡ ਕੈਫੀਨਡ ਡਰਿੰਕ ਦਾ ਇੱਕ ਪਿਆਲਾ ਕੀਬੋਰਡ ਦੇ ਪਾਸੇ ਟਿਕਿਆ ਹੋਇਆ ਹੈ, ਮਕੈਨੀਕਲ ਕੀਬੋਰਡਾਂ ਦੀ ਗੂੰਜ ਵਿੱਚ ਹੈੱਡਫੋਨਾਂ ਵਿੱਚ ਆਵਾਜ਼ਾਂ ਦੀ ਇੱਕ ਮਨਪਸੰਦ ਸਿੰਫਨੀ ਵੱਜਦੀ ਹੈ, ਅਤੇ ਪਹਿਲੀ ਐਂਟਰੀ ਕਨਬਨ ਬੋਰਡ 'ਤੇ ਬੈਕਲਾਗ ਟਿਕਟਾਂ ਦੀ ਸੂਚੀ "ਇਨਵੈਸਟੀਗੇਟ varnishreload sh: echo: I/O error in ਸਟੇਜਿੰਗ" (ਸਟੇਜਿੰਗ ਵਿੱਚ "varnishreload sh: echo: I/O ਗਲਤੀ" ਦੀ ਜਾਂਚ ਕਰੋ) ਦੇ ਨਾਲ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਚਮਕਦੀ ਹੈ। ਜਦੋਂ ਵਾਰਨਿਸ਼ ਦੀ ਗੱਲ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਨਹੀਂ ਹੋ ਸਕਦੀ ਹੈ, ਭਾਵੇਂ ਉਹਨਾਂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੁੰਦੀ, ਜਿਵੇਂ ਕਿ ਇਸ ਕੇਸ ਵਿੱਚ.

ਉਹਨਾਂ ਲਈ ਜੋ ਜਾਣੂ ਨਹੀਂ ਹਨ varnishreload, ਇਹ ਇੱਕ ਸਧਾਰਨ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਸੰਰਚਨਾ ਨੂੰ ਮੁੜ ਲੋਡ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਵਾਰਨਿਸ਼ - VCL ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਜਿਵੇਂ ਕਿ ਟਿਕਟ ਦੇ ਸਿਰਲੇਖ ਤੋਂ ਪਤਾ ਲੱਗਦਾ ਹੈ, ਸਟੇਜ ਵਿੱਚ ਇੱਕ ਸਰਵਰ ਵਿੱਚ ਗਲਤੀ ਆਈ ਹੈ, ਅਤੇ ਕਿਉਂਕਿ ਮੈਨੂੰ ਵਿਸ਼ਵਾਸ ਸੀ ਕਿ ਸਟੇਜ ਵਿੱਚ ਵਾਰਨਿਸ਼ ਦੀ ਰੂਟਿੰਗ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰ ਰਹੀ ਸੀ, ਮੈਂ ਮੰਨਿਆ ਕਿ ਇਹ ਇੱਕ ਮਾਮੂਲੀ ਗਲਤੀ ਹੋਵੇਗੀ। ਇਸ ਲਈ, ਸਿਰਫ਼ ਇੱਕ ਸੁਨੇਹਾ ਜੋ ਪਹਿਲਾਂ ਹੀ ਬੰਦ ਆਉਟਪੁੱਟ ਸਟ੍ਰੀਮ ਵਿੱਚ ਆਇਆ ਹੈ. ਮੈਂ ਆਪਣੇ ਲਈ ਇੱਕ ਟਿਕਟ ਲੈਂਦਾ ਹਾਂ, ਪੂਰੇ ਭਰੋਸੇ ਨਾਲ ਕਿ ਮੈਂ ਇਸਨੂੰ 30 ਮਿੰਟਾਂ ਤੋਂ ਵੀ ਘੱਟ ਸਮੇਂ ਵਿੱਚ ਤਿਆਰ ਕਰਾਂਗਾ, ਅਗਲੇ ਕਬਾੜ ਦੇ ਬੋਰਡ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਲਈ ਆਪਣੇ ਮੋਢੇ 'ਤੇ ਥਪਥਪਾਉਂਦਾ ਹਾਂ ਅਤੇ ਹੋਰ ਜ਼ਰੂਰੀ ਚੀਜ਼ਾਂ 'ਤੇ ਵਾਪਸ ਆ ਜਾਂਦਾ ਹਾਂ।

200 ਕਿਲੋਮੀਟਰ ਪ੍ਰਤੀ ਘੰਟਾ ਦੀ ਰਫ਼ਤਾਰ ਨਾਲ ਕੰਧ ਨਾਲ ਟਕਰਾਉਣਾ

ਇੱਕ ਫਾਈਲ ਖੋਲ੍ਹੀ ਜਾ ਰਹੀ ਹੈ varnishreload, ਡੇਬੀਅਨ ਸਟ੍ਰੈਚ ਚਲਾ ਰਹੇ ਸਰਵਰਾਂ ਵਿੱਚੋਂ ਇੱਕ 'ਤੇ, ਮੈਂ 200 ਲਾਈਨਾਂ ਤੋਂ ਘੱਟ ਲੰਮੀ ਇੱਕ ਸ਼ੈੱਲ ਸਕ੍ਰਿਪਟ ਦੇਖੀ।

ਸਕ੍ਰਿਪਟ ਰਾਹੀਂ ਚੱਲਦੇ ਹੋਏ, ਮੈਨੂੰ ਅਜਿਹਾ ਕੁਝ ਨਹੀਂ ਦਿਸਿਆ ਜੋ ਟਰਮੀਨਲ ਤੋਂ ਸਿੱਧੇ ਕਈ ਵਾਰ ਚਲਾਉਣ ਵੇਲੇ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ।

ਆਖ਼ਰਕਾਰ, ਇਹ ਇੱਕ ਪੜਾਅ ਹੈ, ਭਾਵੇਂ ਇਹ ਟੁੱਟ ਜਾਵੇ, ਕੋਈ ਵੀ ਸ਼ਿਕਾਇਤ ਨਹੀਂ ਕਰੇਗਾ, ਠੀਕ ਹੈ ... ਬਹੁਤ ਜ਼ਿਆਦਾ ਨਹੀਂ. ਮੈਂ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦਾ ਹਾਂ ਅਤੇ ਦੇਖਦਾ ਹਾਂ ਕਿ ਟਰਮੀਨਲ 'ਤੇ ਕੀ ਲਿਖਿਆ ਜਾਵੇਗਾ, ਪਰ ਗਲਤੀਆਂ ਹੁਣ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦੀਆਂ।

ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕੁਝ ਹੋਰ ਦੌੜਦਾ ਹਾਂ ਕਿ ਮੈਂ ਕੁਝ ਵਾਧੂ ਕੋਸ਼ਿਸ਼ਾਂ ਤੋਂ ਬਿਨਾਂ ਗਲਤੀ ਨੂੰ ਦੁਬਾਰਾ ਨਹੀਂ ਬਣਾ ਸਕਦਾ, ਅਤੇ ਮੈਂ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹਾਂ ਕਿ ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਅਜੇ ਵੀ ਇੱਕ ਗਲਤੀ ਸੁੱਟਣਾ ਹੈ।

ਕੀ ਸਕ੍ਰਿਪਟ STDOUT ਨੂੰ ਰੋਕ ਸਕਦੀ ਹੈ (ਵਰਤਦੇ ਹੋਏ > &-)? ਜਾਂ STDERR? ਨਾ ਹੀ ਅੰਤ ਵਿੱਚ ਕੰਮ ਕੀਤਾ.

ਸਪੱਸ਼ਟ ਹੈ ਕਿ ਸਿਸਟਮਡ ਰਨ ਵਾਤਾਵਰਨ ਨੂੰ ਕਿਸੇ ਤਰੀਕੇ ਨਾਲ ਬਦਲਦਾ ਹੈ, ਪਰ ਕਿਵੇਂ, ਅਤੇ ਕਿਉਂ?
ਮੈਂ ਵਿਮ ਨੂੰ ਚਾਲੂ ਕਰਦਾ ਹਾਂ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰਦਾ ਹਾਂ 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 ਸੰਰਚਨਾ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ${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 ਸੰਰਚਨਾ ਨੂੰ ਅਕਸਰ ਕਈ ਫਾਈਲਾਂ ਤੋਂ ਇਕੱਠਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਸੀ-ਸ਼ੈਲੀ ਦੀਆਂ ਟਿੱਪਣੀਆਂ ਦੀ ਵਰਤੋਂ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਇੱਕ ਸੰਰਚਨਾ ਫਾਈਲ ਨੂੰ ਦੂਜੀ ਵਿੱਚ ਕਿੱਥੇ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜੋ ਕੋਡ ਸਨਿੱਪਟ ਦੀ ਹੇਠਲੀ ਲਾਈਨ ਬਾਰੇ ਹੈ।
ਸ਼ਾਮਲ ਫਾਈਲਾਂ ਦਾ ਵਰਣਨ ਕਰਨ ਵਾਲੀਆਂ ਟਿੱਪਣੀਆਂ ਲਈ ਸੰਟੈਕਸ ਦਾ ਹੇਠਾਂ ਦਿੱਤਾ ਫਾਰਮੈਟ ਹੈ:

// 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" ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਤਾਂ ਜੋ ਮੈਂ ਸੇਵਾ ਦੇ ਮੁੜ ਚਾਲੂ ਹੋਣ ਦੀ ਕਿਸੇ ਵੀ ਪਰੇਸ਼ਾਨੀ ਤੋਂ ਬਿਨਾਂ sed ਸਕ੍ਰਿਪਟ ਨੂੰ ਲਿਖਣ 'ਤੇ ਧਿਆਨ ਦੇ ਸਕਾਂ।

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, ਫਿਰ ਲਾਲਚ ਨਾਲ ਟੈਕਸਟ ਨੂੰ ਖਾ ਲਓ ਜਿਸ ਵਿੱਚ ਉਸ ਲਾਈਨ ਵਿੱਚ ਦੋਵੇਂ ਨੰਬਰ ਸ਼ਾਮਲ ਹਨ, ਅਤੇ ਇਸ ਕਾਰਵਾਈ ਤੋਂ ਬਾਅਦ ਜੋ ਵੀ ਬਚਿਆ ਹੈ ਉਸਨੂੰ ਬਚਾਓ। ਸਟੋਰ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਜਾਰੀ ਕਰੋ ਅਤੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਖਤਮ ਕਰੋ।

ਸਧਾਰਨ, ਹੈ ਨਾ?

ਅਸੀਂ sed ਸਕ੍ਰਿਪਟ ਅਤੇ ਇਸ ਤੱਥ ਤੋਂ ਖੁਸ਼ ਸੀ ਕਿ ਇਹ ਸਾਰੇ ਮੂਲ ਕੋਡ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਮੇਰੇ ਸਾਰੇ ਟੈਸਟਾਂ ਨੇ ਲੋੜੀਂਦੇ ਨਤੀਜੇ ਦਿੱਤੇ, ਇਸਲਈ ਮੈਂ ਸਰਵਰ 'ਤੇ "ਵਾਰਨਿਸ਼ਰੀਲੋਡ" ਨੂੰ ਬਦਲਿਆ ਅਤੇ ਦੁਬਾਰਾ ਦੌੜ ਗਿਆ systemctl reload varnish. ਗੰਦੀ ਗਲਤੀ echo: write error: Broken pipe ਸਾਡੇ ਚਿਹਰੇ 'ਤੇ ਫਿਰ ਹਾਸਾ ਆ ਗਿਆ। ਇੱਕ ਅੱਖ ਮਾਰਦਾ ਕਰਸਰ ਟਰਮੀਨਲ ਦੇ ਹਨੇਰੇ ਖਾਲੀ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ ਇੱਕ ਨਵੀਂ ਕਮਾਂਡ ਦੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਸੀ...

ਸਰੋਤ: www.habr.com