CODEWITHSUNDEEP
mavenjenkinspom.xml
user2004266
user2004266

Reputation: 267

Maven: change version properties in pom.xml

I have a Maven pom.xml, I build project and release project deploy with Jenkins.

But before and after build "release version" we need set my version in

For example: I have in pom.xml

<properties>
   <version-own>0.0.21-SNAPSHOT</version-own>
</properties>

before release I need set like this

<properties>
   <version-own>0.0.25</version-own>
</properties>

after release I need set like this

<properties>
   <version-own>0.0.27-SNAPSHOT</version-own>
</properties>

How can this be done?

Upvotes: 24

Views: 65300

Answers (6)

Aleksandr Panzin
Aleksandr Panzin

Reputation: 2037

There is one way to to that easily. With one command you can change whichever part you want:

For cut and paste:

mvn build-helper:parse-version versions:set -DbuildNumber=555 '-DnewVersion=${parsedVersion.majorVersion}.${parsedVersion.minorVersion}.${parsedVersion.incrementalVersion}-${buildNumber}'

For clarity:

mvn build-helper:parse-version versions:set -DbuildNumber=555
   '-DnewVersion=
                  ${parsedVersion.majorVersion}
                 .${parsedVersion.minorVersion}
                 .${parsedVersion.incrementalVersion}
                 -${buildNumber}'

This is a concise example how to update versions in one go with build values

Upvotes: 8

MariuszS
MariuszS

Reputation: 31595

There is something like parsedVersion.nextIncrementalVersion

mvn build-helper:parse-version versions:set -DnewVersion=\${parsedVersion.majorVersion}.\${parsedVersion.minorVersion}.\${parsedVersion.nextIncrementalVersion} versions:commit

Upvotes: 1

John Smith
John Smith

Reputation: 21

Build-helper plugin supports regex replacements, and can even parse version numbers if need be. http://www.mojohaus.org/build-helper-maven-plugin/

Upvotes: 2

despot
despot

Reputation: 7377

Looking at this comment you are describing that you are using this version to provide a dependency. maven-release-plugin should help you manage the versions for you. So provide that plugin in your pom.xml.

And for the step of manually providing the release and development version, create a job in jenkins which will have 2 string parameters:
developmentVersion
releaseVersion
Add "Invoke top-level Maven targets" build step to execute the releasing (for example): 

clean release:clean release:prepare release:perform -DdevelopmentVersion=${developmentVersion} -DreleaseVersion=${releaseVersion}

When building the job, it will prompt you to insert both the developmentVersion and releaseVersion.

Cheers,
Despot

Upvotes: 0

Anew
Anew

Reputation: 5522

If you don't have to use your own version property, consider the following that will operate on your <project><version>0.0.21-SNAPSHOT</version></project> element:

mvn versions:set versions:commit -DnewVersion="0.0.25"

That will modify your pom and adjust the version to your liking. You'll likely want to commit this change to your source code control repository, for this the scm plugin's scm:checkin goal works just fine (assuming you want this to be automated):

mvn scm:checkin -Dincludes=pom.xml -Dmessage="Setting version, preping for release."

Then you can perform your release (I recommend the maven-release-plugin), after which you can set your new version and commit it as above.

The versions plugin is your friend. Scripting the above would likely involve some parameterized build, or preferably the groovy plugin for jenkins which allows you to get the maven-specific build variables.

Upvotes: 34

chad
chad

Reputation: 7537

For starters, you can do it by hand. If your build follows maven conventions well, you could probably leverage one of a couple of maven plugins that exist for helping with the management of version numbers.

The maven-versions-plugin helps automate manual changes to version numbers. It has nice CLI commands to help tune up your poms before doing releases.

Then there's the maven-release-plugin that automates the whole process of cutting a release. It will change your snapshot to a release version, then roll it to the next snapshot after the release build. During all this process it commits discrete versions of the poms to source control.

Again, the secret to seeing success in the more automated bits of the maven community is whether your build is doing things the maven way or not. Hacked, highly tweaked, non-conventional builds usually have a lot of barriers to successful use of the release plugin.

Upvotes: 8

Related Questions