Série CI:Resolvendo problemas de Unicode maven no Jenkins

Olá Pessoal,

O post de hoje é bem rápido, mas muito recorrente quando estamos montando um ambiente continuo. No meu caso tive problemas de Unicode quando o jenkins executou mvn test. Vamos ver como resolver.

Lets go… 

O problema

A questão é que os testes vão falhar. Se você tem algum teste que faz validação que envolve acento, por exemplo  você espera “João”  e devido ao problema de Unicode veio sem o acento e outro caractere. Como resolver?

 

readerwebbuildfailuretestes

A solução

É bem simples, precisamos apenas no nosso pom.xml informar qual Unicode vamos usar, nesse caso UTF-8. Daí precisamos configurar as propriedades assim:

<properties>

<maven.test.failure.ignore>false</maven.test.failure.ignore> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

   <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>

</properties>

 E agora podemos executar um mvn clean. E em seguida mandar o Jenkins compilar e o resultado será:

readerwebbuildsucessunicode

Pronto, problema resolvido. Simples não?

Abraços, see ya!!!

Série CI:Build Automatizado com Jenkins e GitHub

Olá Pessoal,

No último post vimos como conectar o Jenkins com o GitHub. Hoje veremos como automatizar o nosso build, ou seja, se alguma mudança ocorreu no repositório, um novo build é iniciado.

Lets go…

Starting…

Considerando que você tem o cenário do post anterior conforme a imagem a seguir:

 

cijenkinscenario

Clique no projeto MyBookStore e vá em configure.

Em build trigger deixe assim:

buildtriggerjenkins

O que fizemos?

Simples, estamos dizendo que a cada mudança no github vamos precisar rodar um novo build, porém, como estamos rodando localmente o jenkins, não tem como o Github informar ao Jenkins que algo mudou, então faremos o Jenkins verificar a cada 1min se algo mudou no Github. Essa é a forma que temos de fazer isso quando não temos o jenkins em um IP Público.

Feito isso, vá em manage jenkins >> configure system

E em GitHub Web Hook deixamos assim:

githubwebhook

Após inserir seus dados do github e a url do repositório, clique em test credential.

Agora vamos testar e ver se o build vai iniciar automaticamente. Mas antes veremos como estamos:

 

historybookstorebuild

No meu caso tenho o histórico de build acima. É esperado que se algo for alterado no repositório uma nova build seja iniciada, claro que não será de imediato, mas sim cada 1 min.

Vá no seu GitHub e acesse o projeto:

mybookstoregithubjenkins

Aperte a tecla T e você poderá realizar uma pesquisa no GitHub. Procure por store e escolha StoreMatrix.java 

storematrixgithub

É a classe que vamos realizar a alteração e aguardar o Jenkins build. Ao selecionar a classe, clique no botão Edit e adicione o atributo address.

addressaddedstorematrix

Clique no botão commit changes .

Vamos aguardar por 1 min e ver se o jenkins inicia o build. O resultado é como a seguir:

buildqueuejenkinsbookstore

Pronto! Temos agora nosso build automatizado conectado ao jenkins. Simples, não?

Vou ficando por aqui e espero que tenham gostado do post.

Abraços, see ya!!

Série CI: Conectando Jenkins com GitHub

Olá Pessoal,

No post de hoje vamos ver como buildar nossos projetos no jenkins e mantê-lo conectado a um repositório. No nosso caso escolhemos o github por usar o Git. Claro que poderia ser um outro repositório, até mesmo local, mas o Github é o mais popular repositório Git.

Lets go…

Starting

Antes de mais nada vou considerar que você já conhece um pouco de Git e GitHub, pois não entrarei em detalhes de como cada um funciona, para isso  você precisa ter:

– Um repositório criado no GiHub;

– Git na sua máquina local

Os nossos steps

Basicamente criaremos um projeto e em seguida faremos um push para o GitHub. Tendo o projeto no nosso repositório remoto, vamos configurar o Jenkins para conversar com o GitHub  e poder realizar  “pull” quando o build for inicializado.

Step 1

  1. Abra o seu eclipse e crie um Java Project chamado MyBookStore.

cimybookstore

  1. Feito isso, envie esse projeto para o GitHub.

 

cimybookstoregithub

