Makefile.toml

# Copyright 2015-2019 Benjamin Fry <benjaminfry@me.com>
#
# Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
# http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
# http://opensource.org/licenses/MIT>, at your option. This file may not be
# copied, modified, or distributed except according to those terms.

# This is a Makefile for `cargo make`, to use it first install cargo-make with `cargo install cargo-make`

[config]
skip_core_tasks = true
on_error_task = "on_error"

[config.modify_core_tasks]
# if true, all core tasks are set to private (default false)
private = true

## General environment configuration
[env]
TARGET_DIR = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}/target"
CARGO_MAKE_WORKSPACE_TARGET_DIRECTORY = "${TARGET_DIR}"
CARGO_MAKE_WORKSPACE_SKIP_MEMBERS = "examples/*"
CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = "true"
CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY = "${TARGET_DIR}/kcov"
CARGO_MAKE_KCOV_DOWNLOAD_DIRECTORY = "${TARGET_DIR}/kcov-dl"
CARGO_MAKE_KCOV_VERSION = "37"

# This can be overriden (e.g. in pg-extend crate) to specify a more limited set of features
#   because we use features for enabling different versions of pg, this should not be --all-features in general
#ALL_FEATURES = ""

# Defaults are all for postgres version 12
PG_VERSION = { source = "${CARGO_MAKE_PROFILE}", default_value = "12.1", mapping = { v10 = "10.11", v11 = "11.6" }}
PGPORT = { source = "${CARGO_MAKE_PROFILE}", default_value = "5444", mapping = { v10 = "5442", v11 = "5443" }}
PGSERVICE = { unset = true }
PGHOST = "/tmp/"
PGDATABASE = "postgres"
PSQLRC = "/dev/null" # This ensures that every psql invocation will skip the user's .psqlrc file"
ALL_FEATURES = { source = "${CARGO_MAKE_PROFILE}", default_value = "", mapping = { v10 = "--features=fdw", v11 = "--features=fdw" }}

PG_DIR = "${TARGET_DIR}/postgres"
PG_DL_DIR = "${PG_DIR}"
PG_BUILD_DIR = "${PG_DIR}/postgres_build_${PG_VERSION}"
PG_INSTALL_DIR = "${PG_DIR}/postgres_${PG_VERSION}"
PG_BIN_DIR = "${PG_INSTALL_DIR}/bin"
PG_DB_DIR = "${TARGET_DIR}/postgres_db_${PG_VERSION}"
POSTGRES_TEST_DB = "pg_extend_rs_test_db"
PG_LOGPATH = "${TARGET_DIR}/postgres-${PG_VERSION}.log"

PATH = "${PG_BIN_DIR}:${PATH}"
PG_CONFIG = "${PG_BIN_DIR}/pg_config"

##
## Installation tasks
##

[tasks.install-openssl]
description = "Installs OpenSSL on Windows"
workspace = false
env = { OPENSSL_VERSION = "1_1_1d", OPENSSL_DIR = "${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}\\target\\OpenSSL" }
condition = { platforms = ["windows"], files_not_exist = ["${OPENSSL_DIR}"] }
script_runner = "powershell"
script_extension = "ps1"
script = [
'''
mkdir ${env:CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}\\target
mkdir ${env:CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}\\target\OpenSSL
Invoke-WebRequest -URI "http://slproweb.com/download/Win64OpenSSL-${env:OPENSSL_VERSION}.exe" -OutFile "${env:CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}\target\OpenSSL.exe"
Start-Process -FilePath "${env:CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY}\target\OpenSSL.exe" -ArgumentList "/SILENT /VERYSILENT /SP- /DIR=${env:OPENSSL_DIR}"
Invoke-WebRequest "https://curl.haxx.se/ca/cacert.pem" -O "${env:OPENSSL_DIR}\cacert.pem"
'''
]

[tasks.install-postgres]
description = "Installs Postgres"
workspace = false
windows_alias = "empty"
script_runner = "@shell"
script = [
'''
set -e

if ${PG_BIN_DIR}/postgres --version ; then exit 0 ; fi

echo "Installing Postgres ${PG_VERSION:?} into ${PG_INSTALL_DIR:?}"

# download
PG_DL_PATH="${PG_DL_DIR:?}/postgres_${PG_VERSION}.tar.bz2"
PG_URL=https://ftp.postgresql.org/pub/source/v${PG_VERSION:?}/postgresql-${PG_VERSION:?}.tar.bz2

if ! [ -f "${PG_DL_PATH:?}" ]; then
    echo "Retrieving ${PG_URL:?}"
    mkdir -p ${PG_DL_DIR:?}
    curl -s -o ${PG_DL_PATH:?} ${PG_URL:?}
fi

# build
echo "Building ${PG_BUILD_DIR:?}"
mkdir -p ${PG_BUILD_DIR:?}

current_dir=${PWD}
cd ${PG_BUILD_DIR:?}

bunzip2 -k -d -f ${PG_DL_PATH:?}
PG_TAR_PATH="${PG_DL_DIR}/postgres_${PG_VERSION}.tar"
tar -xf ${PG_TAR_PATH:?}

cd postgresql-${PG_VERSION}
./configure --prefix=${PG_INSTALL_DIR} --with-pgport=${PGPORT} --enable-cassert --without-readline
make install

cd ${current_dir:?}
${PG_BIN_DIR}/postgres --version

rm -r ${PG_BUILD_DIR:?}
rm ${PG_TAR_PATH:?}
rm ${PG_DL_PATH:?}
'''
]

