Tratamento de Solicitações de Pull de Emergência Usando Filas de Mesclagem

Gerenciamento de solicitações de pull de emergência tem sido um tópico de debate na comunidade de desenvolvedores desde o surgimento das práticas Ágil e DevOps.

Nessas situações, precisamos de um sistema que possa priorizar essas ‘solicitações urgentes’ sobre os PRs regulares e nos permita adiar alguns testes de CI, se necessário.

Uma boa estratégia pode ser implementar uma fila de merge separada, que nos permita antecipar a fila padrão mesmo antes dos testes de CI e acelerar nossas correções urgentes para a produção.

Neste artigo, criaremos duas filas de merge com o Mergify acionado por rótulos de PR. Configuraremos uma para PRs regulares e outra para lidar com PRs de emergência.

Então, vamos nos encarregar e começar! 

Para esta demonstração, vamos inicializar uma simples aplicação React. E para CI, usaremos CircleCI.

Criaremos duas filas de merge:

• default: Todos os PRs passarão por ela regularmente. Requer verificações CircleCI antes de processar.
• urgente: Esta fila é apenas para os PRs que possuem o rótulo urgente no PR. Isso permite que os PRs passem para a frente dos PRs na fila padrão sem executar os testes CircleCI.

Com essa configuração, uma solicitação de pull com o rótulo urgente entrará na fila antes mesmo de o CI ser executado.

Ela estará na frente da fila padrão. O Mergify atualizará a solicitação de pull com sua branch base, se necessário, aguardará a aprovação do CI e, em seguida, mesclará a solicitação de pull.

Do ponto de vista da equipe de desenvolvimento também, este é um processo bastante simples. O desenvolvedor precisa apenas adicionar uma etiqueta urgente ao criar o PR para acelerar o processo.

Configuração do Nosso Projeto

Vamos começar configurando nosso projeto. Criaremos uma nova aplicação React usando create-react-app.

mkdir emergency-pr-demo
cd emergency-pr-demo
git init
npx create-react-app .

Para referência, esta será a estrutura final do nosso projeto depois de adicionarmos nossa configuração de CI e Mergify.

emergency-pr-demo/
├── .circleci
│   └── config.yml
├── README.md
├── package-lock.json
├── package.json
├── .gitignore
├── .mergify.yml
├── .vscode
├── public
│   ├── favicon.ico
│   ├── index.html
│   ├── logo192.png
│   ├── logo512.png
│   ├── manifest.json
│   └── robots.txt
└── src
    ├── App.css
    ├── App.js
    ├── App.test.js
    ├── index.css
    ├── index.js
    ├── logo.svg
    ├── reportWebVitals.js
    └── setupTests.js

Criando Configuração de CI

Para executar nossos testes, usaremos CircleCI. É fácil de configurar e começar a usar.

Aqui, criaremos um arquivo config.yml em um novo diretório .circleci na raiz do nosso projeto.

Criaremos um trabalho simples build_and_test que primeiro nos ajudará a verificar se nosso projeto está sendo construído conforme o esperado e depois executará os testes de unidade com o comando npm run test.

version: 2.1
orbs:
  node: circleci/[email protected]

jobs:
  build_and_test:
    executor: node/default
    steps:
      - checkout
      - node/install-packages:
          pkg-manager: npm
      - run:
          command: npm run test
          name: Run tests
      - run:
          command: npm run build
          name: Build app
      - persist_to_workspace:
          root: ~/project
          paths:
            - .

workflows:
  test_my_app:
    jobs:
      - build_and_test

Criando Configuração de Mergify

Agora é hora de criar nosso arquivo de configuração Mergify.

Mergify é uma ferramenta que automatiza o processo de mesclagem de pull requests em repositórios de código com base em regras e condições predefinidas.

Precisamos definir duas filas em nosso arquivo de configuração conforme planejado: urgente e padrão.

Ambos possuem as mesmas merge_conditions, check-success=ci/circleci: build_and_test, o que significa que o código deve passar com sucesso na verificação build_and_test no CircleCI antes de ser mesclado.

