C#-നായി PVS-Studio ഉപയോഗിച്ച് GitLab-ലെ ലയന അഭ്യർത്ഥനകളുടെ വിശകലനം

GitLab ഇഷ്ടപ്പെടുകയും ബഗുകളെ വെറുക്കുകയും ചെയ്യുന്നുണ്ടോ? നിങ്ങളുടെ സോഴ്സ് കോഡിന്റെ ഗുണനിലവാരം മെച്ചപ്പെടുത്തണോ? അപ്പോൾ നിങ്ങൾ ശരിയായ സ്ഥലത്ത് എത്തിയിരിക്കുന്നു. ലയന അഭ്യർത്ഥനകൾ പരിശോധിക്കുന്നതിന് PVS-Studio C# അനലൈസർ എങ്ങനെ കോൺഫിഗർ ചെയ്യാമെന്ന് ഇന്ന് ഞങ്ങൾ നിങ്ങളോട് പറയും. എല്ലാവർക്കും യുണികോൺ മാനസികാവസ്ഥയും സന്തോഷകരമായ വായനയും നേരുന്നു.

പിവിഎസ്-സ്റ്റുഡിയോ C, C++, C#, Java എന്നിവയിൽ എഴുതിയ പ്രോഗ്രാമുകളുടെ സോഴ്സ് കോഡിലെ പിശകുകളും സാധ്യതയുള്ള കേടുപാടുകളും തിരിച്ചറിയുന്നതിനുള്ള ഒരു ഉപകരണമാണ്. Windows, Linux, macOS എന്നിവയിലെ 64-ബിറ്റ് സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കുന്നു. 32-ബിറ്റ്, 64-ബിറ്റ്, ഉൾച്ചേർത്ത ARM പ്ലാറ്റ്‌ഫോമുകൾക്കായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന കോഡ് വിശകലനം ചെയ്യാൻ കഴിയും.

വഴിയിൽ, ഞങ്ങൾ PVS-Studio 7.08 പുറത്തിറക്കി, അതിൽ ഞങ്ങൾ ഒരുപാട് കാര്യങ്ങൾ ചെയ്തു രസകരമായ. ഉദാഹരണത്തിന്:

• ലിനക്സിനും മാകോസിനും സി# അനലൈസർ;
• റൈഡറിനായുള്ള പ്ലഗിൻ;
• പുതിയ ഫയൽ ലിസ്റ്റ് ചെക്കിംഗ് മോഡ്.

ഫയൽ ലിസ്റ്റ് ചെക്കിംഗ് മോഡ്

മുമ്പ്, ചില ഫയലുകൾ പരിശോധിക്കുന്നതിന്, അനലൈസറിന് ഫയലുകളുടെ ഒരു ലിസ്റ്റ് സഹിതം ഒരു .xml കൈമാറേണ്ടത് ആവശ്യമാണ്. എന്നാൽ ഇത് വളരെ സൗകര്യപ്രദമല്ലാത്തതിനാൽ, .txt കൈമാറാനുള്ള കഴിവ് ഞങ്ങൾ ചേർത്തിട്ടുണ്ട്, ഇത് ജീവിതം വളരെ ലളിതമാക്കുന്നു.

നിർദ്ദിഷ്ട ഫയലുകൾ പരിശോധിക്കുന്നതിന്, നിങ്ങൾ ഫ്ലാഗ് വ്യക്തമാക്കണം --sourceFiles (-f) കൂടാതെ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് സഹിതം .txt കൈമാറുക. ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

pvs-studio-dotnet -t path/to/solution.sln -f fileList.txt -o project.json

കമ്മിറ്റ് ചെക്കിംഗ് സജ്ജീകരിക്കാനോ അഭ്യർത്ഥനകൾ പിൻവലിക്കാനോ നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, ഈ മോഡ് ഉപയോഗിച്ച് നിങ്ങൾക്കത് ചെയ്യാനും കഴിയും. വിശകലനം ചെയ്യുന്നതിനായി ഫയലുകളുടെ ഒരു ലിസ്റ്റ് നേടുന്നതിലായിരിക്കും വ്യത്യാസം, നിങ്ങൾ ഉപയോഗിക്കുന്ന സിസ്റ്റങ്ങളെ ആശ്രയിച്ചിരിക്കും.

