Makefile.toml

##############################################
# Environment variables
#

# Environment scripts will be run after global environment variables get defined.
# However, this has to be put in the beginning of the toml file, otherwise it won't run at all.
env_scripts = [
'''
#!@duckscript
echo "Setting environment variables ..."
git_branch = get_env BUILD_BRANCH
if is_empty ${git_branch}
    git_branch = set "${CARGO_MAKE_GIT_BRANCH}"
    git_branch = replace ${git_branch} " " "_"
    git_branch = replace ${git_branch} "/" "_"
    git_branch = replace ${git_branch} "-" "_"
end
set_env BUILD_BRANCH ${git_branch}
set_env BUILD_TAG "${BUILD_VERSION}.${git_branch}"
'''
]

[env]
# Build settings
BUILD_VERSION = "${CARGO_MAKE_CRATE_VERSION}"
BUILD_BRANCH = { value = "", condition = { env_not_set = ["BUILD_BRANCH"] } }
BUILD_CONFIG = { source = "${CARGO_MAKE_PROFILE}", default_value = "debug", mapping = { "production" = "release" } }
BUILD_TARGET = { value = "${CARGO_MAKE_RUST_TARGET_TRIPLE}", condition = { env_not_set = ["BUILD_TARGET"] } }

# Cargo make doesn't support passing target as parameter yet, so we have to manually set these variables instead of reading from predefined ones.
BUILD_ARCH.source = "${BUILD_TARGET}"
BUILD_ARCH.default_value = "${CARGO_MAKE_RUST_TARGET_ARCH}"
BUILD_ARCH.mapping.x86_64 = "x64"
BUILD_ARCH.mapping.i686-pc-windows-msvc = "x86"
BUILD_ARCH.mapping.x86_64-pc-windows-msvc = "x64"
BUILD_ARCH.mapping.aarch64-pc-windows-msvc = "arm64"
BUILD_ARCH.mapping.i686-unknown-linux-gnu = "x86"
BUILD_ARCH.mapping.x86_64-unknown-linux-gnu = "x64"
BUILD_ARCH.mapping.arm-unknown-linux-gnueabi = "arm"
BUILD_ARCH.mapping.aarch64-unknown-linux-gnu = "arm64"
BUILD_ARCH.mapping.x86_64-apple-darwin = "x64"

BUILD_OS.source = "${BUILD_TARGET}"
BUILD_OS.default_value = "${CARGO_MAKE_RUST_TARGET_OS}"
BUILD_OS.mapping.i686-pc-windows-msvc = "windows"
BUILD_OS.mapping.x86_64-pc-windows-msvc = "windows"
BUILD_OS.mapping.aarch64-pc-windows-msvc = "windows"
BUILD_OS.mapping.i686-unknown-linux-gnu = "linux"
BUILD_OS.mapping.x86_64-unknown-linux-gnu = "linux"
BUILD_OS.mapping.arm-unknown-linux-gnueabi = "linux"
BUILD_OS.mapping.aarch64-unknown-linux-gnu = "linux"
BUILD_OS.mapping.x86_64-apple-darwin = "macos"

BUILD_FLAVOR = "${BUILD_OS}.${BUILD_ARCH}"

GCC_XCOMPILER_ID.source = "${BUILD_TARGET}"
GCC_XCOMPILER_ID.default_value = ""
GCC_XCOMPILER_ID.mapping.i686-unknown-linux-gnu = "x86_64-linux-gnu"
GCC_XCOMPILER_ID.mapping.arm-unknown-linux-gnueabi = "arm-linux-gnueabi"
GCC_XCOMPILER_ID.mapping.aarch64-unknown-linux-gnu = "aarch64-linux-gnu"

# File names and directories
RNP_FILE_NAME = { source = "${BUILD_OS}", default_value = "rnp", mapping = { "windows" = "rnp.exe" } }
RNP_SERVER_FILE_NAME = { source = "${BUILD_OS}", default_value = "rnp_server", mapping = { "windows" = "rnp_server.exe" } }
BUILD_DIR = "${CARGO_MAKE_WORKING_DIRECTORY}/target/${BUILD_TARGET}/${BUILD_CONFIG}"
PUBLISH_DIR = "${CARGO_MAKE_WORKING_DIRECTORY}/publish/${BUILD_TARGET}"

