Artifactory Gradle Plugin

plugins {
    id("com.jfrog.artifactory") version "6.+"
}

plugins {
    id "com.jfrog.artifactory" version "6.+"
}

plugins {
    id("com.jfrog.artifactory") apply false
}

allprojects {
    apply(plugin = "com.jfrog.artifactory")
}

plugins {
    id 'com.jfrog.artifactory' apply false
}

allprojects {
    apply plugin: 'com.jfrog.artifactory'
}

configure<ArtifactoryPluginConvention> {
    publish {
        contextUrl = "http://127.0.0.1:8081/artifactory"
        repository {
            repoKey = "libs-snapshot-local"
            username = project.property("artifactory_user") as String
            password = project.property("artifactory_password") as String
        }
        defaults {
            publications("ALL_PUBLICATIONS")
        }
    }
}

artifactory {
    publish {
        contextUrl = 'http://127.0.0.1:8081/artifactory'
        repository {
            repoKey = 'libs-snapshot-local'
            username = "${artifactory_user}"
            password = "${artifactory_password}"
        }
        defaults {
            publications('ALL_PUBLICATIONS')
        }
    }
}

./gradlew artifactoryPublish

configure<ArtifactoryPluginConvention> {
    publish { /* ... */ }
    buildInfo { /* ... */ }
    proxy { /* ... */ }

    clientConfig.timeout = 600
    clientConfig.connectionRetries = 4
    clientConfig.insecureTls = false
    clientConfig.isIncludeEnvVars = true
    clientConfig.envVarsExcludePatterns = "*password*,*secret*"
    clientConfig.envVarsIncludePatterns = "*not-secret*"
}

artifactory {
    publish { /* ... */ }
    buildInfo { /* ... */ }
    proxy { /* ... */ }

    clientConfig.timeout = 600
    clientConfig.setConnectionRetries(4)
    clientConfig.setInsecureTls(false)
    clientConfig.setIncludeEnvVars(true)
    clientConfig.setEnvVarsExcludePatterns('*password*,*secret*')
    clientConfig.setEnvVarsIncludePatterns('*not-secret*')
}

publish {
    contextUrl = "http://127.0.0.1:8081/artifactory"
    repository {
        repoKey = "libs-snapshot-local"
        // Or use release and snapshot repositories:
        // releaseRepoKey = "libs-release-local"
        // snapshotRepoKey = "libs-snapshot-local"
        username = project.property("artifactory_user") as String
        password = project.property("artifactory_password") as String
        ivy {
            ivyLayout = "[organization]/[module]/ivy-[revision].xml"
            artifactLayout = "[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]"
            mavenCompatible = true
        }
    }
    defaults {
        publications("mavenJava", "ivyJava")
    }
    publishBuildInfo = true
    forkCount = 5
}

publish {
    contextUrl = 'http://127.0.0.1:8081/artifactory'
    repository {
        repoKey = 'libs-snapshot-local'
        username = "${artifactory_user}"
        password = "${artifactory_password}"
        ivy {
            ivyLayout = '[organization]/[module]/ivy-[revision].xml'
            artifactLayout = '[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]'
            mavenCompatible = true
        }
    }
    defaults {
        publications('mavenJava', 'ivyJava')
    }
    publishBuildInfo = true
    forkCount = 5
}

buildInfo {
    buildName = "my-build"
    buildNumber = "" + Random(System.currentTimeMillis()).nextInt(20000)
    project = "project-key"
    addEnvironmentProperty("test.adding.dynVar", Date().toString())
    generatedBuildInfoFilePath = "/path/to/myBuildInfoCopy.json"
    deployableArtifactsFilePath = "/path/to/myArtifactsInBuild.json"
}

buildInfo {
    setBuildName('my-build')
    setBuildNumber('' + new Random(System.currentTimeMillis()).nextInt(20000))
    setProject('project-key')
    addEnvironmentProperty('test.adding.dynVar', new java.util.Date().toString())
    setGeneratedBuildInfoFilePath('/path/to/myBuildInfoCopy.json')
    setDeployableArtifactsFilePath('/path/to/myArtifactsInBuild.json')
}

buildInfo.build.name=my-super-cool-build
buildInfo.build.number=r9001

proxy {
    host = 'www.somehost.org'
    port = 8080
    username = 'userid'
    password = 'password'
    noProxy = 'internal.myorg.com'
}

systemProp.http.proxyHost=www.somehost.org
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=userid
systemProp.http.proxyPassword=password

tasks.named<ArtifactoryTask>("artifactoryPublish") {
    publications(
        publishing.publications["ivyJava"],
        "mavenJava",
        "ALL_PUBLICATIONS"
    )
    setProperties(mapOf("key1" to "value1", "key2" to "value2"))
    skip = false
    setPublishArtifacts(true)
    setPublishPom(true)
    setPublishIvy(true)
    setModuleType("GRADLE")
}

artifactoryPublish {
    publications('ALL_PUBLICATIONS')
    properties = ['qa.level': 'basic', 'dev.team': 'core']
    properties {
        simpleFile '**:**:**:*@*', simpleFile: 'only on settings file'
    }
    skip = false
    publishArtifacts = true
    publishPom = true
    publishIvy = true
    moduleType = 'GRADLE'
}

publishing {
    publications {
        mavenJava(MavenPublication) {
            from components.java
        }
        ivyJava(IvyPublication) {
            from components.java
        }
    }
}