ഒരു ലയന അഭ്യർത്ഥന പരിശോധിക്കുന്നതിനുള്ള തത്വം

ലയന സമയത്ത് അനലൈസർ കണ്ടെത്തിയ പ്രശ്നങ്ങൾ അതിൽ വീഴുന്നില്ലെന്ന് ഉറപ്പാക്കുക എന്നതാണ് ചെക്കിന്റെ പ്രധാന സാരാംശം. യജമാനന് ശാഖ. എല്ലാ സമയത്തും മുഴുവൻ പ്രോജക്റ്റും വിശകലനം ചെയ്യാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ല. മാത്രമല്ല, ബ്രാഞ്ചുകൾ ലയിപ്പിക്കുമ്പോൾ, നമുക്ക് മാറിയ ഫയലുകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ട്. അതിനാൽ, ഒരു ലയന അഭ്യർത്ഥന പരിശോധന ചേർക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു.

ഒരു സ്റ്റാറ്റിക് അനലൈസർ നടപ്പിലാക്കുന്നതിന് മുമ്പ് ഒരു ലയന അഭ്യർത്ഥന ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്:

അതായത്, ശാഖയിൽ ഉണ്ടായിരുന്ന എല്ലാ പിഴവുകളും മാറ്റങ്ങൾ, മാസ്റ്റർ ബ്രാഞ്ചിലേക്ക് മാറും. ഞങ്ങൾക്ക് ഇത് ആവശ്യമില്ലാത്തതിനാൽ, ഞങ്ങൾ വിശകലനം ചേർക്കുന്നു, ഇപ്പോൾ ഡയഗ്രം ഇതുപോലെ കാണപ്പെടുന്നു:

ഞങ്ങൾ വിശകലനം ചെയ്യുന്നു മാറ്റങ്ങൾ2 കൂടാതെ, പിശകുകളൊന്നുമില്ലെങ്കിൽ, ലയന അഭ്യർത്ഥന ഞങ്ങൾ അംഗീകരിക്കുന്നു, അല്ലാത്തപക്ഷം ഞങ്ങൾ അത് നിരസിക്കുന്നു.

വഴിയിൽ, C/C++ എന്നതിനായുള്ള കമ്മിറ്റുകൾ വിശകലനം ചെയ്യാനും പിൻവലിക്കാനും നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് അതിനെക്കുറിച്ച് വായിക്കാം ഇവിടെ.

GitLab

GitLab ഒരു ഓപ്പൺ സോഴ്‌സ് വെബ് അധിഷ്‌ഠിത DevOps ലൈഫ് സൈക്കിൾ ടൂളാണ്, അത് Git-ന് സ്വന്തം വിക്കി, ഇഷ്യൂ ട്രാക്കിംഗ് സിസ്റ്റം, CI/CD പൈപ്പ്‌ലൈൻ, മറ്റ് സവിശേഷതകൾ എന്നിവയുള്ള ഒരു കോഡ് റിപ്പോസിറ്ററി മാനേജ്‌മെന്റ് സിസ്റ്റം നൽകുന്നു.

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

അഭിപായപ്പെടുക. താഴെ വിവരിച്ചിരിക്കുന്ന പരിസ്ഥിതി സജ്ജീകരിക്കുന്ന രീതി സാധ്യമായ ഒന്നാണ്. വിശകലനത്തിനും അനലൈസർ സമാരംഭിക്കുന്നതിനും ആവശ്യമായ പരിസ്ഥിതി സജ്ജീകരിക്കുന്നതിനുള്ള ഘട്ടങ്ങൾ കാണിക്കുക എന്നതാണ് ലക്ഷ്യം. ഒരുപക്ഷേ നിങ്ങളുടെ കാര്യത്തിൽ പരിസ്ഥിതി തയ്യാറാക്കലിന്റെയും (റിപ്പോസിറ്ററികൾ ചേർക്കുന്നതിന്റെയും ഒരു അനലൈസർ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന്റെയും) വിശകലനത്തിന്റെയും ഘട്ടങ്ങൾ വേർതിരിക്കുന്നത് കൂടുതൽ അനുയോജ്യമാകും: ഉദാഹരണത്തിന്, ആവശ്യമായ പരിതസ്ഥിതിയിൽ ഡോക്കർ ഇമേജുകൾ തയ്യാറാക്കി അവ ഉപയോഗിക്കുക, അല്ലെങ്കിൽ മറ്റേതെങ്കിലും രീതി.