[tasks.install-audit]
description = "Installs cargo-audit"
workspace = false
condition_script = ["if cargo audit --version ; then exit 1 ; else exit 0 ; fi"]
command = "cargo"
args = ["install", "cargo-audit"]

[tasks.install-with]
description = "Installs cargo-with"
workspace = false
condition_script = ["if cargo with --version ; then exit 1 ; else exit 0 ; fi"]
command = "cargo"
args = ["install", "cargo-with", "--git=https://github.com/bluejekyll/cargo-with.git", "--branch=master"]

##
## Postgres operations

[tasks.pg-init-db-dir]
description = "Creates the test DB used by the integration tests"
workspace = false
condition = { files_not_exist = ["${PG_DB_DIR}/pg_wal"] }
dependencies = ["install-postgres"]
script_runner = "@shell"
script = [
'''
set -e

echo "Intializing postgres db ${PG_DB_DIR:?}"
rm -rf ${PG_DB_DIR:?}
mkdir -p ${PG_DB_DIR:?}
${PG_BIN_DIR}/pg_ctl init -D ${PG_DB_DIR:?} -l ${PG_LOGPATH}
'''
]

[tasks.pg-start]
description = "Starts Postgres"
workspace = false
dependencies = ["pg-init-db-dir"]
script_runner = "@shell"
script = [
'''
set -e

if ${PG_BIN_DIR}/pg_isready ; then exit 0 ; fi

echo "Starting postgres ${PG_DB_DIR:?}"
mkdir -p ${PG_DB_DIR:?}

cp ${CARGO_MAKE_WORKSPACE_WORKING_DIRECTORY:?}/integration-tests/postgresql.conf ${PG_DB_DIR:?}/
mv ${PG_LOGPATH:?} ${PG_LOGPATH}.bak || true

${PG_BIN_DIR}/pg_ctl start -D ${PG_DB_DIR:?} -l ${PG_LOGPATH:?}
${PG_BIN_DIR}/pg_isready -t 5
${PG_BIN_DIR}/psql postgres -o /dev/null -c "SELECT 1" # check the connection works
'''
]

[tasks.pg-create-db]
description = "Creates the test DB used by the integration tests"
workspace = false
dependencies = ["pg-start"]
script_runner = "@shell"
script = [
'''
set -e

echo "Creating DB ${POSTGRES_TEST_DB:?}"
${PG_BIN_DIR}/psql postgres -o /dev/null -c "SELECT 1" # check the connection works
${PG_BIN_DIR}/psql postgres -c "CREATE DATABASE ${POSTGRES_TEST_DB:?};" || true
'''
]

[tasks.pg-drop-db]
description = "Creates the test DB used by the integration tests"
workspace = false
dependencies = ["pg-start"]
script_runner = "@shell"
script = [
'''
set -e

echo "Dropping DB ${POSTGRES_TEST_DB:?}"
${PG_BIN_DIR}/psql postgres -o /dev/null -c "SELECT 1" # check the connection works
${PG_BIN_DIR}/psql postgres -c "DROP DATABASE ${POSTGRES_TEST_DB:?};" || true
'''
]

[tasks.pg-stop]
description = "Starts Postgres"
workspace = false
dependencies = ["pg-init-db-dir"]
script_runner = "@shell"
script = [
'''
set -e

echo "Stopping postgres ${PG_DB_DIR:?}"
${PG_BIN_DIR}/pg_ctl stop -D ${PG_DB_DIR:?} -l ${PG_LOGPATH} || true
'''
]

[tasks.psql]
description = "Connects psql to"
dependencies = ["pg-create-db"]
workspace = false
script_runner = "@shell"
script = [
'''
set -e

echo "Connection to postgres ${PG_DB_DIR:?} ${POSTGRES_TEST_DB:?}"
${PG_BIN_DIR}/psql ${POSTGRES_TEST_DB:?}
'''
]

