Análise de solicitudes de combinación en GitLab usando PVS-Studio para C#

Gústache GitLab e odias os erros? Queres mellorar a calidade do teu código fonte? Entón chegaches ao lugar indicado. Hoxe dirémosche como configurar o analizador PVS-Studio C# para comprobar as solicitudes de combinación. Teña un humor de unicornio e feliz lectura para todos.

PVS-Estudio é unha ferramenta para identificar erros e posibles vulnerabilidades no código fonte dos programas escritos en C, C++, C# e Java. Funciona en sistemas de 64 bits en Windows, Linux e macOS. Pode analizar código deseñado para plataformas ARM integradas de 32 bits, 64 bits e.

Por certo, lanzamos PVS-Studio 7.08, no que fixemos moitas cousas interesante. Por exemplo:

• analizador de C# para Linux e macOS;
• complemento para Rider;
• novo modo de verificación da lista de ficheiros.

Modo de verificación da lista de ficheiros

Anteriormente, para comprobar determinados ficheiros, era necesario pasar un .xml cunha lista de ficheiros ao analizador. Pero como isto non é moi cómodo, engadimos a posibilidade de transferir .txt, o que fai a vida moi sinxela.

Para comprobar ficheiros específicos, debes especificar a marca --Arquivos fonte (-f) e transferir .txt cunha lista de ficheiros. Parece así:

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

Se estás interesado en configurar a comprobación de commit ou as solicitudes de extracción, tamén podes facelo usando este modo. A diferenza estará en obter unha lista de ficheiros para analizar e dependerá dos sistemas que esteas a usar.

O principio de verificación dunha solicitude de combinación

A esencia principal da comprobación é garantir que os problemas detectados polo analizador durante a fusión non caian no mestre rama. Tampouco queremos analizar todo o proxecto cada vez. Ademais, ao combinar ramas, temos unha lista de ficheiros modificados. Polo tanto, suxiro engadir unha comprobación de solicitude de combinación.

Este é o aspecto dunha solicitude de combinación antes de implementar un analizador estático:

É dicir, todos os erros que había no filial mudanzas, pasará á rama mestra. Como non queremos isto, engadimos análise, e agora o diagrama ten o seguinte aspecto:

Analizamos cambios 2 e, se non hai erros, aceptamos a solicitude de fusión, se non, rexeitámola.

Por certo, se estás interesado en analizar as confirmacións e as solicitudes de extracción para C/C++, podes ler sobre iso aquí.

GitLab

GitLab é unha ferramenta de ciclo de vida DevOps baseada na web de código aberto que ofrece un sistema de xestión de repositorio de código para Git coa súa propia wiki, sistema de seguimento de problemas, canalización de CI/CD e outras funcións.

Antes de comezar a analizar as solicitudes de fusión, debes rexistrarte e cargar o teu proxecto. Se non sabes como facelo, suxíroo un artigo meu colega.

Nota. O método de configuración do entorno que se describe a continuación é un dos posibles. O obxectivo é mostrar os pasos para configurar o entorno necesario para a análise e o lanzamento do analizador. Quizais no teu caso sería máis óptimo separar as fases de preparación do contorno (engadir repositorios, instalar un analizador) e análise: por exemplo, preparar imaxes de Docker co entorno necesario e utilizalas, ou algún outro método.

Para entender mellor o que vai ocorrer agora, suxiro mirar o seguinte diagrama:

O analizador require .NET Core SDK 3 para funcionar, polo que antes de instalar o analizador cómpre engadir os repositorios de Microsoft desde os que se instalarán as dependencias necesarias para o analizador. Engadindo repositorios de Microsoft para varias distribucións de Linux descrito no documento correspondente.

Para instalar PVS-Studio a través do xestor de paquetes, tamén terá que engadir os repositorios de PVS-Studio. Engadir repositorios para diferentes distribucións descríbese con máis detalle en sección pertinente da documentación.

O analizador require unha clave de licenza para funcionar. Podes obter unha licenza de proba en Páxina de descarga do analizador.

Nota. Teña en conta que o modo de operación descrito (análise das solicitudes de combinación) require unha licenza Enterprise. Polo tanto, se queres probar este modo de funcionamento, non esquezas indicar no campo "Mensaxe" que precisas unha licenza Enterprise.

Se se produce unha solicitude de combinación, só necesitamos analizar a lista de ficheiros modificados, se non, analizaremos todos os ficheiros. Despois da análise, necesitamos converter os rexistros no formato que necesitamos.

Agora, tendo o algoritmo de traballo diante dos teus ollos, podes pasar a escribir un guión. Para iso, cómpre cambiar o ficheiro .gitlab-ci.yml ou, se non existe, crealo. Para crealo, debes facer clic no nome do teu proxecto -> Configurar CI/CD.

Agora estamos preparados para escribir o guión. Escribamos primeiro o código que instalará o analizador e introduzamos a licenza:

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

Dado que a instalación e a activación deben producirse antes que todos os outros scripts, usamos unha etiqueta especial antes_script. Déixame explicar un pouco este fragmento.

Preparación para instalar o analizador:

  - 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

Engadindo repositorios e analizadores de 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

Activación da licenza:

  - pvs-studio-analyzer credentials $PVS_NAME $PVS_KEY

$PVS_NAME - Nome de usuario.

$PVS_KEY - clave de produto.

Recuperando as dependencias do proxecto onde $CI_PROJECT_DIR - ruta completa ao directorio do proxecto:

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

