Esta página foi traduzida pela API Cloud Translation.

Sistemas de build baseados em tarefas

Nesta página, abordamos sistemas de build baseados em tarefas, como eles funcionam e algumas das complicações que podem ocorrer com esses sistemas. 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 de trabalho fundamental é 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 de shell, a maioria dos sistemas de build modernos exige que os engenheiros criem arquivos de build que descrevam como executar o build.

Confira este exemplo do manual do Ant (link em inglês):

<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 com uma lista de tarefas (as tags <target> no XML). O Ant usa a palavra target para representar uma tarefa e usa a palavra tarefa para se referir a comandos. Cada tarefa executa uma lista de comandos possíveis definidos pelo Ant, o que inclui a criação e a exclusão de diretórios, a execução de javac e a criação de 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 depende. Essas dependências formam um gráfico acíclico, como mostrado na Figura 1.

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

Os usuários executam suas versões fornecendo tarefas para a ferramenta de linha de comando do Ant. Por exemplo, quando um usuário digita ant dist, o Ant segue estas etapas:

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

No final, o código executado pelo Ant ao executar a tarefa dist é equivalente ao seguinte script de 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 com isso. Podemos criar novos arquivos de build em outros diretórios e vinculá-los. É possível adicionar facilmente novas tarefas que dependem das atuais de maneiras arbitrárias e complexas. Precisamos transmitir apenas 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, originalmente lançado em 2000. Outras ferramentas, como Maven e Gradle, foram aprimoradas no Ant nos anos seguintes e o substituíram adicionando recursos como gerenciamento automático de dependências externas e uma sintaxe mais limpa sem nenhum XML. No entanto, a natureza desses novos sistemas permanece a mesma: eles permitem que os engenheiros escrevam scripts de build de maneira modular e com base em princípios como tarefas, além de fornecer 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 eficientes, permitindo que você faça praticamente tudo o que imaginar com elas. No entanto, esse poder tem desvantagens, e os sistemas de build baseados em tarefas podem ser difíceis de trabalhar à medida que os scripts de build ficam mais complexos. O problema com esses sistemas é que eles acabam atribuindo muito poder aos engenheiros e pouco poder ao sistema. Como o sistema não tem ideia do que os scripts estão fazendo, o desempenho é prejudicado, já que ele precisa ser muito conservador na forma como programa e executa as etapas de build. E não há como o sistema confirmar se cada script está fazendo o que deveria. Portanto, os scripts tendem a se tornar mais complexos e acabar sendo outra coisa que precisa de depuração.

Dificuldade de carregar etapas do build em paralelo

As estações de trabalho de desenvolvimento modernas são bastante potentes, com vários núcleos capazes de executar várias etapas de compilação em paralelo. Porém, sistemas baseados em tarefas muitas vezes não conseguem carregar a execução de tarefas em paralelo, mesmo quando parece que deveriam ser capazes. Suponha que a tarefa A depende das tarefas B e C. Como as tarefas B e C não têm dependência umas das outras, é seguro executá-las ao mesmo tempo para que o sistema possa chegar mais rapidamente à tarefa A? Talvez, se não utilizarem 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. Em geral, não há como o sistema saber, então ele precisa arriscar esses conflitos, o que leva a problemas de build raros, mas muito difíceis de depurar, ou precisa restringir a execução de todo o build em uma única linha de execução em um único processo. Isso pode ser um grande desperdício de uma máquina de desenvolvimento poderosa e descarta completamente a possibilidade de distribuir o build em várias máquinas.

Dificuldade em executar builds incrementais

Um bom sistema de build permite que os engenheiros executem builds incrementais confiáveis, de modo que uma pequena mudança não exija que toda a base de código seja recriada do zero. Isso é especialmente importante se o sistema de compilação for lento e não conseguir carregar as etapas de build em paralelo pelas razões mencionadas acima. Mas, infelizmente, sistemas de build baseados em tarefas também apresentam dificuldades nesse caso. Como as tarefas podem fazer qualquer coisa, em geral, 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. Dessa forma, elas não precisam ser executadas novamente se os arquivos de origem subjacentes não tiverem sido alterados. Mas, sem outras informações, o sistema não tem certeza. Talvez a tarefa faça o download de um arquivo que possa ter sido alterado ou grave um carimbo de data/hora que pode ser diferente a cada execução. Para garantir a correção, o sistema normalmente 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 é viável, mas muitas vezes é um problema muito mais complicado do que parece. Por exemplo, em linguagens como C++, que permitem que os arquivos sejam incluídos diretamente por outros arquivos, é impossível determinar todo o conjunto de arquivos que precisa ser monitorado quanto a mudanças sem analisar as origens de entrada. Os engenheiros geralmente usam atalhos, que podem levar a problemas raros e frustrantes em que um resultado de tarefa é reutilizado mesmo quando não deveria. Quando isso acontece com frequência, os engenheiros acostumam a executar a execução de forma limpa antes de cada build para chegar a um novo estado, o que impossibilita ter um build incremental. Descobrir quando uma tarefa precisa ser executada novamente é surpreendentemente sutil, além de ser um trabalho mais executado por máquinas do que pelos humanos.

Dificuldade para manter e depurar scripts

Por fim, os scripts de build impostos por sistemas de build baseados em tarefas costumam ser difíceis de trabalhar. Embora eles geralmente sejam menos investigativos, os scripts de build são códigos exatamente como o sistema que está sendo criado e são lugares fáceis para os 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, então, a altera para produzir a 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 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 acidentalmente faz uma suposição sobre a máquina que está executando a tarefa, como o local de uma ferramenta ou o valor de variáveis de ambiente específicas. A tarefa funciona na máquina, mas falha sempre que outro desenvolvedor a tenta.
Uma tarefa contém um componente não determinístico, como fazer o download de um arquivo da Internet ou adicionar um carimbo de data/hora a um build. As pessoas recebem resultados potencialmente diferentes toda vez que executam o build, o que significa que os engenheiros nem sempre poderão reproduzir e corrigir as falhas ou falhas uns dos outros que ocorrem em um sistema de compilação automatizado.
Tarefas com várias dependências podem criar disputas. Se a tarefa A depender da tarefa B e C, e as tarefas B e C modificarem o mesmo arquivo, a tarefa A receberá um resultado diferente dependendo de qual das tarefas B e C concluir 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. Desde que os engenheiros possam escrever um código arbitrário executado durante a criação, o sistema não terá informações suficientes para executar as versões de maneira rápida e correta. Para resolver o problema, precisamos tirar o poder das mãos dos engenheiros e colocá-la de volta nas mãos do sistema e reconciliar o papel do sistema não como tarefas em execução, mas como produção de artefatos.

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