# Sign settings (Use RNP_SIGNING_URL as enablement key.)
RNP_SIGNING_URL = { value = "${RNP_SIGNING_URL}", condition = { env_set = ["RNP_SIGNING_URL"] } }
RNP_SIGNING_VAULT_URL = { value = "", condition = { env_not_set = ["RNP_SIGNING_VAULT_URL"] } }
RNP_SIGNING_CLIENT_ID = { value = "", condition = { env_not_set = ["RNP_SIGNING_CLIENT_ID"] } }
RNP_SIGNING_CLIENT_SECRET = { value = "", condition = { env_not_set = ["RNP_SIGNING_CLIENT_SECRET"] } }
RNP_SIGNING_CERT_NAME = { value = "", condition = { env_not_set = ["RNP_SIGNING_CERT_NAME"] } }

# Debug settings
RUST_BACKTRACE = "full" # Enable full stack trace all the time.

# Tools
GNU_TAR = { source = "${BUILD_OS}", default_value = "tar", mapping = { "macos" = "gtar" } }

##############################################
# Init development environment
#

# Install build tools
[tasks.install-build-tools]
description = "Install build tools."
windows_alias = "install-build-tools-windows"
linux_alias = "install-build-tools-linux"
mac_alias = "install-build-tools-mac"

[tasks.install-build-tools-windows]
description = "Install build tools on windows."
script = '''
@echo off

:: Install toolchains for cross builds
echo Installing rust target: %BUILD_TARGET%.
rustup target install %BUILD_TARGET%

:: Install AzureSignTool
:: dotnet tool update is now the better (or more expected) way to install the tools. For details, please see the PR and issue below:
:: - https://github.com/dotnet/cli/pull/10205
:: - https://github.com/dotnet/sdk/issues/9500
echo Installing AzureSignTool.
dotnet tool update --global azuresigntool
'''

[tasks.install-build-tools-linux]
description = "Install build tools on linux."
script_runner="bash"
script = '''
# "sudo" needs to be added within this script, since running "sudo cargo" might results in cargo not found error.
sudo apt update

# Install GCC and required libs/tools
echo "Installing build tools and required libs."
sudo apt install -y build-essential libssl-dev

case "${BUILD_TARGET}" in
    "i686-unknown-linux-gnu")
        # For building x86 binary, we are using gcc-multilib.
        # This package is conflicting with other gcc-* packages, but we don't know any better package to use.
        # But sadly, this package is lacking of tools that we need to build ARM/ARM64, so we can only pick 1 to use - either support x86 or ARM/ARM64.
        sudo apt install -y gcc-multilib
        ;;
    "arm-unknown-linux-gnueabi")
        sudo apt install -y gcc-arm-linux-gnueabi binutils-arm-linux-gnueabi
        ;;
    "aarch64-unknown-linux-gnu")
        sudo apt install -y gcc-aarch64-linux-gnu binutils-aarch64-linux-gnu
        ;;
esac

# Install toolchains for cross builds
echo "Installing rust target: ${BUILD_TARGET}"
rustup target install ${BUILD_TARGET}
'''

[tasks.install-build-tools-mac]
description = "Install build tools on mac."
script_runner="bash"
script = '''
echo "Installing build tools: binutils"
brew install binutils
'''

# Install scripts for packing packages
[tasks.install-pack-tools]
description = "Install pack tools."
linux_alias = "install-pack-tools-linux"
mac_alias = "install-pack-tools-mac"

[tasks.install-pack-tools-linux]
description = "Install pack tools on linux."
script_runner="bash"
script = '''
# "sudo" needs to be added within this script, since running "sudo cargo" might results in cargo not found error.
# Add dotnet source and key
wget https://packages.microsoft.com/config/ubuntu/20.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

# Add https support to apt and sync apt repo
sudo apt update
sudo apt install -y apt-transport-https
sudo apt update

# Install dotnet SDK
sudo apt install -y dotnet-sdk-5.0

# Install required misc tools
sudo apt install -y p7zip-full
'''

