linux.gradle

/*
 * Copyright 2024 Thoughtworks, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import com.thoughtworks.go.build.Architecture
import com.thoughtworks.go.build.InstallerMetadataTask
import com.thoughtworks.go.build.InstallerType
import groovy.json.JsonOutput
import org.apache.commons.codec.digest.DigestUtils
import org.apache.tools.ant.filters.ConcatFilter

enum PackageType {

  deb {
    // Debian packages allow either most recent or minimum Java version in dependencies because
    // Java 21 was not available on Debian releases despite it being preferred, although was available for Ubuntu.
    String jreDependency(Project project) {
      "openjdk-${project.packagedJavaVersion.feature}-jre-headless | openjdk-${project.targetJavaVersion}-jre-headless"
    }

    String jreBinaryLocator(Project project) {
      // Find the most recent version that was installed
      """ls /usr/lib/jvm/java-${project.packagedJavaVersion.feature}-openjdk-\$(dpkg --print-architecture)/bin/java \
            /usr/lib/jvm/java-${project.targetJavaVersion}-openjdk-\$(dpkg --print-architecture)/bin/java \
         2>/dev/null | tail -1"""
    }

    List<String> configureFpm(Project project, File buildRoot, InstallerType installerType) {
      List<String> fpmArgs = []
      fpmArgs += ['-t', 'deb']
      fpmArgs += ['--deb-no-default-config-files']

      // for basic stuff like `ls`, `id`
      fpmArgs += ['--depends', 'coreutils']

      // for `ps`
      fpmArgs += ['--depends', 'procps']

      fpmArgs += ['--depends', jreDependency(project)]

      // HACK: for debian packages :(, since manifests cannot contain fine grained ownership
      def tmpDir = project.file("${project.buildDir}/tmp")
      tmpDir.mkdirs()

      File dirPermissons = File.createTempFile("dirPermissions-", ".json", tmpDir)
      File filePermissions = File.createTempFile("filePermissions-", ".json", tmpDir)

      fpmArgs += ['--template-value', "dir_permissions=${dirPermissons}"]
      fpmArgs += ['--template-value', "file_permissions=${filePermissions}"]

      dirPermissons.write(JsonOutput.toJson(installerType.directories))
      filePermissions.write(JsonOutput.toJson(installerType.configFiles))
      return fpmArgs
    }
  },
  rpm {
    String jreDependency(Project project) {
      "java-${project.packagedJavaVersion.feature}-openjdk-headless"
    }

    String jreBinaryLocator(Project project) {
      "echo \"/etc/alternatives/jre_${project.packagedJavaVersion.feature}/bin/java\""
    }

    List<String> configureFpm(Project project, File buildRoot, InstallerType installerType) {
      List<String> fpmArgs = []

      fpmArgs += ['-t', 'rpm']
      fpmArgs += ['--rpm-os', 'linux'] // allows running fpm on osx

      // for basic stuff like `ls`, `id`
      fpmArgs += ['--depends', 'coreutils']

      // for `ps`
      fpmArgs += ['--depends', 'procps']

      fpmArgs += ['--depends', jreDependency(project)]

      fpmArgs += ['--rpm-defattrfile', '0444']
      fpmArgs += ['--rpm-defattrdir', '0755']

      installerType.directories.each {
        dirName, permissions ->
          if (permissions.ownedByPackage) {
            fpmArgs += ['--rpm-attr', "${Integer.toOctalString(permissions.mode)},${permissions.owner},${permissions.group}:${dirName}"]
          }
      }

      project.fileTree(buildRoot).files.forEach({ File eachFile ->
        if (eachFile.canExecute()) {
          def relativePath = buildRoot.toURI().relativize(eachFile.toURI()).getPath()
          fpmArgs += ['--rpm-attr', "0755,root,root:/${relativePath}"]
        }
      })

      installerType.configFiles.each {
        fileName, permissions ->
          // set ownership and mode on the rpm manifest
          fpmArgs += ['--rpm-attr', "${Integer.toOctalString(permissions.mode)},${permissions.owner},${permissions.group}:${fileName}"]
      }

      return fpmArgs

    }
  }

  /**
   * @return POSIX shell script that will find a path to the optimal JRE java binary for the relevant package
   */
  abstract jreBinaryLocator(Project project)
  abstract List<String> configureFpm(Project project, File buildRoot, InstallerType installerType)
}