Uma vez que o projeto já está no repositório, vamos ao Jenkins fazer as devidas configurações (estou considerando que você já tem o jenkins rodando na sua máquina, conforme o primeiro post da série).

Acesse o Jenkins e vá em Manage Jenkins  e escolha Manage Plugins. Alguns plugins o Jenkins já traz e outros precisamos instalar. Na aba de Installed verifique se o plugin do GitHub Plugin está instalado:

githubplugin

Se não estiver, vá na aba de available e procure pelo plugin. Instale também um plugin chamado Git Plugin. Esse é para que o Jenkins possa rodar os comandos do Git.

Note: use a opção install without restart.

Configurando o Jenkins

Agora vamos configurar o jenkins, portanto em manage jenkins escolha configure system e observe que você deve ter uma Git na lista:

jenkinsconfigsystem

Esses caras servem para configuramos e dizermos ao jenkins como ele deve se comportar se o projeto que fomos buildar usar um deles. Não é requerido preencher todos, exceto se você tem N projetos e cada projeto tem que usar uma estrutura diferente, por um usar ant e outro maven, daí você precisa configurar tanto maven quando o ant nessa parte do Jenkins.

Primeiro vamos configurar o JDK que é requerido para qualquer projeto Java onde precisamos compilar as classes .java.

Coloque o local onde instalou o Java, conforme a imagem a seguir:

jenkinsjdk

Assim dizemos ao jenkins onde está o nosso Java e qual ele deve usar para compilar as nossas classes durante o build

Agora vamos para o Git

jenkinsgitconfigure

Nada de diferente, apenas informamos onde está o Git na nossa máquina.

Deixamos as próximas opções da maneira default. Agora vamos configurar o Git Plugin que contém as informações do usuário que fez o commit.

jenkinsgituserconfigure

Observe que estamos configurando o Git e não GitHub.

Essa é uma das partes mais importantes e demorei horas para descobrir, aqui vamos colocar key-gen registrado lá no github:

publishsshkenkinsgithub

Em Github web Hook deixei a opção Manually manage hook URLs selecionada. Salve as modificações.

Pronto, jenkins configurado.

Criando Jobs no Jenkins

Agora vamos criar um job no Jenkins para o nosso projeto.

jenkinsnewjob

E darei o mesmo nome do projeto:

jobjenkinsbookstore

Ao criar o job, vamos para as configurações que nos interessa:

gitsourcecodejenkins

Precisamos informar onde está o nosso repositório, pode estar localmente ou remoto. No nosso caso está remoto no GitHub, que é o:

https://github.com/camilolopes/myworkspace.git

sourcecodegitjenkins

E deixamos assim. É esse cara que o jenkins fará o clone, por isso que ele precisa da URL.

Feito isso podemos salvar e buildar nosso projeto:

jenkinsbuildbookstore

Clique na barra de loading à esquerda para ver o log:

jenkinsgithubstoreclone

Observe que o jenkins conectou ao github e está trazendo o que temos no repositório, nesse caso MyBookStore.

Resultado

A seguir o resultado:

jenkinsresult

A nuvem, eu costumo dizer que o projeto passou por algumas turbulências, o solzão está tudo tranquilo, todo time pode ir para praia tranquilo que ninguém vai ligar para incomodar.

Pronto, temos nosso projeto  sendo construído pelo Jenkins.

Falha no Jenkins

Vamos simular uma falha e ver o que acontece, e para isso precisamos alterar a classe para que o código não compile:

mybookstorenocompile

Daí podemos mandar essa alteração para o GitHub. Uma vez com o código alterado no github:

githubcodechangestore

Precisamos configurar o maven, então vá em manage jenkins e na parte do maven deixe assim:

mavenconfigurejenkins

Esquecemos de configurar no Job como será o build, então vá no job que criamos e depois em configure e deixe assim o build:

buildmavenjenkins

Clique em advanced do build

buildmavencompile

No eclipse, clique com o botão direito no projeto e adicione Maven >> e habilite o maven.

Agora commit e manda as alterações para o github.

Agora vamos mandar o Jenkins buildar nosso projeto e ver o que acontece:

jenkinsfailurebuildstore

Vamos tentar arrumar isso corrigindo o código, altere o código e mande para o GitHub.

githubfixedstore