[tasks.install-pack-tools-mac]
description = "Install pack tools on mac."
script_runner="bash"
script = '''
echo "Installing pack tools: gnu-tar"
brew install gnu-tar
'''

# Install tools for checking test coverage.
[tasks.install-test-coverage-tools]
description = "Install test coverage tools."
linux_alias = "install-test-coverage-tools-linux"

[tasks.install-test-coverage-tools-linux]
description = "Install test coverage tools on linux."
script_runner="bash"
script = '''
cargo install cargo-tarpaulin
'''

##############################################
# Build
#
[tasks.build]
description = "Build the program."
clear = true
dependencies = ["dump-env", "format", "cargo-build", "make-symbol", "sign-binary"]

[tasks.dump-env]
description = "Dump environment variables."
script_runner = "@duckscript"
script = '''
echo "PROFILE = ${CARGO_MAKE_PROFILE}"
echo "BUILD_VERSION = ${BUILD_VERSION}"
echo "BUILD_BRANCH = ${BUILD_BRANCH}"
echo "BUILD_CONFIG = ${BUILD_CONFIG}"
echo "BUILD_TARGET = ${BUILD_TARGET}"
echo "BUILD_ARCH = ${BUILD_ARCH}"
echo "BUILD_OS = ${BUILD_OS}"
echo "BUILD_FLAVOR = ${BUILD_FLAVOR}"
echo "GCC_XCOMPILER_ID = ${GCC_XCOMPILER_ID}"
'''

# Format the code in dev profile.
[tasks.format]
description = "Use rustfmt to format the code."
condition = { profiles = ["development"] }
install_crate = "rustfmt"
command = "cargo"
args = ["fmt", "--", "--emit=files"]

# Cargo build
[tasks.cargo-build]
description = "Run cargo build."
run_task = [
    { name = "cargo-build-dev", condition = { profiles = ["development"] } },
    { name = "cargo-build-release", condition = { profiles = ["production"] } },
]

[tasks.cargo-build-dev]
description = "Run cargo build with dev profile."
command = "cargo"
args = ["build", "--target", "${BUILD_TARGET}"]

[tasks.cargo-build-release]
description = "Run cargo build with release profile."
command = "cargo"
args = ["build", "--release", "--target", "${BUILD_TARGET}"]

# Make symbols
[tasks.make-symbol]
windows_alias = "make-symbol-win"
linux_alias = "make-symbol-linux"
mac_alias = "make-symbol-mac"

[tasks.make-symbol-win]
script_runner = "@duckscript"
script = '''
echo "Windows builds generates PDB by default, so nothing to generate here."
'''

[tasks.make-symbol-linux]
script_runner="bash"
script = '''
GCC_PREFIX=""
if [[ "${GCC_XCOMPILER_ID}" != "" ]]; then
    GCC_PREFIX="${GCC_XCOMPILER_ID}-";
fi

declare -a BIN_FILES=("rnp" "rnp_server")
for BIN_FILE in "${BIN_FILES[@]}"; do
    echo "Removing existing symbol file: ${BUILD_DIR}/${BIN_FILE}.debug"
    rm -f ${BUILD_DIR}/${BIN_FILE}.debug

    echo "Generating new symbol file (with GCC prefix \"${GCC_PREFIX}\"): ${BUILD_DIR}/${BIN_FILE}.debug"
    ${GCC_PREFIX}objcopy --only-keep-debug "${BUILD_DIR}/${BIN_FILE}" "${BUILD_DIR}/${BIN_FILE}.debug"
    ${GCC_PREFIX}strip --strip-debug --strip-unneeded -p "${BUILD_DIR}/${BIN_FILE}"
    ${GCC_PREFIX}objcopy --add-gnu-debuglink="${BUILD_DIR}/${BIN_FILE}.debug" "${BUILD_DIR}/${BIN_FILE}"
done
'''