A seção pull_request_rules detalha como as solicitações de pull devem ser gerenciadas. Colocaremos nosso PR na fila urgente se tiver a etiqueta urgente. Caso contrário, ele entrará na fila padrão.

.mergify.yml

queue_rules:
  - name: urgent
    merge_conditions:
      - "check-success=ci/circleci: build_and_test"

  - name: default
    merge_conditions:
      - "check-success=ci/circleci: build_and_test"

pull_request_rules:
  - name: move to urgent queue when label urgent
    conditions:
      - base=main
      - label=urgent
    actions:
      queue:
        name: urgent

  - name: merge using the default queue after running the CI checks
    conditions:
      - base=main
      - "check-success=ci/circleci: build_and_test"
      - label!=urgent
    actions:
      queue:
        name: default

Configuração do Repositório

Não, seguiríamos em frente e criaríamos um novo repositório no GitHub. 

Após isso, precisaríamos fazer um commit inicial e enviar nosso código usando os seguintes comandos:

git add .
git commit -m "Initial commit"
git remote add origin <REPO_URL>
git push -u origin master

Em seguida, precisaríamos configurar o CircleCI. Para isso, visitaremos o Painel do CircleCI, depois iremos à seção de projetos e configuraremos nosso projeto.

Também precisaríamos especificar nossa main branch. O CircleCI detectará automaticamente nosso arquivo config nesse caso.

Podemos instalar o Mergify em nossa conta do GitHub visitando dashboard.mergify.com ou github.com/apps/mergify/installations/new e fazendo login com nossa conta do GitHub.

Então, poderíamos selecionar os repositórios aos quais queremos dar acesso ao Mergify.

Uma vez configurado, poderíamos ver ambas as nossas filas no Painel Mergify.

Abertura do Primeiro PR (PR Regular)

Agora vamos começar criando nosso primeiro PR. Primeiro criaríamos um novo ramo regular-pr

git checkout -b regular-pr
git add .

Apenas para fins de demonstração, agora adicionaremos uma classe no arquivo App.css.

.Regular-change-class {
    background-color: white;
}

Após isso, faríamos um commit e enviaríamos nossas alterações ao GitHub.

git commit -m 'regular CSS change'
git push --set-upstream origin regular-pr

Em seguida, abriremos uma Pull Request sem nenhum rótulo.

Abertura do Segundo PR (PR Urgente)

Agora criaríamos um novo ramo urgent-pr, para nossas alterações.

git checkout main
git branch -b urgent-pr

Primeiro, faremos um commit, onde criaremos um novo componente Urgent.js.

import React from "react";

export default function Urgent() {
  return <div>This is an Urgent Change</div>;
}

Agora, enviaremos este ramo (urgent-pr) para nosso repositório no GitHub.

git add .
git commit -m 'Create a component for Urgent change'
git push --set-upstream origin urgent-pr

Então, vamos ao nosso repositório e abrimos um novo PR do ramo urgent-pr para o ramo main e adicionamos um novo rótulo urgent.

O Mergify automaticamente coloca o segundo PR na fila urgent e então executa os testes de CI e mescla-o com o ramo main.

Então, mescla o primeiro PR automaticamente.

Você pode verificar o repositório do GitHub aqui para referência: github.com/hugoescafit/emergency-pr-demo

Conclusão

É isso por enquanto!

Neste tutorial, exploramos o processo de configurar duas filas de merge distintas, padrão e urgente, com a ajuda do Mergify e de como configurar verificações de CI com a ajuda do CircleCI. Também vimos como priorizar PRs de emergência sobre os regulares.

Existem várias outras soluções para gerenciar solicitações de pull de emergência, como criar uma branch especial de hotfix para isso, ter revisores dedicados e até mesmo sobrepor verificações manualmente. Mas as filas de merge são uma das melhores e mais fáceis de implementar estratégias para lidar com esse problema.

Visite Mergify para começar a adicionar filas de merge ao seu aplicativo!