E agora vamos buildar pra ver o que acontece:

buildifxedbookstore

Pronto, assim concluímos essa parte. Um pouco cansativo na primeira vez devido a configurações, mas depois fica mais fácil. No próximo post veremos como automatizar, ou seja, com uma mudança no nosso repositório remoto, automaticamente o build começa. Fez push para o github, o build  começa a validar.

Abraços, see  ya!!

Série CI: Executando unit tests Jenkins via Maven

Olá Pessoal,

No post de hoje veremos como executar os unit tests, após executarmos mvn compile. Vou considerar que você já tem o Jenkins instalado e um projeto configurado.

Lets go…

Starting…

Primeiro passo é ir em configure do projeto no Jenkins, pare o mouse em cima do projeto/job criado e escolha  configure.

Em Build, configuramos para rodar mvn compile.

buildmavencompile

Mas e se você quiser também rodar os unit tests? Simples, basta adicionar mvn test

Clique no botão add build step escolha Invoke top-level Maven targets e deixe conforme a imagem a seguir:

mvntestbuild

Pronto, após  o compile vamos executar os testes.

Um problema

Se você mandar construir uma build e todos os testes tiverem passando, você não tem problemas aparentemente, mas faça um teste falhar e mande construir. Certamente verá isso:

 

readerwebbuildfailuretestes

Ué, um teste falhou, mas o build foi dado como sucess. Esse é o problema e vamos resolver.

Solução

A solução é muito simples, apenas vamos dizer que as falhas na execução de qualquer unit tests não podem ser ignoradas, para isso precisamos atualizar o comando mvn test, deixando assim:

test -Dmaven.test.failure.ignore=false

mvntestignoretest

Salve as alterações e rode uma nova build clicando em build now. E aguarde….

Resultado

É isso que esperamos:

readerwebtestpassedjenkinsbuild

Pronto. Agora sempre que um teste falhar a construção da build também vai falhar.

Vou ficando por aqui e espero que tenham gostado do post.

See ya!! 

Série CI:Maven + Jenkins + Git

Olá Pessoal, no post de hoje vamos ver como integrar maven + jenkis + git. É algo aparentemente simples, mas que na primeira vez me deu umas dores de cabeças chatas até deixar tudo redondo e resolvi compartilhar com vocês.

Lets go…

 O problema

Sempre temos que ter um problema para que o nosso dia fique mais emocionante. Então eu tinha alguns:

  1. Queria montar um ambiente automatizado com o jenkins ;
  2. Queria conectar o jenkins com o git;
  3. Queria fazer meu jenkins buildar pelo maven ;
  4. Não ter um Java Project apenas;
  5. Não queria ter mais de um repositório no Git, ou seja, nada de um repositório por projeto.

Bem, do problema 1 ao 3 eu já tinha resolvido facilmente, mas os pontos 4 e 5 estavam me incomodando, porque eu queria ter mais de um projeto para ter as coisas organizadas e melhor para trabalhar, sem falar que a manutenção fica mais fácil. Também há outro fator, eu sou preguiçoso para coisas repetitivas, odeio ter que fazer mais de uma vez o mesmo trabalho. Gosto de fazer o trabalho chato uma vez e se precisar mudar algo amanhã, que o esforço seja o mínimo possível.

A solução

Após horas de tentativas de montar a estrutura ideal que queria, cheguei a uma que atendeu ao que precisava, ou seja, atingi os 5 pontos citados anteriormente. Como? Simples assim:

  • Repositório: crie um repositório git, que aqui chamei de trunk
  • Parent: crie um maven Project chamado parent. Nele vou colocar as dependências base e comum nos projetos. Adicionei os outros projetos como module do projeto parent.
  • Filho 1: criei um Project maven chamado readers-core que será um projeto focado apenas no back-end da aplicação.
  • Filho 2 : criei um Project maven com suporte JSF que será focado na parte de front-end, porém esse projeto tem uma dependência do projeto filho 1 (readers-core).

Cada projeto tem seu próprio pom.xml, isso evita de ter um pom.xml com tudo e sabemos que quando a configuração de XML começa a crescer é um inferno pra ficar dando manutenção e se achar nele. Daí cada projeto terá no seu pom.xml aquilo que ele precisa de fato, por exemplo, o projeto ereaders-core não precisa ter uma dependência  JSF definida no pom.xml, porque esse é um projeto que não foca em front-end.