[tasks.make-symbol-mac]
script = '''
declare -a BIN_FILES=("rnp" "rnp_server")
for BIN_FILE in "${BIN_FILES[@]}"; do
    echo "Removing existing symbol file: ${BUILD_DIR}/${BIN_FILE}.debug"
    rm -f ${BUILD_DIR}/${BIN_FILE}.debug

    echo "Generating new symbol file: ${BUILD_DIR}/${BIN_FILE}.debug"
    /usr/local/opt/binutils/bin/gobjcopy --only-keep-debug "${BUILD_DIR}/${BIN_FILE}" "${BUILD_DIR}/${BIN_FILE}.debug"
    strip -S "${BUILD_DIR}/${BIN_FILE}"
    /usr/local/opt/binutils/bin/gobjcopy --add-gnu-debuglink="${BUILD_DIR}/${BIN_FILE}.debug" "${BUILD_DIR}/${BIN_FILE}"
done
'''

# Sign
[tasks.sign-binary]
description = "Run AzureSignTool to sign the binaries."
condition = { platforms = ["windows"], env_set = [ "RNP_SIGNING_URL" ] }
script_runner = "@duckscript"
script = '''
BIN_FILES = array "rnp.exe" "rnp_server.exe"
for BIN_FILE in ${BIN_FILES}
    BIN_FILE_PATH = set "${BUILD_DIR}/${BIN_FILE}"
    echo "Sign binary: ${BIN_FILE_PATH}"
    exec AzureSignTool sign -du ${RNP_SIGNING_URL} -kvu ${RNP_SIGNING_VAULT_URL} -kvt ${RNP_SIGNING_TENANT_ID} -kvi ${RNP_SIGNING_CLIENT_ID} -kvs ${RNP_SIGNING_CLIENT_SECRET} -kvc ${RNP_SIGNING_CERT_NAME} -v "${BIN_FILE_PATH}"
end
'''

##############################################
# Pack packages
#
[tasks.pack]
description = "Pack binaries into packages."
run_task = [
    { name = ["pack-prepare", "pack-binaries", "pack-symbols", "pack-zip", "pack-nuget", "pack-msix", "pack-choco", "pack-scripts", "sign-packages"], condition = { platforms = ["windows"] } },
    { name = ["pack-prepare", "pack-binaries", "pack-symbols", "pack-tar", "pack-nuget", "pack-deb", "pack-source"], condition = { platforms = ["linux"] } },
    { name = ["pack-prepare", "pack-binaries", "pack-symbols", "pack-tar", "pack-nuget", "pack-brew"], condition = { platforms = ["mac"] } },
]

[tasks.pack-prepare]
description = "Prepare environments for pack."
script_runner = "@duckscript"
script = '''
if is_dir ${PUBLISH_DIR}
    echo "Removing publish directory: ${PUBLISH_DIR}"
    rm -r ${PUBLISH_DIR}
end

echo "Creating publish directory: ${PUBLISH_DIR}"
mkdir ${PUBLISH_DIR}
'''

[tasks.pack-binaries]
description = "Pack binaries."
script_runner = "@duckscript"
script = '''
OUT_DIR = set "${PUBLISH_DIR}/bin"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

echo "Copying binaries from build output: ${BUILD_DIR}"
cp ${BUILD_DIR}/${RNP_FILE_NAME} ${OUT_DIR}/${RNP_FILE_NAME}
cp ${BUILD_DIR}/${RNP_SERVER_FILE_NAME} ${OUT_DIR}/${RNP_SERVER_FILE_NAME}

echo "Copying key documents from source code"
cp README.md ${OUT_DIR}/README.md
cp LICENSE.txt ${OUT_DIR}/LICENSE.txt
'''

[tasks.pack-symbols]
description = "Pack symbol files."
script_runner = "@duckscript"
script = '''
OUT_DIR = set "${PUBLISH_DIR}/symbols"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

BIN_FILES = array "rnp" "rnp_server"
for BIN_FILE in ${BIN_FILES}
    if is_path_exists ${BUILD_DIR}/${BIN_FILE}.pdb
        cp ${BUILD_DIR}/${BIN_FILE}.pdb ${OUT_DIR}/${BIN_FILE}.pdb
    end

    if is_path_exists ${BUILD_DIR}/${BIN_FILE}.debug
        cp ${BUILD_DIR}/${BIN_FILE}.debug ${OUT_DIR}/${BIN_FILE}.debug
    end
end
'''

