Gerando pacotes do ALBPM com Maven e Ant

Publicado em novembro 30, 2009

O Maven é um framework da Apache que possui muitas utilidades, uma delas é a geração de pacotes das aplicações sem que seja necessário uma IDE para realizar tal trabalho, isso é muito útil para que toda a equipe possa gerar um pacote da aplicação sem que seja necessário ter todo o projeto configurado em sua máquina, dessa forma fica-se independente de IDE e máquinas.

Outra utilidades do Maven é o gerenciamento de dependências da aplicação, pois uma vez que sua aplicação use outras bibliotecas, não se faz por necessário incluir os devidos JARs no repositório da aplicação, basta apenas informar isso no Maven e deixar que ele se encarregue de encontrar essas bibliotecas e baixar para sua máquina.

No caso do ALBPM (Aqualogic BPM), temos um cenário um pouco diferente, pois no final das contas tudo que é gerado são arquivos XML com as informações dos seus processos, então nesse caso usamos o Maven apenas para geração de pacotes. No ALBPM, um pacote nada mais é que o diretório da aplicação compactado (zipado) com uma extensão específica, no caso *.exp, deve-se considerar ainda a exclusão de alguns diretórios na geração do pacote, pois esses diretórios são gerados em tempo de compilação pela engine do ALBPM. Baseado nisso, criei uma configuração do Maven que será responsável pela geração de pacote de um projeto no ALBPM.

Usei ainda uma integração do Maven com o Ant, através de um plugin específico do Maven, onde o Ant será responsável por realizar algumas rotinas bem específicas, como renomear o arquivo gerado e apagar diretórios que não serão usados.

Vale ressaltar que eu testei essa rotina apenas para o ALBPM na versão 6.*, no caso da versão 5.*, acho que não deve mudar muita coisa, mas a extensão do pacote gerada é diferente, portanto será necessário algumas adaptações para que essa rotina funcione também nessa versão. No caso das versões já com a Oracle como responsável pelo produto (OracleBPM), essa rotina também deverá funcionar sem problemas.

Criando o POM do Maven

Como nosso projeto do ALBPM possui apenas um único módulo, será necessário a criação apenas de um único arquivo *.pom, que no caso será o responsável por incluir os plugins que serão usados, além de chamar um arquivo com algumas tasks do Ant. Dessa forma, o arquivo POM fica assim:

 XML |  copiar código |? 
01
<project xmlns="http://maven.apache.org/POM/4.0.0"
02
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
03
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
04
 
05
	<modelVersion>4.0.0</modelVersion>
06
	<groupId>com.b2w</groupId>
07
	<artifactId>ControleOrcamento</artifactId>
08
	<packaging>pom</packaging>
09
	<version>1.0</version>
10
	<name>ControleOrcamento Project</name>	
11
 
12
	<properties>
13
		<packageName>ControleOrcamento</packageName>
14
		<packageDirectory>package</packageDirectory>
15
		<packageExtension>exp</packageExtension>		
16
	</properties>
17
 
18
	<build>
19
	   	<plugins>
20
	   		<plugin>
21
				<artifactId>maven-assembly-plugin</artifactId>
22
				<executions>
23
					<execution>
24
						<id>assemble-zip</id>
25
						<phase>install</phase>
26
						<goals>
27
							<goal>attached</goal>
28
						</goals>
29
					</execution>
30
				</executions>
31
				<configuration>
32
                                       <appendAssemblyId>false</appendAssemblyId>   
33
					<finalName>${packageName}</finalName>                 
34
					<descriptors>
35
						<descriptor>assembly-descriptor.xml</descriptor>
36
					</descriptors>
37
				</configuration>
38
			</plugin>
39
      		<plugin>
40
				<groupId>org.apache.maven.plugins</groupId>
41
				<artifactId>maven-antrun-plugin</artifactId>
42
				<executions>									
43
					<execution>
44
						<id>rename-package</id>
45
						<phase>install</phase>
46
						<configuration>
47
							<tasks>
48
								<property name="package_name" value="${packageName}"></property>
49
								<property name="package_extension" value="${packageExtension}"></property>
50
								<property name="package_directory" value="${packageDirectory}"></property>
51
								<ant antfile="maven-setup.xml" ></ant>
52
							</tasks>							
53
						</configuration>
54
						<goals>
55
							<goal>run</goal>
56
						</goals>
57
					</execution>					
58
				</executions>
59
			</plugin>
60
	    </plugins>
61
	</build>  	
62
 
63
	<repositories>
64
		<repository>
65
			<id>default</id>
66
			<name>Internal</name>
67
			<url>http://intranet/archiva/repository/internal</url>
68
		</repository>
69
		<repository>
70
			<id>ideais</id>
71
			<name>Ideais</name>
72
			<url>http://intranet/archiva/repository/ideais</url>
73
		</repository>
74
		<repository>
75
			<id>thirdparty</id>
76
			<name>Thirdparty Artifacts</name>
77
			<url>http://intranet/archiva/repository/thirdparty</url>
78
		</repository>	
79
	</repositories>
80
 
