tt.manifest.toml¶
The manifest of a distribution of tt: the
tt core and the tt modules that tt binary build tt compiles into one
binary. The build writes tt.manifest.lock and tt.manifest.sum next to
it.
manifest_version = "0.1"
manifest_kind = "tt-distribution"
[package]
name = "tt"
[core]
tt = "v3.0.0-alpha.3"
[distribution]
title = "Tarantool CLI EE"
edition = "ee"
integrity = "rsa"
standard = true
exclude = ["emmylua"]
builtin = true
external_modules = true
bundle_sources = ["customer-zone", "rws", "github"]
[build]
ssl = "openssl_static"
tags = ["netgo"]
[dependencies]
probe = "../tt-probe"
foo = "github.com/acme/tt-foo@v1.2.0"
bar = { module = "github.com/acme/tools", version = "v0.3.0", package = "github.com/acme/tools/ttbar", symbol = "Commands" }
[replace]
"example.com/lib" = "./libs/lib"
"github.com/acme/lib/v2" = "github.com/acme/lib/v2@main"
Only manifest_version and manifest_kind are required: the smallest
manifest builds tt itself, with its standard modules, on the core of the tt
that runs the build. An
unknown field is an error, unless the manifest declares a newer minor
manifest_version than tt knows, in which case it is a warning. Another
major version is refused.
Top level¶
| Field | Required | |
|---|---|---|
manifest_version |
yes | the format version: "0.1" |
manifest_kind |
yes | "tt-distribution"; a manifest without it is the manifest of an application, app.manifest.toml |
[package]¶
| Field | Default | |
|---|---|---|
name |
tt |
the name of the binary: letters, digits, ., _ and -, starting with a letter or a digit |
[core]¶
The tt core the binary is built on. tt and path exclude each other.
| Field | Default | |
|---|---|---|
tt |
the version of the core of the tt that runs the build | a Go version query for the core module |
path |
a local checkout of tt, relative to the manifest's directory | |
module |
github.com/tarantool/tt/v3 |
the Go module of the core, for a fork; a path checkout must hold it |
tt is resolved by the go command, as go list -m <module>@<tt>:
- a version, such as
v3.0.0-alpha.3; - a commit hash, for a commit no tag points to;
latest: the newest release, or the newest pre-release while there is none;- a prefix, such as
v3orv3.1: the newest release with that prefix. Go readsv3as a version prefix, never as the branchv3, and a prefix matches no pre-release: while tt 3 has pre-releases only,v3matches nothing; - a comparison, such as
<v3.1.0; - a branch or a tag whose name is not a version.
The lock pins what the query resolved to until --update. Pin an exact
version or a commit anyway, so that --update and a build with no lock
take what the manifest says.
Without tt, a build by a tt whose version Go cannot fetch - a development
build - fails: set tt or path. --core and TT_DIST_CORE override
[core] for one build (see
Building on another core).
[distribution]¶
How the binary presents itself and what it has besides its modules.
| Field | Default | |
|---|---|---|
title |
Tarantool CLI |
the name the binary presents itself under, in the help and in tt version |
edition |
none | semver build metadata after the short version: ee makes it 3.1.0+ee |
integrity |
none |
the integrity provider: none or rsa (see Sign packages) |
standard |
true |
the standard modules of the core, at its commit (see Standard modules) |
exclude |
none | the standard modules left out, by name; "builtin" is builtin = false. Not allowed with standard = false |
builtin |
true, false when exclude lists builtin |
tt's own commands, the module builtin |
external_modules |
true |
external modules and tt modules |
bundle_sources |
["customer-zone", "rws", "github"] |
where tt binary install and tt binary search find prebuilt products, in order; the first source with a product is the one asked for it: customer-zone is the customer zone of tarantool.io, with --credentials-file, for Tarantool Enterprise, the SDK, TCM and tt-ee; rws is the static RPMs of rws.tarantool.org, for Tarantool Community 3 on Linux with glibc; github is the releases of tt on GitHub, for tt and its latest release. Without the customer zone these products are installed from --local-dir only; without rws or github every version of Tarantool Community or tt is built from source. [] is no source |
The version of the distribution is taken from git describe in the
manifest's directory; VERSION_LABEL follows it.
Standard modules¶
The standard modules are the modules of the core's repository that the
official tt is built with: aeon, build, emmylua and wasm in tt
3.0.0-alpha.3. build has the build backends of tt (see
the application manifest); the core
has none of its own. wasm has tt wasm and the check of the .wasm files
of a package. The package standard of the core,
github.com/tarantool/tt/v3/standard, lists
them, so a distribution gets the ones a newer core adds without an edit of
its manifest. They are built at the commit of the core, or from its checkout,
as every module of the core's repository is.
excludeleaves modules out by name, their code too. A name the core does not list is an error that lists the ones it does.builtin, tt's own commands, is a standard module too, though the core adds it itself rather than the packagestandard.exclude = ["builtin"]andbuiltin = falsesay the same, and may be written together;builtin = truewith"builtin"inexcludeis an error. Withstandard = false,builtinalone decides.- A module of
[dependencies]with the name of a standard module takes its place: a fork ofaeon, or a local checkout of it. Name it inexcludetoo to say so; otherwise the build warns. It is a warning and not an error, so that a manifest that listsaeonitself, as manifests did before the standard modules, and a manifest with a module of a name a newer core adds to the set, still build. - The lock names the standard modules the binary has, without the excluded
ones and those
[dependencies]replaces, and withoutbuiltin:standard = ['aeon', 'build', 'wasm']in its[core]for the manifest above.--lockedfails when the build would take others. - The build reads the list from the source of the package
standardand imports the constructor of each module it takes into themainit generates, as it does for[dependencies]; themaindoes not call the package. A core before v3.0.0-alpha.3 has no packagestandard, and a build on it withstandardon fails: setstandard = falseand list the modules. The build tells by the package itself, not by the version, so a fork or a commit of the core is told right.
[build]¶
How the binary is compiled. The lock does not record these: one lock builds the binary any way.
| Field | Default | |
|---|---|---|
ssl |
default |
the TLS implementation: default, openssl or openssl_static; TT_CLI_BUILD_SSL overrides it |
cgo |
on for openssl and openssl_static only |
build with cgo |
tags |
none | build tags added to the ones of the TLS implementation; no commas or spaces |
ldflags |
none | linker flags added after tt's own, one flag per entry |
[dependencies]¶
The tt modules, by name. The name is the module's name in tt - in
tt version --modules, in its log records and in errors about its
commands: a letter followed by letters, digits, - and _. builtin is
taken while tt's own commands are in, see builtin and exclude of
[distribution]. A module with the name of a standard module takes its
place (see Standard modules).
A module is a string or a table. The string is one of:
- a local directory:
.,.., or a path that starts with./,../or/, relative to the manifest's directory; - a Go module path:
github.com/tarantool/tt/modules/aeon; - a Go module path and a version query after
@:github.com/acme/tt-foo@v1.2.0.
The table has the fields:
| Field | Default | |
|---|---|---|
module |
from the go.mod of path |
the Go module path; required without path, and must match the go.mod with it |
version |
the commit of the core for a module of the core's repository, latest for any other |
a Go version query; not allowed with path, nor for a module of the core's repository, which follows the core |
path |
a local directory with the module, relative to the manifest's directory | |
package |
the root package of the module | the import path of the package with the constructor; a package of module |
symbol |
New |
the constructor, an exported identifier of type func(sdk.Services) []sdk.Mount, or func(sdk.Services) sdk.Module for a module that provides build backends or checks of the files of a package |
kind |
tt-module |
the only kind there is |
source |
path with path, registry without |
The SDK modules a module requires are taken from the core - at its commit,
or from its checkout - whatever the module's go.mod says (see
Write a tt module).
[replace]¶
Go modules of the build taken from elsewhere, as replace directives of
the main module the build generates, which a tt module cannot carry itself.
A key is a Go module path, with @version to replace that version only. A
value is a local directory (it starts with ./, ../ or /, relative to
the manifest's directory) that holds the module, or module@version, where
the version may be any query; the lock pins what it resolves to. The core,
the modules of its repository and the modules of [dependencies] cannot be
replaced here. A replacement no package of the build comes from has no
effect, with a warning. See
Replacing Go modules.