A estrutura ficou assim

–meu repositório git

                –parent-project maven

                               –projeto Java A

                               –projeto Java  B

Na prática

Bem, não vou explicar como instalar o jenkins na máquina, nem o Git.No blog há posts relacionados nas devidas sessões. 

  1. Crie um repositório Git (O meu chamei de trunk.)
  2. Criando o projeto parent

Esse cara aqui é o mais importante, pois é pra ele que vamos apontar o Jenkins.  Portanto, crie um maven Project:

 

mavenproject

** Você vai precisar ter o Jboss Tools instalado Plugin instalado na sua IDE Eclipse.

No próximo passo

 

mavenstep2project

Observe que criei uma pasta chamada parent-project dentro de trunk. Faça isso.

 

No ultimo passo, deixe conforme a imagem a seguir:

 

mavenconfigureproject

Agora crie dois maven project, porém no segundo passo deixe assim:

 

mavenprojectchildren

** o package  você decide. Eu criei um .jar para o projeto core e .war para o projeto web.

No meu caso:

mavenprojectsmine

Abra o arquivo pom.xml do parent-project e adicione os dois outros projetos como modules:

moduleparentproejct

Abra o pom.xml de um dos projetos que você criou (no meu caso ereaders-core.) e em parent deixe assim:

parentconfigproject

Faça o mesmo para o outro projeto.

Para projetos Web

Se você criou um projeto web, terá que alterar seu pom.xml  conforme a seguir. No meu caso, criei um maven project e depois adicionei “capacidades de JSF”, isso porque o Jboss tools nos permite fazer isso.  Daí a estrutura do projeto fica assim.

 

readersweb

Nós precisamos informar ao maven onde está o web.xml para que ele possa gerar o .war.

Para isso, clique com o botão direito no pom.xml do projeto web e vá na opção maven >> add plugin. Na janela que aparece, informe o seguinte:

<groupId>org.apache.maven.plugins</groupId>

<artifactId>maven-war-plugin</artifactId>

Feito isso, vá no modo de edição do pom.xml e adicione o código abaixo:

<configuration>

<webXml>..\readers-web\WebContent\WEB-INF\web.xml</webXml>

</configuration>

O código completo:

<plugin>

                    <groupId>org.apache.maven.plugins</groupId>

                    <artifactId>maven-war-plugin</artifactId>

                    <configuration>

                    <webXml>..\readers-web\WebContent\WEB-INF\web.xml</webXml>

                    </configuration>

             </plugin>

            

Se não fizesse, o seu build ia falhar, porque ele não ia saber o caminho do web.xml. Por default o maven ia procurar em seuprojeto\ WEB-INF.

Alterando a versão do Java no maven

Se você estiver usando um projeto web com suporte servlet 3.0 é requerido Java 6, mas o maven por default usa Java 5. Para alterar basta adicionar o plugin no pom.xml do projeto web:

groupId>org.apache.maven.plugins</groupId>

                    <artifactId>maven-compiler-plugin</artifactId>

                    <version>3.0</version>

E depois editar adicionando as informações a seguir:

<configuration>

                    <source>1.6</source>

                    <target>1.6</target>

                    </configuration>

 

Feito isso podemos buildar nosso projeto dentro do eclipse e ver o que acontece, portanto clique com o botão direito no parent-project, vá em Run As >> Maven Install

resultmavenbuildinstall

O resultado final deve ser conforme a imagem acima. Simples, não? Agora foi, mas antes disso tive problemas chatos. Um deles foi esse do .war.

No Jenkins

Agora vamos para o Jenkins e criar um job para buildar esse projeto

O meu chamei de parent-project e escolher a opção maven. 

As configurações são bem simples, a mais chata foi a do build, como veremos a seguir.  Como estou usando o Git, então informei onde está o repositório:

jenkinsrepostrunkmaven

E no build configurei:

jenkinsparentprojectpom

Salve as alterações e clique em Build Now

resultparentprojectjenkins

E o resultado  é o build construído.

Bom, essa foi uma das soluções que achei mais viável para o meu projeto. Espero que tenha gostado.

Compartilhe sua experiência… como tem feito?

Abraços, see ya!