##
## Standard tasks for testing, building, etc.
##

# TODO: actually make this await rather than sleep
[tasks.await-update]
description = "awaits the package to show up in crates.io"
script_runner = "@shell"
script = [
'''
sleep 10
'''
]

[tasks.clean-kcov]
description = "Remove the kcov installation"
workspace = false
script_runner = "@shell"
script = [
'''
rm -rf ${CARGO_MAKE_KCOV_INSTALLATION_DIRECTORY:?}
'''
]

[tasks.clean]
description = "Remove only the current workspace member"
command = "cargo"
args = ["clean", "-p", "${CARGO_MAKE_CRATE_NAME}"]

[tasks.clean-build]
description = "Remove only the current workspace member"
workspace = false
script_runner = "@shell"
script = [
'''
rm -rf ${TARGET_DIR:?}/debug
'''
]

[tasks.clean-db]
description = "Removes the DB directory"
workspace = false
script_runner = "@shell"
script = [
'''
rm -rf ${PG_DB_DIR:?}
'''
]

[tasks.clean-all]
description = "Remove only the current workspace member"
workspace = false
script_runner = "@shell"
script = [
'''
rm -rf ${TARGET_DIR:?}
rm -rf target
'''
]

[tasks.update]
description = "Update dependencies"
command = "cargo"
args = ["update", "-p", "${CARGO_MAKE_CRATE_NAME}"]

[tasks.fmt]
description = "Check formatting with rustfmt"
command = "cargo"
args = ["fmt", "--", "--check"]

[tasks.check]
description = "Run a quick check on all the crates"
dependencies = ["install-postgres"]
command = "cargo"
args = ["check", "--all-targets", "@@remove-empty(FEATURES)"]

[tasks.doc]
description = "Run a quick check on all the crates"
dependencies = ["install-postgres"]
command = "cargo"
args = ["doc", "@@remove-empty(FEATURES)"]

[tasks.build]
description = "Build all the crates"
dependencies = ["install-postgres"]
command = "cargo"
args = ["build", "--all-targets", "@@remove-empty(FEATURES)"]

[tasks.test]
description = "Run tests on all the crates"
command = "cargo"
args = ["test", "--all-targets", "@@remove-empty(FEATURES)"]

[tasks.clippy]
description = "Run the clippy linter on all crates"
#dependencies = ["clean", "install-postgres"]
dependencies = ["clean-build", "install-postgres"]
command = "cargo"
#args = ["clippy", "--all-targets", "${ALL_FEATURES}", "--", "-D", "warnings"]
# FIXME: the cbove command is correct, but seems to hit an issue with clippy and library paths, not clear why...
workspace = false
args = ["clippy", "--all", "--all-targets", "--", "-D", "warnings"]

[tasks.build-bench]
description = "Check that all benchmarks compile"
dependencies = ["clean", "install-postgres"]
command = "cargo"
toolchain = "nightly"
args = ["bench", "--no-run"]

[tasks.audit]
description = "Run cargo audit on all crates"
workspace = false
dependencies = ["check", "install-audit"]
command = "cargo"
args = ["audit", "--deny-warnings", "--ignore=RUSTSEC-2020-0016"]

[tasks.all]
description = "Run check, build, and test on all crates"
dependencies = ["check", "build", "test"]

[tasks.default]
description = "Run the all task"
run_task = "all"

[tasks.on_error]
description = "Dumps addition information to the CLI on failure"
workspace = false
script_runner = "@shell"
script = [
'''
echo "!!!!Dumping PG log after failure!!!!"
cat ${PG_LOGPATH} || true
'''
]

##
## All feature testing builds
##

[tasks.default-features]
description = "Run all with default features"
dependencies = ["install-openssl"]
env = { FEATURES = "" }
run_task = { name = "all", fork = true }

[tasks.no-default-features]
description = "Run all with --no-default-features"
dependencies = ["install-openssl"]
env = { FEATURES = "--no-default-features" }
run_task = { name = "all", fork = true }

[tasks.all-features]
description = "Run all with --all-features"
dependencies = ["install-openssl"]
env = { FEATURES = "${ALL_FEATURES}" }
run_task = { name = "all", fork = true }

##
## publishing
##

[tasks.package]
description = "package artifacts for each crate"
command = "cargo"
args = ["package", "--locked"]

[tasks.inner_publish]
description = "publish next release"
dependencies = ["await-update", "update", "check", "package"]
private = true
command = "cargo"
args = ["publish", "--verbose", "--locked"]

[tasks.publish]
description = "publish next release"
workspace = false
env = { CARGO_MAKE_WORKSPACE_SKIP_MEMBERS = "integration-tests/*;examples/*"}
run_task = { name = "inner_publish", fork = true }