build.gradle

import org.apache.tools.ant.taskdefs.condition.Os
import com.bmuschko.gradle.izpack.*
import org.gradle.plugins.ide.eclipse.model.AccessRule

buildscript {
  dependencies {
    classpath 'com.bmuschko:gradle-izpack-plugin:3.0'
  }
}

plugins {
  id 'java'
  id 'application'
  id 'eclipse'
  id 'me.champeau.jmh' version '0.6.6'
  id 'com.bmuschko.izpack' version '3.2'
  id 'com.github.hierynomus.license-report' version "0.16.1"
  id "de.undercouch.download" version "4.0.0"
}

repositories {
  mavenCentral()
  maven { url 'https://jitpack.io' }
}

dependencies {

  compileOnly 'org.projectlombok:lombok:1.18.34'
  annotationProcessor 'org.projectlombok:lombok:1.18.34'
  testCompileOnly 'org.projectlombok:lombok:1.18.34'
  testAnnotationProcessor 'org.projectlombok:lombok:1.18.34'

  testImplementation 'org.junit.jupiter:junit-jupiter:5.4.2'
  testImplementation 'org.assertj:assertj-core:3.23.1'
  testImplementation 'org.mockito:mockito-core:4.7.0'
  testImplementation 'org.projectlombok:lombok:1.18.34'

  implementation 'com.google.guava:guava:24.1-jre'
  implementation 'commons-codec:commons-codec:1.6'
  implementation 'commons-io:commons-io:2.4'
  implementation 'org.apache.commons:commons-lang3:3.1'
  implementation 'org.apache.commons:commons-collections4:4.0'
  implementation 'org.xerial:sqlite-jdbc:3.7.2'
  implementation 'com.j256.ormlite:ormlite-core:4.48'
  implementation 'com.j256.ormlite:ormlite-jdbc:4.48'
  implementation 'com.google.protobuf:protobuf-java:2.6.1'
  implementation 'org.slf4j:slf4j-api:1.7.14'
  implementation 'org.slf4j:slf4j-log4j12:1.7.25'
  implementation 'com.googlecode.java-diff-utils:diffutils:1.2.1'
  implementation 'com.google.re2j:re2j:1.1'
  implementation 'com.github.mobius-software-ltd:mqtt-parser:parser-1.0.3'
  implementation 'net.arnx:jsonic:1.3.0'
  implementation 'org.json:json:20180813'
  implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-cbor:2.10.0'
  implementation 'com.fasterxml.jackson.core:jackson-databind:2.10.0'
  implementation 'org.msgpack:jackson-dataformat-msgpack:0.8.18'
  implementation 'org.bouncycastle:bcpkix-jdk15on:1.64'
  implementation 'commons-net:commons-net:3.6'
  implementation 'org.nanohttpd:nanohttpd:2.3.1'
  implementation 'com.google.code.gson:gson:2.8.6'
  implementation 'org.apache.commons:commons-math3:3.0'
  implementation 'org.jfree:jfreechart:1.5.3'
  implementation 'org.ejml:ejml-all:0.41'
  implementation 'at.favre.lib:hkdf:1.1.0'
  implementation 'org.eclipse.jetty.http2:http2-hpack:11.0.11'
  implementation 'org.eclipse.jetty.http3:http3-qpack:11.0.11'
  implementation 'com.github.docker-java:docker-java:3.3.0'
  implementation 'com.github.docker-java:docker-java-transport-httpclient5:3.3.0'
  implementation 'org.apache.commons:commons-compress:1.26.2'
  implementation 'com.github.luben:zstd-jni:1.5.6-3'
  implementation files('libs/agent15.jar')

  izpack 'org.codehaus.izpack:izpack-dist:5.1.3'

  // load additional dena modules if it exists
  ['dena/', 'denaN/', 'denaL/'].each { def dir ->
    def libs = file(dir + 'libraries.gradle')
    if (libs.exists()) {
      Eval.me(libs.text).each { def lib ->
        implementation lib
      }
    }
  }

}

downloadLicenses {
  licenses = [ 'com.github.mobius-software-ltd:mqtt-parser:parser-1.0.3' : license('GNU Lesser General Public License 2.1', 'https://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt') ]
}

tasks.withType(JavaCompile) {
  options.encoding = "UTF-8"
}

tasks.withType(Test) {
  systemProperty "file.encoding", "UTF-8"
}

test {
  useJUnitPlatform()
}

mainClassName = "packetproxy/PacketProxy"

task setVersion {
  project.ext.version = "git describe --tags --abbrev=0".execute().text.replace("\n","")
}

