How to update the <latest> tag in maven-metadata-local when installing an artifact?

Question

In the project I am working on we have various multi-module projects being developed in parallel, some of which are dependent on others. Because of this we are using using version ranges, e.g. [0.0.1,), for our internal dependencies during development so that we can always work against the latest snapshot versions. (I understand that this isn't considered best practice, but for now at least we are stuck with the current project structure.) We have build profiles set up so that when we perform a release all the version ranges get replaced with RELEASE to compile against the latest released version.

We have to use ranges as opposed to LATEST because when installing an artifact locally, the <latest> tag inside maven-metadata-local.xml is never updated, and so specifying LATEST will get the last version deployed to our Artifactory server. The problem with the ranges though is that the build process seems to have to download all the metadata files for all the versions of an artifact to be able to determine the latest version. As our project goes on we are accumulating more and more versions and artifacts so our builds are taking longer and longer. Specifying LATEST avoids this but means that changes from local artifact installs are generally not picked up.

Is there any way to get the <latest> tag in the maven-metadata-local.xml file to be updated when installing an artifact locally?

Answer 1

I had the same problem, so I wrote a maven plugin to handle it for me. It's a pretty extreme workaround, but it does work.

The documentation for creating maven plugins is on The Apache Maven Project. You could just create a plugin project from the command line archetype and add this mojo to your project.

/**
 * Inserts a "latest" block into the maven-metadata-local.xml in the user's local
 * repository using the currently configured version number.
 * 
 * @version Sep 23, 2013
 */
@Mojo( name = "latest-version", defaultPhase = LifecyclePhase.INSTALL )
public class InstallLatestVersionMojo extends AbstractMojo {

/**
 * Location of the .m2 directory
 */
@Parameter( defaultValue = "/${user.home}/.m2/repository", property = "outputDir", required = true )
private File repositoryLocation;

@Parameter( defaultValue = "${project.groupId}", property = "groupId", required = true )
private String groupId;

@Parameter( defaultValue = "${project.artifactId}", property = "artifactId", required = true )
private String artifactId;

/**
 * Version to use as the installed version
 */
@Parameter( defaultValue = "${project.version}", property = "version", required = true )
private String version;

public void execute() throws MojoExecutionException, MojoFailureException {
    try {
        // Fetch the xml file to edit from the user's repository for the project
        File installDirectory = getInstallDirectory(repositoryLocation, groupId, artifactId);
        File xmlFile = new File(installDirectory, "maven-metadata-local.xml");
        Document xml = getXmlDoc(xmlFile);

        if (xml != null) {
            // Fetch the <latest> node
            Node nodeLatest = getNode(xml, "/metadata/versioning/latest");
            if (nodeLatest == null) {
                // If <latest> does not yet exist, insert it into the <versioning> block before <versions>
                nodeLatest = xml.createElement("latest");
                Node versioningNode = getNode(xml, "/metadata/versioning");
                if (versioningNode != null) {
                    versioningNode.insertBefore(nodeLatest, getNode(xml, "metadata/versioning/versions"));
                }
            }
            // set the version on the <latest> node to the newly installed version
            nodeLatest.setTextContent(version);
            // save the xml
            save(xmlFile, xml);
        }

    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

private void save(File xmlFile, Document xml) throws TransformerFactoryConfigurationError, TransformerException {
    Transformer transformer = TransformerFactory.newInstance().newTransformer();
    transformer.setOutputProperty(OutputKeys.INDENT, "yes");
    Result output = new StreamResult(xmlFile);
    Source input = new DOMSource(xml);
    transformer.transform(input, output);
}

private Node getNode(Document source, String path) throws XPathExpressionException{
    Node ret = null;
    XPathExpression xPath = getPath(path);
    NodeList nodes = (NodeList) xPath.evaluate(source, XPathConstants.NODESET);
    if(nodes.getLength() > 0 ) {
        ret = nodes.item(0);
    }
    return ret;
}

private XPathExpression getPath(String path) throws XPathExpressionException{
    XPath xpath = XPathFactory.newInstance().newXPath();
    return xpath.compile(path);
}

private File getInstallDirectory(File repositoryLocation, String groupId, String artifactId) {
    String group = groupId.replace('.', '/');
    return new File(repositoryLocation, group + "/" + artifactId);
}

private Document getXmlDoc(File xmlFile) throws ParserConfigurationException, SAXException, IOException {
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
    DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
    return dBuilder.parse(xmlFile);
}

}

Answer 2

How about defining those internal dependencies as modules in one reactor pom? That way you'll compile against the compiled sources (in target/classes) instead of against a jar, and you'll always have the latest code.

Answer 3

If you are working with SNAPSHOT's you don't need version ranges apart from that never use version ranges (only in extrem rare situtions). With version ranges your build is not reproducible which should be avoided in my opinion under any circumstance.

But you can use things like this:

<version>[1.2.3,)</version

but as you already realized that caused some problems, but I would suggest to use the versions-maven-plugin as an alternative to update the projects pom files accordingly.

mvn clean versions:use-latest-versions scm:checkin deploy -Dmessage="update versions" -DperformRelease=true

This can be handled by CI solution like Jenkins. But I got the impression that you are doing some basic things wrong. In particular if you need to use version ranges.