ਬੈਸ਼ ਸਕ੍ਰਿਪਟਿੰਗ ਵਧੀਆ ਅਭਿਆਸ: ਭਰੋਸੇਯੋਗ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਬੈਸ਼ ਸਕ੍ਰਿਪਟਾਂ ਲਈ ਇੱਕ ਤੇਜ਼ ਗਾਈਡ

ਮਨਾਪੀ ਦੁਆਰਾ ਸ਼ੈੱਲ ਵਾਲਪੇਪਰ

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

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

ਲੇਖ ਵਿੱਚ, ਲੇਖਕ ਸਾਂਝਾ ਕਰਦਾ ਹੈ ਕਿ ਉਸਨੇ ਪਿਛਲੇ ਕੁਝ ਸਾਲਾਂ ਵਿੱਚ ਕੀ ਸਿੱਖਿਆ ਹੈ, ਨਾਲ ਹੀ ਕੁਝ ਆਮ ਗਲਤੀਆਂ ਜਿਨ੍ਹਾਂ ਨੇ ਉਸਨੂੰ ਗਾਰਡ ਤੋਂ ਬਾਹਰ ਕਰ ਦਿੱਤਾ ਹੈ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਹਰੇਕ ਸੌਫਟਵੇਅਰ ਡਿਵੈਲਪਰ, ਆਪਣੇ ਕਰੀਅਰ ਦੇ ਕਿਸੇ ਸਮੇਂ, ਰੁਟੀਨ ਕੰਮ ਦੇ ਕੰਮਾਂ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।

ਟ੍ਰੈਪ ਹੈਂਡਲਰ

ਜ਼ਿਆਦਾਤਰ ਬੈਸ਼ ਸਕ੍ਰਿਪਟਾਂ ਜਿਨ੍ਹਾਂ ਦਾ ਮੈਂ ਸਾਹਮਣਾ ਕੀਤਾ ਹੈ ਉਹ ਕਦੇ ਵੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸਫਾਈ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ ਹਨ ਜਦੋਂ ਸਕ੍ਰਿਪਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੌਰਾਨ ਕੁਝ ਅਣਕਿਆਸਿਆ ਵਾਪਰਦਾ ਹੈ।

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

function handle_exit() {
  // Add cleanup code here
  // for eg. rm -f "/tmp/${lock_file}.lock"
  // exit with an appropriate status code
}
  
// trap <HANDLER_FXN> <LIST OF SIGNALS TO TRAP>
trap handle_exit 0 SIGHUP SIGINT SIGQUIT SIGABRT SIGTERM

trap ਇੱਕ ਸ਼ੈੱਲ ਬਿਲਟ-ਇਨ ਕਮਾਂਡ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਕਲੀਨਅੱਪ ਫੰਕਸ਼ਨ ਰਜਿਸਟਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ ਜਿਸਨੂੰ ਕਿਸੇ ਵੀ ਸਿਗਨਲ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਹੈਂਡਲਰਾਂ ਨਾਲ ਵਿਸ਼ੇਸ਼ ਧਿਆਨ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਵੇਂ ਕਿ SIGINT, ਜੋ ਸਕ੍ਰਿਪਟ ਨੂੰ ਅਧੂਰਾ ਛੱਡਣ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ ਤੁਹਾਨੂੰ ਸਿਰਫ ਫੜਨਾ ਚਾਹੀਦਾ ਹੈ EXIT, ਪਰ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਹਰੇਕ ਵਿਅਕਤੀਗਤ ਸਿਗਨਲ ਲਈ ਸਕ੍ਰਿਪਟ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰ ਸਕਦੇ ਹੋ।

ਬਿਲਟ-ਇਨ ਸੈੱਟ ਫੰਕਸ਼ਨ - ਗਲਤੀ 'ਤੇ ਤੇਜ਼ ਸਮਾਪਤੀ

