Makefile.toml

[config]
skip_core_tasks = true
default_to_workspace = false

[env]
BUILDSYS_ROOT_DIR = "${CARGO_MAKE_WORKING_DIRECTORY}"

# For binary installation, this should be a released version (prefixed with a v,
# for example v0.1.0). For the git sourcecode installation method, this can be
# any git rev, e.g. a tag, sha, or branch name.
TWOLITER_VERSION = "v0.4.6"
TWOLITER_SHA256_AARCH64 = "12ac3f5a6c641e29481c79289bd07cf1c3494a65e3d283d582feb1d28d8bf2a7"
TWOLITER_SHA256_X86_64 = "4a2db7c4d0aac75c6b682336539ee57371cfb6dfea81689d07fc1f4a940fd5c5"

# For binary installation, this is the GitHub repository that has binary release artifacts attached
# to it, for example https://github.com/bottlerocket-os/twoliter. For git sourcecode installation,
# this is any URI that can be used in a git clone command.
TWOLITER_REPO = "https://github.com/bottlerocket-os/twoliter"

# Skip installing Twoliter if it is already installed and its version
# matches the requested version.
TWOLITER_REUSE_EXISTING_INSTALL="true"

# Allow Twoliter to be installed from a binary distribution if binaries are expected to exist for
# the host OS and architecture.
TWOLITER_ALLOW_BINARY_INSTALL="true"

# Allow Twoliter to be installed by building from sourcecode.
TWOLITER_ALLOW_SOURCE_INSTALL="true"

# If you know the version string returned by Twoliter will not match TWOLITER_VERSION (e.g. when you
# are testing changes to Twoliter itself), set this to true to prevent re-installation.
TWOLITER_SKIP_VERSION_CHECK="false"

# Where Twoliter will be installed.
TWOLITER_INSTALL_DIR = "${BUILDSYS_ROOT_DIR}/tools/twoliter"

# The logging verbosity for Twoliter: error, warn, info, debug, trace
TWOLITER_LOG_LEVEL = "info"

# The project file that configures Twoliter.
TWOLITER_PROJECT = "${BUILDSYS_ROOT_DIR}/Twoliter.toml"

BUILDSYS_ARCH = { script = ['echo "${BUILDSYS_ARCH:-$(uname -m)}"'] }
BUILDSYS_BUILD_DIR = "${BUILDSYS_ROOT_DIR}/build"
BUILDSYS_PACKAGES_DIR = "${BUILDSYS_BUILD_DIR}/rpms"
BUILDSYS_STATE_DIR = "${BUILDSYS_BUILD_DIR}/state"
BUILDSYS_IMAGES_DIR = "${BUILDSYS_BUILD_DIR}/images"
BUILDSYS_TOOLS_DIR = "${BUILDSYS_ROOT_DIR}/tools"
BUILDSYS_SOURCES_DIR = "${BUILDSYS_ROOT_DIR}/sources"
BUILDSYS_SBKEYS_DIR = "${BUILDSYS_ROOT_DIR}/sbkeys"
BUILDSYS_SBKEYS_PROFILE = { script = ['echo "${BUILDSYS_SBKEYS_PROFILE:-local}"'] }
BUILDSYS_TIMESTAMP = { script = ["date +%s"] }
BUILDSYS_VERSION_BUILD = { script = ["git describe --always --dirty --exclude '*' || echo 00000000"] }
# For now, release config path can't be overridden with -e, because it's used
# later in this section.  You have to edit the path here in Makefile.toml to
# use a different Release.toml.
BUILDSYS_RELEASE_CONFIG_PATH = "${BUILDSYS_ROOT_DIR}/Release.toml"
BUILDSYS_VERSION_IMAGE = { script = ["awk -F '[ =\"]+' '$1 == \"version\" {print $2}' ${BUILDSYS_RELEASE_CONFIG_PATH}"] }
# This can be overridden with -e to build a different variant from the variants/ directory
BUILDSYS_VARIANT = { script = ['echo "${BUILDSYS_VARIANT:-aws-k8s-1.24}"'] }
# Product name used for file and directory naming
BUILDSYS_NAME = "bottlerocket"
# "Pretty" name used to identify OS in os-release, bootloader, etc.
# If you're building a Bottlerocket remix, you'd want to set this to something like
# "Bottlerocket Remix by ${CORP}" or "${CORP}'s Bottlerocket Remix"
BUILDSYS_PRETTY_NAME = "Bottlerocket OS"

