Перейти к содержанию

Пакеты

Пакет - это приложение, описанное файлом 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 их искал.

Версия пакета определяется в следующем порядке:

  1. строка файла VERSION рядом с манифестом;
  2. ближайший тег версии в git, v1.2.0 или 1.2.0: 1.2.0 на самом теге, 1.2.1-dev.3+gabc1234 через три коммита после него;
  3. 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] из следующих источников:

  1. старшая версия в кэше сред выполнения, ~/.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/;
  2. бинарная установка 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 идут вместе с ним, а локфайл фиксирует имя установки;
  3. активные 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.