Sistemas de build baseados em tarefas

Informar um problema Ver fonte Nightly · 8.3 · 8.2 · 8.1 · 8.0 · 7.6

Esta página aborda sistemas de build baseados em tarefas, como eles funcionam e algumas das complicações que podem ocorrer com eles. Depois dos scripts de shell, os sistemas de build baseados em tarefas são a próxima evolução lógica da criação.

Noções básicas sobre sistemas de build baseados em tarefas

Em um sistema de build baseado em tarefas, a unidade fundamental de trabalho é a tarefa. Cada tarefa é um script que pode executar qualquer tipo de lógica, e as tarefas especificam outras tarefas como dependências que precisam ser executadas antes delas. A maioria dos principais sistemas de build em uso hoje, como Ant, Maven, Gradle, Grunt e Rake, é baseada em tarefas. Em vez de scripts shell, a maioria dos sistemas de build modernos exige que os engenheiros criem arquivos de build que descrevam como realizar o build.

Confira este exemplo do manual do Ant:

<project name="MyProject" default="dist" basedir=".">
   <description>
     simple example build file
   </description>
   <!-- set global properties for this build -->
   <property name="src" location="src"/>
   <property name="build" location="build"/>
   <property name="dist" location="dist"/>

   <target name="init">
     <!-- Create the time stamp -->
     <tstamp/>
     <!-- Create the build directory structure used by compile -->
     <mkdir dir="${build}"/>
   </target>
   <target name="compile" depends="init"
       description="compile the source">
     <!-- Compile the Java code from ${src} into ${build} -->
     <javac srcdir="${src}" destdir="${build}"/>
   </target>
   <target name="dist" depends="compile"
       description="generate the distribution">
     <!-- Create the distribution directory -->
     <mkdir dir="${dist}/lib"/>
     <!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
     <jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
   </target>
   <target name="clean"
       description="clean up">
     <!-- Delete the ${build} and ${dist} directory trees -->
     <delete dir="${build}"/>
     <delete dir="${dist}"/>
   </target>
</project>

O arquivo de build é escrito em XML e define alguns metadados simples sobre o build junto com uma lista de tarefas (as tags <target> no XML). O Ant usa a palavra target para representar uma tarefa e a palavra task para se referir a comandos. Cada tarefa executa uma lista de comandos possíveis definidos pelo Ant, que incluem criar e excluir diretórios, executar javac e criar um arquivo JAR. Esse conjunto de comandos pode ser estendido por plug-ins fornecidos pelo usuário para abranger qualquer tipo de lógica. Cada tarefa também pode definir as tarefas de que depende usando o atributo "depends". Essas dependências formam um gráfico acíclico, como mostrado na Figura 1.

Gráfico de acrílico mostrando dependências

Figura 1. Um gráfico acíclico mostrando dependências

Os usuários realizam builds fornecendo tarefas à ferramenta de linha de comando do Ant. Por exemplo, quando um usuário digita ant dist, o Ant realiza as seguintes etapas:

  1. Carrega um arquivo chamado build.xml no diretório atual e o analisa para criar a estrutura de gráfico mostrada na Figura 1.
  2. Procura a tarefa chamada dist, que foi fornecida na linha de comando, e descobre que ela tem uma dependência da tarefa chamada compile.
  3. Procura a tarefa chamada compile e descobre que ela tem uma dependência da tarefa chamada init.
  4. Procura a tarefa chamada init e descobre que ela não tem dependências.
  5. Executa os comandos definidos na tarefa init.
  6. Executa os comandos definidos na tarefa compile, desde que todas as dependências dessa tarefa tenham sido executadas.
  7. Executa os comandos definidos na tarefa dist, desde que todas as dependências dessa tarefa tenham sido executadas.

No final, o código executado pelo Ant ao executar a tarefa dist é equivalente ao seguinte script shell:

./createTimestamp.sh
mkdir build/
javac src/* -d build/
mkdir -p dist/lib/
jar cf dist/lib/MyProject-$(date --iso-8601).jar build/*

Quando a sintaxe é removida, o arquivo de build e o script de build não são muito diferentes. Mas já ganhamos muito fazendo isso. Podemos criar novos arquivos de build em outros diretórios e vinculá-los. Podemos adicionar facilmente novas tarefas que dependem de tarefas atuais de maneiras arbitrárias e complexas. Basta transmitir o nome de uma única tarefa para a ferramenta de linha de comando ant, e ela determina tudo o que precisa ser executado.

O Ant é um software antigo, lançado originalmente em 2000. Outras ferramentas, como Maven e Gradle, melhoraram o Ant nos anos seguintes e o substituíram ao adicionar recursos como gerenciamento automático de dependências externas e uma sintaxe mais limpa sem XML. Mas a natureza desses sistemas mais novos permanece a mesma: eles permitem que os engenheiros escrevam scripts de build de maneira modular e baseada em princípios como tarefas e forneçam ferramentas para executar essas tarefas e gerenciar dependências entre elas.

O lado sombrio dos sistemas de build baseados em tarefas

Como essas ferramentas permitem que os engenheiros definam qualquer script como uma tarefa, elas são extremamente poderosas e permitem fazer praticamente tudo o que você imaginar. Mas esse poder tem desvantagens, e os sistemas de build baseados em tarefas podem se tornar difíceis de trabalhar à medida que os scripts de build ficam mais complexos. O problema desses sistemas é que eles acabam muito poder aos engenheiros e não o suficiente ao sistema. Como o sistema não tem ideia do que os scripts estão fazendo, o desempenho é afetado, já que ele precisa ser muito conservador na forma como agenda e executa as etapas de build. Além disso, não há como o sistema confirmar se cada script está fazendo o que deveria. Por isso, eles tendem a aumentar em complexidade e acabam sendo outra coisa que precisa de depuração.

Dificuldade de paralelizar etapas de build

As estações de trabalho de desenvolvimento modernas são bastante potentes, com vários núcleos capazes de executar várias etapas de build em paralelo. Mas os sistemas baseados em tarefas geralmente não conseguem paralelizar a execução de tarefas, mesmo quando parece que deveriam conseguir. Suponha que a tarefa A dependa das tarefas B e C. Como as tarefas B e C não dependem uma da outra, é seguro executá-las ao mesmo tempo para que o sistema possa chegar à tarefa A mais rapidamente? Talvez, se eles não acessarem nenhum dos mesmos recursos. Mas talvez não. Talvez ambos usem o mesmo arquivo para rastrear os status, e executá-los ao mesmo tempo cause um conflito. Não há uma maneira geral de o sistema saber, então ele precisa arriscar esses conflitos (resultando em problemas de build raros, mas muito difíceis de depurar) ou restringir todo o build para ser executado em uma única linha de execução em um único processo. Isso pode ser um grande desperdício de uma máquina de desenvolvedor potente e elimina completamente a possibilidade de distribuir o build em várias máquinas.

Dificuldade em realizar builds incrementais

Um bom sistema de build permite que os engenheiros realizem builds incrementais confiáveis, de modo que uma pequena mudança não exija a reconstrução de todo o codebase do zero. Isso é especialmente importante se o sistema de build for lento e não puder paralelizar as etapas de build pelos motivos mencionados acima. Mas, infelizmente, os sistemas de build baseados em tarefas também têm dificuldades aqui. Como as tarefas podem fazer qualquer coisa, não há como verificar se elas já foram concluídas. Muitas tarefas simplesmente usam um conjunto de arquivos de origem e executam um compilador para criar um conjunto de binários. Portanto, elas não precisam ser executadas novamente se os arquivos de origem não tiverem sido alterados. Mas, sem mais informações, o sistema não pode afirmar isso com certeza. Talvez a tarefa faça o download de um arquivo que poderia ter mudado ou grave um carimbo de data/hora que pode ser diferente em cada execução. Para garantir a correção, o sistema geralmente precisa executar novamente todas as tarefas durante cada build. Alguns sistemas de build tentam ativar builds incrementais permitindo que os engenheiros especifiquem as condições em que uma tarefa precisa ser executada novamente. Às vezes, isso é possível, mas muitas vezes é um problema muito mais complicado do que parece. Por exemplo, em linguagens como C++, que permitem que arquivos sejam incluídos diretamente por outros arquivos, é impossível determinar o conjunto inteiro de arquivos que precisam ser monitorados para mudanças sem analisar as fontes de entrada. Os engenheiros muitas vezes acabam tomando atalhos, e esses atalhos podem levar a problemas raros e frustrantes em que um resultado de tarefa é reutilizado mesmo quando não deveria ser. Quando isso acontece com frequência, os engenheiros adquirem o hábito de executar a limpeza antes de cada build para ter um estado novo, o que anula completamente o propósito de ter um build incremental. Descobrir quando uma tarefa precisa ser executada novamente é surpreendentemente sutil e é um trabalho melhor feito por máquinas do que por humanos.

Dificuldade em manter e depurar scripts

Por fim, os scripts de build impostos por sistemas de build baseados em tarefas geralmente são difíceis de trabalhar. Embora geralmente recebam menos atenção, os scripts de build são códigos como o sistema que está sendo criado e são lugares fáceis para bugs se esconderem. Confira alguns exemplos de bugs muito comuns ao trabalhar com um sistema de build baseado em tarefas:

  • A tarefa A depende da tarefa B para produzir um arquivo específico como saída. O proprietário da tarefa B não percebe que outras tarefas dependem dela e a muda para produzir saída em um local diferente. Isso não pode ser detectado até que alguém tente executar a tarefa A e descubra que ela falha.
  • A tarefa A depende da tarefa B, que depende da tarefa C, que está produzindo um arquivo específico como saída, necessário para a tarefa A. O proprietário da tarefa B decide que ela não precisa mais depender da tarefa C, o que faz com que a tarefa A falhe, mesmo que a tarefa B não se importe com a tarefa C.
  • O desenvolvedor de uma nova tarefa faz uma suposição acidental sobre a máquina que executa a tarefa, como a localização de uma ferramenta ou o valor de variáveis de ambiente específicas. A tarefa funciona na máquina dele, mas falha sempre que outro desenvolvedor tenta.
  • Uma tarefa contém um componente não determinístico, como o download de um arquivo da Internet ou a adição de um carimbo de data/hora a um build. Agora, as pessoas recebem resultados potencialmente diferentes a cada vez que executam o build. Isso significa que os engenheiros nem sempre conseguem reproduzir e corrigir as falhas uns dos outros ou as falhas que ocorrem em um sistema de build automatizado.
  • Tarefas com várias dependências podem criar condições de disputa. Se a tarefa A depender das tarefas B e C, e as tarefas B e C modificarem o mesmo arquivo, a tarefa A terá um resultado diferente dependendo de qual das tarefas B e C for concluída primeiro.

Não há uma maneira de uso geral para resolver esses problemas de desempenho, correção ou capacidade de manutenção no framework baseado em tarefas apresentado aqui. Enquanto os engenheiros puderem escrever códigos arbitrários que são executados durante o build, o sistema não terá informações suficientes para sempre executar builds de maneira rápida e correta. Para resolver o problema, precisamos tirar um pouco do poder dos engenheiros e devolvê-lo ao sistema, além de reconceituar a função do sistema não como execução de tarefas, mas como produção de artefatos.

Essa abordagem levou à criação de sistemas de build baseados em artefatos, como Blaze e Bazel.