When using the maven-publish gradle plugin , it publishes both the myapp.jar and myapp-sources.jar files to the maven repo.
How can I exclude the publish of the myapp-sources.jar to the maven repo.
Following is the publishing section for the build.gradle file for my project
project.group = 'com.test'
project.version = '0.0.1'
sourceCompatibility = '8'
publishing {
publications {
maven(MavenPublication){
groupId = project.group
artifactId = project.name
version = project.version
from components.java
artifact jar
}
}
}
Related
I have a Kotlin project organised like so:
project-name
> project-name-core
> project-name-domain
My gradle publishing script is set up like this:
publishing {
repositories {
mavenLocal()
}
publications.all {
pom.withXml(configureMavenCentralMetadata)
}
publications {
mavenPublication(MavenPublication) {
from components.java
groupId 'com.project'
artifactId 'project-name'
artifact sourcesJar
artifact javadocJar
}
}
}
When I run ./gradlew publishToMavenLocal I can see project-name in the local repository cache, but not project-name-core or project-name-domain.
How do I configure gradle to publish my sub-modules to the maven local repository cache?
Best guess is that you only applied the publishing plugin to the root project and not the subprojects.
If you intend to publish the root project (src/) in addition to the subprojects, then you should move the configurations to the allprojects block:
allprojects {
publishing {
publications.all {
pom.withXml(configureMavenCentralMetadata)
}
publications {
mavenPublication(MavenPublication) {
from components.java
groupId 'com.project'
artifactId 'project-name'
artifact sourcesJar
artifact javadocJar
}
}
}
}
Otherwise if you only want to publish the subprojects, then replace allprojects with subprojects
Also, you don't need to add configure the repositories with mavenLocal().
I am in a gradle 4.10 Spring Boot project called rest and in my build.gradle I have renamed the boot jar that is created by adding
bootJar.baseName = 'myprefix-rest'
When I run ./gradlew bootJar it creates a file called myprefix-rest-0.1.jar as expected.
However, when I add the maven-publish publish plugin and try to publish, it publishes the file called rest-0.1.jar
publishing {
publications {
bootJava(MavenPublication) {
artifact bootJar
}
}
repositories {
maven {
url = "$buildDir"
}
}
}
Why is it not picking up the baseName?
Why is it not picking up the baseName?
From the MavenPublication docs,
The default Maven POM identifying attributes are mapped as follows:
groupId - project.group
artifactId - project.name
version - project.version
so the actual file name of the boot jar file is not being used. You can overrride the artifactId,
publishing {
publications {
bootJava(MavenPublication) {
artifact bootJar
artifactId bootJar.baseName
}
}
..
}
I need to pack all microservices made with Spring Boot into one big EAR.
The project is organized like this:
/root
build.gradle
settings.gradle
/project1
build.gradle
...
/project3
build.gradle
...
/project3
build.gradle
...
The root settings.gradle contains:
rootProject.name = "mysystem"
include("project1")
include("project2")
include("project3")
The build.gradle in root contains
apply plugin: 'ear'
allprojects {
group = 'de.example'
}
dependencies {
deploy project(path:':project1', configuration:'archives')
deploy project(path:':project2', configuration:'archives')
deploy project(path:':project3', configuration:'archives')
}
ear {
deploymentDescriptor {
applicationName = "myproject"
initializeInOrder = true
displayName = "My Project"
description = "My Project EAR"
}
}
The project build.gradle looks like
buildscript {
ext {
springBootVersion = '2.0.2.RELEASE'
}
repositories {
mavenCentral()
}
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
}
}
apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
defaultTasks 'bootWar'
repositories {
mavenCentral()
// Maven Spring Repository for Milestone Releases (optional for development but don't use it in Production)
maven { url 'https://repo.spring.io/libs-milestone-local' }
// Maven Spring Repository for Stable Releases
maven { url 'https://repo.spring.io/libs-release-local' }
}
dependencyManagement {
imports {
mavenBom 'org.springframework.cloud:spring-cloud-dependencies:Finchley.RELEASE'
}
}
dependencies {
compile("org.springframework.boot:spring-boot-starter") {
}
compile('org.springframework.boot:spring-boot-starter-json')
compile("org.springframework.boot:spring-boot-starter-web") {
}
providedCompile('org.springframework.boot:spring-boot-starter-tomcat')
}
When I run gradle bootWar per project it generates the WAR in build/lib per project.
But when I run gradle ear in the root project, the output is like this:
Working Directory: D:\Workspace\root
Gradle User Home: D:\Workspace\.gradle
Gradle Distribution: Gradle wrapper from target build
Gradle Version: 4.3
Java Home: C:\Programme\Java\jdk8
JVM Arguments: None
Program Arguments: None
Build Scans Enabled: false
Offline Mode Enabled: false
Gradle Tasks: ear
Parallel execution with configuration on demand is an incubating feature.
:project1:compileJava
:project2:compileJava
:project3:compileJava
:project1:processResources
:project1:classes
:project1:war SKIPPED
:project2:processResources
:project2:classes
:project2:war SKIPPED
:project3:processResources
:project3:classes
:project3:war SKIPPED
:ear
BUILD SUCCESSFUL in 2s
7 actionable tasks: 7 executed
The result is an EAR with 1k size. There is no WAR generated per project. When I run gradle bootWar on every project and then run gradle ear, it works and the resulting EAR has 130Mb and includes all WARs.
Is there a way, that I only need to run gradle ear and it generates the WARs from bootWar?
In a gradle Spring Boot project the "war" task is disabled in lieu of the "bootWar" task.
Setup the "ear" task in the parent build.gradle to depend on the "bootWar" task(s).
ear {
dependsOn ':project1:bootWar'
}
I'm trying to publish a snapshot of grails 3 plugin to remote maven repository (Artifactory). Here is my build script:
import org.springframework.util.StringUtils
buildscript {
ext {
grailsVersion = project.grailsVersion
}
repositories {
jcenter()
mavenLocal()
mavenCentral()
maven { url "https://repo.grails.org/grails/core" }
maven { url "${artifactory_contextUrl}"
credentials {
username "${artifactory_user}"
password "${artifactory_password}"
}
name = "remote-maven-repo"
}
}
dependencies {
classpath "org.grails:grails-gradle-plugin:$grailsVersion"
classpath "org.jfrog.buildinfo:build-info-extractor-gradle:3.1.2"
}
}
plugins {
id "io.spring.dependency-management" version "0.5.2.RELEASE"
id "com.jfrog.bintray" version "1.2"
}
String baseVersion = "0.1.0-%customer%-SNAPSHOT"
String currentVersion = "$baseVersion".replaceAll('%customer%',property('plugin.default.customer').toUpperCase())
version currentVersion
group "org.grails.plugins"
apply plugin: 'maven'
apply plugin: 'maven-publish'
apply plugin: "com.jfrog.artifactory"
apply plugin: 'eclipse'
apply plugin: 'idea'
apply plugin: "spring-boot"
apply plugin: "org.grails.grails-plugin"
apply plugin: "org.grails.grails-gsp"
println "Current customer mode: [${property("plugin.default.customer")}]"
ext {
grailsVersion = project.grailsVersion
gradleWrapperVersion = project.gradleWrapperVersion
}
String defaultVersion = "default"
// Custom versioning scheme, take version of dependency with 'default' version from gradle.preperties
configurations.all {
resolutionStrategy.eachDependency { DependencyResolveDetails details ->
if (details.requested.version == defaultVersion) {
customer = property("plugin.default.customer")
String version = resolveDefaultVersion(details.requested.group, details.requested.name, customer)
details.useVersion(version)
}
}
}
configurations.all {
// check for updates every build
resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
}
String resolveDefaultVersion(String group, String name, String customer) {
if(group == 'com.mycompany.domain' && name == 'custom-lib'){
String version = property("custom-lib.${customer}.version")
println "resolved artifact [$group.$name] version [$version]"
return version
}
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
repositories {
mavenLocal()
mavenCentral()
maven { url "https://repo.grails.org/grails/core" }
add buildscript.repositories.getByName("remote-maven-repo")
}
dependencyManagement {
imports {
mavenBom "org.grails:grails-bom:$grailsVersion"
}
applyMavenExclusions false
}
dependencies {
provided 'org.springframework.boot:spring-boot-starter-logging'
provided "org.springframework.boot:spring-boot-starter-actuator"
provided "org.springframework.boot:spring-boot-autoconfigure"
provided "org.springframework.boot:spring-boot-starter-tomcat"
provided "org.grails:grails-web-boot"
provided "org.grails:grails-dependencies"
provided 'javax.servlet:javax.servlet-api:3.1.0'
testCompile "org.grails:grails-plugin-testing"
console "org.grails:grails-console"
//Security
compile "org.grails.plugins:spring-security-core:3.0.0.M1"
compile "org.grails.plugins:spring-security-acl:3.0.0.M1"
//Not grails3 compatible
//compile "org.grails.plugins:spring-security-oauth2-provider:2.0-RC5"
compile "org.grails.plugins:hibernate:4.3.10.6"
//configurable customer-dependent dependency, take version from gradle.properties
compile group: "com.mycompany.domain", name:"custom-lib", version:"$defaultVersion", changing: true
}
task wrapper(type: Wrapper) {
gradleVersion = gradleWrapperVersion
}
publishing {
publications {
mavenJava(MavenPublication) {
from components.java
// gradle can't handle custom versioning scheme and will left com.mycompany.domain.custom-lib version value as 'default' in generated pom, we will fix it here.
pom.withXml {
asNode().get('dependencies').get(0).get('dependency').each { dep ->
String pomVer = dep.get("version").text()
String pomArtifactId = dep.get("artifactId").text()
String pomGroupId = dep.get("groupId").text()
if(pomVer == defaultVersion){
String customer = property("plugin.default.customer")
dep.get("version").get(0).setValue(resolveDefaultVersion(pomGroupId, pomArtifactId, customer))
}else if (StringUtils.isEmpty(pomVer)){
//gradle also left dependencies with provided scope in pom without version --> remove these dependencies
dep.replaceNode {}
}
}
}
}
}
repositories {
maven {
name 'myArtifactory'
url "${artifactoryContextUrl}/${(project.version.endsWith('-SNAPSHOT') ? snapshotRepoKey : releaseRepoKey)}"
credentials {
username = artifactory_user
password = artifactory_password
}
}
}
}
install.repositories.mavenInstaller.pom.whenConfigured { pom ->
pom.dependencies.findAll { it.version == defaultVersion }.each { dep ->
dep.version = resolveDefaultVersion(dep.groupId, dep.artifactId, property("plugin.default.customer"))
}
}
When I'm running gradle install - to install plugin in local m2 repo everything works fine, and pom looks good, it has dependencies with exactly the same scopes and versions, also provided dependencies are excluded from pom during publishing to local repository. When I'm running gradle publishMavenJavaPublicationToMyArtifactoryRepository pom is looking quite strange, gradle is ignoring defined in build script dependencies scopes and always using runtime. As an example:
pom after gradle install:
<dependency>
<groupId>org.grails.plugins</groupId>
<artifactId>spring-security-acl</artifactId>
<version>3.0.0.M1</version>
<scope>compile</scope>
</dependency>
pom after gradle publishMavenJavaPublicationToMyArtifactoryRepository:
<dependency>
<groupId>org.grails.plugins</groupId>
<artifactId>spring-security-acl</artifactId>
<version>3.0.0.M1</version>
<scope>runtime</scope>
</dependency>
Also pom after gradle install doesn't contain dependencies with scope provided. Pom.xml after gradle publishMavenJavaPublicationToMyArtifactoryRepository contains
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
without version, gradle doesn't like that.
Why am I receiving such different results? How can I generate the same pom for gradle publishMavenJavaPublicationToMyArtifactoryRepository as for gradle install. I don't like an opportunity to edit pom in publications section. Any help is highly appreciated.
This is a known limitation of the incubating new maven-publish plugin. The install task uses the "old"/stable Install task. If you really rely on these scopes, one workaround might be to use the gradle based "uploadArchives" task instead of relying on the bintray plugin for publishing your archives. Alternatively you can implement a fix by using the xml hooks of the new publish plugin.
I'm having issues with publishing to local nexus maven repository.
I admit, I don't have much experience with using gradle.
I will say that I have tried understanding the documentation and examples that are given through the gradle website (along with a few stackoverflow questions).
I am getting the following error when I try to publish:
Execution failed for task ':publishMavenPublicationToMavenRepository'.
> Failed to publish publication 'maven' to repository 'maven'
> Error deploying artifact 'com.myproject:myproject-sdk:jar': Error deploying artifact: Resource to deploy not found: File: http://git.site.com:8081/nexus/content/repositories/releases/com/myproject/myproject-sdk/3.0.0/myproject-sdk-3.0.0.jar does not exist
the entire build.gradle file looks like this:
apply plugin: 'java'
apply plugin: 'maven-publish'
apply plugin: 'build-version'
buildscript {
repositories {
maven { url "http://git.site.com:8081/nexus/content/groups/public" }
maven { url 'https://geonet.artifactoryonline.com/geonet/public-releases' }
mavenCentral()
}
dependencies {
classpath 'nz.org.geonet:gradle-build-version-plugin:1.+'
}
}
repositories {
maven {
url "http://git.site.com:8081/nexus/content/groups/public"
}
}
dependencies {
testCompile group: 'junit', name: 'junit', version: '4.11'
compile 'com.google.code.gson:gson:2.2.4'
compile 'commons-codec:commons-codec:1.9'
}
task sourceJar(type: Jar) {
from sourceSets.main.allJava
}
publishing {
publications {
maven(MavenPublication) {
artifactId = 'myproject-sdk'
groupId = 'com.myproject'
version '3.0.0'
from components.java
artifact sourceJar {
classifier "sources"
}
}
}
repositories {
maven {
// nexus maven credentials
credentials {
username "MY_USERNAME"
password ""MY_PASSWORD"
}
if(version.endsWith('-SNAPSHOT')) {
url "http://git.site.com:8081/nexus/content/repositories/snapshots"
} else {
url "http://git.site.com:8081/nexus/content/repositories/releases"
}
}
}
}
I am using Android Studio and this project is a Java project.
I don't understand the message because it says "Resource to deploy not found" and it points to a url at nexus.
I would expect a message like "Resource to deploy not found: File: c:/directory_that_doesn't_exist/whatever.jar"
Additional Information -
The gradle tasks listed under 'All tasks' are:
assemble
build
buildDependents
buildNeeded
check
classes
clean
compileJava
compileTestJava
generatePomFileForMavenPublication
jar
javadoc
processResources
processTestResources
publish
publishMavenPublicationToMavenLocal
publishMavenPublicationToMavenRepository
publishToMavenLocal
sourceJar
test
testClasses