task createVersionFile(dependsOn: "setVersion") {
  new File("${projectDir}/src/main/resources/version").text = project.ext.version
}

task setName(dependsOn: "setVersion") {
  project.ext.nameInstaller    = "PacketProxy-${project.ext.version}-Installer.jar"
  project.ext.nameMacInstallApp = "PacketProxy-${project.ext.version}-Installer-Mac.app" 
  project.ext.nameMacRelease   = "PacketProxy-${project.ext.version}-Installer-Mac.zip" 
  project.ext.nameMacSignedReleaseJPackage = "PacketProxy-${project.ext.version}.dmg" 
  project.ext.nameMacSignedRelease = "PacketProxy-${project.ext.version}-Installer-Mac-Signed.dmg" 
  project.ext.nameWin32Release = "PacketProxy-${project.ext.version}-Installer-Win32.jar" 
  project.ext.nameWin64Release = "PacketProxy-${project.ext.version}-Installer-Win64.jar" 
  project.ext.nameLinuxReleaseDir = "PacketProxy-${project.ext.version}-Linux" 
  project.ext.nameLinuxRelease = "PacketProxy-${project.ext.version}-Linux.tar.gz" 
}

task setPath(dependsOn: "setName") {
  project.ext.pathInstaller     = "${buildDir}/distributions/${project.ext.nameInstaller}"
  project.ext.pathWorkDir       = "${buildDir}/distributions"
  // Mac
  project.ext.pathMacWorkDir    = "${buildDir}/distributions/mac"
  project.ext.pathMacTarget     = "${project.ext.pathMacWorkDir}/target"
  project.ext.pathMacInstaller  = "${project.ext.pathMacWorkDir}/${project.ext.nameInstaller}"
  project.ext.pathMacInstallApp = "${project.ext.pathMacWorkDir}/${project.ext.nameMacInstallApp}"
  project.ext.pathMacRelease    = "${project.ext.pathMacWorkDir}/${project.ext.nameMacRelease}"
  project.ext.pathMacSignedReleaseJPackage = "${project.ext.pathMacWorkDir}/${project.ext.nameMacSignedReleaseJPackage}"
  project.ext.pathMacSignedRelease = "${project.ext.pathMacWorkDir}/${project.ext.nameMacSignedRelease}"
  // Win32
  project.ext.pathWin32WorkDir   = "${buildDir}/distributions/win32"
  project.ext.pathWin32Target    = "${project.ext.pathWin32WorkDir}/target"
  project.ext.pathWin32Installer = "${project.ext.pathWin32WorkDir}/${project.ext.nameInstaller}"
  project.ext.pathWin32Release   = "${project.ext.pathWin32WorkDir}/${project.ext.nameWin32Release}"
  // Win64
  project.ext.pathWin64WorkDir   = "${buildDir}/distributions/win64"
  project.ext.pathWin64Target    = "${project.ext.pathWin64WorkDir}/target"
  project.ext.pathWin64Installer = "${project.ext.pathWin64WorkDir}/${project.ext.nameInstaller}"
  project.ext.pathWin64Release   = "${project.ext.pathWin64WorkDir}/${project.ext.nameWin64Release}"
  // Linux
  project.ext.pathLinuxWorkDir   = "${buildDir}/distributions/Linux"
  project.ext.pathLinuxTarget    = "${project.ext.pathLinuxWorkDir}/target"
  project.ext.pathLinuxInstaller = "${project.ext.pathLinuxWorkDir}/${project.ext.nameInstaller}"
  project.ext.pathLinuxReleaseDir = "${project.ext.pathLinuxWorkDir}/${project.ext.nameLinuxReleaseDir}"
  project.ext.pathLinuxRelease   = "${project.ext.pathLinuxWorkDir}/${project.ext.nameLinuxRelease}"
}

task setAppleSignInfo {
  project.ext.appleId      = "xxxx@gmail.com"
  project.ext.applePasswd  = "aaaa-bbbb-cccc-dddd"
  project.ext.signedKey    = "YOURNAME (123456ABCD)"
  project.ext.teamId       = "123456ABCD"
}

eclipse {
  classpath {
    file {
      whenMerged {
        def jre = entries.find { it.path.contains 'org.eclipse.jdt.launching.JRE_CONTAINER' }
        jre.accessRules.add(new AccessRule('accessible', 'com/**'))
        jre.accessRules.add(new AccessRule('accessible', 'sun/**'))
      }
    }
  }
}

