Пакеты¶
Пакет - это приложение, описанное файлом app.manifest.toml: его имя,
версии Tarantool и tt, на которых оно работает, его зависимости,
компоненты, из которых оно собирается, и продукты, в виде которых оно
упаковывается. Пакет разрабатывается в проекте,
упаковывается в архив и устанавливается из него.
Манифест¶
manifest_version = "0.1"
[package]
name = "kv-api"
[platform]
tarantool = ">=3.0.0" # [ce] by default; ">=3.3.0[ee]" for Enterprise
tt = ">=3.0.0"
[dependencies]
checks = ">=3.0.0" # a rock from the rock servers
mylib = { source = "path", path = "../mylib" }
[dev_dependencies]
luatest = "*"
[components.app]
path = "kv"
tt new создаёт каркас манифеста; tt package add и tt package remove
редактируют секцию [dependencies] на месте, сохраняя комментарии и
порядок. Неизвестное поле считается ошибкой, поэтому опечатка не останется
незамеченной. Описание всех полей приведено в
справочнике.
Локфайл¶
app.manifest.lock рядом с манифестом фиксирует точные версии всех
зависимостей, прямых и транзитивных. Его коммитят: сборка одного и того же
коммита везде установит одни и те же версии. Для rock-модуля с сервера с
rock-индексом он фиксирует ещё и sha256
файлов этой версии, а установка проверяет файл своей платформы по этой
контрольной сумме.
Локфайл меняется только по запросу:
tt package add,tt package removeиtt package resolveзаново разрешают локфайл под то, что объявлено в манифесте, сохраняя все версии, уже зафиксированные в локфайле. Измениться могут только добавленная зависимость и то, что требуется ей.tt package update [NAME]берёт самые новые версии, разрешённые ограничениями, для всех зависимостей или только для NAME.tt package buildиtt package packразрешают локфайл, переставший соответствовать манифесту, сохраняя зафиксированные версии. С флагом--lockedони вместо этого завершаются с ошибкой, как и требуется в CI.
Версия, которая следует за веткой, scm-1 или dev-1, выбирается, только
если её явно указывает ограничение или других версий у rock-модуля нет, а
разрешение на неё предупреждает, что локфайл не зафиксирует неизменный код.
Так же обстоит дело и с версией, которую tt создал из незакоммиченных
изменений, 1.2.0.dirty-1: её получает любая такая сборка коммита. Версия,
которую tt создаёт из коммита, 1.2.1.dev.3.gabc1234-1 или
0.0.0.dev.36.g7170ebf-1, называет этот коммит и считается релизом.
Локфайл сверяется с манифестом по manifest_hash - хешу того, что
объявляет манифест (его таблиц, ключей и значений), а не байтов файла.
Комментарии, пустые строки и отступы, порядок ключей и таблиц, кавычки
строк и форма записи таблицы (встроенная, ключи через точку) не
учитываются, поэтому такая правка оставляет локфайл актуальным. Изменение
ключа или значения делает локфайл устаревшим, включая поля, которые ничего
не фиксируют, вроде description; устаревшим считается и локфайл,
записанный версией tt, которая хешировала манифест иначе. Тогда
tt package resolve записывает хеш заново и, если ни одна версия не
изменилась, сообщает, что именно переписал в локфайле, а не что он
актуален.
tt package deps показывает, что объявлено в манифесте и во что это
разрешил локфайл, без обращения к сети.
Зависимости берутся с rock-серверов; см. Rock-серверы.
Компоненты и продукты¶
Компонент - это часть пакета: каталог с файлами и, при необходимости, сборкой.
Компонент раскладывает свои файлы по пути
.rocks/share/tarantool/<namespace>/, где <namespace> - имя пакета,
если в компоненте не указано иное. Его файлами считаются *.lua и *.so из
его каталога path, если только в include не перечислены другие;
компонент go раскладывает только то, что указано в include. Backend
сборки создаёт то, что запрашивает его блок, перед структурой каталогов, и один
компонент может создавать всё сразу:
- модуль в
.rocks/lib/tarantool/<namespace>/: нативный модуль бэкендовc,lua-c,cargoилиzigсmodule, либоcmake,makeиshellвoutput; - файл данных в
.rocks/share/tarantool/<namespace>/: например, компонент WebAssembly, см. Run WebAssembly components, либо элементoutputсto = "share"; - программу в
.rocks/bin/: бэкендовgo,cargoилиzigсbin, либо элементoutputсto = "bin". Её запускает внешний процесс приложения.
В руководстве Build a module in Rust описан
backend cargo, а в Build a module in Zig -
backend zig. Поле kind компонента, "module" или "executable",
устарело: tt проверяет то, что оно указывает, на соответствие результатам
сборки.
Нативный модуль - это <module>.so в
.rocks/lib/tarantool/<namespace>/ и <module>.dylib на macOS, где
Tarantool не ищет файл с другим именем: бэкенды c, lua-c, cargo и
zig дают ему такое имя, cmake копирует собранный им .so туда под
именем .dylib, а раскладываемый компонентом файл .dylib попадает туда
точно так же, как .so.
Продукт - это набор компонентов, собираемых и упаковываемых вместе. В
манифесте без секции [products] есть один неявный продукт, default,
состоящий из всех компонентов.
Сборка¶
tt package build разрешает локфайл, устанавливает зависимости в
.rocks/, запускает бэкенды сборки компонентов и раскладывает
компоненты вместе с version.lua пакета. tt package fetch только
устанавливает .rocks/ по локфайлу, без сборки.
Компоненты раскладываются в _build/rock/<product>/ и устанавливаются в
.rocks/ как rock с именем пакета в его версии: манифест дерева .rocks/
перечисляет их файлы так же, как файлы зависимостей, а сборка под другой
версией заменяет этот rock. Если зависимость устанавливает тот же файл, что
и пакет, сборка завершается с ошибкой.
Каталог _build/rock/<product>/ сохраняется между сборками, а
_build/rock/<product>.json фиксирует, какой компонент положил туда
каждый из его файлов. Сборка удаляет из него и тем самым из .rocks/ то,
что больше не принадлежит ни одному компоненту: файл, удалённый из
исходного кода, либо файлы компонента, исключённого из продукта. Файлы,
записанные пропущенной инкрементальной сборкой, остаются; остаётся и то,
что положили туда другие компоненты, когда сборка одного компонента
запускается через --component. Файл, однажды записанный бэкендом в
TT_OUTPUT_DIR и с тех пор не изменявшийся, сохраняется за ним точно так
же, как актуальная цель make; флаг --rebuild начинает работу с пустого
_build/rock/<product>/, поэтому в каталоге остаётся только то, что сборка
записывает заново. Компонент, чей блок build изменился, собирается так же,
как при --rebuild: то, что создала его предыдущая сборка, удаляется из
_build/rock/<product>/ до запуска сборки, TT_BUILD_DIR очищается, и
остаётся только то, что создаёт сборка: так, переименование модуля в блоке
(module = "hello" заменено на module = "greet") не оставит после себя
файл hello.so. Сборка также удаляет из .rocks/ версии зависимостей,
отличные от зафиксированной в локфайле, и исправляет дерево .rocks/,
которое более старый tt оставил несогласованным со своим манифестом.
- Backend сборки находит программы из
.tarantool/binпроекта - то, что установилиtt binaryиtt wasm prepare, - в началеPATH, независимо от наличия.env/activate.sh. - Сборка
makeилиshellсincremental = trueпропускается, пока ни один из файлов, от которых она зависит, не изменился; см. Инкрементальная сборка. - Файл
.wasm, раскладываемый компонентом или записываемый его сборкой вshare/, обязан быть бинарным файлом WebAssembly: любой другой приводит к ошибке сборки, а базовый модуль (core module), который tarantool-wasm не загружает, раскладывается с предупреждением. Проверка совпадает с проверкой стандартного модуляwasm, а дистрибутив без него её не выполняет. - Командам
tt package build,fetchиpackне нужен Tarantool: если tt не находит его ни в.tarantool/bin, ни вPATH, пакет из Lua всё равно собирается и упаковывается. То, что компилируется с заголовочными файлами Tarantool, в этом случае завершается с ошибкой, сообщая о причине: компонентcилиlua-c- до того, как начнётся сборка, а rock с сервера с частью на C - в процессе. Сборкеmake,shellилиcmakeне передаётся расположение Tarantool, переменныеTT_TARANTOOL_PREFIXиTT_TARANTOOL_INCLUDE_DIRостаются неустановленными, и она завершается с ошибкой сама по себе, если ей требуются заголовочные файлы. Tarantool, чьих заголовков tt не находит (см. где он их ищет), собирается так же, а компонентcилиlua-cзавершается с ошибкой с перечислением каталогов, в которых tt их искал.
Версия пакета определяется в следующем порядке:
- строка файла
VERSIONрядом с манифестом; - ближайший тег версии в git,
v1.2.0или1.2.0:1.2.0на самом теге,1.2.1-dev.3+gabc1234через три коммита после него; 0.0.0-dev.<N>+g<sha>при отсутствии тега.
Тег с префиксом v, как и прежде, считается версией, включая v1.2; тег
без него принимается только в полном формате SemVer, 1.2.0 или
1.2.0-rc.1, поскольку простое число нередко обозначает дату или номер
сборки. Любой другой тег пропускается в пользу предшествующего ему тега
версии. Из нескольких тегов версий на одном коммите выбирается старшая
версия, а из v1.2.0 и 1.2.0 берётся тег v1.2.0, независимо от того,
какой из них аннотированный или более новый.
Незакоммиченные изменения, кроме изменений самого локфайла, добавляют
dirty в метаданные сборки: 1.2.0+dirty.
Проект в подкаталоге репозитория - проект в монорепозитории или
зависимость по пути внутри репозитория зависящего от неё проекта -
получает версию только по своему каталогу. Версией становится версия
последнего коммита, изменившего этот каталог, и только изменения внутри
него добавляют dirty: коммит или изменение в других местах репозитория не
меняет версию и не делает устаревшим локфайл проекта, зависящего от него по
пути. Тег учитывается на этом коммите или до него, но не на более позднем
коммите, не затронувшем каталог: чтобы выпустить релиз проекта, тег ставят
на изменяющий его коммит. Число <N> считает коммиты в истории этого
коммита, включая коммиты в других частях репозитория, как и в случае
коммитов после тега. Проект в корне репозитория получает версию по HEAD и
всему дереву.
В коде версия читается как require('<name>.version').version; чтобы
исключить version.lua, задайте generate_version_lua = false в секции
[package].
Инкрементальная сборка¶
Сборку компонента make или shell, независимо от того, что именно она
создаёт, можно пропускать, когда с момента предыдущей сборки ни один файл,
от которого она зависит, не изменился:
[components.calc.build]
backend = "shell"
command = "tarawasm"
args = ["all"]
incremental = true
Перед сборкой такого компонента tt package build вычисляет хеш его
входных данных:
- его блока сборки, включая
env,cwd,outputи всё остальное; - файлов по пути
path: каждого обычного файла с его правами доступа и содержимым, а каждой символической ссылки - по месту, куда она указывает.
Некоторые файлы не считаются входными данными:
- скрытые файлы на любой глубине:
.git,.tarawasm, сами файлы.gitignore; - файлы каталогов
_build/и_runtime/; - файлы, игнорируемые файлами
.gitignore: проекта, промежуточных каталогов до компонента и самого компонента, каждый для своего поддерева, как их читает git, но без правил исключения из конфигурации git (core.excludesFile,.git/info/exclude).
То, что сборка записывает и что не хранится в git - результаты сборки, сгенерированные привязки (bindings), - не входит во входные данные, и хеш сохраняется от одной сборки к другой.
Сборка пропускается, если хеш совпадает с зафиксированным при её последней
успешной сборке в _build/cache/<component>.json, а результаты той сборки
по-прежнему на месте:
- файлы, перечисленные в
output; - файлы компонента, включённые в структуру каталогов;
- созданные сборкой модули, файлы данных и программы согласно записи в
_build/results.json: файлы, которые она создала или изменила на любой глубине, и файлы, созданные более ранней сборкой и оставленные без изменений, подобно актуальной целиmake.
Сборка, чьи файлы в _build/rock/ были с тех пор очищены, запускается снова;
очищенное дерево .rocks/ заново получает оттуда rock пакета. Пропущенная
сборка снова копирует файлы, перечисленные в output, в _build/rock/, и
структура каталогов компонента выполняется так же, как после любой сборки.
Команда tt -V package build выводит в журнал каждый пропущенный компонент.
Пропущенная сборка вообще не запускает свой backend. Цель make с
собственными правилами выполняется быстро, если ничего не изменилось, и
может не требовать incremental: без этого флага tt запускает make каждый
раз, и make сам решает, что нужно пересобрать.
Хеш учитывает не всё, от чего зависит сборка:
- компиляторы и их версии;
- окружение, в котором работает tt, за исключением
envблока сборки; - файлы за пределами
pathкомпонента, включая файлы другого каталогаcwd; - зависимости в
.rocks/.
После изменения этих параметров команды tt package build --rebuild и
tt package pack --rebuild собирают каждый инкрементальный компонент и
записывают результат; удаление _build/cache/ даёт тот же эффект, как и
tt package clean для очищаемых ею компонентов.
Компонент, чья сборка создаёт файлы, не игнорируемые ни одним .gitignore,
получает новый хеш при каждой сборке и собирается заново каждый раз, как
если бы он не был инкрементальным. tt wasm new создаёт файл .gitignore
для компонента WebAssembly и объявляет его инкрементальным.
Очистка¶
tt package clean удаляет то, что создали сборки, и ничего лишнего:
_build/, кроме_build/tt.lock: деревья сборки компонентов (TT_BUILD_DIR), записи инкрементальных сборок и того, что создал каждый компонент, stage-каталоги, сборки зависимостей по пути и архивы, записанныеtt package packв_build/pack/;- rock пакета в
.rocks/по списку файлов из манифеста rock-модуля: то, что установила сборка.
Rock'и зависимостей остаются, как и пакеты, помещённые в .rocks/ командой
tt package install, манифест, локфайл и исходные файлы. Файл, созданный
сборкой рядом с исходным кодом, также остаётся, включая файлы из списка
output: tt не может отличить его от файла, сохраняемого проектом. То, что
оставил инструмент, backend компонента удаляет, если умеет, до того, как tt
удалит что-либо; то, что генерирует сам проект, удаляет команда из секции
[hooks.clean] манифеста (см. справочник).
Следующая сборка заново собирает каждый компонент. Для пакета из Lua, чей
hook pre_build генерирует src/gen/year.lua, а hook очистки удаляет
src/gen/, как в примере из справочника:
$ tt package clean --dry-run
would run the clean hook
would remove _build/rock
would remove myapp 1.0.0-1 from .rocks (4 files)
.rocks/share/tarantool/rocks/myapp/1.0.0-1/myapp-1.0.0-1.rockspec
.rocks/share/tarantool/myapp/init.lua
.rocks/share/tarantool/myapp/src/gen/year.lua
.rocks/share/tarantool/myapp/version.lua
$ tt package clean
ran the clean hook
removed _build/rock
removed myapp 1.0.0-1 from .rocks (4 files)
$ ls -A _build
tt.lock
Компонент со сборкой добавляет своё дерево сборки и записи:
_build/component, _build/cache, _build/results.json.
Флаг --dry-run ничего не удаляет и не запускает; -V выводит список
файлов rock-модуля, как и холостой запуск. tt package clean <component>
очищает один компонент: его дерево сборки, записи и его файлы в
_build/rock/, после того как отработает очистка его бэкенда. Rock пакета
при этом тоже удаляется из .rocks/, поскольку он устанавливается целиком,
и следующая сборка установит его снова, собирая компонент даже тогда, когда
он инкрементальный и ничего не изменилось. Hook очистки запускается только
при очистке пакета целиком.
Один процесс за раз¶
Команды, изменяющие проект, удерживают его блокировку, _build/tt.lock:
tt package build, fetch, pack, clean, add, remove, update и
resolve, tt package install и uninstall в области установки проекта,
tt test во время сборки, а также команды модулей, изменяющие проект, такие как
команды tt wasm. Другая команда, попытавшаяся изменить проект в это время,
ждёт освобождения блокировки и сообщает об этом:
$ tt package build
• waiting for another tt working on the project /home/me/myapp (pid 48213)
Ctrl-C прерывает ожидание. Команды, только читающие проект, такие как
tt package deps и list, не берут блокировку и ничего не ждут. Процесс
tt, запущенный хуком или сборкой в том же проекте (например,
tt package fetch в хуке post_build), работает под блокировкой
запустившего его tt, а не ждёт её: tt передаёт имя своей блокировки в
TT_PROJECT_LOCK, которую наследуют запускаемые им команды. Блокировка
снимается при завершении tt, как бы оно ни произошло, поэтому принудительно
завершённый tt не оставляет после себя зависшей блокировки; файл
_build/tt.lock остаётся для следующей команды. Каталог без
app.manifest.toml блокировку не получает.
Упаковка¶
tt package pack собирает пакет и упаковывает его в
_build/pack/<name>-<version>-<os>-<arch>.tt, архив формата tar.zst,
выводя путь к нему. Архив воспроизводим: двукратная упаковка одного и того
же коммита даёт байт в байт одинаковый результат. В архив входят:
- манифест, локфайл и
VERSION; .rocks/: rock пакета и rock-модули зависимостей, кроме dev-зависимостей, вместе с манифестом дерева; файл из.rocks/, не принадлежащий ни одному rock-модулю, пропускается с предупреждением;.templates/: шаблоны экземпляров проекта, каждый проверен;_runtime/: версии Tarantool и tt, на которых работает пакет, а также TCM, если его запрашивает[platform].tcm;- файлы, перечисленные в
[package].include, и файлы лицензий.
Другие файлы проекта, например init.lua в его корне, в архив не попадают,
если только они не указаны в [package].include. Поэтому кластерная
конфигурация пакета загружает его код как app.module: <name>, из
.rocks/.
Каждая среда выполнения выбирается первой подходящей под [platform] из
следующих источников:
- старшая версия в кэше сред выполнения,
~/.cache/tt/runtimes/<tarantool|tt|tcm>/<ce|ee>/<version>/($XDG_CACHE_HOME/tt/runtimes/, если переменная задана;~/Library/Caches/tt/runtimes/на macOS). Ни одна команда его не наполняет: в нём хранятся сборки, помещённые туда вручную, каталог сbin/<name>и, для Tarantool, егоLICENSEиinclude/tarantool/; - бинарная установка tt в проекте, в
.tarantool/versions/: активная версия, которую выбираютtt binary installиtt binary switch, а иначе - самая старшая версия. Таким образом, командыtt binary install tarantool 3.8.1илиtt binary install ttв проекте выбирают то, что упакует pack. Требование[ee]выбираетtarantool-eeиtt-ee; SDK или сборка, названная по коммиту, не берутся. Заголовочные файлы tarantool идут вместе с ним, а локфайл фиксирует имя установки; - активные
tarantoolиtt, с предупреждением.
Если tarantool не найден, первые два источника остаются единственными,
откуда его можно взять, и упаковка завершается ошибкой, когда подходящей
версии нет ни в одном из них. tt binary устанавливает tarantool без файла
лицензии, поэтому pack предупреждает, что в архив помещается версия из
установки без лицензии.
Флаг --without-deps упаковывает только сам пакет: без _runtime/ и без
зависимостей, которые tt package install скачивает по локфайлу; дерево
.rocks/ содержит только rock самого пакета, включая компонент с
namespace = "". Такой архив называется ...-any.tt, если в нём нет
нативных файлов.
Упаковка в rock¶
Пакет, от которого зависят другие проекты, например модуль Tarantool,
упаковывается в виде rock-модуля: tt package pack --format rock. Rock
содержит файлы, разложенные сборкой, rock пакета, который
tt package build устанавливает в .rocks/, и файлы лицензий из
[package].license_files в каталоге doc/, где LuaRocks хранит документы
rock-модуля: в проекте, установившем rock, они находятся в
.rocks/share/tarantool/rocks/<name>/<version>/doc/. Rock записывается
вместе со своим файлом rockspec:
$ tt package pack --format rock --out dist
.../mylib/dist/mylib-1.2.0-1.linux-x86_64.rock
.../mylib/dist/mylib-1.2.0-1.rockspec
Создаётся бинарный rock той платформы, на которой работает tt, если в
пакете есть нативный файл (модуль или программа), а иначе -
<name>-<version>.all.rock; нативный файл, собранный под другую платформу,
приводит к ошибке упаковки. Версия совпадает с версией пакета с номером
ревизии из --revision, по умолчанию 1: его поднимают, чтобы опубликовать
новую сборку уже выпущенной версии.
Проекту не нужен собственный rockspec: tt генерирует его из манифеста.
Зависимостями становятся диапазоны, объявленные в [dependencies] и
компонентами продукта, а не версии, зафиксированные в локфайле, а
[platform].tarantool становится зависимостью от tarantool; источником
служит [package].repository на коммите версии: source.tag - это тег
версии в том виде, в каком он записан в git, а для версии коммита без тега
(например, 1.2.1-dev.3+gabc1234) - полный sha коммита, поскольку в
LuaRocks нет поля для коммита. LuaRocks загружает git-источник через
git clone --branch, которая не принимает хеш коммита, поэтому при
попытке скачать исходный код такого rockspec она завершится с ошибкой, вместо
того чтобы забрать другой коммит; сам tt исходный код rock-модуля не скачивает.
Версия dirty из незакоммиченных изменений и версия из файла VERSION
указывают репозиторий без коммита, а для версии dirty добавляется
соответствующий комментарий; пакет без repository получает источник
file://.. Секция [package] задаёт описание, лицензию и сопровождающих,
а [platform].platforms - поддерживаемые платформы. Сборка уже выполнена,
поэтому тип сборки - none, и rockspec одинаков для rock-модуля любой
платформы. Зависимость по пути приводит к ошибке упаковки: у проектов,
устанавливающих rock, такого каталога нет. К ошибке приводит и продукт без
собственного rock-модуля, причём обе проверки завершают упаковку до начала
сборки, а не через несколько минут после её запуска. Зависимость из
собственного реестра объявляется с предупреждением, поскольку в rockspec
нельзя указать сервер.
Каталог --out, по умолчанию _build/pack/, после записи rock-модуля
индексируется как rock-сервер с сохранением уже имеющихся там rock-модулей:
упаковка на каждой платформе в один и тот же каталог наполняет общий сервер.
В каталоге создаются манифесты LuaRocks и
rock-индекс, tt-rocks-index.json,
построенные по всем находящимся в нём rock-модулям и rockspec:
$ ls dist
manifest
manifest-5.1
manifest-5.2
manifest-5.3
manifest-5.4
mylib-1.2.0-1.linux-x86_64.rock
mylib-1.2.0-1.rockspec
tt-rocks-index.json
После этого другой проект может зависеть от этого rock-модуля, а его локфайл фиксирует sha256 каждого файла версии из индекса, что проверяется при каждой установке rock-модуля:
[dependencies]
mylib = { version = ">=1.2.0", registry = "/path/to/dist" }
Rock, упакованный заново с той же версией, но другими байтами, перестаёт
соответствовать такому локфайлу: tt package resolve фиксирует его заново, а
уже опубликованный rock вместо этого получает новую --revision. Rock'и с
нескольких машин, собранные в один каталог - например, из заданий матрицы CI, -
индексируются командой tt package index DIR, которая умеет записывать и
индекс, хранящийся отдельно от rock-модулей, для файлов на страницах релизов;
см. Запись индекса.
--format tt,rock упаковывает архив .tt и rock за одну сборку; флаг
--without-deps и подпись применяются только к архиву.
--format rock-src упаковывает исходный rock, <name>-<version>.src.rock, для
платформы, под которую бинарный rock не опубликован: тот же rockspec и файлы
проекта, отслеживаемые git, включая подмодули, вместе с файлом VERSION с этой
версией, поскольку у распакованного rock-модуля нет истории git для её
вычисления. Манифест и файлы лицензий упаковываются независимо от того,
отслеживает ли их git, а отсутствие файла лицензии приводит к ошибке упаковки,
как и для бинарного rock-модуля; файл компонента, который git не отслеживает и
не игнорирует, исключается с предупреждением, поскольку в бинарный rock он
попадает, а в сборку исходного rock-модуля - нет. Вне git-репозитория
упаковываются все файлы проекта, кроме _build/, .rocks/ и _runtime/.
Исходный rock воспроизводим: его записи не сохраняют прав доступа, кроме бита
исполняемости, и не имеют собственного времени: каждая запись в обоих видах
rock-модулей датирована 1980-01-01 00:00 - самым ранним временем формата zip,
которое unzip -l отображает с учётом часового пояса. Упаковка одного только
исходного rock-модуля ничего не собирает - ни hook, ни backend, ничего не
устанавливается в .rocks/ - поэтому ей не нужны компилятор и заголовочные
файлы Tarantool; манифест проверяется, а локфайл разрешается или отклоняется при
--locked, как это делает сборка. Флаг --format rock,rock-src выполняет
сборку один раз, для бинарного rock-модуля. Упаковка на каждой платформе с
--format rock и одна в любом месте с --format rock-src наполняют сервер
всеми rock-модулями версии.
Проект, зависящий от такого rock-модуля, собирает его из исходного rock-модуля,
когда на серверах, с которых он устанавливается, нет rock-модуля под его
платформу - ни бинарного, ни .all: tt скачивает исходный rock в _build/src/,
собирает в нём пакет по его манифесту, как собирает зависимость по пути, и
устанавливает в .rocks/ в версии, зафиксированной в локфайле, включая ревизию,
с файлами лицензий пакета в doc/, как в его бинарном rock-модуле; отсутствие в
исходном rock-модуле файла, который git не отслеживал при упаковке, вызывает
предупреждение. Hook'и пакета при этом не запускаются. Собранный таким образом
rock не пересобирается, пока дерево содержит его в этой версии. Исходный rock,
не являющийся пакетом tt (без app.manifest.toml), приводит к ошибке сборки.
Исходный rock собирает только tt: LuaRocks, включая tt rocks, не находит в нём
ничего для сборки (см. tt rocks).
В руководстве Publish a module as a rock весь этот путь пройден на примере одного модуля: манифест, версии, rock-модули, сервер и индекс для них, а также проект, который от него зависит.
Установка¶
tt package install ARCHIVE устанавливает пакет в одну из
областей установки (scope):
- Проект (по умолчанию): пакет становится гостем проекта. Его rock-модули
добавляются в
.rocks/проекта и его манифест, каждый проверяется по списку файлов, и для проекта создаются командные обёртки; когда два пакета фиксируют зависимость на разных версиях, установка выбирает версию, принимаемую обоими, или завершается ошибкой с объяснением причины. Проект, не имеющий собственного Tarantool, получает рантайм из архива. - Область установки пользователя или системы: архив становится версией
приложения,
<root>/versions/<name>/<name>_<version>/, и<root>/apps/<name>указывает на неё. Его среда выполнения попадает в<root>/versions/, используется совместно, как бинарный файл, установленный черезtt binary, и приложение работает на нём независимо от того, что выбрано в<root>/bin/; командные обёртки его rock-модулей записываются для этой версии там же, кроме подписанной версии, которая устанавливается точно в том виде, в каком была подписана. Версии сосуществуют рядом;--upgradeустанавливает только более новую версию, а--forceпереустанавливает уже имеющуюся, в чём отказывает, пока запущен экземпляр приложения.
tt package list показывает содержимое области установки;
tt package uninstall удаляет гостя из проекта или все версии приложения из
области установки пользователя или системы, сохраняя данные экземпляров в
<root>/var/ и пару хоста в <root>/etc/<name>/.
Архив с зависимостями устанавливается без доступа к сети. См. Install an application for a user и Run instances under systemd.