# These can be overridden with -e to change configuration for pubsys (`cargo
# make repo`).  In addition, you can set RELEASE_START_TIME to determine when
# update waves and repo metadata expiration times will start, instead of
# starting now.  (This can be an RFC3339 date, or an offset like "in X
# hours/days/weeks".)
PUBLISH_EXPIRATION_POLICY_PATH = "${BUILDSYS_ROOT_DIR}/tools/pubsys/policies/repo-expiration/2w-2w-1w.toml"
PUBLISH_WAVE_POLICY_PATH = "${BUILDSYS_BUILD_DIR}/tools/waves/default-waves.toml"
PUBLISH_INFRA_CONFIG_PATH = "${BUILDSYS_ROOT_DIR}/Infra.toml"
# Default repo to read from PUBLISH_INFRA_CONFIG_PATH
PUBLISH_REPO = "default"
# The version of tuftool (without the 'v') that we will install and use for
# publishing-related steps
PUBLISH_TUFTOOL_VERSION="0.10.0"

# This can be overridden with -e to change the path to the file containing SSM
# parameter templates.  This file determines the parameter names and values
# that will be published to SSM when you run `cargo make ssm`.  See
# tools/pubsys/policies/ssm/README.md for more information.
PUBLISH_SSM_TEMPLATES_PATH = "${BUILDSYS_ROOT_DIR}/tools/pubsys/policies/ssm/defaults.toml"

# This can be overridden with -e to change the source path
# for the Licenses.toml file
BUILDSYS_LICENSES_CONFIG_PATH = "${BUILDSYS_ROOT_DIR}/Licenses.toml"

# Specifies whether to validate all targets when validating TUF repositories
REPO_VALIDATE_TARGETS = "true"
# Specifies the timeframe to look for upcoming repository metadata expirations
REPO_METADATA_EXPIRING_WITHIN = "3 days"
# When refreshing repositories, you can set REPO_UNSAFE_REFRESH=true to refresh repositories that have expired metadata files.

# You can also set PUBLISH_REGIONS to override the list of regions from
# Infra.toml for AMI and SSM commands; it's a comma-separated list like
# "us-west-2,us-east-1".
# You can set NO_PROGRESS=true to not print progress bars during snapshot upload.
# You can use ALLOW_CLOBBER=true with the `ssm` task to make it overwrite existing values.
# (This is not required with `promote-ssm` because the intent of promotion is overwriting.)

# This can be overridden to provide a custom import spec for a VMware OVA.
# Using configuration from Infra.toml, we substitute the correct value for
# network, and whether or not to mark a VM as a template
VMWARE_IMPORT_SPEC_PATH = "${BUILDSYS_ROOT_DIR}/tools/pubsys/support/vmware/import_spec.template"

# You can set VMWARE_DATACENTERS to override the list of datacenters from
# Infra.toml for VMware commands; it's a comma-separated list like
# "datacenter1,datacenter2"

# Disallow pulling directly Upstream URLs when lookaside cache results in MISSes as a fallback.
# To use the upstream source as fallback, override this on the command line and set it to 'true'
BUILDSYS_UPSTREAM_SOURCE_FALLBACK = "false"

