Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

How do you deal with maven-3 timestamped snapshots efficiently?

Tags:

java

maven-3

Now that maven-3 did drop support for the <uniqueVersion>false</uniqueVersion> for snapshot artefacts it seems that you really need to use timestamped SNAPSHOTS. Especially m2eclipse, which does use maven 3 internally seems to be affected with it, update-snapshots does not work when the SNAPSHOTS are not unique.

It seemed best practice before to set all snapshots to uniqueVersion=false

Now, it seems no big problem to switch to the timestamped version, after all they are managed by a central nexus repository, which is able to delete old snapshots in regular intervalls.

The problem are the local developer workstations. Their local repository quickly does grow very large with unique snapshots.

How to deal with this problem ?

Right now i see the folowing possible solutions:

  • Ask the developers to purge the repository in regular intervals (which leads to lots of fustration, as it takes long time to delete and even longer to download everything needed)
  • Set up some script which does delete all SNAPSHOT directories from the local repository and ask developers to run that script from time to time (better than the first, but still takes quite some time to run and download current snapshots)
  • use the dependency:purge-local-repository plugin (Does have problems when run from eclipse, due to open files, needs to be run from each project)
  • set up nexus on every workstation and set up a job to clean old snapshots (best result, but I don't want to maintain 50+ nexus servers, plus memory is always tight on developer workstations)
  • stop using SNAPSHOTS at all

What is the best way to keep your local repository from filling up your hard drive space ?

Update:

To verify the beaviour and to give more info i setup a small nexus server, build two projects (a and b) and try:

a:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">   <modelVersion>4.0.0</modelVersion>   <groupId>de.glauche</groupId>   <artifactId>a</artifactId>   <version>0.0.1-SNAPSHOT</version>   <distributionManagement>     <snapshotRepository>         <id>nexus</id>         <name>nexus</name>         <url>http://server:8081/nexus/content/repositories/snapshots</url>     </snapshotRepository>   </distributionManagement>  </project> 

b:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">   <modelVersion>4.0.0</modelVersion>   <groupId>de.glauche</groupId>   <artifactId>b</artifactId>   <version>0.0.1-SNAPSHOT</version>     <distributionManagement>     <snapshotRepository>         <id>nexus</id>         <name>nexus</name>         <url>http://server:8081/nexus/content/repositories/snapshots/</url>     </snapshotRepository>   </distributionManagement>  <repositories>     <repository>         <id>nexus</id>         <name>nexus</name>         <snapshots>             <enabled>true</enabled>         </snapshots>         <url>http://server:8081/nexus/content/repositories/snapshots/</url>     </repository>  </repositories>   <dependencies>     <dependency>         <groupId>de.glauche</groupId>         <artifactId>a</artifactId>         <version>0.0.1-SNAPSHOT</version>     </dependency>   </dependencies> </project> 

Now, when i use maven and run "deploy" on "a", i'll have

a-0.0.1-SNAPSHOT.jar a-0.0.1-20101204.150527-6.jar a-0.0.1-SNAPSHOT.pom a-0.0.1-20101204.150527-6.pom 

in the local repository. With a new timestamp version each time i run the deploy target. The same happens when i try to update Snapshots from the nexus server (close "a" Project, delete it from local repository, build "b")

In an environment where lots of snapshots get build (think hudson server ...), the local reposioty fills up with old versions fast

Update 2:

To test how and why this is failing i did some more tests. Each test is run against clean everything (de/glauche gets delete from both machines and nexus)

  • mvn deploy with maven 2.2.1 :

local repository on machine A does contain snapshot.jar + snapshot-timestamp.jar

BUT: only one timestamped jar in nexus, metadata reads:

<?xml version="1.0" encoding="UTF-8"?> <metadata>   <groupId>de.glauche</groupId>   <artifactId>a</artifactId>   <version>0.0.1-SNAPSHOT</version>   <versioning>     <snapshot>       <timestamp>20101206.200039</timestamp>        <buildNumber>1</buildNumber>     </snapshot>     <lastUpdated>20101206200039</lastUpdated>   </versioning> </metadata> 
  • run update dependencies (on machine B) in m2eclipse (embedded m3 final) -> local repository has snapshot.jar + snapshot-timestamp.jar :(
  • run package goal with external maven 2.2.1 -> local repository has snapshot.jar + snapshot-timestamp.jar :(

Ok, next try with maven 3.0.1 (after removing all traces of project a)

  • local repository on machine A looks better, only one one non-timestamped jar

  • only one timestamped jar in nexus, metadata reads:

    de.glauche a 0.0.1-SNAPSHOT

    <snapshot>   <timestamp>20101206.201808</timestamp>   <buildNumber>3</buildNumber> </snapshot> <lastUpdated>20101206201808</lastUpdated> <snapshotVersions>   <snapshotVersion>     <extension>jar</extension>     <value>0.0.1-20101206.201808-3</value>     <updated>20101206201808</updated>   </snapshotVersion>   <snapshotVersion>     <extension>pom</extension>     <value>0.0.1-20101206.201808-3</value>     <updated>20101206201808</updated>   </snapshotVersion> </snapshotVersions> 

  • run update dependencies (on machine B) in m2eclipse (embedded m3 final) -> local repository has snapshot.jar + snapshot-timestamp.jar :(

  • run package goal with external maven 2.2.1 -> local repository has snapshot.jar + snapshot-timestamp.jar :(

So, to recap: The "deploy" goal in maven3 works better than in 2.2.1, the local repository on the creating machine looks fine. But, the receiver always ends up with lots of timestamed versions ...

What am i doing wrong ?

Update 3

I also did test various other configurations, first replace nexus with artifactory -> same behaviour. Then use linux maven 3 clients to download the snapshots from the repository manager -> local repository still has timestamped snapshots :(

like image 277
mglauche Avatar asked Nov 25 '10 09:11

mglauche


People also ask

Why is it best practice not to release snapshot versions of maven artifacts?

Rule #3 Never release using the Time-Stamped snapshot The release plugin will still fail if you do this because it correctly understands you have SNAPSHOT dependencies. The plugin has a flag to allow bypass this check and people unfortunately use it far too often.

How does maven snapshot work?

A Maven snapshot is a special version of a Maven package that refers to the latest production branch code. It is a development version that precedes the final release version. You can identify a snapshot version of a Maven package by the suffix SNAPSHOT that is appended to the package version.

How often does maven check for snapshot updates?

data-service project is releasing 1.0-SNAPSHOT for every minor change. Although, in case of SNAPSHOT, Maven automatically fetches the latest SNAPSHOT on daily basis, you can force maven to download latest snapshot build using -U switch to any maven command.

What is snapshot dependency in maven?

Snapshot simply means depending on your configuration Maven will check latest changes on a special dependency. Snapshot is unstable because it is under development but if on a special project needs to has a latest changes you must configure your dependency version to snapshot version.


1 Answers

The <uniqueVersion> configuration applied to artifacts that were deployed (via mvn deploy) to a Maven repository such as Nexus.

To remove these from Nexus, you can easily create an automated job to purge the SNAPSHOT repository every day. It can be configured to retain a certain number of shapshots or keep them for a certain period of time. Its super easy and works great.

Artifacts in the local repository on a developer machine get there from the "install" goal and do not use these timestamps...they just keep replacing the one and only SNAPSHOT version unless you are also incrementing the revision number (e.g. 1.0.0-SNAPSHOT to 1.0.1-SNAPSHOT).

like image 66
HDave Avatar answered Oct 01 '22 08:10

HDave