Para unha análise correcta, o proxecto debe construírse correctamente e as súas dependencias deben ser restauradas (por exemplo, deben descargarse os paquetes NuGet necesarios).

Podes establecer variables de ambiente que conteñan información de licenza facendo clic escenario, e despois - en CI/CD.

Na xanela que se abre, busca o elemento Variables, fai clic no botón da dereita Expandir e engadir variables. O resultado debería verse así:

Agora podes pasar á análise. Primeiro, imos engadir un script para unha análise completa. Á bandeira -t pasamos o camiño da solución á bandeira -o escriba o camiño ao ficheiro no que se escribirán os resultados da análise. Tamén nos interesa o código de devolución. Neste caso, estamos interesados ​​en que a operación se deteña cando o código de retorno contén información de que se emitiron avisos durante a análise. Este é o aspecto deste fragmento:

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

Os códigos de retorno funcionan co principio dunha máscara de bits. Por exemplo, se se emitiron avisos como resultado da análise, entón o código de devolución será igual a 8. Se a licenza caduca nun mes, o código de devolución será igual a 4. Se se detectaron erros durante a análise, e a licenza caduca nun mes, o código devolve, escribiranse ambos os valores: sume os números e obtén o código de retorno final - 8+4=12. Así, comprobando os bits correspondentes, pódese obter información sobre varios estados durante a análise. Os códigos de retorno descríbense con máis detalle na sección "Códigos de retorno pvs-studio-dotnet (Linux / macOS)" do documento "Comprobando proxectos de Visual Studio / MSBuild / .NET Core desde a liña de comandos usando PVS-Studio".

Neste caso, estamos interesados ​​en todos os códigos de devolución onde aparece 8.

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

Recibiremos 1 cando o código de devolución conteña o bit do número que nos interesa, se non, recibiremos 0.

É hora de engadir a análise da solicitude de combinación. Antes de facelo, imos preparar un lugar para o guión. Necesitamos que se execute só cando se produza unha solicitude de combinación. Parece así:

merge:
  script:
  only:
  - merge_requests

Pasemos ao propio guión. Atopeime co feito de que a máquina virtual non sabe nada orixe/mestre. Entón, axudámolo un pouco:

  - git fetch origin

Agora obtemos a diferenza entre as ramas e gardamos o resultado txt ficheiro:

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

Onde $CI_COMMIT_SHA – hash do último compromiso.

A continuación, comezamos a analizar a lista de ficheiros usando a bandeira -f. Transferímoslle o ficheiro .txt recibido previamente. Ben, por analoxía coa análise completa, miramos os códigos de retorno:

  - 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

O script completo para comprobar unha solicitude de combinación terá o seguinte aspecto:

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

Todo o que queda é engadir a conversión de rexistro despois de que todos os scripts sexan procesados. Usamos a etiqueta despois_script e utilidade Plog-conversor:

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

Utilidade Plog-conversor é un proxecto de código aberto que se usa para converter informes de erros do analizador en varias formas, como HTML. Unha descrición máis detallada da utilidade dáse na subsección "Plog Converter Utility" sección pertinente da documentación.

Por certo, se queres traballar con informes .json localmente desde o IDE, suxiro que o noso complemento para IDE Rider. O seu uso descríbese con máis detalle en documento pertinente.

Por comodidade, aquí está .gitlab-ci.yml ao completo:

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

Despois de engadir todo ao ficheiro, fai clic en Confirmar cambios. Para ver que todo está correcto, vai a CI / CD -> Liñas de tubería -> Carreira. Abrirase unha xanela de máquina virtual, ao final da cal debería haber o seguinte:

serra Job triunfou - éxito, todo está ben. Agora podes probar o que fixeches.

Exemplos de traballo

Para un exemplo de traballo, imos crear un proxecto sinxelo (en mestre) que conterá varios ficheiros. Despois diso, noutra rama cambiaremos só un ficheiro e tentaremos facer unha solicitude de combinación.

Consideremos dous casos: cando o ficheiro modificado contén un erro e cando non. Primeiro, un exemplo cun erro.

Digamos que hai un ficheiro na rama mestra Programa.cs, que non contén erros, pero noutra rama o desenvolvedor engadiu código erróneo e quere facer unha solicitude de combinación. Que tipo de erro cometeu non é tan importante, o principal é que existe. Por exemplo, o operador esqueceu xogar (Si, tan mal):

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

Vexamos o resultado de analizar un exemplo cun erro. Ademais, para asegurarme de que só se analizou un ficheiro, engadín a marca -r á liña de lanzamento de pvs-studio-dotnet:

Vemos que o analizador atopou un erro e non permitiu fusionar ramas.

Imos comprobar o exemplo sen erro. Corrixindo o código:

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

Resultados da análise da solicitude de combinación:

Como podemos ver, non se atoparon erros e a execución da tarefa foi exitosa, que é o que queriamos comprobar.

Conclusión

Eliminar o código malo antes de fusionar ramas é moi cómodo e agradable. Polo tanto, se está a usar CI/CD, intente incorporar un analizador estático para comprobar. Ademais, isto faise de forma moi sinxela.

Grazas pola súa atención.

Se queres compartir este artigo cun público de fala inglesa, utiliza a ligazón de tradución: Nikolay Mironov. Análise de solicitudes de combinación en GitLab usando PVS-Studio para C#.

Fonte: www.habr.com