# We require license checks to pass to build an image.  If you're working on a
# local change and don't have license information yet, you can run with `-e
# BUILDSYS_ALLOW_FAILED_LICENSE_CHECK=true` to allow the build to continue even
# if the license check fails.
BUILDSYS_ALLOW_FAILED_LICENSE_CHECK = "false"

# Disallow pulling licenses from Upstream URLs. To fetch licenses from the upstream source,
# override this on the command line and set it to 'true'
BUILDSYS_UPSTREAM_LICENSE_FETCH= "false"

# This controls how many `docker build` commands we'll invoke at once.
BUILDSYS_JOBS = "8"

CARGO_HOME = "${BUILDSYS_ROOT_DIR}/.cargo"
# This needs to end with pkg/mod so that we can mount the parent of pkg/mod as GOPATH.
GO_MOD_CACHE = "${BUILDSYS_ROOT_DIR}/.gomodcache/pkg/mod"
GO_MODULES = ""
DOCKER_BUILDKIT = "1"

# This is the filename suffix for operations that write out AMI information to
# file.  It can be overridden with -e in situations where a user is using
# multiple `Infra.toml` files for publishing to different places, and wants to
# write AMI information to specifically named files.
AMI_DATA_FILE_SUFFIX = "amis.json"

# This is the filename suffix for operations that write out SSM parameter information
# to file. It can be overridden with -e.
SSM_DATA_FILE_SUFFIX = "ssm-params.json"

# The type of testsys test that should be run.
# `quick` will run a quick test which usually tests that the instances are reachable.
# `conformance` will run a certified conformance test, these tests may take up to 3 hrs.
# `migration` will run an upgrade downgrade test including:
#    1: an initial `quick` test
#    2: a migration from TESTSYS_STARTING_VERSION to BUILDSYS_FULL_VERSION
#    3: a `quick` test on the migrated instances
#    4: a migration from BUILDSYS_FULL_VERSION back to TESTSYS_STARTING_VERSION
#    5: a final `quick` test on the downgraded instances
# TESTSYS_STARTING_IMAGE_ID can be used to provide the correct starting image for migration tests.
TESTSYS_TEST = "quick"
# The default path to the testsys cluster's kubeconfig file. This is used for all testsys calls.
CARGO_MAKE_DEFAULT_TESTSYS_KUBECONFIG_PATH = "${BUILDSYS_ROOT_DIR}/testsys.kubeconfig"
# The last released version of bottlerocket.
TESTSYS_STARTING_VERSION = { script = ["git tag --list --sort=version:refname 'v*' | tail -1"] }
# The commit for the last release of bottlerocket.
TESTSYS_STARTING_COMMIT = { script = ["git describe --tag ${TESTSYS_STARTING_VERSION} --always --exclude '*' || echo 00000000"] }
TESTSYS_TESTS_DIR = "${BUILDSYS_ROOT_DIR}/tests"
TESTSYS_TEST_CONFIG_PATH = "${BUILDSYS_ROOT_DIR}/Test.toml"

[env.development]
# Certain variables are defined here to allow us to override a component value
# on the command line.

TWOLITER = "${TWOLITER_INSTALL_DIR}/twoliter"

# Depends on ${BUILDSYS_JOBS}.
CARGO_MAKE_CARGO_LIMIT_JOBS = "--jobs ${BUILDSYS_JOBS}"
CARGO_MAKE_CARGO_ARGS = "--offline --locked"

# Depends on ${BUILDSYS_ARCH} and ${BUILDSYS_VARIANT}.
BUILDSYS_OUTPUT_DIR = "${BUILDSYS_IMAGES_DIR}/${BUILDSYS_ARCH}-${BUILDSYS_VARIANT}"

