This Confluence has been LDAP enabled, if you are an ASF Committer, please use your LDAP Credentials to login. Any problems file an INFRA jira ticket please.

Child pages
  • Packaging vs Type - Derived and Attached Artifacts

Versions Compared


  • This line was added.
  • This line was removed.
  • Formatting was changed.
Comment: Migrated to Confluence 4.0


Here, a simple call to project.attachArtifact( Artifact artifact ) is appropriate. In the specific use cases:

  • ear:ear would create the client based on configuration, and attach it
  • a webapp plugin could have a goal, bound to packaging, that when configured published a set of tlds as well as bundled them into a jar

Attachment at deploy step


This is pretty sound from general use cases, though there have been a
couple of problems to arise:

  • inconsistency could lead to confusion
  • guaranteeing snapshots match versions


I believe this is ok. The naming was different to ensure it is clear
that they can be different, and packaging IS A SUBSET of <type>,
guaranteeing they can be handled consistently. Any value of packaging
should have 1 type that matches exactly, and possibly more types that
are associated with it. Any type has 0..1 matching packaging.


Firstly, we differentiate types in the following way:

  • that specified by packaging
  • other types "tied" to the packaging (eg ejb-client and ejb)
  • other types only generated by particular optional goals (eg distribution)

Untied objects can be manually attached, and tied objects can be manually detached. From this, it seems sensible that attachment is only a matter of configuration, with sensible defaults, rather than something specific in the design. Note that there are different scenarios: attachment by configuration is appropriate for ejb client, but when set it should always happen. For distributions, sources, etc it is appropriate to only attach at release - they do not need to be deployed for snapshots.

  • deploying a distribution MUST deploy the JAR - ie, any deployment must
    deploy both the POM and the artifact of the packaging (+ anything tied
    to it, like an ejb-client or sources).
  • deploying an artifact MUST deploy any "tied" artifacts - eg, deploying
    an EJB must deploy its client
  • deploying an artifact NEED NOT deploy any "untied" artifacts - eg,
    deploying a JAR doesn't deploy the distribution by default - it must be
    configured to do so, or the goal added

This ensures that a POM is always deployed and updated for every
deployment of anything, and that the primary artifact and anything tied
to it is never orphaned.


However, there are a few interesting points here:

  • have decided to make groupId/artifactId unique, regardless of type. Therefore, type is not required to lookup an artifact at all (though it would be helpful in indicating what type the artifact is when reading the pom)
  • the above could mean that type could be replaced by by something solely to identify the classifier
  • if not, then either the type needs to map to a packaging + classifier, or a classifier field needs to be added
  • if the type is being mapped, this needs to be quite flexible - ie a plugin can provide its own, but this means that arbitrary classifiers can't be used. This has positives and negatives of its own.

I am in favour of using type mappings, at least to start with. The positives are:

  • avoids arbitrary classifiers, making artifactId be well considered
  • avoids requirement of additional metadata field in the dependency element
  • can't create your own classifiers, must stick to those provided by the plugin producing the artifact
  • must build in the mapping to all plugins providing a packaging.