418 lines
16 KiB
Groovy
418 lines
16 KiB
Groovy
import static org.gradle.internal.logging.text.StyledTextOutput.Style
|
|
|
|
import org.apereo.cas.metadata.*
|
|
import org.gradle.internal.logging.text.*
|
|
|
|
import groovy.json.*
|
|
import groovy.time.*
|
|
|
|
import java.nio.file.*
|
|
import java.util.*
|
|
import java.security.*
|
|
|
|
buildscript {
|
|
repositories {
|
|
mavenLocal()
|
|
mavenCentral()
|
|
gradlePluginPortal()
|
|
maven {
|
|
url 'https://oss.sonatype.org/content/repositories/snapshots'
|
|
mavenContent { snapshotsOnly() }
|
|
}
|
|
maven {
|
|
url "https://repo.spring.io/milestone"
|
|
mavenContent { releasesOnly() }
|
|
}
|
|
}
|
|
dependencies {
|
|
classpath "org.apache.ivy:ivy:${project.ivyVersion}"
|
|
classpath "org.apereo.cas:cas-server-core-configuration-metadata-repository:${project.'cas.version'}"
|
|
}
|
|
}
|
|
apply plugin: "de.undercouch.download"
|
|
|
|
task run(group: "build", description: "Run the CAS web application in embedded container mode") {
|
|
dependsOn 'build'
|
|
doLast {
|
|
def casRunArgs = Arrays.asList("-server -noverify -Xmx2048M -XX:+TieredCompilation -XX:TieredStopAtLevel=1".split(" "))
|
|
project.javaexec {
|
|
jvmArgs = casRunArgs
|
|
classpath = project.files("build/libs/cas.war")
|
|
systemProperties = System.properties
|
|
logger.info "Started ${commandLine}"
|
|
}
|
|
}
|
|
}
|
|
|
|
task setExecutable(group: "CAS", description: "Configure the project to run in executable mode") {
|
|
doFirst {
|
|
project.setProperty("executable", "true")
|
|
logger.info "Configuring the project as executable"
|
|
}
|
|
}
|
|
|
|
task executable(type: Exec, group: "CAS", description: "Run the CAS web application in standalone executable mode") {
|
|
dependsOn setExecutable, 'build'
|
|
doFirst {
|
|
workingDir "."
|
|
if (!Os.isFamily(Os.FAMILY_WINDOWS)) {
|
|
commandLine "chmod", "+x", bootWar.archivePath
|
|
}
|
|
logger.info "Running ${bootWar.archivePath}"
|
|
commandLine bootWar.archivePath
|
|
}
|
|
}
|
|
|
|
|
|
task debug(group: "CAS", description: "Debug the CAS web application in embedded mode on port 5005") {
|
|
dependsOn 'build'
|
|
doLast {
|
|
logger.info "Debugging process is started in a suspended state, listening on port 5005."
|
|
def casArgs = Arrays.asList("-Xmx2048M".split(" "))
|
|
project.javaexec {
|
|
jvmArgs = casArgs
|
|
debug = true
|
|
classpath = project.files("build/libs/cas.war")
|
|
systemProperties = System.properties
|
|
logger.info "Started ${commandLine}"
|
|
}
|
|
}
|
|
}
|
|
|
|
task showConfiguration(group: "CAS", description: "Show configurations for each dependency, etc") {
|
|
doLast() {
|
|
def cfg = project.hasProperty("configuration") ? project.property("configuration") : "compile"
|
|
configurations.getByName(cfg).each { println it }
|
|
}
|
|
}
|
|
|
|
task allDependenciesInsight(group: "build", type: DependencyInsightReportTask, description: "Produce insight information for all dependencies") {}
|
|
|
|
task allDependencies(group: "build", type: DependencyReportTask, description: "Display a graph of all project dependencies") {}
|
|
|
|
task casVersion(group: "CAS", description: "Display the current CAS version") {
|
|
doFirst {
|
|
def verbose = project.hasProperty("verbose") && Boolean.valueOf(project.getProperty("verbose"))
|
|
if (verbose) {
|
|
def out = services.get(StyledTextOutputFactory).create("CAS")
|
|
println "******************************************************************"
|
|
out.withStyle(Style.Info).println "Apereo CAS ${project.version}"
|
|
out.withStyle(Style.Description).println "Enterprise Single SignOn for all earthlings and beyond"
|
|
out.withStyle(Style.SuccessHeader).println "- GitHub: "
|
|
out.withStyle(Style.Success).println "https://github.com/apereo/cas"
|
|
out.withStyle(Style.SuccessHeader).println "- Docs: "
|
|
out.withStyle(Style.Success).println "https://apereo.github.io/cas"
|
|
out.withStyle(Style.SuccessHeader).println "- Blog: "
|
|
out.withStyle(Style.Success).println "https://apereo.github.io"
|
|
println "******************************************************************"
|
|
} else {
|
|
println project.version
|
|
}
|
|
}
|
|
}
|
|
|
|
task springBootVersion(description: "Display current Spring Boot version") {
|
|
doLast {
|
|
println rootProject.springBootVersion
|
|
}
|
|
}
|
|
|
|
task zip(type: Zip) {
|
|
from projectDir
|
|
exclude '**/.idea/**', '.gradle', 'tmp', '.git', '**/build/**', '**/bin/**', '**/out/**', '**/.settings/**'
|
|
destinationDirectory = buildDir
|
|
archiveFileName = "${project.name}.zip"
|
|
def zipFile = new File("${buildDir}/${archiveFileName}")
|
|
doLast {
|
|
if (zipFile.exists()) {
|
|
println "Zip archive is available at ${zipFile.absolutePath}"
|
|
}
|
|
}
|
|
}
|
|
|
|
task createKeystore(group: "CAS", description: "Create CAS keystore") {
|
|
def dn = "CN=cas.example.org,OU=Example,OU=Org,C=US"
|
|
if (project.hasProperty("certificateDn")) {
|
|
dn = project.getProperty("certificateDn")
|
|
}
|
|
def subjectAltName = "dns:example.org,dns:localhost,ip:127.0.0.1"
|
|
if (project.hasProperty("certificateSubAltName")) {
|
|
subjectAltName = project.getProperty("certificateSubAltName")
|
|
}
|
|
|
|
doFirst {
|
|
def certDir = project.getProperty("certDir")
|
|
def serverKeyStore = project.getProperty("serverKeystore")
|
|
def exportedServerCert = project.getProperty("exportedServerCert")
|
|
def storeType = project.getProperty("storeType")
|
|
def keystorePath = "$certDir/$serverKeyStore"
|
|
def serverCert = "$certDir/$exportedServerCert"
|
|
|
|
mkdir certDir
|
|
// this will fail if thekeystore exists and has cert with cas alias already (so delete if you want to recreate)
|
|
logger.info "Generating keystore for CAS with DN ${dn}"
|
|
exec {
|
|
workingDir "."
|
|
commandLine "keytool", "-genkeypair", "-alias", "cas",
|
|
"-keyalg", "RSA",
|
|
"-keypass", "changeit", "-storepass", "changeit",
|
|
"-keystore", keystorePath,
|
|
"-dname", dn, "-ext", "SAN=${subjectAltName}",
|
|
"-storetype", storeType
|
|
}
|
|
logger.info "Exporting cert from keystore..."
|
|
exec {
|
|
workingDir "."
|
|
commandLine "keytool", "-exportcert", "-alias", "cas",
|
|
"-storepass", "changeit", "-keystore", keystorePath,
|
|
"-file", serverCert
|
|
}
|
|
logger.info "Import $serverCert into your Java truststore (\$JAVA_HOME/lib/security/cacerts)"
|
|
}
|
|
}
|
|
|
|
task unzipWAR(type: Copy, group: "CAS", description: "Explodes the CAS web application archive") {
|
|
dependsOn 'build'
|
|
def destination = "${buildDir}/app"
|
|
|
|
from zipTree("build/libs/cas.war")
|
|
into "${destination}"
|
|
doLast {
|
|
println "Unzipped WAR into ${destination}"
|
|
}
|
|
}
|
|
|
|
task verifyRequiredJavaVersion {
|
|
def currentVersion = org.gradle.api.JavaVersion.current()
|
|
logger.info "Checking current Java version ${currentVersion} for required Java version ${project.targetCompatibility}"
|
|
if (!currentVersion.name.equalsIgnoreCase("${project.targetCompatibility}")) {
|
|
logger.warn("Careful: Current Java version ${currentVersion} does not match required Java version ${project.targetCompatibility}")
|
|
}
|
|
}
|
|
|
|
task copyCasConfiguration(type: Copy, group: "CAS",
|
|
description: "Copy the CAS configuration from this project to /etc/cas/config") {
|
|
from "etc/cas/config"
|
|
into new File('/etc/cas/config').absolutePath
|
|
doFirst {
|
|
new File('/etc/cas/config').mkdirs()
|
|
}
|
|
}
|
|
|
|
|
|
def tomcatDirectory = "${buildDir}/apache-tomcat-${tomcatVersion}"
|
|
project.ext."tomcatDirectory" = tomcatDirectory
|
|
|
|
def explodedDir = "${buildDir}/app"
|
|
def explodedResourcesDir = "${buildDir}/cas-resources"
|
|
|
|
def resourcesJarName = "cas-server-webapp-resources"
|
|
def templateViewsJarName = "cas-server-support-thymeleaf"
|
|
|
|
task unzip(type: Copy, group: "CAS", description: "Explodes the CAS archive and resources jar from the CAS web application archive") {
|
|
dependsOn unzipWAR
|
|
from zipTree("${explodedDir}/WEB-INF/lib/${templateViewsJarName}-${project.'cas.version'}.jar")
|
|
into explodedResourcesDir
|
|
|
|
from zipTree("${explodedDir}/WEB-INF/lib/${resourcesJarName}-${project.'cas.version'}.jar")
|
|
into explodedResourcesDir
|
|
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
|
|
doLast {
|
|
println "Exploded WAR resources into ${explodedResourcesDir}"
|
|
}
|
|
}
|
|
|
|
task downloadShell(group: "Shell", description: "Download CAS shell jar from snapshot or release maven repo", type: Download) {
|
|
def shellDir = project.providers.gradleProperty("shellDir").get()
|
|
def casVersion = project.providers.gradleProperty("cas.version").get()
|
|
def downloadFile
|
|
if (casVersion.contains("-SNAPSHOT")) {
|
|
def snapshotDir = "https://oss.sonatype.org/content/repositories/snapshots/org/apereo/cas/cas-server-support-shell/${casVersion}/"
|
|
def files = new org.apache.ivy.util.url.ApacheURLLister().listFiles(new URL(snapshotDir))
|
|
files = files.sort { it.path }
|
|
files.each {
|
|
if (it.path.endsWith(".jar")) {
|
|
downloadFile = it
|
|
}
|
|
}
|
|
} else {
|
|
downloadFile = "https://repo1.maven.org/maven2/org/apereo/cas/cas-server-support-shell/${casVersion}/cas-server-support-shell-${casVersion}.jar"
|
|
}
|
|
new File("${shellDir}").mkdir()
|
|
logger.info "Downloading file: ${downloadFile}"
|
|
src downloadFile
|
|
dest new File("${shellDir}", "cas-server-support-shell-${casVersion}.jar")
|
|
overwrite false
|
|
}
|
|
|
|
task runShell(group: "Shell", description: "Run the CAS shell") {
|
|
dependsOn downloadShell
|
|
def casVersion = project.providers.gradleProperty("cas.version").get()
|
|
doLast {
|
|
println "Run the following command to launch the shell:\n\tjava -jar ${project.shellDir}/cas-server-support-shell-${casVersion}.jar"
|
|
}
|
|
}
|
|
|
|
task debugShell(group: "Shell", description: "Run the CAS shell with debug options, wait for debugger on port 5005") {
|
|
dependsOn downloadShell
|
|
def casVersion = project.providers.gradleProperty("cas.version").get()
|
|
doLast {
|
|
println """
|
|
Run the following command to launch the shell:\n\t
|
|
java -Xrunjdwp:transport=dt_socket,address=5000,server=y,suspend=y -jar ${project.shellDir}/cas-server-support-shell-${casVersion}.jar
|
|
"""
|
|
}
|
|
}
|
|
|
|
task listTemplateViews(group: "CAS", description: "List all CAS views") {
|
|
dependsOn unzip
|
|
|
|
def templateViews = fileTree(explodedResourcesDir).matching {
|
|
include "**/*.html"
|
|
}
|
|
.collect {
|
|
return it.path.replace(explodedResourcesDir, "")
|
|
}
|
|
.toSorted()
|
|
|
|
doFirst {
|
|
templateViews.each { println it }
|
|
}
|
|
}
|
|
|
|
task getResource(group: "CAS", description: "Fetch a CAS resource and move it into the overlay") {
|
|
dependsOn unzip
|
|
|
|
def resourceName = project.providers.gradleProperty("resourceName").getOrNull()
|
|
def resourcesDirectory = fileTree(explodedResourcesDir)
|
|
def projectDirectory = projectDir
|
|
|
|
doFirst {
|
|
def results = resourcesDirectory.matching {
|
|
include "**/${resourceName}.*"
|
|
include "**/${resourceName}"
|
|
}
|
|
if (results.isEmpty()) {
|
|
println "No resources could be found matching ${resourceName}"
|
|
return
|
|
}
|
|
if (results.size() > 1) {
|
|
println "Multiple resources found matching ${resourceName}:\n"
|
|
results.each {
|
|
println "\t-" + it.path.replace(explodedResourcesDir, "")
|
|
}
|
|
println "\nNarrow down your search criteria and try again."
|
|
return
|
|
}
|
|
|
|
def fromFile = explodedResourcesDir
|
|
def resourcesDir = "src/main/resources"
|
|
new File(resourcesDir).mkdir()
|
|
|
|
def resourceFile = results[0].canonicalPath
|
|
def toResourceFile = new File("${projectDirectory}", resourceFile.replace(fromFile, resourcesDir))
|
|
toResourceFile.getParentFile().mkdirs()
|
|
|
|
Files.copy(Paths.get(resourceFile), Paths.get(toResourceFile.absolutePath), StandardCopyOption.REPLACE_EXISTING)
|
|
println "Copied file ${resourceFile} to ${toResourceFile}"
|
|
}
|
|
}
|
|
|
|
task createTheme(group: "CAS", description: "Create theme directory structure in the overlay") {
|
|
def theme = project.providers.gradleProperty("theme").getOrNull()
|
|
|
|
doFirst {
|
|
def builder = new FileTreeBuilder()
|
|
new File("src/main/resources/${theme}.properties").delete()
|
|
|
|
builder.src {
|
|
main {
|
|
resources {
|
|
"static" {
|
|
themes {
|
|
"${theme}" {
|
|
css {
|
|
'cas.css'('')
|
|
}
|
|
js {
|
|
'cas.js'('')
|
|
}
|
|
images {
|
|
'.ignore'('')
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
templates {
|
|
"${theme}" {
|
|
fragments {
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
"${theme}.properties"("""cas.standard.css.file=/themes/${theme}/css/cas.css
|
|
cas.standard.js.file=/themes/${theme}/js/cas.js
|
|
""")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def skipValidation = project.hasProperty("validate") && project.property("validate").equals("false")
|
|
if (!skipValidation) {
|
|
task validateConfiguration(type: Copy, group: "CAS",
|
|
description: "Validate CAS configuration") {
|
|
def file = new File("${projectDir}/src/main/resources/application.properties")
|
|
if (file.exists()) {
|
|
throw new GradleException("This overlay project is overriding a CAS-supplied configuration file at ${file.path}. "
|
|
+ "Overriding this file will disable all default CAS settings that are provided to the overlay, and "
|
|
+ "generally has unintended side-effects. It's best to move your configuration inside an application.yml "
|
|
+ "file, if you intend to keep the configuration bundled with the CAS web application. \n\nTo disable this "
|
|
+ "validation step, run the build with -Pvalidate=false.");
|
|
}
|
|
}
|
|
processResources.dependsOn(validateConfiguration)
|
|
}
|
|
|
|
task exportConfigMetadata(group: "CAS", description: "Export collection of CAS properties") {
|
|
def file = new File(project.rootDir, 'config-metadata.properties')
|
|
def queryType = ConfigurationMetadataCatalogQuery.QueryTypes.CAS
|
|
if (project.hasProperty("queryType")) {
|
|
queryType = ConfigurationMetadataCatalogQuery.QueryTypes.valueOf(project.findProperty("queryType"))
|
|
}
|
|
doLast {
|
|
file.withWriter('utf-8') { writer ->
|
|
def props = CasConfigurationMetadataCatalog.query(
|
|
ConfigurationMetadataCatalogQuery.builder()
|
|
.queryType(queryType)
|
|
.build())
|
|
.properties()
|
|
props.each { property ->
|
|
writer.writeLine("# Type: ${property.type}");
|
|
writer.writeLine("# Module: ${property.module}")
|
|
writer.writeLine("# Owner: ${property.owner}")
|
|
if (property.deprecationLevel != null) {
|
|
writer.writeLine("# This setting is deprecated with a severity level of ${property.deprecationLevel}.")
|
|
if (property.deprecationReason != null) {
|
|
writer.writeLine("# because ${property.deprecationReason}")
|
|
}
|
|
if (property.deprecationReason != null) {
|
|
writer.writeLine("# Replace with: ${property.deprecationReason}")
|
|
}
|
|
}
|
|
writer.writeLine("#")
|
|
def description = property.description.replace("\n", "\n# ").replace("\r", "")
|
|
description = org.apache.commons.text.WordUtils.wrap(description, 70, "\n# ", true)
|
|
writer.writeLine("# ${description}")
|
|
writer.writeLine("#")
|
|
writer.writeLine("# ${property.name}: ${property.defaultValue}")
|
|
writer.writeLine("")
|
|
}
|
|
}
|
|
println "Configuration metadata is available at ${file.absolutePath}"
|
|
}
|
|
}
|