View Source

Arc unpack as a debian package

First, we need to define a few properties in the pom file
{code:language=xml|title=Pom file properties}<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.deb.name>${groupId}.${artifactId}</maven.deb.name>
<maven.deb.libfolder>/usr/share/${maven.deb.name}</maven.deb.libfolder>
<maven.deb.docfolder>/usr/share/doc/${maven.deb.name}</maven.deb.docfolder>
<maven.deb.manfolder>/usr/share/man</maven.deb.manfolder>
<maven.deb.binfolder>/usr/bin</maven.deb.binfolder>
<maven.deb.assembly>debian-prepare</maven.deb.assembly>
</properties>
{code}
Basically, these just allows us to use consistent names in the plugin configs that follow.

Then we come to the <build> section. The first thing to do, is to enable filtering on the resources. This is done such
{code:language=xml}<build>
<resources>
<resource>
<filtering>true</filtering>
<directory>src/main/resources</directory>
</resource>
</resources>{code}
The effect of this is that you can use $\{maven.deb.name\}

and the like in the config files, and have this replaced during the build.&nbsp;

Firstly, we want to ensure that the jar file is as executable as we can easily make it. To do this, we must make a manifest. This is done with the jar-plugin
{code:language=xml}<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jar-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<archive>
<manifest>
<mainClass>dk.statsbiblioteket.scape.arcunpacker.Archive</mainClass>
<addDefaultImplementationEntries>true</addDefaultImplementationEntries>
<addClasspath>true</addClasspath>
<classpathPrefix>${maven.deb.libfolder}</classpathPrefix>
</manifest>
<manifestEntries>
<mode>development</mode>
<url>${pom.url}</url>
</manifestEntries>
</archive>
<excludes>
<exclude>debian/**</exclude>
<exclude>scripts/**</exclude>
</excludes>
</configuration>
</plugin>{code}
In the manifest, I declare the main class, and the classpath. Notice that I declare the classpathPrefix to be the maven.deb.libfolder, in order for the system to be able to resolve the dependencies when installed as a debian package.

Okay, the jar file is now generated correctly. Lets start on generating the package. First, we need to use maven to get all the dependencies. This is done with the assembly plugin
{code:language=xml}<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.2-beta-5</version>
<configuration>
<descriptors>
<descriptor>src/main/assembly/${maven.deb.assembly}.xml</descriptor>
</descriptors>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
{code}
This plugin uses the deb assembly. So, what will the deb.assembly do? Lets look at it.&nbsp;
{code:language=xml}<assembly>
<id>debian-prepare</id>

<formats>
<format>dir</format>
</formats>

<dependencySets>

<dependencySet>
<outputDirectory>jars</outputDirectory>
<useTransitiveDependencies>true</useTransitiveDependencies>
<useTransitiveFiltering>true</useTransitiveFiltering>
<useProjectArtifact>false</useProjectArtifact>
</dependencySet>

</dependencySets>

</assembly>
{code}
Basically, it puts all the jar dependencies of the project in one dir, ready for inclusion in the debian package.&nbsp;

Time to make the first version of the deb. We need another plugin in the pom file to do that.
{code:language=xml}<plugin>
<artifactId>jdeb</artifactId>
<groupId>org.vafer</groupId>
<version>0.9</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>jdeb</goal>
</goals>
<configuration>
<deb>${project.build.directory}/${artifactId}${version}-java.deb</deb>
<controlDir>${project.build.directory}/classes/debian/control/</controlDir>
                            <dataSet> <dataSet>
<data>
<src>${project.build.directory}/${project.build.finalName}-${maven.deb.assembly}/${project.build.finalName}/jars</src>
<type>directory</type>
<mapper>
<type>perm</type>
<prefix>${maven.deb.libfolder}</prefix>
</mapper>
</data>
<data>
<src>${project.build.directory}/${project.build.finalName}.jar</src>
<type>file</type>
<mapper>
<type>perm</type>
<prefix>${maven.deb.libfolder}</prefix>
</mapper>
</data>

</dataSet>
</configuration>
</execution>
</executions>
</plugin>
{code}
Note that it is important that this plugin is placed below the assembly plugin, as they both execute in the package phase, and jdeb depends on the debian assembly having been run.

So, what will this plugin do?

Well, it will make a debian package, with the filename $\{project.build.directory\}/$\{artifactId\}$\{version\}-java.deb.

The ever-important control file should be found in&nbsp;$\{project.build.directory\}/classes/debian/control/ More about that file later.

The lib folder&nbsp;$\{maven.deb.libfolder\} should contain the jars, from the debian-prepare assembly detailed above. Oh, and the project jar should also go there, as it was not included in the assembly.

So, now we just need to detail the control file, and we have the first barebone deb file.&nbsp;

Make a file "control" in resources/debian/control, with this content
{code:language=none}Package: [[groupId]].[[artifactId]]
Version: [[version]]
Section: java
Priority: optional
Architecture: all
Depends: default-jre (>= 1.5)
Maintainer: Asger Askov Blekinge <[email protected]>
Description: unpacker app for arc and warc files, based on the heritrix crawler
This is the extended description
{code}