sourceSets {
  main {
    java {
      def list = ['src/main/java/core']

      // load additional dena sources if it exists
      ['dena/', 'denaN/', 'denaL/'].each { def dir ->
        def srcs = file(dir + 'sources.gradle')
        if (srcs.exists()) {
          Eval.me(srcs.text).each { def src ->
            if (file(dir + src).exists()) {
              list << dir + src
            }
          }
        }
      }
      srcDirs = list
    }
    resources {
      def list = ['src/main/resources']
      // load additional dena resources if it exists
      ['dena/', 'denaN/', 'denaL/'].each { def dir ->
        def srcs = file(dir + 'resources.gradle')
        if (srcs.exists()) {
          Eval.me(srcs.text).each { def src ->
            if (file(dir + src).exists()) {
              list << dir + src
            }
          }
        }
      }
      srcDirs = list
    }
  }
  test {
    java {
      def list = ['src/test/java']
      // load additional dena tests if it exists
      ['dena/', 'denaN/', 'denaL/'].each { def dir ->
        def srcs = file(dir + 'tests.gradle')
        if (srcs.exists()) {
          Eval.me(srcs.text).each { def src ->
            if (file(dir + src).exists()) {
              list << dir + src
            }
          }
        }
      }
      srcDirs = list
    }
  }
}

jmh {
  fork = 2
}

jar {
  duplicatesStrategy = DuplicatesStrategy.INCLUDE
  doFirst {
    def serviceDir = file("${buildDir}/META-INF/services")
    serviceDir.deleteDir()
    serviceDir.mkdirs()
    for (file in configurations.runtimeClasspath) {
      zipTree(file).matching{ include 'META-INF/services/*' }.each { f ->
        new File(serviceDir, f.name) << f.getText("UTF-8") << "\n"
      }
    }
  }
  manifest {
    attributes (
      "Main-Class": project.mainClassName,
      "Class-Path": configurations.runtimeClasspath.collect { it.getName() }.join(' ')
    )
  }
  from {
    configurations.runtimeClasspath.collect {
      it.isDirectory() ? it : zipTree(it).matching {
        exclude "META-INF/**"
      }
    }
  }
  from {
    fileTree(buildDir).matching {
      include 'META-INF/services/*'
    }
  }
}

task prepareJPackage(dependsOn: "jar") {
  doFirst {
    def workDir = "${project.ext.pathMacWorkDir}"
    delete "${workDir}"
    new File("${workDir}").mkdirs()
    download {
      src "https://d3pxv6yz143wms.cloudfront.net/11.0.5.10.1/amazon-corretto-11.0.5.10.1-macosx-x64.tar.gz"
      dest "${workDir}/OpenJDK11.tar.gz"
    }
    copy {
      from tarTree(resources.gzip("${workDir}/OpenJDK11.tar.gz"))
      into file("${workDir}/OpenJDK11")
    }
    // create icon
    copy {
      from "${projectDir}/src/main/resources/gui/icon.png"
      into "${workDir}/icon.iconset/"
    }
    exec {
      executable "sh"
      args "-c", "mv ${workDir}/icon.iconset/icon.png ${workDir}/icon.iconset/icon_256x256.png"
    }
    exec {
      executable "sh"
      args "-c", "iconutil -c icns --output ${workDir}/icon.icns ${workDir}/icon.iconset/"
    }
  }
  onlyIf { Os.isFamily(Os.FAMILY_MAC) }
}


class CreateWinTarget extends DefaultTask {
  @Input
  String workDir = ''
  @Input
  String targetDir = ''
  @Input
  String jdkUrl = ''

  @TaskAction
  void start() {
    project.delete {
      delete "${workDir}"
    }
    new File("${workDir}").mkdirs()
    new File("${targetDir}").mkdirs()
    project.copy {
      from "${project.buildDir}/reports/license/dependency-license.html"
      from "${project.projectDir}/LICENSES"
      into "${targetDir}/licenses"
    }
    project.copy {
      from "${project.projectDir}/src/main/resources/gui/icon.ico"
      into "${targetDir}"
      rename('icon.ico', 'PacketProxy.ico')
    }
    project.copy {
      from "${project.buildDir}/libs/PacketProxy.jar"
      into "${targetDir}"
    }
    project.download {
      src "${jdkUrl}"
      dest "${workDir}/OpenJDK11.zip"
    }
    project.copy {
      from project.zipTree("${workDir}/OpenJDK11.zip")
      into project.file("${workDir}/OpenJDK11")
    }
    project.copy {
      from project.file("${workDir}/OpenJDK11/jdk11.0.5_10")
      into project.file("${targetDir}/OpenJDK11")
    }
  }
}