[tasks.pack-source]
description = "Pack source package."
script_runner = "bash"
script = '''
INT_DIR="${BUILD_DIR}/source"

# Clean up
if [ -d "${INT_DIR}" ]; then
    echo "Removing intermediate directory: ${INT_DIR}"
    rm -rf "${INT_DIR}"
fi
echo "Creating intermediate directory: ${INT_DIR}"
mkdir "${INT_DIR}"

# Prepare the source package
echo "Copying source code to ${INT_DIR}"
cp -r `ls -a | grep -E -v '^(target|publish|log\..*|\.|\..)$'` "${INT_DIR}/"
cd "${INT_DIR}" && git clean -xfd && cd -

# Create source packages
OUT_DIR="${PUBLISH_DIR}/source"
if [ -d "${OUT_DIR}" ]; then
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -rf "${OUT_DIR}"
fi
echo "Creating new output directory: ${OUT_DIR}"
mkdir "${OUT_DIR}"

CRATE_FILE_PATH="${OUT_DIR}/rnp.crate.7z"
echo "Pack source code for crate publishing: ${CRATE_FILE_PATH}"
cd "${INT_DIR}" && 7z -t7z a "${CRATE_FILE_PATH}" . && cd -

echo "Cleanup git info in intermediate directory for source code publishing: ${INT_DIR}"
rm -rf "${INT_DIR}/.git"

ZIP_FILE_PATH="${OUT_DIR}/rnp.source.${BUILD_TAG}.zip"
echo "Pack source code into zip: ${ZIP_FILE_PATH}"
cd "${INT_DIR}" && 7z -tzip a "${ZIP_FILE_PATH}" . && cd -

TAR_FILE_PATH="${OUT_DIR}/rnp.source.${BUILD_TAG}.tar.gz"
echo "Pack source code into tar: ${TAR_FILE_PATH}"
cd "${INT_DIR}" && ${GNU_TAR} --transform "s/^\.\///g" -zcvf "${TAR_FILE_PATH}" . && cd -
'''

[tasks.pack-zip]
description = "Pack zip package."
script_runner = "@duckscript"
script = '''
OUT_DIR = set "${PUBLISH_DIR}/zipped"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

ZIP_FILE_PATH = set "${OUT_DIR}/rnp.${BUILD_TAG}.${BUILD_FLAVOR}.zip"
echo "Pack binaries ${PUBLISH_DIR}/bin/* to ${ZIP_FILE_PATH}"
exec 7z -tzip a ${ZIP_FILE_PATH} ${PUBLISH_DIR}/bin/*
'''

[tasks.pack-tar]
description = "Pack tar package."
script_runner = "bash"
script = '''
OUT_DIR="${PUBLISH_DIR}/zipped"
if [ -d "${OUT_DIR}" ]; then
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -rf "${OUT_DIR}"
fi
echo "Creating new output directory: ${OUT_DIR}"
mkdir "${OUT_DIR}"

TAR_FILE_PATH="${OUT_DIR}/rnp.${BUILD_TAG}.${BUILD_FLAVOR}.tar.gz"
echo "Pack binaries ${PUBLISH_DIR}/bin/* to ${TAR_FILE_PATH}"
${GNU_TAR} --transform "s/.*\///g" -zcvf "${TAR_FILE_PATH}" ${PUBLISH_DIR}/bin/*
'''

[tasks.pack-nuget]
description = "Pack nuget package."
script_runner = "@duckscript"
script = '''
!include_files ./build/scripts/pack_utils.ds

INT_DIR = set "${BUILD_DIR}/nuget"

# Clean up
if is_dir ${INT_DIR}
    echo "Removing intermediate directory: ${INT_DIR}"
    rm -r ${INT_DIR}
end

# Prepare to build package
echo "Copying bin output as intermediate directory: ${INT_DIR}"
cp ${PUBLISH_DIR}/bin ${INT_DIR}
eval_build_template_file "./build/templates/nuget_packages/rnp_nupkg.csproj" ${INT_DIR}/rnp_nupkg.csproj

# Build to output folder
OUT_DIR = set "${PUBLISH_DIR}/nuget"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

echo "Build package from ${INT_DIR} to ${OUT_DIR}"
exec dotnet pack ${INT_DIR}/rnp_nupkg.csproj -o ${OUT_DIR}
'''