ഇപ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് നന്നായി മനസ്സിലാക്കാൻ, ഇനിപ്പറയുന്ന ഡയഗ്രം നോക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു:

അനലൈസറിന് പ്രവർത്തിക്കാൻ .NET കോർ SDK 3 ആവശ്യമാണ്, അതിനാൽ അനലൈസർ ഇൻസ്റ്റാൾ ചെയ്യുന്നതിന് മുമ്പ് നിങ്ങൾ അനലൈസറിന് ആവശ്യമായ ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്ന Microsoft റിപ്പോസിറ്ററികൾ ചേർക്കേണ്ടതുണ്ട്. വിവിധ ലിനക്സ് വിതരണങ്ങൾക്കായി Microsoft repositories ചേർക്കുന്നു അനുബന്ധ പ്രമാണത്തിൽ വിവരിച്ചിരിക്കുന്നു.

പാക്കേജ് മാനേജർ വഴി PVS-Studio ഇൻസ്റ്റാൾ ചെയ്യാൻ, നിങ്ങൾ PVS-Studio ശേഖരണങ്ങളും ചേർക്കേണ്ടതുണ്ട്. വ്യത്യസ്ത വിതരണങ്ങൾക്കായി ശേഖരണങ്ങൾ ചേർക്കുന്നത് കൂടുതൽ വിശദമായി വിവരിച്ചിരിക്കുന്നു ഡോക്യുമെന്റേഷന്റെ പ്രസക്തമായ വിഭാഗം.

അനലൈസറിന് പ്രവർത്തിക്കാൻ ലൈസൻസ് കീ ആവശ്യമാണ്. എന്നതിൽ നിങ്ങൾക്ക് ട്രയൽ ലൈസൻസ് ലഭിക്കും അനലൈസർ ഡൗൺലോഡ് പേജ്.

അഭിപായപ്പെടുക. വിവരിച്ച പ്രവർത്തന രീതിക്ക് (ലയന അഭ്യർത്ഥനകളുടെ വിശകലനം) ഒരു എന്റർപ്രൈസ് ലൈസൻസ് ആവശ്യമാണെന്ന് ദയവായി ശ്രദ്ധിക്കുക. അതിനാൽ, നിങ്ങൾക്ക് ഈ പ്രവർത്തന രീതി പരീക്ഷിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഒരു എന്റർപ്രൈസ് ലൈസൻസ് ആവശ്യമാണെന്ന് "സന്ദേശം" ഫീൽഡിൽ സൂചിപ്പിക്കാൻ മറക്കരുത്.

ഒരു ലയന അഭ്യർത്ഥന സംഭവിക്കുകയാണെങ്കിൽ, ഞങ്ങൾ മാറ്റിയ ഫയലുകളുടെ ലിസ്റ്റ് മാത്രം വിശകലനം ചെയ്യേണ്ടതുണ്ട്, അല്ലാത്തപക്ഷം ഞങ്ങൾ എല്ലാ ഫയലുകളും വിശകലനം ചെയ്യും. വിശകലനത്തിന് ശേഷം, നമുക്ക് ആവശ്യമുള്ള ഫോർമാറ്റിലേക്ക് ലോഗുകൾ പരിവർത്തനം ചെയ്യേണ്ടതുണ്ട്.