task createWin64Target(type: CreateWinTarget, dependsOn: ['jar', 'downloadLicenses']) {
  workDir   = project.ext.pathWin64WorkDir
  targetDir = project.ext.pathWin64Target
  jdkUrl    = 'https://d3pxv6yz143wms.cloudfront.net/11.0.5.10.1/amazon-corretto-11.0.5.10.1-windows-x64.zip'
}

task createLinuxTarget(dependsOn: ['jar', 'downloadLicenses']) {
  doFirst {
    def workDir   = project.ext.pathLinuxWorkDir
    def targetDir = project.ext.pathLinuxTarget
    def jdkUrl    = 'https://corretto.aws/downloads/resources/11.0.8.10.1/amazon-corretto-11.0.8.10.1-linux-x64.tar.gz'

    delete {
      delete "${workDir}"
    }
    new File("${workDir}").mkdirs()
    new File("${targetDir}").mkdirs()
    copy {
      from "${project.buildDir}/reports/license/dependency-license.html"
      from "${project.projectDir}/LICENSES"
      into "${targetDir}/share/packetproxy/licenses"
    }
    copy {
      from "${project.projectDir}/src/main/resources/gui/icon.ico"
      into "${targetDir}/share/packetproxy"
      rename('icon.ico', 'PacketProxy.ico')
    }
    copy {
      from "${project.buildDir}/libs/PacketProxy.jar"
      into "${targetDir}/share/packetproxy"
    }
    download {
      src "${jdkUrl}"
      dest "${workDir}/OpenJDK11.tar.gz"
    }
    copy {
      from tarTree(resources.gzip("${workDir}/OpenJDK11.tar.gz"))
      into file("${workDir}/OpenJDK11")
    }
    copy {
      from file("${workDir}/OpenJDK11/amazon-corretto-11.0.8.10.1-linux-x64")
      into file("${targetDir}/share/packetproxy/OpenJDK11")
    }
    copy {
      from "${projectDir}/installer/izpack/packetproxy"
      into "${targetDir}/bin/"
    }
  }
}

task preIzpack {
  doFirst {
    copy {
      from "${projectDir}/installer/izpack/shortcutSpec.xml"
      into "${project.ext.pathWorkDir}"
    }
    copy {
      from "${projectDir}/src/main/resources/gui/installer_leftside_image.png"
      into "${project.ext.pathWorkDir}"
    }
    copy {
      from "${projectDir}/src/main/resources/gui/installer_icon.png"
      into "${project.ext.pathWorkDir}"
    }
  }
}

task izpackWin64 (type: CreateInstallerTask, dependsOn: ['createWin64Target', 'preIzpack']) {
  baseDir = file(project.ext.pathWin64Target)
  installFile = file("${projectDir}/installer/izpack/installer.xml")
  outputFile = file(project.ext.pathWin64Installer)
  compression = 'deflate'
  compressionLevel = 9
  appProperties = ['app.group': 'PacketProxy', 'app.name': 'PacketProxy', 'app.title': 'PacketProxy',
                   'app.version': project.ext.version, 'app.subpath': "PacketProxy-${project.ext.version}"]
}

task izpackLinux (type: CreateInstallerTask, dependsOn: ['createLinuxTarget', 'preIzpack']) {
  baseDir = file(project.ext.pathLinuxTarget)
  installFile = file("${projectDir}/installer/izpack/installer.xml")
  outputFile = file(project.ext.pathLinuxInstaller)
  compression = 'deflate'
  compressionLevel = 9
  appProperties = ['app.group': 'PacketProxy', 'app.name': 'PacketProxy', 'app.title': 'PacketProxy',
                   'app.version': project.ext.version, 'app.subpath': "PacketProxy-${project.ext.version}"]
}

task createMacJPackage(type: Exec, dependsOn: "prepareJPackage") {
  workingDir "${projectDir}"
  commandLine = [
    "/Library/Java/JavaVirtualMachines/jdk-15.jdk/Contents/Home/bin/jpackage",
    "--verbose",
    "-d", "${project.ext.pathMacWorkDir}",
    "-n", "PacketProxy",
    "-i", "${buildDir}/libs/",
    "--app-version", project.ext.version,
    "--icon", "${project.ext.pathMacWorkDir}/icon.icns",
    "--main-jar", "PacketProxy.jar",
    "--mac-sign",
    "--mac-signing-key-user-name", "${project.ext.signedKey}"
  ]
  onlyIf { Os.isFamily(Os.FAMILY_MAC) }
}

