build.openfire-plugin.gradle

import org.apache.tools.ant.filters.ReplaceTokens

import java.time.Duration
import java.time.Instant

repositories {
    mavenCentral()
    maven {
        url = 'https://maven.atlassian.com/repository/public'
    }
    maven {
        url = 'https://igniterealtime.org/archiva/repository/maven/'
    }
}

configurations {
    jspc
}

dependencies {
    compileOnly "org.igniterealtime.openfire:xmppserver:${minOpenfireVersion}"
    testImplementation "org.igniterealtime.openfire:xmppserver:${minOpenfireVersion}"
    jspc 'org.apache.ant:ant:1.10.15'
}

def canonicalName = project.name.replaceAll('\\W', '').toLowerCase()

tasks.register('confirmChangeLog') {
    group = 'verification'
    description = 'Checks the changelog contains the current date - but only if this is not a SNAPSHOT version'
    def changelog = new File('src/plugin/changelog.html')
    inputs.file(changelog)
    def expectedDate = new Date().format("MMMM d, yyyy")
    doFirst {
        if (!changelog.text.contains(expectedDate)) {
            throw new Exception("The changelog at ${changelog} does not contain todays date (${expectedDate}) - remember to update it!")
        }
    }
}
tasks.confirmChangeLog.onlyIf { !(project.version as String).contains("SNAPSHOT") }
tasks.check.dependsOn tasks.confirmChangeLog

tasks.register('jspcLoggingProperties', WriteProperties) {
    destinationFile = file("${layout.buildDirectory.get()}/jspc-log4j/log4j2.properties")
    property('appender.console.type', 'Console')
    property('appender.console.name', 'STDOUT')
    property('appender.console.layout.type', 'PatternLayout')
    property('appender.console.layout.pattern', '%m%n')
}

def jspCompile(File srcDir, File destDir, File mergedWebXml, String javaPackage) {
    def xmlFragment = file("${destDir}/web.xml.fragment")
    // Create the target WEB-INF folder so the JspC can create the web.xml.partial
    xmlFragment.getParentFile().mkdirs()
    providers.javaexec {
        classpath = files(
                sourceSets.main.compileClasspath,
                tasks.jspcLoggingProperties.destinationFile.getAsFile().get().parent,
                configurations.jspc
        )
        mainClass = 'org.apache.jasper.JspC'
        args = ['-webapp', srcDir.absolutePath,
                '-d', file("${destDir}/java").absolutePath,
                '-p', javaPackage,
                '-failFast',
                '-l',
                '-die',
                '-source', java.sourceCompatibility.toString(),
                '-target', java.targetCompatibility.toString(),
                '-webxmlencoding', 'UTF-8',
                '-webinc', xmlFragment.absolutePath
        ]
    }
    def webXmlOriginal = file("${srcDir}/WEB-INF/web.xml")
    if (webXmlOriginal.exists() && xmlFragment.exists()) {
        // Merge the partial XML with the original
        String originalXML = webXmlOriginal.text
        String xmlToMerge = xmlFragment.text
        String mergedXML = originalXML.replaceFirst('(?s)(<web-app.*?>)', '$1' + xmlToMerge)
        mergedWebXml.text = mergedXML
    }
}

tasks.register('jspcAdmin') {
    dependsOn jspcLoggingProperties
    ext.inputDir = file('src/main/webapp-admin')
    ext.outputDir = file("${layout.buildDirectory.get()}/generated/sources/jsp-admin")
    ext.webXml = file("${outputDir}/web.xml")
    inputs.dir inputDir
    outputs.dir outputDir
    doFirst {
        jspCompile(inputDir as File, outputDir as File, webXml as File,
                "org.jivesoftware.openfire.plugin.${canonicalName}.jsp.admin")
    }
}
tasks.jspcAdmin.onlyIf { !tasks.jspcAdmin.inputs.files.empty }
tasks.compileJava.dependsOn tasks.jspcAdmin
sourceSets.main.java.srcDirs file("${jspcAdmin.outputDir}/java").absolutePath

tasks.register('jspcClient') {
    dependsOn jspcLoggingProperties
    ext.inputDir = file('src/main/webapp-client')
    ext.outputDir = file("${layout.buildDirectory.get()}/generated/sources/jsp-client")
    ext.webXml = file("${outputDir}/web.xml")
    inputs.dir inputDir
    outputs.dir outputDir
    doFirst {
        jspCompile(inputDir as File, outputDir as File, webXml as File,
                "org.jivesoftware.openfire.plugin.${canonicalName}.jsp.client")
    }
}
tasks.jspcClient.onlyIf { !tasks.jspcClient.inputs.files.empty }
tasks.compileJava.dependsOn tasks.jspcClient
sourceSets.main.java.srcDirs file("${jspcClient.outputDir}/java").absolutePath

tasks.sourcesJar.dependsOn jspcAdmin, jspcClient