artifactory {
    publish {
        defaults {
            publications('mavenJava', 'ivyJava')
        }
    }
}

artifactoryPublish {
    properties = ['qa.level': 'basic', 'q.os': 'win32, deb, osx']
}

artifactoryPublish {
    properties {
        foo '*:*:*:*@*', platform: 'linux', 'win64'
        mavenJava 'org.jfrog:*:*:*@*', key1: 'val1'
        all 'org.jfrog:shared:1.?:*@*', key2: 'val2', key3: 'val3'
    }
}

./gradlew clean api:artifactoryPublish shared:artifactoryPublish

buildscript {
  repositories {
    mavenCentral()
  }
  dependencies {
    classpath "org.jfrog.buildinfo:build-info-extractor-gradle:4.+"
  }
}
apply plugin: "com.jfrog.artifactory"

// Replace <plugin version> with the version of the Gradle Artifactory Plugin.
plugins {
  id "com.jfrog.artifactory" version "<plugin version>"
}

repositories {
        mavenCentral()
        maven {
                url "http://repo.myorg.com/artifactory/libs-releases"
                credentials {
                        username = "resolver"
                password = "resolverPaS*"
                }
        }

        ivy {
                url "http://localhost:8081/artifactory/ivy-releases"
                layout "pattern", {
                ivy "[organization]/[module]/[revision]/ivy.xml"
                artifact "[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]"
                m2compatible = true
        }
        }
}

artifactory {
  contextUrl = 'http://repo.myorg.com/artifactory'
  publish {
    contextUrl = 'http://repo.myorg.com/artifactory'
    repository {
      repoKey = 'integration-libs'
      username = 'deployer'
      password = 'deployerPaS*'
      ivy {
        ivyLayout = '[organization]/[module]/[revision]/[type]s/ivy-[revision].xml'
        artifactLayout = '[organization]/[module]/[revision]/[module]-[revision](-[classifier]).[ext]'
        mavenCompatible = true
      }
    }
    defaults {
        publications ('ivyJava','mavenJava','foo')
        publishConfigs('archives', 'published')
        properties = ['qa.level': 'basic', 'q.os': 'win32, deb, osx']
        properties {
            foo '*:*:*:*@*', platform: 'linux', 'win64'
            mavenJava 'org.jfrog:*:*:*@*', key1: 'val1'
            all 'org.jfrog:shared:1.?:*@*', key2: 'val2', key3: 'val3'
        }
        publishBuildInfo = true
        publishArtifacts = true
        publishPom = true
        publishIvy = true
    }
  }
  clientConfig.setIncludeEnvVars(true)
  clientConfig.setEnvVarsExcludePatterns('*password*,*secret*')
  clientConfig.setEnvVarsIncludePatterns('*not-secret*')
  clientConfig.info.addEnvironmentProperty('test.adding.dynVar',new java.util.Date().toString())
  clientConfig.info.setBuildName('new-strange-name')
  clientConfig.info.setBuildNumber('' + new java.util.Random(System.currentTimeMillis()).nextInt(20000))
  clientConfig.info.setProject('project-key')
  clientConfig.timeout = 600
  clientConfig.setInsecureTls(false)
}

defaults {
        publishConfigs ('a','b','foo')
        mavenDescriptor = '/home/froggy/projects/proj-a/fly-1.0.pom'
        ivyDescriptor = 'fly-1.0-ivy.xml'
        properties = ['qa.level': 'basic', 'q.os': 'win32, deb, osx']
        properties {
            foo '*:*:*:*@*', platform: 'linux', 'win64'
            archives 'org.jfrog:*:*:*@*', key1: 'val1'
            all 'org.jfrog:shared:1.?:*@*', key2: 'val2', key3: 'val3'
        }
        publishBuildInfo = true
        publishArtifacts = true
        publishPom = true
        publishIvy = false
    }

artifactoryPublish {
    skip = false
    contextUrl = 'http://repo.myorg.com/artifactory'
    publications ('a','b','c')
    properties = ['qa.level': 'basic', 'q.os': 'win32, deb, osx']
    properties {
        c '**:**:**:*@*', cProperty: 'only in c'
    }
    clientConfig.publisher.repoKey = 'integration-libs'
    clientConfig.publisher.username = 'deployer'
    clientConfig.publisher.password = 'deployerPaS'

    clientConfig.publisher.setExcludePatterns("*artifacts-to-exclude-1*,*artifacts-to-exclude-2*")
    clientConfig.publisher.setFilterExcludedArtifactsFromBuild(true)

    clientConfig.publisher.minChecksumDeploySizeKb = 10
}

artifactory {
        publish {
                contextUrl = 'http://localhost:8081/artifactory'
                repository {
                        repoKey = "libs-snapshot-local"
                        username = "user"
                        password = "pass"
                }
        }
}

./gradlew clean api:artifactoryPublish shared:artifactoryPublish

artifactory {
  ...
  clientConfig.proxy.host = 'www.somehost.org'
  clientConfig.proxy.port = '8080'
  clientConfig.proxy.username = 'userid'
  clientConfig.proxy.password = 'password'
}

systemProp.http.proxyHost=www.somehost.org
systemProp.http.proxyPort=8080
systemProp.http.proxyUser=userid
systemProp.http.proxyPassword=password