Escolar Documentos
Profissional Documentos
Cultura Documentos
br
INTEGRAÇÃO CONTÍNUA
Valores Em uma equipe com vários desenvolvedores, todos trabalhando na elaboração de um mesmo
Princípios sistema, qual a melhor forma de unificar as diversas alterações feitas na base de
Papéis código? Processos ágeis como o xp utilizam a prática conhecida como Integração
Outros Recursos Contínua para solucionar essa questão.
Práticas Integração contínua consiste em integrar o trabalho diversas vezes ao dia, assegurando que a
base de código permaneça consistente ao final de cada integração. Nesse artigo, você
conhecerá os passos necessários para usar essa prática em seu dia-a-dia, primeiro de forma
manual, com foco nos conceitos, e depois de forma automatizada.
Repositórios e versionamento
Uma das ações mais importantes para permitir que diversos desenvolvedores trabalhem juntos
em um mesmo projeto é utilizar um sistema de controle de versões, que chamaremos aqui de
"repositório de código" ou simplesmente "repositório". Existem muitos desses sistemas
disponíveis no mercado, tais como CVS, Microsoft Visual SourceSafe, Subversion, Rational
ClearCase, entre outros. Nesse artigo iremos utilizar o CVS para apoiar nosso exemplo. Trata-se
de um software open source amplamente utilizado em todo o mundo.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 1/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Guardar versões é como ter um botão de "desfazer" à nossa disposição. Quando cometemos um
erro em um arquivo e o colocamos acidentalmente no repositório, o repositório nos permite
recuperar a versão anterior. No caso da classe CestaCompras, por exemplo, imagine que a
primeira versão funcionasse perfeitamente e, ao implementarmos a inserção e remoção de
produtos, tivéssemos inserido um bug por falta de atenção. Suponha ainda que o bug só fosse
percebido quando a classe já estivesse em produção. Nesse tipo de situação, a possibilidade de
controlar versões com um repositório de código é muito útil, por exemplo, porque nos permite
obter a versão original rapidamente (a que funcionava) e colocá-la no ar até que a versão mais
recente (com problemas) seja corrigida.
Quando diversas pessoas trabalham juntas em um projeto, o repositório se torna o destino final
de tudo o que é produzido. Quando um desenvolvedor armazena seu trabalho no repositório,
dizemos que está fazendo uma integração, isto é, está integrando o que acabou de produzir com
o que seus colegas também vêm produzindo e armazenando no repositório.
Formas de integração
www.desenvolvimentoagil.com.br/xp/praticas/integracao 2/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Em um projeto, com várias pessoas trabalhando juntas, é comum acontecerem situações nas
quais dois ou mais desenvolvedores precisem editar determinado arquivo ao mesmo tempo.
Como tratar essa possibilidade?
Existem duas abordagens utilizadas. Na mais simples, o primeiro desenvolvedor que precisa
editar um arquivo faz um checkout desse arquivo e, enquanto o estiver editando ninguém mais
consegue alterá-lo. Ou seja, o arquivo passa a ter apenas acesso de leitura para todos os outros
desenvolvedores. (Fazer um checkout significa trazer uma cópia de um ou mais arquivos
do repositório para a estação de trabalho do desenvolvedor.) Usa-se esse modelo de edição de
arquivos em sistemas como o Microsoft Visual SourceSafe, por exemplo.
A outra abordagem, que iremos tratar com mais detalhes ao longo do artigo, é adotada
freqüentemente por usuários do CVS e do Subversion, por exemplo. Nela, cada desenvolvedor
faz checkout de todo o projeto para a sua máquina, e tem liberdade para editar qualquer arquivo
sem ter que se preocupar se outras pessoas também estarão editando o mesmo arquivo que ele.
Quando termina sua tarefa, o desenvolvedor pede ao CVS para integrar seu código ao
repositório. Para cada arquivo que alterou, o CVS verifica se outra pessoa também fez
alterações. Quando isso ocorre, torna-se necessário fazer um merge, isto é, unificar as
alterações dos diferentes desenvolvedores.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 3/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
O modelo de trabalho do CVS traz uma série de vantagens, mas parece mais arriscado que
aquele em que desenvolvedores editam arquivos com exclusividade sobre os mesmos.
Entretanto, utilizando as recomendações que veremos adiante, você poderá utilizá-lo de forma
segura. Assim poderá editar arquivos livremente, sabendo que na hora de integrar não irá causar
nenhum mal aos arquivos já presentes no repositório.
Para que você possa experimentar o processo de integração, iremos ajudá-lo a simular o que
aconteceria em um pequeno projeto, cujo objetivo é criar uma calculadora
usando práticas do xp. Sendo assim, além da integração contínua, outras práticas serão
usadas, tais como programação em par e desenvolvimento orientado a testes, mas não é
necessário conhecer detalhes sobre essas técnicas para acompanhar o artigo.
Nesse exemplo, iremos considerar uma equipe composta por quatro desenvolvedores: Ana,
Bruno, Carlos, e Denise. Eles irão trabalhar em pares, e usarão dois computadores diferentes.
Em um computador, Ana e Bruno irão trabalhar juntos, enquanto no outro estarão Carlos e
Denise. O Eclipse será utilizado no projeto.
Para simular as condições exatas desse projeto, será necessário criar em seu computador dois
workspaces, um para cada par. No meu computador, por exemplo, criei os seguintes diretórios:
www.desenvolvimentoagil.com.br/xp/praticas/integracao 4/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Você também deverá ser capaz de abrir duas cópias diferentes do Eclipse, de modo que possa
alterar o conteúdo de cada workspace, à medida que avançarmos na explicação. Uma forma
simples de fazer isso é instalar o Eclipse em dois diretórios diferentes. No meu caso, por
exemplo, ele foi instalado nos seguintes diretórios:
/Users/vinicius/eclipseAB
/Users/vinicius/eclipseCD
Iniciando o exemplo
Iremos começar simulando o par Ana e Bruno. Para isso, execute o Eclipse reservado para eles.
Em seguida, configure-o para utilizar o workspace destinado a esse par, através da
opção File|Switch Workspace. Veja a Figura 1.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 5/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Nesse momento o Eclipse irá perguntar se você deseja direcionar os arquivos compilados para o
diretório bin. Aceite essa sugestão. Agora só falta adicionar o diretório srcTeste. Para isso,
clique novamente no botão Add Folder e em seguida no botão Create New Folder e
digite srcTeste. Com isso, os diretórios onde serão armazenados os fontes estão configurados.
Configurando o JUnit
www.desenvolvimentoagil.com.br/xp/praticas/integracao 6/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Usaremos a segunda opção porque, mais tarde, ao colocar o projeto no repositório, queremos
que ele seja armazenado com todos os arquivos e bibliotecas dos quais depende, incluindo a
biblioteca do JUnit.
Primeiras classes
Agora, vamos supor que depois de alguns minutos trabalhando, Ana e Bruno produziram as
classes apresentadas na Listagem 1. Ao escrevê-las no Eclipse, note que a
classe CalculadoraTeste deve ser colocada no srcTeste, enquanto a
classe Calculadora ficará no src. Veja a Figura 3.
view plainprint?
package jm;
import junit.framework.TestCase;
public class CalculadoraTeste extends TestCase {
Calculadora calculadora = new Calculadora();
public void testSoma() {
assertEquals(3, calculadora.soma(1, 2));
}
public void testSubtracao() {
assertEquals(1, calculadora.subtrai(3, 2));
}
public void testDivisao() {
assertEquals(2, calculadora.divide(2, 1));
}
public void testMultiplicao() {
assertEquals(2, calculadora.multiplica(1, 2));
}
}
www.desenvolvimentoagil.com.br/xp/praticas/integracao 8/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Para que os pares possam integrar o que produzem usando o CVS é necessário importar o
projeto no CVS, isto é, adicionar os primeiros arquivos do projeto no repositório. Começamos
configurando o Eclipse para acessar o repositório.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 9/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
www.desenvolvimentoagil.com.br/xp/praticas/integracao 10/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Agora que o Eclipse reconhece o repositório, você pode importar o projeto. Volte para a
perspectiva Java, clique com o botão direito sobre o topo da estrutura do projeto e escolha a
opção Team>Share Project. Desse ponto em diante, selecione as opções padrões oferecidas
pelas telas do wizard, conforme ilustrado na Figura 6.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 11/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Definindo o nome do módulo no CVS, isto é, como o projeto será conhecido no CVS.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 12/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
www.desenvolvimentoagil.com.br/xp/praticas/integracao 13/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
www.desenvolvimentoagil.com.br/xp/praticas/integracao 14/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Sempre que armazenamos novos arquivos ou alterações de arquivos no CVS, ele sugere a
inserção de comentários, descrevendo o que está sendo armazenado, o porquê das mudanças
www.desenvolvimentoagil.com.br/xp/praticas/integracao 15/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
etc. A necessidade desses comentários depende das características de cada projeto, como
veremos adiante.
Checkout do projeto
Agora que o projeto já está no CVS, vamos imaginar que o outro par, formado por Carlos e
Denise, comece a contribuir com o projeto. Para isso, é necessário que eles configurem
o Eclipse para acessar o repositório e façam o checkout de todos os arquivos do projeto até o
momento.
Para que você possa simular essa situação, execute a instalação do Eclipse que foi destinada
para esse segundo par. Em seguida, configure o IDE para usar o workspace de Carlos e Denise,
acionando File|Switch Workspace, e digitando a sua localização (no meu
caso, /Users/vinicius/workspaceCD).
www.desenvolvimentoagil.com.br/xp/praticas/integracao 16/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Clique com o botão direito sobre o projeto e escolha a opção Check Out As. Depois
escolha Check out as project in the workspace, como ilustrado na Figura 8. Por fim,
mude para a perspectiva Java, onde você encontrará os arquivos do projeto.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 17/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Pares programando em paralelo
Nesse momento, os dois pares estão com a versão original dos arquivos em seus respectivos
workspaces. Iremos simular agora uma situação em que cada par altera um arquivo diferente do
outro.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 18/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
view plainprint?
package jm;
import junit.framework.TestCase;
public class CalculadoraTeste extends TestCase {
public static final int UM = 1;
public static final int DOIS = 2;
private static final int TRES = 3;
Calculadora calculadora = new Calculadora();
public void testSoma() {
assertEquals(TRES, calculadora.soma(UM, DOIS));
}
public void testSubtracao() {
assertEquals(UM, calculadora.subtrai(TRES, DOIS));
}
public void testDivisao() {
assertEquals(DOIS, calculadora.divide(DOIS, UM));
}
public void testMultiplicao() {
assertEquals(DOIS, calculadora.multiplica(UM, DOIS));
}
}
www.desenvolvimentoagil.com.br/xp/praticas/integracao 19/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
view plainprint?
package jm;
public class Calculadora {
public int soma(int somando, int outroSomando) {
return somando + outroSomando;
}
public int subtrai(int minuendo, int subtraendo) {
return minuendo - subtraendo;
}
public int divide(int dividendo, int divisor) {
return dividendo/ divisor;
}
public int multiplica(int multiplicando, int multiplicador) {
return multiplicando * multiplicador;
}
}
Nesse ponto, cada par terá contribuído de alguma forma com o projeto. Supondo que eles não
tivessem mais nada a fazer com relação à calculadora, seria recomendável integrar suas
alterações ao repositório. Desenvolvedores que trabalham com xp procuram integrar o que
produzem inúmeras vezes ao dia, razão pela qual essa prática é chamada de integração
contínua. Toda vez que o código está consistente, ou seja, quando todo o projeto compila e
todos os testes automatizados executam perfeitamente, pode-se efetuar uma integração.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 20/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Integrar com freqüência significa fazer algumas pequenas alterações no código, assegurar a
consistência do mesmo – e também verificar se a base de código guardada no repositório, uma
vez acrescida dessas pequenas alterações, continuará funcionando corretamente. Fazer
pequenas mudanças e validá-las várias vezes ao dia é vantajoso. Se integramos um pouco de
cada vez, o esforço é menor, o potencial de erros diminui e eventuais erros podem ser tratados
mais facilmente. Sobretudo, ao final de cada integração, buscamos assegurar que
o repositório continue consistente, para que integrações futuras não sejam afetadas
negativamente por eventuais erros da integração corrente.
Voltando ao Eclipse, a forma mais simples de integrar alterações nele é pedindo que o código
local seja sincronizado com o repositório. Para fazer isso, no workspace de Ana e Bruno, clique
com o botão direito na raiz do projeto e escolha a opção Team>Synchronize with Repository.
Nesse ponto, pode ser que o Eclipse avise que a ação está associada à
perspectiva Synchronize, conforme a Figura 9. Se for o caso, será perguntado se você aceita
mudar para essa perspectiva. Responda que sim e prossiga.
O Eclipse mostra que a única diferença entre o projeto em sua estação e o que está no
repositório é a modificação feita na classe CalculadoraTeste que agora deverá ser gravada
www.desenvolvimentoagil.com.br/xp/praticas/integracao 21/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
no CVS. Clique com o botão direito sobre a raiz do projeto e escolha Commit. Veja as Figuras
10 e 11.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 22/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Agora que Ana e Bruno integraram sua contribuição, é a vez de Carlos e Denise fazerem o
mesmo. Mas dessa vez eles seguirão o modelo de integração contínua proposto pelo xp.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 23/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Veremos adiante a explicação de cada passo, bem como a execução do roteiro manualmente.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 24/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Figura 12: Testes passam, permitindo que o código possa ser armazenado no repositório.
Isso pode se tornar um problema se cada integração consumir muito tempo. Mas, esse
normalmente não é o caso em xp, porque os pares integram diversas vezes por dia, o que torna
cada integração relativamente rápida (por haver pouco a ser integrado de cada vez).
É necessário garantir que apenas um par integre de cada vez. Isso pode ser conseguido de
inúmeras formas. Por exemplo, a equipe pode separar um computador para ser usado
exclusivamente com o propósito de integrar. Assim, o par que quiser integrar deve copiar o
www.desenvolvimentoagil.com.br/xp/praticas/integracao 25/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
workspace para esse computador, ir até ele, executar o roteiro de integração e voltar para sua
estação de trabalho quando tiver terminado. Mais adiante, trataremos de situações nas quais a
equipe seja grande demais e não possa trabalhar junta em um mesmo ambiente, dificultando
assim o uso de um computador exclusivo para integração.
Outra alternativa consiste em adotar um sinalizador, que é um instrumento visual cuja posse
determina quem pode integrar no momento. O sinalizador pode ser qualquer coisa que indique
claramente que uma integração está ocorrendo. Por exemplo, um de nossos clientes, a Ancar,
utiliza um boneco de borracha do Bob Esponja! Quando um par deseja integrar, deve obter o
boneco, pressioná-lo duas vezes (fazendo um barulho que indica o início da integração) e, em
seguida, colocá-lo sobre o monitor. Quando a integração termina, o par pressiona o boneco uma
vez, indicando que a integração terminou, e o coloca em outro lugar (ou simplesmente o repassa
para o próximo par que quiser integrar). Veja o Bob Esponja em ação na Figura 13.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 26/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Figura 13: Bob Esponja usado como sinalizador para indicar quem conquistou a vez de integrar.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 27/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Para que o desenvolvedor possa ter acesso ao código que havia escrito antes de efetuar
o update, caso necessite, é recomendável que se faça uma cópia de segurança do diretório
contendo o projeto antes de executar o update.
4. Fazer update do projeto
Antes de gravar alterações no repositório, temos que integrá-las na máquina reservada para
integrações. Para isso, executamos um update. Trata-se de um comando do CVS que traz para
nossa estação tudo aquilo que foi alterado no repositório desde a última vez que foi executado
um checkout.
O Eclipse ajuda a realizar o update de forma simples. Para ver como o processo funciona, mude
para o Eclipse que está simulando o par Carlos e Denise. Agora, peça para sincronizar com o
repositório clicando com o botão direito na raiz do projeto e escolhendo a
opção Team>Synchronize with Repository. Você deverá ver o conteúdo da Figura 14.
Note que a classe CalculadoraTeste é mostrada com uma seta para a esquerda. Isso indica
que a versão do repositório está mais nova que a versão na estação de trabalho. Portanto, é
www.desenvolvimentoagil.com.br/xp/praticas/integracao 28/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
necessário substituir a versão local, pela versão no CVS. Clique sobre essa classe com o botão
direito e escolha a opção Update, como mostrado na Figura 15.
Agora que já temos todas as novidades do repositório, podemos prosseguir. Mas antes,
podemos aproveitar para resolver um pequeno detalhe. Veja novamente a Figura 15. Repare no
diretório bin. O Eclipse nos informa, através de uma seta apontando para a direita contendo um
sinal de adição, que ele precisa ser adicionado ao CVS. Entretanto, esse diretório armazena o
código compilado de nossa aplicação, que normalmente não precisa ser armazenado
no repositório. Podemos configurar o CVS para ignorar todo o conteúdo desse diretório, de
www.desenvolvimentoagil.com.br/xp/praticas/integracao 29/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
modo que não seja mais mostrado durante o processo de sincronização. Para tanto, clique sobre
ele com o botão direito e escolha a opção Add to .cvignore.
6. Fazer commit
Para fazer um commit (armazenar suas alterações no repositório), basta clicar com o botão
direito sobre a raiz do projeto e escolher a opção Commit.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 30/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Possíveis problemas
O cenário descrito anteriormente representa o melhor caso, quando tudo corre bem. Mas nem
sempre as coisas funcionam de primeira. Vários problemas podem ocorrer durante a integração,
e é útil conhecer os principais deles.
view plainprint?
package jm;
blic class Calculadora {
public int soma(int valor, int outroValor) {
return valor + outroValor;
www.desenvolvimentoagil.com.br/xp/praticas/integracao 31/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
}
public int subtrai(int valor, int outroValor) {
return valor - outroValor;
}
public int divide(int valor, int outroValor) {
return valor / outroValor;
}
public int multiplica(int valor, int outroValor) {
return valor * outroValor;
}
public double raizQuadrada(double numero) {
return Math.sqrt(numero);
}
Note na listagem que, além do novo método, o código ainda contém a versão antiga dos
parâmetros. Portanto, já está diferente do que se encontra no CVS. Ao fazer a integração, Ana e
Bruno enfrentarão um conflito, isto é, uma ou mais linhas de código foram editadas ao mesmo
tempo por mais de um par e portanto o CVS não sabe como conciliar as contribuições de cada
um. Quando isso acontece, o par que está integrando é responsável por conciliar as
modificações manualmente. (É importante salientar que no xp os pares têm total autonomia para
integrar sempre que alcançarem um ponto no desenvolvimento em que considerem apropriado
fazê-lo.)
Na Figura 16, você observa o que o Eclipse informou quando Ana e Bruno sincronizaram o
projeto. Os símbolos vermelhos indicam a existência de conflitos. Clicando-se duas vezes sobre
o arquivo, o Eclipse mostra a tela da Figura 17.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 32/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
www.desenvolvimentoagil.com.br/xp/praticas/integracao 33/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Figura 17: Eclipse revela as diferenças entre o código local e o armazenado no CVS.
Para solucionar essa questão, começaremos trazendo do CVS todas as mudanças que não
geram conflito. Para isso, basta clicar no ícone indicado na Figura 18. O resultado dessa ação é
www.desenvolvimentoagil.com.br/xp/praticas/integracao 34/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Figura 18: Clicando-se no ícone enfatizado em vermelho o CVS traz todas as alterações não-
conflitantes.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 35/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Apesar de o Eclipse ainda acusar um conflito, analisando a classe notamos que o código já está
correto. Ele apenas acusou o conflito devido a uma sobreposição de edições em linhas idênticas,
tanto no código que está no workspace, quanto no que está no repositório. Precisamos apenas
informar ao Eclipse que o código que temos agora já está integrado, de modo que possamos
fazer o commit do mesmo. Para isso, basta clicar com o botão direito sobre a
www.desenvolvimentoagil.com.br/xp/praticas/integracao 36/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Automatizando a integração
É importante que o processo de integração seja automatizado para assegurar que os passos não
sejam esquecidos e também garantir maior velocidade. Para automação pode-se utilizar, por
exemplo, o script do Ant mostrado na Listagem 5 que deve ser armazenado em um arquivo
chamado build.xml na raiz do projeto. Faça o commit desse arquivo e, em seguida, selecione a
opção de menu Window|Show View>Ant. Arraste o arquivo build.xml e o solte nessa view. Você
deverá ver a Figura 20. Para executar o script do Ant, clique com o botão direito do mouse sobre
a raiz da view Ant e selecione a opção de menu Run As>Ant Build como ilustrado na Figura
21.
view plainprint?
<project name="Calculadora" basedir=".." default="integrate">
<property name="project.dir" value="${ant.project.name}"/>
<property name="backup.dir" value="Backup${project.dir}"/>
<property name="src.dir" value="${project.dir}/src"/>
<property name="srcTeste.dir" value="${project.dir}/srcTeste"/>
<property name="build.dir" value="${project.dir}/bin"/>
<property name="lib.dir" value="${project.dir}/lib"/>
<property name="allTests.class" value="jm.AllTests"/>
<property name="cvsroot" value=
":pserver:vinicius@vini-mac:/usr/local/cvs/desenvolvimento"/>
<path id="project.classpath">
<pathelement location="${build.dir}"/>
<fileset dir="${lib.dir}">
<include name="*.jar"/>
www.desenvolvimentoagil.com.br/xp/praticas/integracao 37/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
</fileset>
</path>
<taskdef name="junit"
classname= "org.apache.tools.ant.taskdefs.optional.junit.JUnitTask">
<classpath refid="project.classpath"/>
</taskdef>
<target name="backup">
<delete dir="${backup.dir}"/>
<copy todir="${backup.dir}">
<fileset dir="${project.dir}" defaultexcludes="false" />
</copy>
</target>
<target name="update">
<cvs cvsroot="${cvsroot}" command="update -d ${ant.project.name}"
failonerror="true"/>
</target>
<target name="build">
<mkdir dir="${build.dir}"/>
<javac debug="on" srcdir="${src.dir}" destdir="${build.dir}"
failonerror="true">
<classpath refid="project.classpath"/>
</javac>
<javac debug="on" srcdir="${srcTeste.dir}" destdir="${build.dir}"
failonerror="true">
<classpath refid="project.classpath"/>
</javac>
</target>
lt;target name="test" depends="build">
<dirname file="build.xml" property="current.dir"/>
<junit haltonfailure="true" haltonerror="true" fork="true"
dir="${current.dir}">
<classpath>
<path refid="project.classpath"/>
</classpath>
<formatter type="plain" usefile="false"/>
<test name="${allTests.class}"/>
www.desenvolvimentoagil.com.br/xp/praticas/integracao 38/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
</junit>
</target>
<target name="commit">
<cvs cvsroot="${cvsroot}" command="commit -m '' ${ant.project.name}"
failonerror="true"/>
</target>
<target name="checkout">
<delete dir="${project.dir}"/>
<cvs cvsroot="${cvsroot}" command="checkout -P ${ant.project.name}" />
</target>
<target name="integrate" depends="test, backup, update, test, commit,
checkout">
<antcall target="test"/>
<echo message="Integracao concluida com sucesso."/>
</target>
t;/project>
www.desenvolvimentoagil.com.br/xp/praticas/integracao 39/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
www.desenvolvimentoagil.com.br/xp/praticas/integracao 40/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
www.desenvolvimentoagil.com.br/xp/praticas/integracao 41/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Além disso, para usar a forma automatizada de integração é essencial a existência de testes
automatizados, para garantir que tudo está funcionando antes de efetuar os commits. Se você
analisar atentamente o script build.xml fornecido, notará que qualquer falha de compilação ou
de merge, ou falhas nos testes automatizados, fará o script do Ant ser interrompido antes que
as alterações possam ser gravadas no repositório através do comando commit do CVS. Nas
linhas abaixo, extraídas da Listagem 5, as diretivas que fazem o script ser interrompido
automaticamente em caso de erro estão marcadas em negrito.
view plainprint?
(...)
<cvs cvsroot="${cvsroot}" command="update -d ${ant.project.name}" failonerror="true"/>
(...)
<javac debug="on" srcdir="${src.dir}" destdir="${build.dir}" failonerror="true">
(...)
<javac debug="on" srcdir="${srcTeste.dir}" destdir="${build.dir}" failonerror="true">
(...)
<junit haltonfailure="true" haltonerror="true" fork="true" dir="${current.dir}">
(...)
www.desenvolvimentoagil.com.br/xp/praticas/integracao 42/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
<cvs cvsroot="${cvsroot}" command="commit -m '' ${ant.project.name}" failonerror="true"/>
(...)
Esse modelo de integração procura garantir a maior proteção possível para o repositório,
fazendo com que apenas arquivos consistentes (capazes de compilar e passar nos testes) sejam
armazenados. Esse modelo também força os desenvolvedores a atuarem imediatamente quando
acontecem falhas durante a integração. Desse modo, evita-se que os problemas só sejam
detectados e corrigidos tardiamente.
Nesse modelo, o desenvolvedor integra seu código, executando um subconjunto dos passos
descritos anteriormente:
www.desenvolvimentoagil.com.br/xp/praticas/integracao 43/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
desenvolvedor responsável pelo problema. O desenvolvedor, por sua vez, deve fazer as
correções o mais brevemente possível e colocá-las no repositório.
Na integração assíncrona, a eficiência diminui porque leva mais tempo para o desenvolvedor
descobrir que cometeu um erro. É comum o desenvolvedor receber a notificação de um erro
depois de já ter iniciado uma nova atividade. Ao ser notificado, deve parar a nova tarefa,
relembrar o que havia feito na tarefa anteriormente e corrigir o erro.
Equipes XP, em que todos os desenvolvedores trabalham em pares, em uma mesma sala,
costumam utilizar um único login para toda a equipe acessar o CVS. Isso torna impossível
determinar através dos logs do CVS quem fez determinada alteração. Existem algumas razões
para se agir dessa forma.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 44/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
A integração contínua síncrona, tal como apresentada aqui, leva em conta essa questão. O script
do Ant apresentado usa um único login para o CVS, sem a possibilidade de alterá-lo.
O CVS permite que o desenvolvedor adicione um comentário cada vez que faz o commit de um
arquivo. Assim ele pode, por exemplo, resumir as alterações realizadas e, sobretudo, explicar
porque elas foram feitas. Tais comentários serão úteis para outros desenvolvedores ao
acessarem o histórico de determinado arquivo.
Para acessar esse histórico no Eclipse, por exemplo, clique na classe Calculadora com o botão
direito e escolha a opção Team>Show Resource History. O resultado é mostrado na Figura 23.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 45/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
view plainprint?
<target name="commit">
<cvs cvsroot="${cvsroot}" command="commit -m ''
${ant.project.name}" failonerror="true"/>
t;/target>
O parâmetro –m '' é usado para armazenar um comentário vazio. Em uma equipe na qual se
deseje possibilitar a inclusão de comentários e ainda assim usar a automação do Ant, é possível
alterar o script para que ele solicite o comentário antes de efetuar o commit. Isso é
particularmente importante quando se usa o modelo assíncrono de integração contínua. Nesse
caso, os desenvolvedores normalmente trabalham em separado e é recomendável adicionar
comentários durante os commits. Para isso, basta alterar o target do Ant que faz o commit,
como a seguir:
view plainprint?
<target name="commit">
t;input addproperty="comentario"
message="Comentários para o commit"/>
t;cvs cvsroot="${cvsroot}" command= "commit -m '${comentario}'
www.desenvolvimentoagil.com.br/xp/praticas/integracao 46/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
${ant.project.name}" failonerror="true"/>
/target>
Freqüência de integração
Quando um desenvolvedor integra várias vezes ao dia, eventuais erros de integração são
detectados mais rapidamente, pois obtém-se feedback sobre o que está sendo integrado várias
vezes ao dia. Feedback rápido e menos código produzido significam a possibilidade de
solucionar problemas de integração com maior rapidez, mesmo quando uma equipe não usa
comentários nos commits.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 47/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Conclusões
www.desenvolvimentoagil.com.br/xp/praticas/integracao 48/49
08/05/2022 17:56 Integração Contínua | XP | DesenvolvimentoAgil.com.br
Autoria
Publicado em 10/10/2006.
www.desenvolvimentoagil.com.br/xp/praticas/integracao 49/49