build.gradle

/*
 * Copyright 2018 LinkedIn Corp.
 * Licensed under the BSD 2-Clause License (the "License").
 * See License in the project root for license information.
 */

import java.security.MessageDigest
import java.util.regex.Pattern

buildscript {
  repositories {
    mavenLocal()
    mavenCentral()
  }
}

plugins {
  id "maven-publish"
  id "jacoco"
  id 'com.github.johnrengelman.shadow' version '5.2.0' apply false
  id 'com.github.kt3k.coveralls' version '2.12.2'
  id "org.sonarqube" version "3.0"
}

group = 'com.linkedin.avroutil1'

repositories {
  mavenLocal()
  mavenCentral()
}

//does not include "helper" as that module has its own publishing section (because fat jar)
//does not include "avro-fastserde" as that module has its own publishing section (because we want it to depend on the fat jar)
//does not include "avro-codegen" as that module has its own publishing section (because we want it to depend on the fat jar)
Set<String> projectsToPublish = new HashSet<>(Arrays.asList("spotbugs-plugin", "parser"))
Set<String> projectsToRecordGitInfoFor = new HashSet<>(projectsToPublish)
projectsToRecordGitInfoFor.add("helper")

ext {
  gitHash = "unknown"
  gitName = "unknown"
}

subprojects {

  //apply group and version to all submodules
  group = rootProject.group
  version = rootProject.version

  plugins.withType(JavaPlugin) {

    repositories {
      mavenLocal()
      mavenCentral()
    }

    dependencies {
      testImplementation "org.testng:testng:6.14.3"

      //redirect logging to log4j2 for tests
      testRuntimeOnly "org.apache.logging.log4j:log4j-core:2.17.1"
      testRuntimeOnly "org.apache.logging.log4j:log4j-slf4j-impl:2.17.1"
    }

    //maintain compatibility with java8 runtime
    compileJava {
      sourceCompatibility = '1.8'
      targetCompatibility = '1.8'
      //This flag is only supported and required when building with JDK11
      if (JavaVersion.current() >= JavaVersion.VERSION_11) {
        options.compilerArgs.addAll(['--release', '8'])
      }
    }

    test {
      useTestNG()

      testLogging {
        showStandardStreams = true
        showExceptions = true
        showStackTraces = true
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
        events "started", "passed", "skipped", "failed"
      }
    }

    assemble.dependsOn ':parseGitInfo' //make sure we have git info before packaging

    if (projectsToRecordGitInfoFor.contains(project.name)) {

      jar {

        doFirst { //for some odd reason this is needed to pick up gitHash

          //version embedding at build time
          //we create a file called __Versioning__[md5] and set its payload to contain versioning info
          //
          //the file name is not fixed, but contains an md5 hash of the project group name and version.
          //its not fixed so that if multiple libraries are repackaged (think fat/shaded jar) the versioning files
          //are unlikely to conflict or get overwritten. the md5 hash part is chosen such that builds are
          //"repeatable" - re-running the same build results in the same output. this is nice for incremental builds.
          //
          //the value contains versioning information for both this module and the entire project it was built as part of.
          //
          //this information allows us, at runtime, to determine what libraries/versions exist on a given classpath

          MessageDigest md = MessageDigest.getInstance("MD5")
          md.update(String.valueOf(project.group).getBytes("UTF-8"))
          md.update(String.valueOf(project.name).getBytes("UTF-8"))
          md.update(String.valueOf(project.version).getBytes("UTF-8"))
          byte[] digest = md.digest()
          String hash = hex(digest)

          String versioningFileName = "__Versioning__" + hash
          String versioningPayload = "{" +
              "\"format\":\"v1\"," +
              "\"project\":\"" + rootProject.group + ":" + rootProject.name + ":" + rootProject.version + "\"," +
              "\"module\":\"" + project.group + ":" + project.name + ":" + project.version + "\"," +
              "\"branch\":\"" + rootProject.gitName + "\"," +
              "\"revision\":\"" + rootProject.gitHash + "\"" +
              "}"

          String outFolder = "${project.buildDir}/resources/main/META-INF/"
          mkdir outFolder
          file("${outFolder}/${versioningFileName}").text = versioningPayload
        }

        manifest {
          //embed module names and version information
          //into jar manifests
          attributes(
                  'Name': "${project.name}",
                  'Specification-Title': "${project.name}",
                  'Specification-Version': "${project.version}",
                  'Specification-Vendor': "LinkedIn",
                  'Implementation-Title': "${project.name}",
                  'Implementation-Version': "${project.version}",
                  'Implementation-Vendor': "LinkedIn",
          )
        }
      }
    }

    task sourceJar(type: Jar) {
      from sourceSets.main.allJava
      classifier "sources"
    }

    task javadocJar(type: Jar) {
      from javadoc
      classifier = 'javadoc'
    }

    task testJar(type: Jar) {
      from sourceSets.test.allJava
      classifier = 'tests'
    }

    if (projectsToPublish.contains(project.name)) {
      publishing {
        publications {
          "$project.name"(MavenPublication) {
            groupId project.group
            artifactId project.name
            version project.version

            from components.java
            artifact sourceJar
            artifact javadocJar
            artifact testJar

            //we strive to meet https://central.sonatype.org/pages/requirements.html
            pom {
              name = 'Avro Util'
              description = 'utilities for writing code that works across major avro versions'
              url = 'https://github.com/linkedin/avro-util'

              licenses {
                license {
                  name = 'BSD 2-Clause'
                  url = 'https://raw.githubusercontent.com/linkedin/avro-util/master/LICENSE'
                }
              }
              developers {
                developer {
                  id = 'radai-rosenblatt'
                  name = 'Radai Rosenblatt'
                  email = 'radai.rosenblatt@gmail.com'
                  organization = 'LinkedIn'
                  organizationUrl = 'linkedin.com'
                }
                developer {
                  id = 'abhishekmendhekar'
                  name = 'Abhishek Mendhekar'
                  organization = 'LinkedIn'
                  organizationUrl = 'linkedin.com'
                }
                developer {
                  id = 'jimhe'
                  name = 'Jim He'
                  email = 'jimjhe@gmail.com'
                  organization = 'LinkedIn'
                  organizationUrl = 'linkedin.com'
                }
                developer {
                  id = 'ghosthack'
                  name = 'Adrian Fernandez'
                  email = 'adrian@ghosthack.com'
                  organization = 'LinkedIn'
                  organizationUrl = 'linkedin.com'
                }
              }
              scm {
                connection = 'scm:git:git://github.com:linkedin/avro-util.git'
                developerConnection = 'scm:git:ssh://github.com:linkedin/avro-util.git'
                url = 'https://github.com/linkedin/avro-util'
              }
            }
          }
        }

        repositories {
          mavenLocal()
          maven {
            name "LinkedInJfrog"
            url "https://linkedin.jfrog.io/artifactory/avro-util"
            credentials {
              if (System.getenv('JFROG_USER') != null && System.getenv('JFROG_KEY') != null) {
                username System.getenv('JFROG_USER')
                password System.getenv('JFROG_KEY')
              }
            }
          }
        }
      }
    }
  }

  plugins.withType(CheckstylePlugin) {
    checkstyle {
      toolVersion '8.25'
    }
  }

  plugins.withType(JacocoPlugin) {
    jacoco {
      toolVersion = "0.8.5"
    }

    //we dont need reports at the individual module level as we generate an aggregate
    jacocoTestReport {
      reports {
        xml.enabled false
        html.enabled false
        csv.enabled false
      }
    }
  }
}