# Depends on a number of variables defined above, and each other.
BUILDSYS_VERSION_FULL="${BUILDSYS_VERSION_IMAGE}-${BUILDSYS_VERSION_BUILD}"
# These names are used as prefixes for build and repo steps.
BUILDSYS_NAME_VARIANT="${BUILDSYS_NAME}-${BUILDSYS_VARIANT}-${BUILDSYS_ARCH}"
BUILDSYS_NAME_VERSION="${BUILDSYS_NAME}-${BUILDSYS_VERSION_FULL}"
BUILDSYS_NAME_FULL="${BUILDSYS_NAME_VARIANT}-${BUILDSYS_VERSION_FULL}"
# This name does not include the build short SHA
BUILDSYS_NAME_FRIENDLY = "${BUILDSYS_NAME_VARIANT}-v${BUILDSYS_VERSION_IMAGE}"

# For variant build artifacts.
BUILDSYS_VARIANT_DIR = "${BUILDSYS_OUTPUT_DIR}/${BUILDSYS_VERSION_FULL}"

# Depends on ${BUILDSYS_SBKEYS_DIR} and ${BUILDSYS_SBKEYS_PROFILE}.
BUILDSYS_SBKEYS_PROFILE_DIR = "${BUILDSYS_SBKEYS_DIR}/${BUILDSYS_SBKEYS_PROFILE}"

# Path to repo-specific root role.
PUBLISH_REPO_ROOT_JSON = "${BUILDSYS_ROOT_DIR}/roles/${PUBLISH_REPO}.root.json"
# If you don't specify a signing key in Infra.toml, we generate one at this path.
PUBLISH_REPO_KEY = "${BUILDSYS_ROOT_DIR}/keys/${PUBLISH_REPO}.pem"
# Repo directories have subdirectories for variant/arch, so we only want version here.
PUBLISH_REPO_BASE_DIR = "${BUILDSYS_BUILD_DIR}/repos"
PUBLISH_REPO_OUTPUT_DIR = "${PUBLISH_REPO_BASE_DIR}/${PUBLISH_REPO}/${BUILDSYS_NAME_VERSION}"
# The default name of registered AMIs; override by setting PUBLISH_AMI_NAME.
PUBLISH_AMI_NAME_DEFAULT = "${BUILDSYS_NAME}-${BUILDSYS_VARIANT}-${BUILDSYS_ARCH}-v${BUILDSYS_VERSION_IMAGE}-${BUILDSYS_VERSION_BUILD}"

# The name of the kmod kit archive, used to ease building out-of-tree kernel modules.
BUILDSYS_KMOD_KIT = "${BUILDSYS_VARIANT}-${BUILDSYS_ARCH}-kmod-kit-v${BUILDSYS_VERSION_IMAGE}.tar.xz"
BUILDSYS_KMOD_KIT_PATH = "${BUILDSYS_VARIANT_DIR}/${BUILDSYS_KMOD_KIT}"

# The name of the OVA bundle that will be built if the current variant builds VMDK artifacts
BUILDSYS_OVA = "${BUILDSYS_NAME_VARIANT}-v${BUILDSYS_VERSION_IMAGE}.ova"
BUILDSYS_OVA_PATH = "${BUILDSYS_VARIANT_DIR}/${BUILDSYS_OVA}"
BUILDSYS_OVF_TEMPLATE = "${BUILDSYS_ROOT_DIR}/variants/${BUILDSYS_VARIANT}/template.ovf"

# The default name of uploaded OVAs; override by setting VMWARE_VM_NAME
VMWARE_VM_NAME_DEFAULT = "${BUILDSYS_NAME}-${BUILDSYS_VARIANT}-${BUILDSYS_ARCH}-v${BUILDSYS_VERSION_IMAGE}-${BUILDSYS_VERSION_BUILD}"

# Config file for Boot Configuration initrd generation
BOOT_CONFIG_INPUT = "${BUILDSYS_ROOT_DIR}/bootconfig-input"
# Boot Configuration initrd
BOOT_CONFIG = "${BUILDSYS_ROOT_DIR}/bootconfig.data"