81
</project>

A idéia aqui não estar explicando o que é um POM, sua estrutura, como funciona, etc, a idéia é apenas mostrar como criar um POM com o intuito de gerar pacotes do ALBPM.

Explicando o POM utilizado

No começo do nosso POM temos algumas informações obrigatórias que o Maven exige, portanto acho que não vale a pena citá-las, dessa forma partindo para a declaração das propriedades ( ), nós temos:

packageName – Nome do diretório da aplicação
packageDirectory – Diretório onde deverá ser gerado o pacote
packageExtension – Extensão do pacote a ser gerado

Na parte da declaração de plugins, nós declaramos os dois plugins que utilizaremos: maven-assembly-plugin (será o responsável por gerar o arquivo compactado, excluir os diretórios não desejados, etc) e maven-antrun-plugin (será o responsável por fazer algumas tarefas pontuais como renomear o arquivo compactado e deletar os diretórios não utilizados e que são gerados pelo plugin anterior).

No caso do plugin maven-assembly-plugin, associamos ainda um descriptor, que é um arquivo XML que contém todas as rotinas que esse plugin deverá executar e que possui o seguinte conteúdo:

 XML |  copiar código |? 
01
<assembly>
02
	<formats>
03
		<format>zip</format>
04
	</formats>
05
	<includeBaseDirectory>false</includeBaseDirectory>	
06
	<fileSets>
07
		<fileSet>
08
			<directory>${basedir}/${packageName}</directory>		  			  	
09
			<filtered>true</filtered>			
10
		  	<excludes>		  		
11
				<exclude>**/.svn/**</exclude>
12
				<exclude>**/fuego.portal.jar/**</exclude>
13
				<exclude>**/build/**</exclude>
14
				<exclude>**/system/**</exclude>
15
		  	</excludes>		  	
16
		</fileSet>
17
	</fileSets>	
18
</assembly>

No conteúdo acima, especificamos no elemento
o formato do arquivo a ser gerado, no caso um zip. No elemento informamos ao plugin que não queremos que ele inclua o diretório base no arquivo zip a ser gerado. No elemento definimos uma série de regras que o arquivo a ser zipado deverá obedecer: no primeiro elemento () informamos qual diretório deverá ser zipado, repare que nesse caso usamos os valores das propriedades definido no arquivo POM do Maven. No segundo elemento, no caso , informamos que NÃO queremos que o plugin inclua os diretórios que não possuem arquivos, ou seja, não queremos diretórios em branco. No terceiro elemento (), informamos ao plugin quais são os diretórios e arquivos que NÃO devem ser incluídos no arquivo zip a ser gerado, nesse caso não queremos incluir nenhum diretório/arquivo do SVN, não queremos incluir o JAR fuego.portal, assim como não queremos incluir os diretórios build e system, pois eles são gerados pela IDE em tempo de compilação e não são necessários para nosso pacote.

Explicando o arquivo Ant

No nosso POM, declaramos o plugin maven-antrun-plugin, que será o plugin responsável por executar tasks do Ant.

Ainda no arquivo POM, definimos algumas propriedades que o arquivo Ant deverá conhecer, ou seja, ele irá herdar as propriedades que definimos no POM, bem como definimos qual é o arquivo XML que conterá as taks do Ant a serem executadas, no nosso caso esse arquivo é o maven-setup.xml.

O arquivo maven-setup.xml conterá duas rotinas: uma que é renomear o zip gerado, para ao invés de possuir a extensão .zip, possuir a extensão .exp (propriedade definida no POM e herdada no arquivo Ant), e outra rotina deverá ser remover o diretório target, que é gerado pelo maven-assembly-plugin e que no nosso caso não teria nenhuma utilidade. Dessa forma o conteúdo do nosso arquivo Ant ficou assim:

 XML |  copiar código |? 
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project name="mavensetup" default="setup">
3
	<target name="setup">
4
			<echo level="info">Renomeando o pacote para ${package_name}.${package_extension}</echo>
5
		  	<move file="target/${package_name}.zip" tofile="${package_directory}/${package_name}.${package_extension}"></move>
6
		  	<echo level="info">Apagando o diretorio /target</echo>
7
		  	<delete dir="target"></delete>
8
  	</target>
9
</project>

Repare, que no arquivo Ant usamos as propriedades definidas no nosso POM do Maven e usamos ainda o elemento para termos informação do que o Ant está fazendo.

Resumindo

Usando apenas 3 arquivos (pom.xml, assembly-descriptor.xml, maven-setup.xml) nós temos nosso pacote do ALBPM sendo gerado pelo Maven e pronto para ser deployado na versão enterprise do ALBPM.

Agora basta apenas um mvn install na linha de comando para geração do pacote.

Mais informações

Começando com o Maven

Maven Assembly Plugin

Maven AntRun Plugin

Maven Lifecycle

BPM

Se você gostou desse tópico, por favor considere deixar um comentário ou se inscreva no feed e tenha no futuro todos os tópicos entregues diretamente no seu agregador.

Deixe seu Comentário

(obrigatório)

(obrigatório)