tasks.withType(GenerateModuleMetadata) {
  //we ship helper as a fat helper-all jar, which means we modify the
  //pom.xml for most of our artifacts. gradle's now module metadata publication
  //leaks "internal" dependencies on the regular helper module (which we dont
  //publish) and causes issues. so we disable it
  enabled = false
}

//generates an aggregate coverage report for the entire project
task codeCoverageReport(type: JacocoReport) {
  executionData files()

  project.afterEvaluate {  //delay until this (parent) project is fully configured
    subprojects.each { Project subproject ->
      subproject.afterEvaluate { //delay until sub-module is fully configured (or there wont be any plugins applied)
        if (subproject.pluginManager.hasPlugin('jacoco')) {
          //add source sets from all relevant submodules
          sourceSets subproject.sourceSets.main
        }
        //exclude the generated classes from the code coverage report
        classDirectories.setFrom(files(classDirectories.files.collect {
          fileTree(dir: it, exclude: [
              "by*/*",
              "under*/*",
              "vs*/*"
          ])
        }))
      }
    }
    executionData.setFrom(fileTree(project.rootDir.absolutePath).include("**/build/jacoco/*.exec"))
  }

  reports {
    xml.enabled true
    xml.destination = new File("${buildDir}/reports/jacoco/report.xml")
    html.enabled true
    html.destination = new File("${buildDir}/reports/jacoco/html")
    csv.enabled false
  }
}

coveralls {
  jacocoReportPath "${buildDir}/reports/jacoco/report.xml"
}

//the root project doesnt have a clean task applied (?!), so we add one ourselves.
task clean {
  doLast {
    delete "${buildDir}"
  }
}

wrapper {
  gradleVersion = '7.6.1'
  distributionType = Wrapper.DistributionType.ALL
}

tasks.register("parseGitInfo") {
  group = 'Versioning'
  description = 'retrieves the current branch/tag name and git hash'

  doLast {
    def headFile = file("${rootProject.rootDir}/.git/HEAD")
    if (!headFile.exists()) {
      //we're not a git working copy
      logger.warn("${headFile} not found - this doesnt appear to be a git checkout")
      rootProject.gitHash = "unknown"
      rootProject.gitName = "unknown"
      return
    }
    def contents = headFile.text
    //.git/HEAD is either a hash (if detached head) or a ref
    def refPattern = Pattern.compile("ref:\\s+(refs/(\\w+)/(.*))\\s+\$")
    def matcher = refPattern.matcher(contents)
    if (!matcher.matches()) {
      rootProject.gitHash = contents.trim()
      rootProject.gitName = contents.trim() //use the hash as the branch name
      logger.info("git working copy is in detached head mode at revision ${gitHash}")
    } else {
      def path = matcher.group(1)
      def category = matcher.group(2)
      def name = matcher.group(3)
      def refFile = file("${rootProject.rootDir}/.git/${path}")
      if (!refFile.exists()) {
        //TODO - add support for packed-refs
        throw new IllegalStateException("unable to find ${refFile}")
      }
      rootProject.gitHash = refFile.text.trim()
      rootProject.gitName = name
      def type
      switch (category) {
        case "heads":
          type = "branch"
          break
        case "tags":
          type = "tag"
          break
        default:
          logger.warn("unknown ref folder ${category}")
          type = "unknown"
          break
      }
      logger.info("git working copy is at ${type} ${rootProject.gitName} at revision ${rootProject.gitHash}")
    }
  }
}

static String hex(byte[] bytes) {
  StringBuilder result = new StringBuilder(bytes.length * 2);
  for (byte b : bytes) {
    result.append(String.format("%02X", b));
  }
  return result.toString();
}