# Determines the kubeconfig that should be used by testsys. If no kubeconfig was provided and the
# default kubeconfig location does not exist, use the users default kubeconfig.
CARGO_MAKE_TESTSYS_KUBECONFIG_ARG = {script = [
'''
if ! [ -n "${TESTSYS_KUBECONFIG}" ] && [ -s "${TESTSYS_TESTS_DIR}/testsys.kubeconfig" ] && [ -s "${CARGO_MAKE_DEFAULT_TESTSYS_KUBECONFIG_PATH}" ];then
   echo "No kubeconfig was specified and a kubeconfig was found in 2 possible locations: '${TESTSYS_TESTS_DIR}/testsys.kubeconfig' and '${CARGO_MAKE_DEFAULT_TESTSYS_KUBECONFIG_PATH}'"
   exit 1
fi
if [ -n "${TESTSYS_KUBECONFIG}" ]; then
   # If the user provides a kubeconfig path it should be used.
   echo "--kubeconfig ${TESTSYS_KUBECONFIG}"
elif [ -s "${TESTSYS_TESTS_DIR}/testsys.kubeconfig" ]; then
   # If the kubeconfig is in the TESTSYS_TESTS_DIR it should be used.
   echo "--kubeconfig ${TESTSYS_TESTS_DIR}/testsys.kubeconfig"
elif [ -s "${CARGO_MAKE_DEFAULT_TESTSYS_KUBECONFIG_PATH}" ]; then
   # If the default kubeconfig exists it should be used.
   echo "--kubeconfig ${CARGO_MAKE_DEFAULT_TESTSYS_KUBECONFIG_PATH}"
fi
'''
]}

# Args that will be passed into all testsys invocations.
CARGO_MAKE_TESTSYS_ARGS = "${CARGO_MAKE_TESTSYS_KUBECONFIG_ARG}"

TESTSYS_TEST_CONFIG_PATH = { script = [
'''
if [ -s "${TESTSYS_TEST_CONFIG_PATH}" ] && [ -s "${TESTSYS_TESTS_DIR}/Test.toml" ];then
   echo "There can only be 1 config file. 2 config files were found: '${TESTSYS_TEST_CONFIG_PATH}' and '${TESTSYS_TESTS_DIR}/Test.toml'"
   exit 1
fi
if [ -s "${TESTSYS_TEST_CONFIG_PATH}" ]; then
   # If the config path exists
   echo "${TESTSYS_TEST_CONFIG_PATH}"
elif [ -s "${TESTSYS_TESTS_DIR}/Test.toml" ]; then
   # If the test config is in the TESTSYS_TESTS_DIR it should be used.
   echo "${TESTSYS_TESTS_DIR}/Test.toml"
else
   echo "${TESTSYS_TEST_CONFIG_PATH}"
fi
'''
] }

[tasks.install-twoliter]
script_runner = "bash"
script = [
'''
declare -a flags

if [ "${TWOLITER_REUSE_EXISTING_INSTALL}" = "true" ]; then
   flags+=("--reuse-existing-install")
fi

if [ "${TWOLITER_ALLOW_BINARY_INSTALL}" = "true" ]; then
   if [ "${BUILDSYS_ARCH}" = "aarch64" ]; then
      flags+=("--allow-binary-install" "${TWOLITER_SHA256_AARCH64}")
   else
      flags+=("--allow-binary-install" "${TWOLITER_SHA256_X86_64}")
   fi
fi

if [ "${TWOLITER_ALLOW_SOURCE_INSTALL}" = "true" ]; then
   flags+=("--allow-from-source")
fi

if [ "${TWOLITER_SKIP_VERSION_CHECK}" = "true" ]; then
   flags+=("--skip-version-check")
fi

"${BUILDSYS_TOOLS_DIR}/install-twoliter.sh" \
  --repo "${TWOLITER_REPO}" \
  --version "${TWOLITER_VERSION}" \
  --directory "${TWOLITER_INSTALL_DIR}" \
  "${flags[@]}"
'''
]