tasks.register('openfirePluginAssembly', Jar) {
    dependsOn jar
    dependsOn configurations.runtimeClasspath
    group = 'build'
    description = 'Assembles the Openfire-specific plugin JAR file'
    mustRunAfter(tasks.confirmChangeLog)
    archiveClassifier.set 'openfire-plugin-assembly'

    from(jar.archiveFile) {
        into 'lib'
    }
    from(configurations.runtimeClasspath) {
        into 'lib'
    }
    from('src/main/resources') {
        into 'classes'
    }
    from('src/plugin') {
        filesMatching('plugin.xml') {
            filter(ReplaceTokens, tokens: [
                    name              : pluginName,
                    description       : pluginDescription,
                    version           : version,
                    releaseDate       : new Date().format("yyyy-MM-dd"),
                    minOpenfireVersion: minOpenfireVersion,
                    javaVersion       : java.toolchain.languageVersion.get().toString()
            ])
        }
    }
    from('src/main/webapp-admin') {
        into 'web'
        exclude('**/*.jsp*')
        exclude('**/*.tld')
        exclude('WEB-INF/web.xml')
    }
    from(tasks.jspcAdmin.webXml as File) {
        into 'web/WEB-INF'
    }
    from('src/main/webapp-client') {
        into 'web-client'
        exclude('**/*.jsp*')
        exclude('**/*.tld')
        exclude('WEB-INF/web.xml')
    }
    from(tasks.jspcClient.webXml as File) {
        into 'web-client/WEB-INF'
    }
}
assemble.dependsOn(openfirePluginAssembly)

// Runtime resources are added to the WAR file by openfirePluginAssembly, so skip that stage
tasks.processResources.enabled = false
// But ensure runtime resources are added to the test runtime
sourceSets.test.resources.srcDir 'src/main/resources'

tasks.register('deleteOldPluginInOpenfire', Delete) {
    group = 'deploy'
    description = 'Deletes the current plugin JAR file in the Openfire plugins directory. ' +
            'Requires the OPENFIRE_HOME environment variable to bet set appropriately.'
    doFirst {
        checkOpenfireHomeExists()
        def pluginDir = new File("${System.getenv('OPENFIRE_HOME')}/plugins")
        if (!pluginDir.exists() || !pluginDir.isDirectory()) {
            throw new Exception('Unable to deploy; OPENFIRE_HOME is not set to an Openfire folder')
        }
    }
    delete "${System.getenv('OPENFIRE_HOME')}/plugins/${canonicalName}.jar"
}

static def checkOpenfireHomeExists() {
    if (System.getenv('OPENFIRE_HOME') == null) {
        throw new Exception('Unable to delete existing plugin JAR file; OPENFIRE_HOME environment variable is not set (remember to gradlew --stop)')
    }
}

tasks.register('waitForOpenfireToUnloadPlugin') {
    dependsOn deleteOldPluginInOpenfire
    group = 'deploy'
    description = 'Waits for Openfire to unload the current plugin. Note that the Jetty bug at ' +
            'https://github.com/eclipse/jetty.project/issues/1425 means plugins cannot always be unloaded without restarting Openfire.'
    doFirst {
        checkOpenfireHomeExists()
        def startTime = Instant.now()
        def pluginFolder = new File("${System.getenv('OPENFIRE_HOME')}/plugins/${canonicalName}")
        print "Waiting for Openfire to unload old ${canonicalName}.jar "
        while (pluginFolder.exists() && (startTime + Duration.ofMinutes(1)) > Instant.now()) {
            print '.'
            sleep(1000)
        }
        if (pluginFolder.exists()) {
            throw new Exception('Timeout waiting for Openfire to unload old plugin; either Openfire is not running or the plugin cannot unload cleanly')
        } else {
            println(' unloaded')
        }
    }
}
tasks.waitForOpenfireToUnloadPlugin.mustRunAfter(tasks.check)

tasks.register('copyNewPlugin', Copy) {
    dependsOn openfirePluginAssembly, waitForOpenfireToUnloadPlugin
    group = 'deploy'
    description = "Copies the plugin to the Openfire plugins directory."
    from openfirePluginAssembly.archiveFile
    into "${System.getenv('OPENFIRE_HOME')}/plugins"
    rename ".*", "${canonicalName}.jar"
    doFirst {
        checkOpenfireHomeExists()
    }
}

tasks.register('deploy') {
    dependsOn copyNewPlugin
    group = 'deploy'
    description = 'Waits for Openfire to load the new plugin.'
    doFirst {
        checkOpenfireHomeExists()
        def startTime = Instant.now()
        def pluginFolder = new File("${System.getenv('OPENFIRE_HOME')}/plugins/${canonicalName}")
        print "Waiting for Openfire to install new ${canonicalName}.jar "
        while (!pluginFolder.exists() && (startTime + Duration.ofMinutes(1)) > Instant.now()) {
            print '.'
            sleep(1000)
        }
        if (!pluginFolder.exists()) {
            throw new Exception('Timeout waiting for Openfire to install the plugin; either Openfire is not running or the plugin cannot be installed')
        } else {
            println(' installed')
        }
    }
}

publishing {
    publications {
        plugin(MavenPublication) {
            from components.java
            artifact openfirePluginAssembly
            pom {
                groupId = 'org.igniterealtime.openfire.plugins'
                artifactId = canonicalName
                name = pluginName
                description = pluginDescription
                url = 'https://igniterealtime.org/projects/openfire/plugin-archive.jsp?plugin=' + project.name
            }
        }
    }
    repositories {

        maven {
            credentials {
                username = System.getenv("IGNITE_REALTIME_MAVEN_USERNAME")
                password = System.getenv("IGNITE_REALTIME_MAVEN_PASSWORD")
            }
            url = 'https://igniterealtime.org/archiva/repository/maven/'
        }
    }
}
tasks.publish.dependsOn check