private File destFile(String url) {
  new File(gradle.gradleUserHomeDir, "download-cache/${DigestUtils.md5Hex(url)}/${new File(new URL(url).path).name}")
}

def configureLinuxPackage(DefaultTask packageTask, InstallerType installerType, PackageType packageType, File buildRoot, Configuration configuration, File destDir) {
  packageTask.with {
    dependsOn configuration
    dependsOn extractDeltaPack
    outputs.dir(destDir)

    doFirst {
      project.delete(buildRoot)
      project.mkdir(destDir)

      project.copy {
        from(configuration.singleFile) {
          rename "(.*)", installerType.jarFileName
        }
        into project.file("${buildRoot.path}/usr/share/${installerType.baseName}/lib")
      }

      installerType.directories.each { dirName, permissions ->
        project.file("${buildRoot.path}/${dirName}").mkdirs()
      }

      project.copy {
        from("${rootProject.projectDir}/LICENSE")
        into "${buildRoot.path}/usr/share/doc/${installerType.baseName}"
      }

      project.copy {
        into "${buildRoot.path}/usr/share/${installerType.baseName}/bin"
        fileMode = 0755

        from("${extractDeltaPack.outputs.files.singleFile.path}/wrapper-delta-pack-${project.versions.tanuki}/src/bin/App.sh.in") {
          filter({ String eachLine ->
            eachLine = eachLine
              .replaceAll('@app.name@', installerType.baseName)
              .replaceAll('@app.long.name@', installerType.baseName)
              .replaceAll('@app.description@', installerType.baseName)

            if (eachLine == 'WRAPPER_CMD="./wrapper"') {
              eachLine = 'WRAPPER_CMD="../wrapper/wrapper"'
            }

            if (eachLine == 'WRAPPER_CONF="../conf/wrapper.conf"') {
              eachLine = "WRAPPER_CONF=\"/usr/share/${installerType.baseName}/wrapper-config/wrapper.conf\""
            }

            if (eachLine == 'PIDDIR="."') {
              eachLine = "PIDDIR=\"/var/lib/${installerType.baseName}/run\""
            }

            if (eachLine =~ /^#PASS_THROUGH=/ && installerType.allowPassthrough) {
              eachLine = 'PASS_THROUGH=true'
            }

            if (eachLine == '#RUN_AS_USER=') {
              eachLine = 'RUN_AS_USER=go'
            }

            return eachLine
          })
          rename 'App.sh.in', installerType.baseName
        }
      }

      project.copy {
        into "${buildRoot}/usr/share/${installerType.baseName}/wrapper-config"
        from("${extractDeltaPack.outputs.files.singleFile.path}/wrapper-delta-pack-${project.versions.tanuki}/src/conf/wrapper.conf.in") {
          filter({ String eachLine ->
            eachLine = eachLine
              .replaceAll('@app.name@', installerType.baseName)
              .replaceAll('@app.long.name@', installerType.baseName)
              .replaceAll('@app.description@', installerType.baseName)

//            uncomment the lines below to enable debugging of installers
//            if (eachLine == '# wrapper.debug=TRUE') {
//              eachLine = 'wrapper.debug=TRUE'
//            }
//            if (eachLine == '##include.debug') {
//              eachLine = '#include.debug'
//            }
//            if (eachLine == '#wrapper.license.debug=TRUE') {
//              eachLine = 'wrapper.license.debug=TRUE'
//            }

            if (eachLine == 'wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp') {
              eachLine = 'wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperJarApp'
            }

            if (eachLine == '#encoding=UTF-8') {
              def newLines = [
                '#encoding=UTF-8',
                "wrapper.working.dir=/var/lib/${installerType.baseName}",
                'wrapper.console_input=DISABLED',
                'wrapper.console.flush=TRUE'
              ]

              (installerType.additionalEnvVars + installerType.additionalLinuxEnvVars).forEach { k, v ->
                newLines.add("set.default.${k}=${v}")
              }

              eachLine = newLines.join('\n')
            }

            def allJvmArgs = installerType.jvmArgs + installerType.linuxJvmArgs

            if (eachLine == 'wrapper.java.additional.1=' && !allJvmArgs.isEmpty()) {
              def newLines = []

              allJvmArgs.eachWithIndex { String eachArg, int index ->
                newLines << "wrapper.java.additional.${index + 1}=${eachArg}"
              }


              eachLine = newLines.join('\n')
            }

            if (eachLine == 'wrapper.jarfile=../lib/wrapper.jar') {
              eachLine = "wrapper.jarfile=/usr/share/${installerType.baseName}/wrapper/wrapper.jar"
            }

            if (eachLine == '#wrapper.java.classpath.1=') {
              eachLine = "wrapper.java.classpath.1=/usr/share/${installerType.baseName}/lib/${installerType.jarFileName}"
            }

            if (eachLine == 'wrapper.java.library.path.1=../lib') {
              eachLine = "wrapper.java.library.path.1=/usr/share/${installerType.baseName}/wrapper"
            }

            if (eachLine == 'wrapper.app.parameter.1=<YourMainClass>') {
              eachLine = "wrapper.app.parameter.1=/usr/share/${installerType.baseName}/lib/${installerType.jarFileName}"
            }

            if (eachLine == 'wrapper.logfile=../logs/wrapper.log') {
              eachLine = "wrapper.logfile=/var/log/${installerType.baseName}/${installerType.logFileName}"
            }

            return eachLine
          })

          filter(ConcatFilter, append: file("include/wrapper-license-linux-${installerType.baseName}.conf"))
          filter(ConcatFilter, append: file("include/additional-properties.conf"))

          rename 'wrapper.conf.in', 'wrapper.conf'
        }

        // the actual default config file
        from("include/wrapper-properties-${installerType.baseName}.conf") {
          rename ".*", "wrapper-properties.conf"
          filter(ConcatFilter, append: file("include/wrapper-properties.${installerType.baseName}.conf.example"))
        }
      }

      project.copy {
        into "${buildRoot}/usr/share/${installerType.baseName}/wrapper"
        from("${extractDeltaPack.outputs.files.singleFile}/wrapper-delta-pack-${project.versions.tanuki}/bin") {
          include 'wrapper-linux-x86-64*'
          include 'wrapper-linux-arm-64*'
        }

        from("${extractDeltaPack.outputs.files.singleFile}/wrapper-delta-pack-${project.versions.tanuki}/lib") {
          include 'wrapper.jar'
          include 'libwrapper-linux-x86-64*'
          include 'libwrapper-linux-arm-64*'
        }
      }
    }

    doLast {
      project.exec {
        List<String> cmd = []
        cmd += ['fpm']

//        cmd += ['--debug']
//        cmd += ['-e']
//        cmd += ['--debug-workspace']
        cmd += ['--conflicts', installerType.baseName.replaceFirst(/^go-/, 'cruise-')]
        cmd += ['--replaces', installerType.baseName.replaceFirst(/^go-/, 'cruise-')]
        cmd += ['--force']
        cmd += ['-s', 'dir']
        cmd += ['-C', buildRoot.path]
        cmd += ['--name', installerType.baseName]
        cmd += ['--description', installerType.packageDescription]
        cmd += ['--version', project.goVersion]
        cmd += ['--iteration', distVersion]
        cmd += ['--license', 'Apache-2.0']
        cmd += ['--vendor', 'Thoughtworks, Inc.']
        cmd += ['--category', 'Development/Build Tools']
        cmd += ['--architecture', 'all']
        cmd += ['--maintainer', 'Thoughtworks, Inc.']
        cmd += ['--url', 'https://gocd.org']
        cmd += ['--before-install', project.file('linux/shared/before-install.sh.erb').path]
        cmd += ['--before-upgrade', project.file("linux/${packageType}/before-upgrade.sh.erb").path]
        cmd += ['--after-upgrade', project.file("linux/${packageType}/after-upgrade.sh.erb").path]
        cmd += ['--after-install', project.file("linux/${packageType}/after-install.sh.erb").path]
        cmd += ['--before-remove', project.file("linux/${packageType}/before-remove.sh.erb").path]
        cmd += ['--rpm-posttrans', project.file("linux/rpm/post-tran.sh.erb").path]
        cmd += ['--template-value', "install_scripts_dir=${project.file('linux').path}"]
        cmd += ['--template-scripts']

        installerType.directories.each { dirName, permissions ->
          if (permissions.ownedByPackage) {
            cmd += ['--directories', dirName]
          }
        }

        installerType.configFiles.each { fileName, permissions ->
          if (permissions.confFile) {
            cmd += ['--config-files', fileName.replaceAll(/^\//, '')]
          }
        }

        cmd += packageType.configureFpm(project, buildRoot, installerType)

        commandLine = cmd

        environment += ['JRE_BINARY_LOCATOR': packageType.jreBinaryLocator(project)]

        workingDir "${project.buildDir}/distributions/${packageType}"

        standardOutput = System.out
        errorOutput = System.err
      }
    }
  }

  packageTask.finalizedBy(project.tasks.create("${packageTask.name}Metadata", InstallerMetadataTask.class) {
    architecture = Architecture.all
    it.packageTask = packageTask
    type = installerType
  })
}

def copyMultipleAgentsReadme(DefaultTask packageTask, File buildRoot, InstallerType installerType) {
  packageTask.doFirst {
    project.copy {
      from "go-agent/release/README-running-multiple-agents.md"
      into "${buildRoot.path}/usr/share/doc/${installerType.baseName}"
    }
  }
}

task agentPackageRpm { DefaultTask thisTask ->
  def installerType = InstallerType.agent
  def packageType = PackageType.rpm
  def buildRoot = project.file("${project.buildDir.path}/${installerType.baseName}/${packageType.toString()}/BUILD_ROOT")
  def destDir = project.file("${project.buildDir}/distributions/${packageType}")

  copyMultipleAgentsReadme(thisTask, buildRoot, installerType)
  configureLinuxPackage(thisTask, installerType, packageType, buildRoot, configurations.agentBootstrapperJar, destDir)
}


task agentPackageDeb { DefaultTask thisTask ->
  def installerType = InstallerType.agent
  def packageType = PackageType.deb
  def buildRoot = project.file("${project.buildDir.path}/${installerType.baseName}/${packageType.toString()}/BUILD_ROOT")
  def destDir = project.file("${project.buildDir}/distributions/${packageType}")

  copyMultipleAgentsReadme(thisTask, buildRoot, installerType)
  configureLinuxPackage(thisTask, installerType, packageType, buildRoot, configurations.agentBootstrapperJar, destDir)
}

task serverPackageRpm { DefaultTask thisTask ->
  def installerType = InstallerType.server
  def packageType = PackageType.rpm
  def buildRoot = project.file("${project.buildDir.path}/${installerType.baseName}/${packageType.toString()}/BUILD_ROOT")
  def destDir = project.file("${project.buildDir}/distributions/${packageType}")

  configureLinuxPackage(thisTask, installerType, packageType, buildRoot, configurations.serverJar, destDir)
}

task serverPackageDeb { DefaultTask thisTask ->
  def installerType = InstallerType.server
  def packageType = PackageType.deb
  def buildRoot = project.file("${project.buildDir.path}/${installerType.baseName}/${packageType.toString()}/BUILD_ROOT")
  def destDir = project.file("${project.buildDir}/distributions/${packageType}")

  configureLinuxPackage(thisTask, installerType, packageType, buildRoot, configurations.serverJar, destDir)
}

assemble.dependsOn(":installers:agentPackageRpm", ":installers:serverPackageRpm", ":installers:agentPackageDeb", ":installers:serverPackageDeb")