[tasks.run-twoliter]
dependencies = ["install-twoliter"]
command = "${TWOLITER}"
args = [
    "--log-level=${TWOLITER_LOG_LEVEL}",
    "make",
    "${CARGO_MAKE_TASK}",
    "--project-path=${TWOLITER_PROJECT}",
    "--cargo-home=${CARGO_HOME}",
    "--",
    "${@}",
]

[tasks.deprecated]
dependencies = ["install-twoliter"]
script_runner = "bash"
script = [
'''
echo "The '${CARGO_MAKE_TASK}' task is deprecated."
echo "All it does is ensure that Twoliter is installed."
echo "You should do this with 'cargo make install-twoliter' instead.",
'''
]

[tasks.setup]
run_task = "run-twoliter"

[tasks.setup-build]
run_task = "run-twoliter"

[tasks.fetch]
run_task = "run-twoliter"

[tasks.fetch-sdk]
run_task = "run-twoliter"

[tasks.fetch-toolchain]
run_task = "run-twoliter"

[tasks.fetch-sources]
run_task = "run-twoliter"

[tasks.fetch-vendored]
run_task = "run-twoliter"

[tasks.fetch-external-kits]
dependencies = ["install-twoliter"]
command = "${TWOLITER}"
args = [
    "--log-level=${TWOLITER_LOG_LEVEL}",
    "fetch",
    "--project-path=${TWOLITER_PROJECT}",
    "--arch=${BUILDSYS_ARCH}",
]

[tasks.unit-tests]
run_task = "run-twoliter"

# A top level target for devs to ensure review and patch readiness
[tasks.check]
run_task = "run-twoliter"

[tasks.check-fmt]
run_task = "run-twoliter"

[tasks.check-lints]
run_task = "run-twoliter"

[tasks.check-clippy]
run_task = "run-twoliter"

[tasks.check-shell]
run_task = "run-twoliter"

[tasks.check-golangci-lint]
run_task = "run-twoliter"

[tasks.check-migrations]
run_task = "run-twoliter"

[tasks.build-tools]
run_task = "deprecated"

# Note: this is separate from publish-tools because publish-tools takes a while
# to build and isn't needed to build an image.
[tasks.publish-setup-tools]
run_task = "deprecated"

[tasks.publish-tools]
run_task = "deprecated"

[tasks.build-sbkeys]
run_task = "run-twoliter"

# We need Cargo version 1.51 or higher in order to build a workspace's
# dependency during build-package
[tasks.check-cargo-version]
run_task = "run-twoliter"

[tasks.boot-config]
run_task = "run-twoliter"

[tasks.validate-boot-config]
run_task = "run-twoliter"

# Builds a package including its build-time and runtime dependency packages.
[tasks.build-package]
dependencies = ["fetch-external-kits"]
run_task = "run-twoliter"

[tasks.build-variant]
dependencies = ["fetch-external-kits"]
run_task = "run-twoliter"

[tasks.repack-variant]
run_task = "run-twoliter"

[tasks.fetch-variant]
run_task = "run-twoliter"

[tasks.fetch-friendly-variant]
run_task = "run-twoliter"

[tasks.fetch-ova]
run_task = "run-twoliter"

[tasks.check-licenses]
run_task = "run-twoliter"

[tasks.fetch-licenses]
run_task = "run-twoliter"

[tasks.build]
dependencies = ["fetch-external-kits"]
run_task = "run-twoliter"

[tasks.tuftool]
run_task = "deprecated"

[tasks.publish-setup]
run_task = "run-twoliter"

[tasks.publish-setup-without-key]
run_task = "run-twoliter"

# Builds a local repository based on the 'latest' built targets.  Uses pubsys
# to create a repo under /build/repos, named after the arch/variant/version,
# containing subdirectories for the repo metadata and targets.
[tasks.repo]
run_task = "run-twoliter"

[tasks.validate-repo]
run_task = "run-twoliter"