ਤਰੁੱਟੀਆਂ ਦੇ ਵਾਪਰਨ ਦੇ ਨਾਲ ਹੀ ਉਹਨਾਂ ਦਾ ਜਵਾਬ ਦੇਣਾ ਅਤੇ ਫੌਰੀ ਤੌਰ 'ਤੇ ਲਾਗੂ ਕਰਨਾ ਬੰਦ ਕਰਨਾ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਕਮਾਂਡ ਚਲਾਉਣਾ ਜਾਰੀ ਰੱਖਣ ਨਾਲੋਂ ਕੁਝ ਵੀ ਮਾੜਾ ਨਹੀਂ ਹੋ ਸਕਦਾ:

rm -rf ${directory_name}/*

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਵੇਰੀਏਬਲ directory_name ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ।

ਅਜਿਹੇ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ setਜਿਵੇਂ ਕਿ set -o errexit, set -o pipefail ਜ set -o nounset ਸਕ੍ਰਿਪਟ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ. ਇਹ ਫੰਕਸ਼ਨ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ ਕਿ ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਜਿਵੇਂ ਹੀ ਕਿਸੇ ਗੈਰ-ਜ਼ੀਰੋ ਐਗਜ਼ਿਟ ਕੋਡ ਦਾ ਸਾਹਮਣਾ ਕਰਦੀ ਹੈ, ਪਰਿਭਾਸ਼ਿਤ ਵੇਰੀਏਬਲਾਂ ਦੀ ਵਰਤੋਂ, ਇੱਕ ਪਾਈਪ ਤੋਂ ਅਵੈਧ ਕਮਾਂਡਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਹੋਰ:

#!/usr/bin/env bash

set -o errexit
set -o nounset
set -o pipefail

function print_var() {
  echo "${var_value}"
}

print_var

$ ./sample.sh
./sample.sh: line 8: var_value: unbound variable

ਨੋਟ: ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਜਿਵੇਂ ਕਿ set -o errexit, ਜਿਵੇਂ ਹੀ "ਕੱਚਾ" ਰਿਟਰਨ ਕੋਡ ਹੁੰਦਾ ਹੈ (ਜ਼ੀਰੋ ਤੋਂ ਇਲਾਵਾ) ਸਕ੍ਰਿਪਟ ਤੋਂ ਬਾਹਰ ਆ ਜਾਵੇਗਾ। ਇਸ ਲਈ ਕਸਟਮ ਐਰਰ ਹੈਂਡਲਿੰਗ ਨੂੰ ਪੇਸ਼ ਕਰਨਾ ਬਿਹਤਰ ਹੈ, ਉਦਾਹਰਨ ਲਈ:

#!/bin/bash
error_exit() {
  line=$1
  shift 1
  echo "ERROR: non zero return code from line: $line -- $@"
  exit 1
}
a=0
let a++ || error_exit "$LINENO" "let operation returned non 0 code"
echo "you will never see me"
# run it, now we have useful debugging output
$ bash foo.sh
ERROR: non zero return code from line: 9 -- let operation returned non 0 code

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

ਵਿਕਾਸ ਦੌਰਾਨ ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ShellCheck

ਇਹ ਵਰਗਾ ਕੁਝ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਯੋਗ ਹੈ ਸ਼ੈੱਲ ਚੈੱਕ ਵਧੀਆ ਅਭਿਆਸਾਂ ਦੇ ਵਿਰੁੱਧ ਤੁਹਾਡੇ ਬੈਸ਼ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਤੁਹਾਡੇ ਵਿਕਾਸ ਅਤੇ ਟੈਸਟਿੰਗ ਪਾਈਪਲਾਈਨਾਂ ਵਿੱਚ।

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

ਆਪਣੇ ਖੁਦ ਦੇ ਐਗਜ਼ਿਟ ਕੋਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

POSIX ਵਿੱਚ ਰਿਟਰਨ ਕੋਡ ਸਿਰਫ਼ ਜ਼ੀਰੋ ਜਾਂ ਇੱਕ ਨਹੀਂ ਹਨ, ਬਲਕਿ ਜ਼ੀਰੋ ਜਾਂ ਇੱਕ ਗੈਰ-ਜ਼ੀਰੋ ਮੁੱਲ ਹਨ। ਵੱਖ-ਵੱਖ ਤਰੁਟੀ ਮਾਮਲਿਆਂ ਲਈ ਕਸਟਮ ਐਰਰ ਕੋਡ (201-254 ਦੇ ਵਿਚਕਾਰ) ਵਾਪਸ ਕਰਨ ਲਈ ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਇਹ ਜਾਣਕਾਰੀ ਫਿਰ ਹੋਰ ਸਕ੍ਰਿਪਟਾਂ ਦੁਆਰਾ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਲਈ ਲਪੇਟਦੀਆਂ ਹਨ ਕਿ ਕਿਸ ਕਿਸਮ ਦੀ ਗਲਤੀ ਆਈ ਹੈ ਅਤੇ ਉਸ ਅਨੁਸਾਰ ਪ੍ਰਤੀਕ੍ਰਿਆ ਕਰੋ:

#!/usr/bin/env bash

SUCCESS=0
FILE_NOT_FOUND=240
DOWNLOAD_FAILED=241

function read_file() {
  if ${file_not_found}; then
    return ${FILE_NOT_FOUND}
  fi
}

ਨੋਟ: ਕਿਰਪਾ ਕਰਕੇ ਖਾਸ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਵੇਰੀਏਬਲ ਨਾਵਾਂ ਨਾਲ ਸਾਵਧਾਨ ਰਹੋ ਜੋ ਤੁਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਤਾਂ ਜੋ ਅਚਾਨਕ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨ ਤੋਂ ਬਚਿਆ ਜਾ ਸਕੇ।

ਲੌਗਿੰਗ ਫੰਕਸ਼ਨ

ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਸਮਝਣ ਲਈ ਸੁੰਦਰ ਅਤੇ ਢਾਂਚਾਗਤ ਲੌਗਿੰਗ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਜਿਵੇਂ ਕਿ ਹੋਰ ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਦੇ ਨਾਲ, ਮੈਂ ਹਮੇਸ਼ਾ ਆਪਣੀਆਂ ਬੈਸ਼ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਨੇਟਿਵ ਲੌਗਿੰਗ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ, ਜਿਵੇਂ ਕਿ __msg_info, __msg_error ਅਤੇ ਇਸ 'ਤੇ.

ਇਹ ਸਿਰਫ਼ ਇੱਕ ਥਾਂ 'ਤੇ ਬਦਲਾਅ ਕਰਕੇ ਇੱਕ ਪ੍ਰਮਾਣਿਤ ਲੌਗਿੰਗ ਢਾਂਚਾ ਪ੍ਰਦਾਨ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ:

#!/usr/bin/env bash

function __msg_error() {
    [[ "${ERROR}" == "1" ]] && echo -e "[ERROR]: $*"
}

function __msg_debug() {
    [[ "${DEBUG}" == "1" ]] && echo -e "[DEBUG]: $*"
}

function __msg_info() {
    [[ "${INFO}" == "1" ]] && echo -e "[INFO]: $*"
}

__msg_error "File could not be found. Cannot proceed"

__msg_debug "Starting script execution with 276MB of available RAM"

ਮੈਂ ਆਮ ਤੌਰ 'ਤੇ ਆਪਣੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਕਿਸੇ ਕਿਸਮ ਦੀ ਵਿਧੀ ਰੱਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹਾਂ __init, ਜਿੱਥੇ ਅਜਿਹੇ ਲਾਗਰ ਵੇਰੀਏਬਲ ਅਤੇ ਹੋਰ ਸਿਸਟਮ ਵੇਰੀਏਬਲ ਸ਼ੁਰੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਜਾਂ ਡਿਫੌਲਟ ਮੁੱਲਾਂ 'ਤੇ ਸੈੱਟ ਹੁੰਦੇ ਹਨ। ਇਹ ਵੇਰੀਏਬਲ ਸਕ੍ਰਿਪਟ ਇਨਵੋਕੇਸ਼ਨ ਦੌਰਾਨ ਕਮਾਂਡ ਲਾਈਨ ਵਿਕਲਪਾਂ ਤੋਂ ਵੀ ਸੈੱਟ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਉਦਾਹਰਨ ਲਈ, ਕੁਝ ਅਜਿਹਾ:

$ ./run-script.sh --debug

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

ਮੈਂ ਆਮ ਤੌਰ 'ਤੇ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਅਤੇ ਉਹਨਾਂ ਸੰਰਚਨਾਵਾਂ ਦੇ ਵੇਰਵਿਆਂ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਵਪਾਰ-ਆਫ 'ਤੇ ਕੀ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ ਅਤੇ ਕੀ ਨਹੀਂ ਕਰਨਾ ਹੈ ਦੀ ਚੋਣ ਨੂੰ ਅਧਾਰ ਬਣਾਉਂਦਾ ਹਾਂ ਜੋ ਉਪਭੋਗਤਾ ਨੂੰ ਖੋਜਣਾ ਚਾਹੀਦਾ ਹੈ।

ਮੁੜ ਵਰਤੋਂ ਅਤੇ ਸਾਫ਼ ਸਿਸਟਮ ਸਥਿਤੀ ਲਈ ਆਰਕੀਟੈਕਚਰ

ਮਾਡਯੂਲਰ/ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਕੋਡ

├── framework
│   ├── common
│   │   ├── loggers.sh
│   │   ├── mail_reports.sh
│   │   └── slack_reports.sh
│   └── daily_database_operation.sh

ਮੈਂ ਇੱਕ ਵੱਖਰੀ ਰਿਪੋਜ਼ਟਰੀ ਰੱਖਦਾ ਹਾਂ ਜਿਸਦੀ ਵਰਤੋਂ ਮੈਂ ਇੱਕ ਨਵੇਂ ਪ੍ਰੋਜੈਕਟ/ਬਾਸ਼ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਕਰ ਸਕਦਾ ਹਾਂ ਜੋ ਮੈਂ ਵਿਕਸਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ। ਕੋਈ ਵੀ ਚੀਜ਼ ਜੋ ਦੁਬਾਰਾ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ ਇੱਕ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਅਤੇ ਦੂਜੇ ਪ੍ਰੋਜੈਕਟਾਂ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜੋ ਉਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹਨ। ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਸੰਗਠਿਤ ਕਰਨਾ ਦੂਜੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਆਕਾਰ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਇਹ ਵੀ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਕੋਡ ਬੇਸ ਛੋਟਾ ਹੈ ਅਤੇ ਟੈਸਟ ਕਰਨਾ ਆਸਾਨ ਹੈ।

ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਸਾਰੇ ਲੌਗਿੰਗ ਫੰਕਸ਼ਨ ਜਿਵੇਂ ਕਿ __msg_info, __msg_error ਅਤੇ ਹੋਰ, ਜਿਵੇਂ ਕਿ ਸਲੈਕ ਰਿਪੋਰਟਾਂ, ਵਿੱਚ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਸ਼ਾਮਲ ਹਨ common/* ਅਤੇ ਹੋਰ ਦ੍ਰਿਸ਼ਾਂ ਵਿੱਚ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਜੁੜੋ ਜਿਵੇਂ ਕਿ daily_database_operation.sh.

ਇੱਕ ਸਾਫ਼ ਸਿਸਟਮ ਨੂੰ ਪਿੱਛੇ ਛੱਡੋ

ਜੇਕਰ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਦੇ ਚੱਲਦੇ ਸਮੇਂ ਕੋਈ ਵੀ ਸਰੋਤ ਲੋਡ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਇਹ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਅਜਿਹੇ ਸਾਰੇ ਡੇਟਾ ਨੂੰ ਇੱਕ ਸ਼ੇਅਰਡ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬ ਨਾਮ ਨਾਲ ਸਟੋਰ ਕਰੋ, ਉਦਾਹਰਨ ਲਈ. /tmp/AlRhYbD97/*. ਤੁਸੀਂ ਡਾਇਰੈਕਟਰੀ ਦਾ ਨਾਮ ਚੁਣਨ ਲਈ ਬੇਤਰਤੀਬ ਟੈਕਸਟ ਜਨਰੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ:

rand_dir_name="$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 16 | head -n 1)"

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

ਲਾਕ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

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

ਮੈਂ ਆਮ ਤੌਰ 'ਤੇ ਲਾਕ ਫਾਈਲਾਂ ਬਣਾਉਂਦਾ ਹਾਂ /tmp/project_name/*.lock ਅਤੇ ਸਕ੍ਰਿਪਟ ਦੇ ਸ਼ੁਰੂ ਵਿੱਚ ਉਹਨਾਂ ਦੀ ਮੌਜੂਦਗੀ ਦੀ ਜਾਂਚ ਕਰੋ। ਇਹ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸ਼ਾਨਦਾਰ ਤਰੀਕੇ ਨਾਲ ਸਮਾਪਤ ਕਰਨ ਅਤੇ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਚੱਲ ਰਹੀ ਇੱਕ ਹੋਰ ਸਕ੍ਰਿਪਟ ਦੁਆਰਾ ਸਿਸਟਮ ਸਥਿਤੀ ਵਿੱਚ ਅਚਾਨਕ ਤਬਦੀਲੀਆਂ ਤੋਂ ਬਚਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਲਾਕ ਫਾਈਲਾਂ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਜੇਕਰ ਤੁਹਾਨੂੰ ਦਿੱਤੇ ਗਏ ਹੋਸਟ 'ਤੇ ਸਮਾਨਾਂਤਰ ਤੌਰ 'ਤੇ ਚੱਲਣ ਲਈ ਇੱਕੋ ਸਕ੍ਰਿਪਟ ਦੀ ਲੋੜ ਹੈ।

ਮਾਪੋ ਅਤੇ ਸੁਧਾਰ ਕਰੋ

ਸਾਨੂੰ ਅਕਸਰ ਉਹਨਾਂ ਸਕ੍ਰਿਪਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜੋ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਕਿ ਰੋਜ਼ਾਨਾ ਡਾਟਾਬੇਸ ਓਪਰੇਸ਼ਨ। ਅਜਿਹੇ ਓਪਰੇਸ਼ਨਾਂ ਵਿੱਚ ਆਮ ਤੌਰ 'ਤੇ ਕਦਮਾਂ ਦਾ ਕ੍ਰਮ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ: ਡੇਟਾ ਲੋਡ ਕਰਨਾ, ਵਿਗਾੜਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ, ਡੇਟਾ ਆਯਾਤ ਕਰਨਾ, ਸਥਿਤੀ ਰਿਪੋਰਟਾਂ ਭੇਜਣਾ, ਆਦਿ।

ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਮੈਂ ਹਮੇਸ਼ਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਵੱਖ-ਵੱਖ ਛੋਟੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਤੋੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹਾਂ ਅਤੇ ਉਹਨਾਂ ਦੀ ਸਥਿਤੀ ਅਤੇ ਲਾਗੂ ਹੋਣ ਦੇ ਸਮੇਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰਿਪੋਰਟ ਕਰਦਾ ਹਾਂ:

time source "${filepath}" "${args}">> "${LOG_DIR}/RUN_LOG" 2>&1

ਬਾਅਦ ਵਿੱਚ ਮੈਂ ਇਸ ਨਾਲ ਚੱਲਣ ਦਾ ਸਮਾਂ ਦੇਖ ਸਕਦਾ ਹਾਂ:

tac "${LOG_DIR}/RUN_LOG.txt" | grep -m1 "real"

ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਸਮੱਸਿਆ/ਹੌਲੀ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਵਿੱਚ ਮੇਰੀ ਮਦਦ ਕਰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਅਨੁਕੂਲਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਚੰਗੀ ਕਿਸਮਤ!

ਹੋਰ ਕੀ ਪੜ੍ਹਨਾ ਹੈ:

1. ਜਾਓ ਅਤੇ GPU ਕੈਸ਼.
2. Mail.ru ਕਲਾਉਡ ਸੋਲਿਊਸ਼ਨਜ਼ ਦੇ S3 ਆਬਜੈਕਟ ਸਟੋਰੇਜ ਵਿੱਚ ਵੈਬਹੁੱਕ 'ਤੇ ਆਧਾਰਿਤ ਇੱਕ ਇਵੈਂਟ-ਸੰਚਾਲਿਤ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਇੱਕ ਉਦਾਹਰਨ।
3. ਡਿਜੀਟਲ ਪਰਿਵਰਤਨ ਬਾਰੇ ਸਾਡਾ ਟੈਲੀਗ੍ਰਾਮ ਚੈਨਲ।

ਸਰੋਤ: www.habr.com