[tasks.pack-msix]
description = "Pack msix package."
script_runner = "@duckscript"
script = '''
!include_files ./build/scripts/pack_utils.ds

INT_DIR = set "${BUILD_DIR}/msix"

# Cleanup
if is_dir ${INT_DIR}
    echo "Removing intermediate directory: ${INT_DIR}"
    rm -r ${INT_DIR}
end

# Prepare to build package
echo "Copying bin output as intermediate directory: ${INT_DIR}"
cp ${PUBLISH_DIR}/bin ${INT_DIR}
cp ./assets ${INT_DIR}
eval_build_template_file "./build/templates/msix/appxmanifest.xml" ${INT_DIR}/appxmanifest.xml
eval_build_template_file "./build/templates/msix/appxmappings.txt" ${INT_DIR}/appxmappings.txt

# Build to output folder
OUT_DIR = set "${PUBLISH_DIR}/msix"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

PACKAGE_PATH = set "${OUT_DIR}/rnp.${BUILD_TAG}.${BUILD_FLAVOR}.msix"
echo "Build package from ${INT_DIR} to ${PACKAGE_PATH}"
exec "C:/Program Files (x86)/Windows Kits/10/bin/10.0.19041.0/x64/makeappx.exe" pack /m "${INT_DIR}/appxmanifest.xml" /f "${INT_DIR}/appxmappings.txt" /p ${PACKAGE_PATH}
'''

[tasks.pack-deb]
description = "Pack deb package."
script_runner = "@duckscript"
script = '''
!include_files ./build/scripts/pack_utils.ds

proc_version = readfile "/proc/version"
echo "Read proc version for detecting WSL: ${proc_version}"
wsl_identity = indexof ${proc_version} "microsoft"
if not is_empty ${wsl_identity}
    echo "Found we are running in WSL environment. Building DEBIAN package is not supported in WSL, due to linux chmod is not fully supported by NTFS."
    echo "Skipping build task: pack-deb."
    exit 0
end

INT_DIR = set "${BUILD_DIR}/deb"

# Clean up
if is_dir ${INT_DIR}
    echo "Removing intermediate directory: ${INT_DIR}"
    rm -r ${INT_DIR}
end

# Build deb package
DEB_ARCH = set ${BUILD_ARCH}
if equals ${DEB_ARCH} "x64"
    DEB_ARCH = set "amd64"
end

DEB_PACKAGE_NAME = set "rnp_${BUILD_VERSION}-1_${DEB_ARCH}"
echo "Creating deb package: ${DEB_PACKAGE_NAME}"

INT_DEB_BIN_DIR = set "${INT_DIR}/${DEB_PACKAGE_NAME}/usr/local/bin"
echo "Creating intermediate directory for binary: ${INT_DEB_BIN_DIR}"
mkdir ${INT_DEB_BIN_DIR}

echo "Copy binaries to deb package: ${INT_DEB_BIN_DIR}"
cp ${PUBLISH_DIR}/bin/rnp ${INT_DEB_BIN_DIR}/rnp
cp ${PUBLISH_DIR}/bin/rnp_server ${INT_DEB_BIN_DIR}/rnp_server

INT_DEB_CONTROL_DIR = set "${INT_DIR}/${DEB_PACKAGE_NAME}/DEBIAN"
echo "Creating intermediate directory for debain control: ${INT_DEB_CONTROL_DIR}"
mkdir ${INT_DEB_CONTROL_DIR}

eval_build_template_file "./build/templates/debian/control" ${INT_DEB_CONTROL_DIR}/control

echo "Generating deb package: ${INT_DIR}/${DEB_PACKAGE_NAME}"
exec dpkg-deb --build --root-owner-group ${INT_DIR}/${DEB_PACKAGE_NAME}

# Publish to output folder
OUT_DIR = set "${PUBLISH_DIR}/deb"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

echo "Copying deb package to output folder: File = ${INT_DIR}/${DEB_PACKAGE_NAME}.deb, Target = ${OUT_DIR}"
cp ${INT_DIR}/${DEB_PACKAGE_NAME}.deb ${OUT_DIR}/${DEB_PACKAGE_NAME}.deb
'''