[tasks.check-repo-expirations]
run_task = "run-twoliter"

[tasks.refresh-repo]
run_task = "run-twoliter"

[tasks.ami]
run_task = "run-twoliter"

[tasks.ami-public]
run_task = "run-twoliter"

[tasks.ami-private]
run_task = "run-twoliter"

[tasks.grant-ami]
run_task = "run-twoliter"

[tasks.revoke-ami]
run_task = "run-twoliter"

[tasks.validate-ami]
run_task = "run-twoliter"

[tasks.ssm]
run_task = "run-twoliter"

[tasks.promote-ssm]
run_task = "run-twoliter"

[tasks.validate-ssm]
run_task = "run-twoliter"

[tasks._upload-ova-base]
run_task = "run-twoliter"

# This task runs `_upload-ova-base` which will upload the OVA and *not* mark it
# as a template
[tasks.upload-ova]
run_task = "run-twoliter"

# This task runs `_upload-ova-base` with the environment variable
# `MARK_OVA_AS_TEMPLATE` set, which will upload the OVA *and* mark it as a
# template
[tasks.vmware-template]
run_task = "run-twoliter"

[tasks.clean]
run_task = "run-twoliter"

[tasks.clean-sources]
run_task = "run-twoliter"

[tasks.clean-packages]
run_task = "run-twoliter"

[tasks.clean-images]
run_task = "run-twoliter"

[tasks.clean-repos]
run_task = "run-twoliter"

[tasks.clean-state]
run_task = "run-twoliter"

# Deletes cached code used for Bottlerocket builds
[tasks.purge-cache]
run_task = "run-twoliter"

# This task will delete vendored Go code, primarily, the Go module cache.
# The Go module cache is intentionally readonly and does not have writable
# subdirectories or files. So, we first need to perform the `chmod` in order to
# have permissions to delete it.
# See for more context: https://github.com/golang/go/issues/27455
[tasks.purge-go-vendor]
run_task = "run-twoliter"

# This task will remove all the cached Rust code found in the cargo home dir
[tasks.purge-cargo]
run_task = "run-twoliter"

[tasks.test-tools]
run_task = "deprecated"

[tasks.setup-test]
run_task = "run-twoliter"

# This task is used to test bottlerocket build artifacts. By default the region first listed in Infra.toml
# is used for testing; however, `TESTSYS_REGION` can be used to test in a different region.
[tasks.test]
run_task = "run-twoliter"

# This task will clear all tests from the testsys cluster.
# To delete all passed tests use `cargo make clean-test --passed`
# To delete all failed tests use `cargo make clean-test --failed`
# To delete all incomplete tests use `cargo make clean-test --running`
[tasks.clean-test]
run_task = "run-twoliter"

# This task will clear all tests and resources from the testsys cluster.
[tasks.reset-test]
run_task = "run-twoliter"

# This task will clear all testsys components from the testsys cluster.
[tasks.uninstall-test]
run_task = "run-twoliter"

# This task will clear all testsys components from the testsys cluster.
[tasks.purge-test]
run_task = "run-twoliter"

# This task will call watch on the `status` testsys command to show the results of all tests.
# To see all passed tests use `cargo make watch-test --passed`
# To see all failed tests use `cargo make watch-test --failed`
# To see all incomplete tests use `cargo make watch-test --running`
[tasks.watch-test]
run_task = "run-twoliter"

# This task will call watch on the `status` testsys command to show the results of all tests and
# resources.
# To see all incomplete crds use `cargo make watch-test-all --running`
[tasks.watch-test-all]
run_task = "run-twoliter"

# This task will retrieve testsys logs from a test. You can add `--follow` to continue to receive
# logs as they come in.
[tasks.log-test]
run_task = "run-twoliter"

# This task is useful for using the current tree's testsys without symlinks
[tasks.testsys]
run_task = "run-twoliter"

[tasks.default]
alias = "build"