ഇപ്പോൾ, നിങ്ങളുടെ കൺമുന്നിൽ ജോലിയുടെ അൽഗോരിതം ഉണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഒരു സ്ക്രിപ്റ്റ് എഴുതാൻ പോകാം. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ഫയൽ മാറ്റേണ്ടതുണ്ട് .gitlab-ci.yml അല്ലെങ്കിൽ, അത് നിലവിലില്ലെങ്കിൽ, അത് സൃഷ്ടിക്കുക. ഇത് സൃഷ്ടിക്കാൻ, നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ പേരിൽ ക്ലിക്ക് ചെയ്യണം -> CI/CD സജ്ജീകരിക്കുക.

ഇപ്പോൾ ഞങ്ങൾ തിരക്കഥ എഴുതാൻ തയ്യാറാണ്. അനലൈസർ ഇൻസ്റ്റാൾ ചെയ്യുകയും ലൈസൻസ് നൽകുകയും ചെയ്യുന്ന കോഡ് ആദ്യം എഴുതാം:

before_script:
  - apt-get update && apt-get -y install wget gnupg 

  - apt-get -y install git
  - wget https://packages.microsoft.com/config/debian/10/
packages-microsoft-prod.deb -O packages-microsoft-prod.deb
  - dpkg -i packages-microsoft-prod.deb
  - apt-get update
  - apt-get install apt-transport-https
  - apt-get update
  
  - wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
  - wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
  - apt-get update
  - apt-get -y install pvs-studio-dotnet

  - pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY
  - dotnet restore "$CI_PROJECT_DIR"/Test/Test.sln

മറ്റെല്ലാ സ്ക്രിപ്റ്റുകൾക്കും മുമ്പായി ഇൻസ്റ്റാളേഷനും സജീവമാക്കലും സംഭവിക്കേണ്ടതിനാൽ, ഞങ്ങൾ ഒരു പ്രത്യേക ലേബൽ ഉപയോഗിക്കുന്നു മുമ്പ്_സ്ക്രിപ്റ്റ്. ഈ ശകലം അല്പം വിശദീകരിക്കാം.

അനലൈസർ ഇൻസ്റ്റാൾ ചെയ്യാൻ തയ്യാറെടുക്കുന്നു:

  - wget https://packages.microsoft.com/config/debian/10/
packages-microsoft-prod.deb -O packages-microsoft-prod.deb
  - dpkg -i packages-microsoft-prod.deb
  - apt-get update
  - apt-get install apt-transport-https
  - apt-get update

PVS-Studio റിപ്പോസിറ്ററികളും അനലൈസറും ചേർക്കുന്നു:

  - wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
  - wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
  - apt-get update
  - apt-get -y install pvs-studio-dotnet

ലൈസൻസ് സജീവമാക്കൽ:

  - pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY

$PVS_NAME - ഉപയോക്തൃനാമം.

$PVS_KEY - ഉല്പന്നതാക്കോൽ.

എവിടെ പ്രോജക്റ്റ് ഡിപൻഡൻസികൾ വീണ്ടെടുക്കുന്നു $CI_PROJECT_DIR - പ്രോജക്റ്റ് ഡയറക്ടറിയിലേക്കുള്ള മുഴുവൻ പാത:

  - dotnet restore "$CI_PROJECT_DIR"/Path/To/Solution.sln

ശരിയായ വിശകലനത്തിനായി, പ്രോജക്റ്റ് വിജയകരമായി നിർമ്മിക്കുകയും അതിന്റെ ഡിപൻഡൻസികൾ പുനഃസ്ഥാപിക്കുകയും വേണം (ഉദാഹരണത്തിന്, ആവശ്യമായ NuGet പാക്കേജുകൾ ഡൗൺലോഡ് ചെയ്യണം).

ക്ലിക്കുചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ലൈസൻസ് വിവരങ്ങൾ അടങ്ങിയ എൻവയോൺമെന്റ് വേരിയബിളുകൾ സജ്ജമാക്കാൻ കഴിയും ക്രമീകരണം, അതിനുശേഷവും സിഐ/സിഡി.

തുറക്കുന്ന വിൻഡോയിൽ, ഇനം കണ്ടെത്തുക വേരിയബിളുകൾ, വലതുവശത്തുള്ള ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക വിപുലീകരിക്കുക കൂടാതെ വേരിയബിളുകൾ ചേർക്കുക. ഫലം ഇതുപോലെ ആയിരിക്കണം:

ഇപ്പോൾ നിങ്ങൾക്ക് വിശകലനത്തിലേക്ക് പോകാം. ആദ്യം, പൂർണ്ണമായ വിശകലനത്തിനായി ഒരു സ്ക്രിപ്റ്റ് ചേർക്കാം. പതാകയിലേക്ക് -t പതാകയുടെ പരിഹാരത്തിലേക്കുള്ള പാത ഞങ്ങൾ കടന്നുപോകുന്നു -o വിശകലന ഫലങ്ങൾ എഴുതുന്ന ഫയലിലേക്കുള്ള പാത എഴുതുക. റിട്ടേൺ കോഡിലും ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്. ഈ സാഹചര്യത്തിൽ, റിട്ടേൺ കോഡിൽ വിശകലന സമയത്ത് മുന്നറിയിപ്പുകൾ നൽകിയ വിവരം അടങ്ങിയിരിക്കുമ്പോൾ പ്രവർത്തനം നിർത്തുന്നതിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്. ഈ ശകലം ഇതുപോലെ കാണപ്പെടുന്നു:

job:
  script:
  - exit_code=0
  - pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -o 
PVS-Studio.json || exit_code=$?
  - exit_code=$((($exit_code & 8)/8))
  - if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi

റിട്ടേൺ കോഡുകൾ ഒരു ബിറ്റ് മാസ്കിന്റെ തത്വത്തിൽ പ്രവർത്തിക്കുന്നു. ഉദാഹരണത്തിന്, വിശകലനത്തിന്റെ ഫലമായി മുന്നറിയിപ്പുകൾ നൽകിയിട്ടുണ്ടെങ്കിൽ, റിട്ടേൺ കോഡ് 8 ന് തുല്യമായിരിക്കും. ലൈസൻസ് ഒരു മാസത്തിനുള്ളിൽ കാലഹരണപ്പെടുകയാണെങ്കിൽ, റിട്ടേൺ കോഡ് 4 ന് തുല്യമായിരിക്കും. വിശകലന സമയത്ത് പിശകുകൾ കണ്ടെത്തിയാൽ, ഒരു മാസത്തിനുള്ളിൽ ലൈസൻസ് കാലഹരണപ്പെടും, കോഡ് റിട്ടേൺ, രണ്ട് മൂല്യങ്ങളും എഴുതപ്പെടും: അക്കങ്ങൾ ഒരുമിച്ച് ചേർത്ത് അന്തിമ റിട്ടേൺ കോഡ് നേടുക - 8+4=12. അതിനാൽ, അനുബന്ധ ബിറ്റുകൾ പരിശോധിക്കുന്നതിലൂടെ, വിശകലന സമയത്ത് വിവിധ സംസ്ഥാനങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കും. റിട്ടേൺ കോഡുകൾ ഡോക്യുമെന്റിന്റെ "pvs-studio-dotnet (Linux / macOS) റിട്ടേൺ കോഡുകൾ" വിഭാഗത്തിൽ കൂടുതൽ വിശദമായി വിവരിച്ചിരിക്കുന്നു "PVS-Studio ഉപയോഗിച്ച് കമാൻഡ് ലൈനിൽ നിന്ന് Visual Studio / MSBuild / .NET കോർ പ്രോജക്റ്റുകൾ പരിശോധിക്കുന്നു".

ഈ സാഹചര്യത്തിൽ, 8 ദൃശ്യമാകുന്ന എല്ലാ റിട്ടേൺ കോഡുകളിലും ഞങ്ങൾക്ക് താൽപ്പര്യമുണ്ട്.

  - exit_code=$((($exit_code & 8)/8))

റിട്ടേൺ കോഡിൽ ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ള സംഖ്യയുടെ ബിറ്റ് അടങ്ങിയിരിക്കുമ്പോൾ നമുക്ക് 1 ലഭിക്കും, അല്ലാത്തപക്ഷം നമുക്ക് 0 ലഭിക്കും.