task resignMacJPackage(dependsOn: "createMacJPackage") {
  doFirst {
    exec {
      executable "sh"
      args "-c", "hdiutil convert ${pathMacSignedReleaseJPackage} -format UDRW -o ${project.ext.pathMacWorkDir}/tmp.dmg"
    }
    exec {
      executable "sh"
      args "-c", "hdiutil mount ${project.ext.pathMacWorkDir}/tmp.dmg"
    }
    exec {
      executable "sh"
      args "-c", "rm -rf /tmp/packetproxy; mkdir /tmp/packetproxy; cd /tmp/packetproxy; jar xvf /Volumes/PacketProxy/PacketProxy.app/Contents/app/PacketProxy.jar"
    }
    exec {
      executable "sh"
      args "-c", "cd /tmp/packetproxy/native; for i in \$(find . -type f); do if file \$i | grep Mach-O > /dev/null; then codesign -fv --options=runtime --deep -s \"${project.ext.signedKey}\" \$i; fi; done"
    }
    exec {
      executable "sh"
      args "-c", "cd /tmp/packetproxy; jar cvfm /Volumes/PacketProxy/PacketProxy.app/Contents/app/hoge.jar META-INF/MANIFEST.MF *"
    }
    exec {
      executable "sh"
      args "-c", "mv /Volumes/PacketProxy/PacketProxy.app/Contents/app/hoge.jar /Volumes/PacketProxy/PacketProxy.app/Contents/app/PacketProxy.jar"
    }
    exec {
      executable "sh"
      args "-c", "cd /Volumes/PacketProxy/PacketProxy.app/Contents/; for i in \$(find . -type f); do if file \$i | grep Mach-O > /dev/null; then codesign -fv --options=runtime --deep -s \"${project.ext.signedKey}\" \$i; fi; done"
    }
    exec {
      executable "sh"
      args "-c", "cd /Volumes/PacketProxy; codesign -fv --options=runtime --deep -s \"${project.ext.signedKey}\" --entitlements ${projectDir}/assets/resign/entitlements.xml PacketProxy.app"
    }
    exec {
      executable "sh"
      args "-c", "hdiutil detach /Volumes/PacketProxy"
    }
    exec {
      executable "sh"
      args "-c", "rm ${pathMacSignedReleaseJPackage}; hdiutil convert ${project.ext.pathMacWorkDir}/tmp.dmg -format UDZO -o ${pathMacSignedReleaseJPackage}"
    }
  }
  onlyIf { Os.isFamily(Os.FAMILY_MAC) }
}

task createMacInstaller(type: Exec, dependsOn: "resignMacJPackage") {
  workingDir "${projectDir}"
  commandLine = [
    "mv", project.ext.pathMacSignedReleaseJPackage, project.ext.pathMacSignedRelease
  ]
  onlyIf { Os.isFamily(Os.FAMILY_MAC) }
}

task notaryMacInstaller(type: Exec) {
  workingDir "${projectDir}"
  commandLine = [
    "xcrun", "notarytool", "submit", "${project.ext.pathMacSignedRelease}",
    "--apple-id", "${project.ext.appleId}",
    "--password", "${project.ext.applePasswd}",
    "--team-id", "${project.ext.teamId}",
    "--wait"
  ]
  onlyIf { Os.isFamily(Os.FAMILY_MAC) }
}

task createWin64Release(type: Copy, dependsOn: 'izpackWin64') {
  from "${project.ext.pathWin64Installer}"
  into "${project.ext.pathWin64WorkDir}"
  rename("${project.ext.nameInstaller}", "${project.ext.nameWin64Release}")
}

task createLinuxInstaller(type: Copy, dependsOn: 'izpackLinux') {
  from "${project.ext.pathLinuxInstaller}"
  into "${project.ext.pathLinuxWorkDir}"
  rename("${project.ext.nameInstaller}", "${project.ext.nameLinuxRelease}")
}

task createMacRelease(dependsOn: 'createMacInstaller') {
  /* do nothing */
}

task createWinRelease(dependsOn: 'createWin64Release') {
  /* do nothing */
}

task createLinuxRelease(dependsOn: 'createLinuxInstaller') {
  doFirst {
    exec {
      executable "sh"
      args "-c", "mkdir ${project.ext.pathLinuxReleaseDir}"
    }
    copy {
      from "${projectDir}/installer/izpack/installer.sh"
      from "${project.ext.pathLinuxInstaller}"
      into "${project.ext.pathLinuxReleaseDir}"
    }
    exec {
      executable "sh"
      args "-c", "cd ${project.ext.pathLinuxWorkDir}; tar czvf ${project.ext.nameLinuxRelease} ${project.ext.nameLinuxReleaseDir}"
    }
  }
}

task release(dependsOn: ['createMacRelease', 'createWinRelease', 'createLinuxRelease']) {
}