[tasks.pack-choco]
description = "Pack chocolatecy package source."
script_runner = "@duckscript"
script = '''
!include_files ./build/scripts/pack_utils.ds

# Build to output folder
OUT_DIR = set "${PUBLISH_DIR}/choco"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}
mkdir ${OUT_DIR}/tools

TEMPLATE_DIR = set "./build/templates/chocolatey"
echo "Generating chocolatey package source from ${TEMPLATE_DIR} to ${OUT_DIR}"
eval_build_template_file "${TEMPLATE_DIR}/rnp.nuspec" ${OUT_DIR}/rnp.nuspec
eval_build_template_file "${TEMPLATE_DIR}/tools/chocolateyinstall.ps1" ${OUT_DIR}/tools/chocolateyinstall.ps1
eval_build_template_file "${TEMPLATE_DIR}/tools/LICENSE.txt" ${OUT_DIR}/tools/LICENSE.txt
eval_build_template_file "${TEMPLATE_DIR}/tools/VERIFICATION.txt" ${OUT_DIR}/tools/VERIFICATION.txt
'''

[tasks.pack-brew]
description = "Pack homebrew package source."
script_runner = "@duckscript"
script = '''
!include_files ./build/scripts/pack_utils.ds

# Build to output folder
OUT_DIR = set "${PUBLISH_DIR}/homebrew"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

TEMPLATE_DIR = set "./build/templates/homebrew"
echo "Generating chocolatey package source from ${TEMPLATE_DIR} to ${OUT_DIR}"
eval_build_template_file "${TEMPLATE_DIR}/rnp.rb" ${OUT_DIR}/rnp.rb
'''

[tasks.pack-scripts]
description = "Pack release scripts."
script_runner = "@duckscript"
script = '''
OUT_DIR = set "${PUBLISH_DIR}/scripts"
if is_dir ${OUT_DIR}
    echo "Removing previous output directory: ${OUT_DIR}"
    rm -r ${OUT_DIR}
end
echo "Creating new output directory: ${OUT_DIR}"
mkdir ${OUT_DIR}

RELEASE_SCRIPT_PATH = set "./build/scripts/New-RnpReleasePackages.ps1"
echo "Copying release script from ${RELEASE_SCRIPT_PATH} to ${OUT_DIR}"
cp ${RELEASE_SCRIPT_PATH} "${OUT_DIR}/New-RnpReleasePackages.ps1"
'''

[tasks.sign-packages]
description = "Run AzureSignTool to sign the packages."
condition = { env_set = [ "RNP_SIGNING_URL" ] }
script_runner = "@duckscript"
script = '''
exec AzureSignTool sign -du ${RNP_SIGNING_URL} -kvu ${RNP_SIGNING_VAULT_URL} -kvt ${RNP_SIGNING_TENANT_ID} -kvi ${RNP_SIGNING_CLIENT_ID} -kvs ${RNP_SIGNING_CLIENT_SECRET} -kvc ${RNP_SIGNING_CERT_NAME} -v "${PUBLISH_DIR}/msix/rnp.${BUILD_TAG}.${BUILD_FLAVOR}.msix"
'''

##############################################
# Test
#
[tasks.test]
description = "Run all tests."
clear = true
run_task = [
    { name = "test-dev", condition = { profiles = ["development"] } },
    { name = "test-release", condition = { profiles = ["production"] } },
]

[tasks.test-dev]
description = "Run all tests with dev profile."
command = "cargo"
args = ["test", "--target", "${BUILD_TARGET}", "--", "--nocapture"]

[tasks.test-release]
description = "Run all tests with release profile."
command = "cargo"
args = ["test", "--release", "--target", "${BUILD_TARGET}", "--", "--nocapture"]

##############################################
# Test coverage
#
[tasks.test-coverage]
description = "Check test coverage."
linux_alias = "test-coverage-linux"
script_runner = "@duckscript"
script = '''
echo "Test coverage is only supported on linux."
'''

[tasks.test-coverage-linux]
description = "Check test coverage on linux."
command = "cargo"
args = ["tarpaulin", "-v", "-o", "Xml"]

##############################################
# CI flow
#
[tasks.ci-flow]
dependencies = [
    "build",
    "test",
    "pack",
]