ലയന അഭ്യർത്ഥന വിശകലനം ചേർക്കാനുള്ള സമയമാണിത്. ഇത് ചെയ്യുന്നതിന് മുമ്പ്, നമുക്ക് സ്ക്രിപ്റ്റിനായി ഒരു സ്ഥലം തയ്യാറാക്കാം. ഒരു ലയന അഭ്യർത്ഥന ഉണ്ടാകുമ്പോൾ മാത്രമേ ഞങ്ങൾക്ക് അത് എക്സിക്യൂട്ട് ചെയ്യാവൂ. ഇത് ഇതുപോലെ കാണപ്പെടുന്നു:

merge:
  script:
  only:
  - merge_requests

നമുക്ക് തിരക്കഥയിലേക്ക് തന്നെ പോകാം. വെർച്വൽ മെഷീന് ഒന്നും അറിയില്ല എന്ന വസ്തുത ഞാൻ അഭിമുഖീകരിച്ചു ഉത്ഭവം/മാസ്റ്റർ. അതിനാൽ നമുക്ക് അവളെ കുറച്ച് സഹായിക്കാം:

  - git fetch origin

ഇപ്പോൾ നമുക്ക് ശാഖകൾ തമ്മിലുള്ള വ്യത്യാസം ലഭിക്കുകയും ഫലം സംരക്ഷിക്കുകയും ചെയ്യുന്നു txt ലുള്ള ഫയൽ:

  - git diff --name-only origin/master $CI_COMMIT_SHA > pvs-fl.txt

എവിടെയാണ് $CI_COMMIT_SHA - അവസാന കമ്മിറ്റിന്റെ ഹാഷ്.

അടുത്തതായി, ഞങ്ങൾ ഫ്ലാഗ് ഉപയോഗിച്ച് ഫയലുകളുടെ ലിസ്റ്റ് വിശകലനം ചെയ്യാൻ തുടങ്ങുന്നു -f. മുമ്പ് ലഭിച്ച .txt ഫയൽ ഞങ്ങൾ അതിലേക്ക് മാറ്റുന്നു. ശരി, പൂർണ്ണ വിശകലനവുമായി സാമ്യമുള്ളതിനാൽ, ഞങ്ങൾ റിട്ടേൺ കോഡുകൾ നോക്കുന്നു:

  - exit_code=0
  - pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -f 
pvs-fl.txt -o PVS-Studio.json || exit_code=$?
  - exit_code=$((($exit_code & 8)/8))
  - if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi

ഒരു ലയന അഭ്യർത്ഥന പരിശോധിക്കുന്നതിനുള്ള പൂർണ്ണമായ സ്ക്രിപ്റ്റ് ഇതുപോലെ കാണപ്പെടും:

merge:
  script:
  - git fetch origin
  - git diff --name-only origin/master $CI_COMMIT_SHA > pvs-fl.txt
  - exit_code=0
  - pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -f 
pvs-fl.txt -o PVS-Studio.json || exit_code=$?
  - exit_code=$((($exit_code & 8)/8))
  - if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
  only:
  - merge_requests

എല്ലാ സ്ക്രിപ്റ്റുകളും പ്രോസസ്സ് ചെയ്തതിന് ശേഷം ലോഗ് കൺവേർഷൻ ചേർക്കുന്നത് മാത്രമാണ് അവശേഷിക്കുന്നത്. ഞങ്ങൾ ലേബൽ ഉപയോഗിക്കുന്നു after_script യൂട്ടിലിറ്റിയും പ്ലഗ്-കൺവെർട്ടർ:

after_script:
  - plog-converter -t html -o eLog ./PVS-Studio.json

യൂട്ടിലിറ്റി പ്ലഗ്-കൺവെർട്ടർ പാഴ്‌സർ പിശക് റിപ്പോർട്ടുകൾ HTML പോലുള്ള വിവിധ രൂപങ്ങളിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഒരു ഓപ്പൺ സോഴ്‌സ് പ്രോജക്റ്റാണ്. യൂട്ടിലിറ്റിയുടെ കൂടുതൽ വിശദമായ വിവരണം "പ്ലോഗ് കൺവെർട്ടർ യൂട്ടിലിറ്റി" എന്ന ഉപവിഭാഗത്തിൽ നൽകിയിരിക്കുന്നു. ഡോക്യുമെന്റേഷന്റെ പ്രസക്തമായ വിഭാഗം.

