nomulus/gradle/build.gradle

buildscript {
  if (project.disableDependencyLocking.toBoolean() == false) {
    // Lock buildscript dependencies.
    configurations.classpath {
      resolutionStrategy.activateDependencyLocking()
    }
  }

  dependencies {
    classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.3.3'
    classpath "net.ltgt.gradle:gradle-errorprone-plugin:0.6.1"
    classpath 'org.sonatype.aether:aether-api:1.13.1'
    classpath 'org.sonatype.aether:aether-impl:1.13.1'
  }
}

plugins {
  // Java static analysis plugins. Keep versions consistent with
  // ./buildSrc/build.gradle
  id 'nebula.lint' version '10.4.2'
  // TODO(weiminyu): consider remove net.ltgt.apt. Gradle 5.2+
  //  has similar functionalities.
  id 'net.ltgt.apt' version '0.19' apply false
  id 'net.ltgt.errorprone' version '0.6.1'
  id 'checkstyle'
  id 'com.github.johnrengelman.shadow' version '5.0.0'

  // NodeJs plugin
  id "com.moowork.node" version "1.2.0"
}

apply plugin: google.registry.gradle.plugin.ReportUploaderPlugin

reportUploader {
  // Set the location where we want to upload the build results.
  // e.g. -P uploaderDestination=gcs://domain-registry-alpha-build-result-test
  //
  // If not set - the upload will be skipped
  destination = uploaderDestination

  // The location of the file containing the OAuth2 Google Cloud credentials.
  //
  // The file can contain a Service Account key file in JSON format from the
  // Google Developers Console or a stored user credential using the format
  // supported by the Cloud SDK.
  //
  // If no file is given - the default credentials are used.
  credentialsFile = uploaderCredentialsFile

  // If set to 'yes', each file will be uploaded to GCS in a separate thread.
  // This is MUCH faster.
  multithreadedUpload = uploaderMultithreadedUpload
}

apply from: 'dependencies.gradle'

// Provide defaults for all of the project properties.

// showAllOutput: boolean.  If true, dump all test output during the build.
if (!project.hasProperty('showAllOutput')) {
  ext.showAllOutput = 'false'
}

// Only do linting if the build is successful.
gradleLint.autoLintAfterFailure = false

// Paths to main and test sources.
ext.projectRootDir = "${rootDir}/.."
ext.javaDir = "${rootDir}/../java"
ext.javatestsDir = "${rootDir}/../javatests"

// Tasks to deploy/stage all App Engine services
task deploy {
  group = 'deployment'
  description = 'Deploys all services to App Engine.'
}

task stage {
  group = 'deployment'
  description = 'Generates application directories for all services.'
}

allprojects {
  // Skip no-op project
  if (project.name == 'services') return

  repositories {
    if (rootProject.mavenUrl) {
      maven {
        println "Java dependencies: Using repo $pluginsUrl..."
        url rootProject.mavenUrl
      }
    } else {
      println "Java dependencies: Using Maven Central..."
      mavenCentral()
    }
  }
}

subprojects {
  // Skip no-op project
  if (project.name == 'services') return

  ext.createUberJar = { taskName, binaryName, mainClass ->
    project.tasks.create(
      taskName, com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar) {
      mergeServiceFiles()
      baseName = binaryName
      manifest {
        attributes 'Main-Class': mainClass
      }
      zip64 = true
      classifier = null
      version = null
      configurations = [project.configurations.runtimeClasspath]
      from project.sourceSets.main.output
      // Excludes signature files that accompany some dependency jars, like
      // bonuncycastle. If they are present, only classes from those signed jars are
      // made available to the class loader.
      // see https://discuss.gradle.org/t/signing-a-custom-gradle-plugin-thats-downloaded-by-the-build-system-from-github/1365
      exclude "META-INF/*.SF", "META-INF/*.DSA", "META-INF/*.RSA"
    }
  }

  if (rootProject.disableDependencyLocking.toBoolean() == false) {
    buildscript {
      // Lock buildscript dependencies.
      configurations.classpath {
        resolutionStrategy.activateDependencyLocking()
      }
    }
    // Lock application dependencies.
    dependencyLocking {
      lockAllConfigurations()
    }
  }

  def services = [':services:default',
                  ':services:backend',
                  ':services:tools',
                  ':services:pubapi']

  // Set up all of the deployment projects.
  if (services.contains(project.path)) {

    apply from: "${rootDir.path}/appengine_war.gradle"

    // Return early, do not apply the settings below.
    return
  }

  apply from: "${rootDir.path}/java_common.gradle"

  if (project.name == 'third_party') return

// Path to code generated with annotation processors. Note that this path is
// chosen by the 'net.ltgt.apt' plugin, and may change if IDE-specific plugins
// are applied, e.g., 'idea' or 'eclipse'
  def aptGeneratedDir = "${project.buildDir}/generated/source/apt/main"
  def aptGeneratedTestDir = "${project.buildDir}/generated/source/apt/test"

  def commonlyExcludedResources = ['**/*.java', '**/BUILD']

  sourceSets {
    main {
      java {
        srcDirs = [
            rootProject.javaDir,
            aptGeneratedDir
        ]
      }
      resources {
        srcDirs = [
            rootProject.javaDir
        ]
        exclude commonlyExcludedResources
      }
    }
    test {
      java {
        srcDirs = [
            rootProject.javatestsDir,
            aptGeneratedTestDir
        ]
      }
      resources {
        srcDirs = [
            rootProject.javatestsDir,
        ]
        exclude commonlyExcludedResources
      }
    }
  }

  test {
    testLogging.showStandardStreams = Boolean.parseBoolean(showAllOutput)
  }

  if (project.name == 'core') return

  ext.relativePath = "google/registry/${project.name}"

  sourceSets.each {
    it.java {
      include "${project.relativePath}/"
    }
    it.resources {
      include "${project.relativePath}/"
    }
  }
  project(':core').sourceSets.each {
    it.java {
      exclude "${project.relativePath}/"
    }
    it.resources {
      exclude "${project.relativePath}/"
    }
  }
}