ഐഡിഇയിൽ നിന്ന് പ്രാദേശികമായി .json റിപ്പോർട്ടുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് സൗകര്യപ്രദമായി പ്രവർത്തിക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, ഞങ്ങൾ നിർദ്ദേശിക്കുന്നു പ്ലഗിൻ IDE റൈഡറിനായി. ഇതിന്റെ ഉപയോഗം കൂടുതൽ വിശദമായി വിവരിച്ചിരിക്കുന്നു പ്രസക്തമായ പ്രമാണം.

സൗകര്യാർത്ഥം, ഇതാ .gitlab-ci.yml പൂർണ്ണമായി:

image: debian

before_script:
  - apt-get update && apt-get -y install wget gnupg 

  - apt-get -y install git
  - wget https://packages.microsoft.com/config/debian/10/
packages-microsoft-prod.deb -O packages-microsoft-prod.deb
  - dpkg -i packages-microsoft-prod.deb
  - apt-get update
  - apt-get install apt-transport-https
  - apt-get update
  
  - wget -q -O - https://files.viva64.com/etc/pubkey.txt | apt-key add -
  - wget -O /etc/apt/sources.list.d/viva64.list
https://files.viva64.com/etc/viva64.list
  - apt-get update
  - apt-get -y install pvs-studio-dotnet

  - pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY
  - dotnet restore "$CI_PROJECT_DIR"/Test/Test.sln

merge:
  script:
  - git fetch origin
  - git diff --name-only origin/master $CI_COMMIT_SHA > pvs-fl.txt
  - exit_code=0
  - pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -f 
pvs-fl.txt -o PVS-Studio.json || exit_code=$?
  - exit_code=$((($exit_code & 8)/8))
  - if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
  only:
  - merge_requests

job:
  script:
  - exit_code=0
  - pvs-studio-dotnet -t "$CI_PROJECT_DIR"/Test/Test.sln -o 
PVS-Studio.json || exit_code=$?
  - exit_code=$((($exit_code & 8)/8))
  - if [[ $exit_code == 1 ]]; then exit 1; else exit 0; fi
  
after_script:
  - plog-converter -t html -o eLog ./PVS-Studio.json

ഫയലിലേക്ക് എല്ലാം ചേർത്തുകഴിഞ്ഞാൽ, ക്ലിക്കുചെയ്യുക മാറ്റങ്ങൾ വരുത്തുക. എല്ലാം ശരിയാണെന്ന് കാണുന്നതിന്, പോകുക സിഐ / സിഡി -> പൈപ്പ്ലൈനുകൾ -> പ്രവർത്തിക്കുന്ന. ഒരു വെർച്വൽ മെഷീൻ വിൻഡോ തുറക്കും, അതിന്റെ അവസാനം ഇനിപ്പറയുന്നവ ഉണ്ടായിരിക്കണം:

കണ്ടു ജോബ് വിജയിച്ചു - വിജയം, എല്ലാം ശരിയാണ്. നിങ്ങൾ എന്താണ് ചെയ്തതെന്ന് ഇപ്പോൾ നിങ്ങൾക്ക് പരിശോധിക്കാം.

ജോലിയുടെ ഉദാഹരണങ്ങൾ

ജോലിയുടെ ഒരു ഉദാഹരണത്തിനായി, നമുക്ക് ഒരു ലളിതമായ പ്രോജക്റ്റ് സൃഷ്ടിക്കാം (ഇൻ യജമാനന്) അതിൽ നിരവധി ഫയലുകൾ അടങ്ങിയിരിക്കും. അതിനുശേഷം, മറ്റൊരു ബ്രാഞ്ചിൽ ഞങ്ങൾ ഒരു ഫയൽ മാത്രം മാറ്റി ഒരു ലയന അഭ്യർത്ഥന നടത്താൻ ശ്രമിക്കും.

നമുക്ക് രണ്ട് കേസുകൾ പരിഗണിക്കാം: പരിഷ്കരിച്ച ഫയലിൽ ഒരു പിശക് ഉള്ളപ്പോൾ അത് ഇല്ലാത്തപ്പോൾ. ആദ്യം, ഒരു പിശകുള്ള ഒരു ഉദാഹരണം.

മാസ്റ്റർ ബ്രാഞ്ചിൽ ഒരു ഫയൽ ഉണ്ടെന്ന് പറയാം Program.cs, അതിൽ പിശകുകൾ അടങ്ങിയിട്ടില്ല, എന്നാൽ മറ്റൊരു ബ്രാഞ്ചിൽ ഡെവലപ്പർ തെറ്റായ കോഡ് ചേർക്കുകയും ഒരു ലയന അഭ്യർത്ഥന നടത്തുകയും ചെയ്യുന്നു. അവൻ എന്ത് തെറ്റ് ചെയ്തു എന്നത് അത്ര പ്രധാനമല്ല, പ്രധാന കാര്യം അത് നിലവിലുണ്ട് എന്നതാണ്. ഉദാഹരണത്തിന്, ഓപ്പറേറ്റർ മറന്നു എറിയുക (അതെ, വളരെ തെറ്റാണ്):

void MyAwesomeMethod(String name)
{
  if (name == null)
    new ArgumentNullException(....);
  // do something
  ....
}

ഒരു പിശക് ഉപയോഗിച്ച് ഒരു ഉദാഹരണം വിശകലനം ചെയ്തതിന്റെ ഫലം നോക്കാം. ഒരു ഫയൽ മാത്രമേ പാഴ്‌സ് ചെയ്‌തിട്ടുള്ളൂ എന്ന് ഉറപ്പാക്കാൻ, ഞാൻ ഫ്ലാഗ് ചേർത്തു -r pvs-studio-dotnet ലോഞ്ച് ലൈനിലേക്ക്:

അനലൈസർ ഒരു പിശക് കണ്ടെത്തിയതായും ശാഖകൾ ലയിപ്പിക്കാൻ അനുവദിക്കുന്നില്ലെന്നും ഞങ്ങൾ കാണുന്നു.

ഒരു പിശക് കൂടാതെ ഉദാഹരണം പരിശോധിക്കാം. കോഡ് ശരിയാക്കുന്നു:

void MyAwesomeMethod(String name)
{
  if (name == null)
    throw new ArgumentNullException(....);
  // do something
  ....
}

അഭ്യർത്ഥന വിശകലന ഫലങ്ങൾ ലയിപ്പിക്കുക:

നമുക്ക് കാണാനാകുന്നതുപോലെ, പിശകുകളൊന്നും കണ്ടെത്തിയില്ല, ടാസ്ക് എക്സിക്യൂഷൻ വിജയിച്ചു, അതാണ് ഞങ്ങൾ പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്നത്.

തീരുമാനം

ശാഖകൾ ലയിപ്പിക്കുന്നതിന് മുമ്പ് മോശം കോഡ് നീക്കം ചെയ്യുന്നത് വളരെ സൗകര്യപ്രദവും മനോഹരവുമാണ്. അതിനാൽ നിങ്ങൾ CI/CD ഉപയോഗിക്കുകയാണെങ്കിൽ, പരിശോധിക്കാൻ ഒരു സ്റ്റാറ്റിക് അനലൈസർ എംബെഡ് ചെയ്യാൻ ശ്രമിക്കുക. മാത്രമല്ല, ഇത് വളരെ ലളിതമായി ചെയ്യുന്നു.

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി.

ഇംഗ്ലീഷ് സംസാരിക്കുന്ന പ്രേക്ഷകരുമായി ഈ ലേഖനം പങ്കിടാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, വിവർത്തന ലിങ്ക് ഉപയോഗിക്കുക: Nikolay Mironov. C#-നായി PVS-Studio ഉപയോഗിച്ച് GitLab-ലെ ലയന അഭ്യർത്ഥനകളുടെ വിശകലനം.

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